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

eventsourcing/system.py

@@ -1,42 +1,30 @@
 from __future__ import annotations
 
 import inspect
+import threading
 import traceback
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from queue import Full, Queue
-from threading import Event, Lock, RLock, Thread
 from types import FrameType, ModuleType
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    ClassVar,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    Union,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
+
+from eventsourcing.projection import EventSourcedProjection
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator, Sequence
 
-if TYPE_CHECKING:  # pragma: nocover
     from typing_extensions import Self
 
 from eventsourcing.application import (
     Application,
     NotificationLog,
-    ProcessingEvent,
-    RecordingEvent,
+    ProgrammingError,
     Section,
     TApplication,
 )
-from eventsourcing.domain import DomainEventProtocol
+from eventsourcing.domain import DomainEventProtocol, MutableOrImmutableAggregate
 from eventsourcing.persistence import (
-    IntegrityError,
     Mapper,
     Notification,
     ProcessRecorder,
@@ -45,39 +33,46 @@ from eventsourcing.persistence import (
 )
 from eventsourcing.utils import EnvType, get_topic, resolve_topic
 
-ProcessingJob = Tuple[DomainEventProtocol, Tracking]
-ConvertingJob = Optional[Union[RecordingEvent, List[Notification]]]
+ProcessingJob = tuple[DomainEventProtocol, Tracking]
 
 
-class Follower(Application):
-    """
-    Extends the :class:`~eventsourcing.application.Application` class
-    by using a process recorder as its application recorder, by keeping
-    track of the applications it is following, and pulling and processing
-    new domain event notifications through its :func:`policy` method.
+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
+
+
+ConvertingJob = Optional[Union[RecordingEvent, list[Notification]]]
+
+
+class Follower(EventSourcedProjection):
+    """Extends the :class:`~eventsourcing.projection.EventSourcedProjection` class
+    by pulling notification objects from its notification log readers, by converting
+    the notification objects to domain events and tracking objects and by processing
+    the reconstructed domain event objects.
     """
 
-    follow_topics: ClassVar[Sequence[str]] = []
     pull_section_size = 10
 
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        super().__init_subclass__(**kwargs)
+        # for backwards compatibility, set "topics" if has "follow_topics".
+        cls.topics = getattr(cls, "follow_topics", cls.topics)
+
     def __init__(self, env: EnvType | None = None) -> None:
         super().__init__(env)
-        self.readers: Dict[str, NotificationLogReader] = {}
-        self.mappers: Dict[str, Mapper] = {}
-        self.recorder: ProcessRecorder
+        self.readers: dict[str, NotificationLogReader] = {}
+        self.mappers: dict[str, Mapper] = {}
         self.is_threading_enabled = False
-        self.processing_lock = RLock()
-
-    def construct_recorder(self) -> ProcessRecorder:
-        """
-        Constructs and returns a :class:`~eventsourcing.persistence.ProcessRecorder`
-        for the application to use as its application recorder.
-        """
-        return self.factory.process_recorder()
 
     def follow(self, name: str, log: NotificationLog) -> None:
-        """
-        Constructs a notification log reader and a mapper for
+        """Constructs a notification log reader and a mapper for
         the named application, and adds them to its collections
         of readers and mappers.
         """
@@ -95,13 +90,11 @@ class Follower(Application):
     def pull_and_process(
         self, leader_name: str, start: int | None = None, stop: int | None = None
     ) -> None:
-        """
-        Pull and process new domain event notifications.
-        """
+        """Pull and process new domain event notifications."""
         if start is None:
-            start = self.recorder.max_tracking_id(leader_name) + 1
+            start = self.recorder.max_tracking_id(leader_name)
         for notifications in self.pull_notifications(
-            leader_name, start=start, stop=stop
+            leader_name, start=start, stop=stop, inclusive_of_start=False
         ):
             notifications_iter = self.filter_received_notifications(notifications)
             for domain_event, tracking in self.convert_notifications(
@@ -109,29 +102,41 @@ class Follower(Application):
             ):
                 self.process_event(domain_event, tracking)
 
+    def process_event(
+        self, domain_event: DomainEventProtocol, tracking: Tracking
+    ) -> None:
+        with self.processing_lock:
+            super().process_event(domain_event, tracking)
+
     def pull_notifications(
-        self, leader_name: str, start: int, stop: int | None = None
-    ) -> Iterator[List[Notification]]:
-        """
-        Pulls batches of unseen :class:`~eventsourcing.persistence.Notification`
+        self,
+        leader_name: str,
+        start: int | None,
+        stop: int | None = None,
+        *,
+        inclusive_of_start: bool = True,
+    ) -> Iterator[list[Notification]]:
+        """Pulls batches of unseen :class:`~eventsourcing.persistence.Notification`
         objects from the notification log reader of the named application.
         """
         return self.readers[leader_name].select(
-            start=start, stop=stop, topics=self.follow_topics
+            start=start,
+            stop=stop,
+            topics=self.topics,
+            inclusive_of_start=inclusive_of_start,
         )
 
     def filter_received_notifications(
-        self, notifications: List[Notification]
-    ) -> List[Notification]:
-        if self.follow_topics:
-            return [n for n in notifications if n.topic in self.follow_topics]
+        self, notifications: list[Notification]
+    ) -> list[Notification]:
+        if self.topics:
+            return [n for n in notifications if n.topic in self.topics]
         return notifications
 
     def convert_notifications(
         self, leader_name: str, notifications: Iterable[Notification]
-    ) -> List[ProcessingJob]:
-        """
-        Uses the given :class:`~eventsourcing.persistence.Mapper` to convert
+    ) -> list[ProcessingJob]:
+        """Uses the given :class:`~eventsourcing.persistence.Mapper` to convert
         each received :class:`~eventsourcing.persistence.Notification`
         object to an :class:`~eventsourcing.domain.AggregateEvent` object
         paired with a :class:`~eventsourcing.persistence.Tracking` object.
@@ -147,82 +152,17 @@ class Follower(Application):
             processing_jobs.append((domain_event, tracking))
         return processing_jobs
 
-    # @retry(IntegrityError, max_attempts=50000, wait=0.01)
-    def process_event(
-        self, domain_event: DomainEventProtocol, tracking: Tracking
-    ) -> None:
-        """
-        Calls :func:`~eventsourcing.system.Follower.policy` method with
-        the given :class:`~eventsourcing.domain.AggregateEvent` and a
-        new :class:`~eventsourcing.application.ProcessingEvent` created from
-        the given :class:`~eventsourcing.persistence.Tracking` object.
-
-        The policy will collect any new aggregate events on the process
-        event object.
-
-        After the policy method returns, the process event object will
-        then be recorded by calling
-        :func:`~eventsourcing.application.Application.record`, which
-        will return new notifications.
-
-        After calling
-        :func:`~eventsourcing.application.Application.take_snapshots`,
-        the new notifications are passed to the
-        :func:`~eventsourcing.application.Application.notify` method.
-        """
-        processing_event = ProcessingEvent(tracking=tracking)
-        with self.processing_lock:
-            self.policy(domain_event, processing_event)
-            try:
-                recordings = self._record(processing_event)
-            except IntegrityError:
-                if self.recorder.has_tracking_id(
-                    tracking.application_name,
-                    tracking.notification_id,
-                ):
-                    pass
-                else:
-                    raise
-            else:
-                self._take_snapshots(processing_event)
-                self.notify(processing_event.events)
-                self._notify(recordings)
-
-    @abstractmethod
-    def policy(
-        self,
-        domain_event: DomainEventProtocol,
-        processing_event: ProcessingEvent,
-    ) -> None:
-        """
-        Abstract domain event processing policy method. Must be
-        implemented by event processing applications. When
-        processing the given domain event, event processing
-        applications must use the :func:`~ProcessingEvent.collect_events`
-        method of the given process event object (instead of
-        the application's :func:`~eventsourcing.application.Application.save`
-        method) to collect pending events from changed aggregates,
-        so that the new domain events will be recorded atomically
-        with tracking information about the position of the given
-        domain event's notification.
-        """
-
 
 class RecordingEventReceiver(ABC):
-    """
-    Abstract base class for objects that may receive recording events.
-    """
+    """Abstract base class for objects that may receive recording events."""
 
     @abstractmethod
-    def receive_recording_event(self, recording_event: RecordingEvent) -> None:
-        """
-        Receives a recording event.
-        """
+    def receive_recording_event(self, new_recording_event: RecordingEvent) -> None:
+        """Receives a recording event."""
 
 
 class Leader(Application):
-    """
-    Extends the :class:`~eventsourcing.application.Application`
+    """Extends the :class:`~eventsourcing.application.Application`
     class by also being responsible for keeping track of
     followers, and prompting followers when there are new
     domain event notifications to be pulled and processed.
@@ -230,17 +170,24 @@ class Leader(Application):
 
     def __init__(self, env: EnvType | None = None) -> None:
         super().__init__(env)
-        self.followers: List[RecordingEventReceiver] = []
+        self.previous_max_notification_id: int | None = None
+        self.followers: list[RecordingEventReceiver] = []
 
     def lead(self, follower: RecordingEventReceiver) -> None:
-        """
-        Adds given follower to a list of followers.
-        """
+        """Adds given follower to a list of followers."""
         self.followers.append(follower)
 
-    def _notify(self, recordings: List[Recording]) -> None:
-        """
-        Calls :func:`receive_recording_event` on each follower
+    def save(
+        self,
+        *objs: MutableOrImmutableAggregate | DomainEventProtocol | None,
+        **kwargs: Any,
+    ) -> list[Recording]:
+        if self.previous_max_notification_id is None:
+            self.previous_max_notification_id = self.recorder.max_notification_id()
+        return super().save(*objs, **kwargs)
+
+    def _notify(self, recordings: list[Recording]) -> None:
+        """Calls :func:`receive_recording_event` on each follower
         whenever new events have just been saved.
         """
         super()._notify(recordings)
@@ -260,31 +207,28 @@ class Leader(Application):
 
 
 class ProcessApplication(Leader, Follower):
-    """
-    Base class for event processing applications
+    """Base class for event processing applications
     that are both "leaders" and followers".
     """
 
 
 class System:
-    """
-    Defines a system of applications.
-    """
+    """Defines a system of applications."""
 
-    __caller_modules: ClassVar[Dict[int, ModuleType]] = {}
+    __caller_modules: ClassVar[dict[int, ModuleType]] = {}
 
     def __init__(
         self,
-        pipes: Iterable[Iterable[Type[Application]]],
+        pipes: Iterable[Iterable[type[Application]]],
     ):
         # Remember the caller frame's module, so that we might identify a topic.
-        caller_frame = cast(FrameType, cast(FrameType, inspect.currentframe()).f_back)
+        caller_frame = cast(FrameType, inspect.currentframe()).f_back
         module = cast(ModuleType, inspect.getmodule(caller_frame))
-        type(self).__caller_modules[id(self)] = module
+        type(self).__caller_modules[id(self)] = module  # noqa: SLF001
 
         # Build nodes and edges.
-        self.edges: List[Tuple[str, str]] = []
-        classes: Dict[str, Type[Application]] = {}
+        self.edges: list[tuple[str, str]] = []
+        classes: dict[str, type[Application]] = {}
         for pipe in pipes:
             follower_cls = None
             for cls in pipe:
@@ -298,14 +242,13 @@ class System:
                     if edge not in self.edges:
                         self.edges.append(edge)
 
-        self.nodes: Dict[str, str] = {}
-        for name in classes:
-            topic = get_topic(classes[name])
-            self.nodes[name] = topic
+        self.nodes: dict[str, str] = {}
+        for name, cls in classes.items():
+            self.nodes[name] = get_topic(cls)
 
         # Identify leaders and followers.
-        self.follows: Dict[str, List[str]] = defaultdict(list)
-        self.leads: Dict[str, List[str]] = defaultdict(list)
+        self.follows: dict[str, list[str]] = defaultdict(list)
+        self.leads: dict[str, list[str]] = defaultdict(list)
         for edge in self.edges:
             self.leads[edge[0]].append(edge[1])
             self.follows[edge[1]].append(edge[0])
@@ -319,35 +262,37 @@ class System:
         # Check followers are followers.
         for name in self.follows:
             if not issubclass(classes[name], Follower):
-                raise TypeError("Not a follower class: %s" % classes[name])
+                msg = f"Not a follower class: {classes[name]}"
+                raise TypeError(msg)
 
         # Check each process is a process application class.
         for name in self.processors:
             if not issubclass(classes[name], ProcessApplication):
-                raise TypeError("Not a process application class: %s" % classes[name])
+                msg = f"Not a process application class: {classes[name]}"
+                raise TypeError(msg)
 
     @property
-    def leaders(self) -> List[str]:
+    def leaders(self) -> list[str]:
         return list(self.leads.keys())
 
     @property
-    def leaders_only(self) -> List[str]:
+    def leaders_only(self) -> list[str]:
         return [name for name in self.leads if name not in self.follows]
 
     @property
-    def followers(self) -> List[str]:
+    def followers(self) -> list[str]:
         return list(self.follows.keys())
 
     @property
-    def processors(self) -> List[str]:
+    def processors(self) -> list[str]:
         return [name for name in self.leads if name in self.follows]
 
-    def get_app_cls(self, name: str) -> Type[Application]:
+    def get_app_cls(self, name: str) -> type[Application]:
         cls = resolve_topic(self.nodes[name])
         assert issubclass(cls, Application)
         return cls
 
-    def leader_cls(self, name: str) -> Type[Leader]:
+    def leader_cls(self, name: str) -> type[Leader]:
         cls = self.get_app_cls(name)
         if issubclass(cls, Leader):
             return cls
@@ -355,13 +300,13 @@ class System:
         assert issubclass(cls, Leader)
         return cls
 
-    def follower_cls(self, name: str) -> Type[Follower]:
+    def follower_cls(self, name: str) -> type[Follower]:
         cls = self.get_app_cls(name)
         assert issubclass(cls, Follower)
         return cls
 
     @property
-    def topic(self) -> str | None:
+    def topic(self) -> str:
         """
         Returns a topic to the system object, if constructed as a module attribute.
         """
@@ -371,13 +316,14 @@ class System:
             if value is self:
                 topic = module.__name__ + ":" + name
                 assert resolve_topic(topic) is self
+        if topic is None:
+            msg = f"Unable to compute topic for system object: {self}"
+            raise ProgrammingError(msg)
         return topic
 
 
 class Runner(ABC):
-    """
-    Abstract base class for system runners.
-    """
+    """Abstract base class for system runners."""
 
     def __init__(self, system: System, env: EnvType | None = None):
         self.system = system
@@ -386,65 +332,54 @@ class Runner(ABC):
 
     @abstractmethod
     def start(self) -> None:
-        """
-        Starts the runner.
-        """
+        """Starts the runner."""
         if self.is_started:
             raise RunnerAlreadyStartedError
         self.is_started = True
 
     @abstractmethod
     def stop(self) -> None:
-        """
-        Stops the runner.
-        """
+        """Stops the runner."""
 
     @abstractmethod
-    def get(self, cls: Type[TApplication]) -> TApplication:
-        """
-        Returns an application instance for given application class.
-        """
+    def get(self, cls: type[TApplication]) -> TApplication:
+        """Returns an application instance for given application class."""
+
+    def __enter__(self) -> Self:
+        self.start()
+        return self
+
+    def __exit__(self, *args: object, **kwargs: Any) -> None:
+        self.stop()
 
 
 class RunnerAlreadyStartedError(Exception):
-    """
-    Raised when runner is already started.
-    """
+    """Raised when runner is already started."""
 
 
 class NotificationPullingError(Exception):
-    """
-    Raised when pulling notifications fails.
-    """
+    """Raised when pulling notifications fails."""
 
 
 class NotificationConvertingError(Exception):
-    """
-    Raised when converting notifications fails.
-    """
+    """Raised when converting notifications fails."""
 
 
 class EventProcessingError(Exception):
-    """
-    Raised when event processing fails.
-    """
+    """Raised when event processing fails."""
 
 
 class SingleThreadedRunner(Runner, RecordingEventReceiver):
-    """
-    Runs a :class:`System` in a single thread.
-    """
+    """Runs a :class:`System` in a single thread."""
 
     def __init__(self, system: System, env: EnvType | None = None):
-        """
-        Initialises runner with the given :class:`System`.
-        """
+        """Initialises runner with the given :class:`System`."""
         super().__init__(system=system, env=env)
-        self.apps: Dict[str, Application] = {}
-        self._recording_events_received: List[RecordingEvent] = []
-        self._prompted_names_lock = Lock()
+        self.apps: dict[str, Application] = {}
+        self._recording_events_received: list[RecordingEvent] = []
+        self._prompted_names_lock = threading.Lock()
         self._prompted_names: set[str] = set()
-        self._processing_lock = Lock()
+        self._processing_lock = threading.Lock()
 
         # Construct followers.
         for name in self.system.followers:
@@ -461,34 +396,31 @@ class SingleThreadedRunner(Runner, RecordingEventReceiver):
             self.apps[name] = single
 
     def start(self) -> None:
-        """
-        Starts the runner. The applications mentioned in the system definition
+        """Starts the runner. The applications mentioned in the system definition
         are constructed. The followers are set up to follow the applications
         they are defined as following in the system definition. And the leaders
         are set up to lead the runner itself.
         """
-
         super().start()
 
         # Setup followers to follow leaders.
         for edge in self.system.edges:
             leader_name = edge[0]
             follower_name = edge[1]
-            leader = cast(Leader, self.apps[leader_name])
-            follower = cast(Follower, self.apps[follower_name])
+            leader = cast("Leader", self.apps[leader_name])
+            follower = cast("Follower", self.apps[follower_name])
             assert isinstance(leader, Leader)
             assert isinstance(follower, Follower)
             follower.follow(leader_name, leader.notification_log)
 
         # Setup leaders to lead this runner.
         for name in self.system.leaders:
-            leader = cast(Leader, self.apps[name])
+            leader = cast("Leader", self.apps[name])
             assert isinstance(leader, Leader)
             leader.lead(self)
 
-    def receive_recording_event(self, recording_event: RecordingEvent) -> None:
-        """
-        Receives recording event by appending the name of the leader
+    def receive_recording_event(self, new_recording_event: RecordingEvent) -> None:
+        """Receives recording event by appending the name of the leader
         to a list of prompted names.
 
         Then, unless this method has previously been called and not yet returned,
@@ -498,7 +430,7 @@ class SingleThreadedRunner(Runner, RecordingEventReceiver):
         continues until there are no more prompted names. In this way, a system
         of applications will process all events in a single thread.
         """
-        leader_name = recording_event.application_name
+        leader_name = new_recording_event.application_name
         with self._prompted_names_lock:
             self._prompted_names.add(leader_name)
 
@@ -514,7 +446,7 @@ class SingleThreadedRunner(Runner, RecordingEventReceiver):
 
                     for leader_name in prompted_names:
                         for follower_name in self.system.leads[leader_name]:
-                            follower = cast(Follower, self.apps[follower_name])
+                            follower = cast("Follower", self.apps[follower_name])
                             follower.pull_and_process(leader_name)
 
             finally:
@@ -525,34 +457,23 @@ class SingleThreadedRunner(Runner, RecordingEventReceiver):
             app.close()
         self.apps.clear()
 
-    def get(self, cls: Type[TApplication]) -> TApplication:
+    def get(self, cls: type[TApplication]) -> TApplication:
         app = self.apps[cls.name]
         assert isinstance(app, cls)
         return app
 
-    def __enter__(self) -> Self:
-        self.start()
-        return self
-
-    def __exit__(self, *args: object, **kwargs: Any) -> None:
-        self.stop()
-
 
 class NewSingleThreadedRunner(Runner, RecordingEventReceiver):
-    """
-    Runs a :class:`System` in a single thread.
-    """
+    """Runs a :class:`System` in a single thread."""
 
     def __init__(self, system: System, env: EnvType | None = None):
-        """
-        Initialises runner with the given :class:`System`.
-        """
+        """Initialises runner with the given :class:`System`."""
         super().__init__(system=system, env=env)
-        self.apps: Dict[str, Application] = {}
-        self._recording_events_received: List[RecordingEvent] = []
-        self._recording_events_received_lock = Lock()
-        self._processing_lock = Lock()
-        self._previous_max_notification_ids: Dict[str, int] = {}
+        self.apps: dict[str, Application] = {}
+        self._recording_events_received: list[RecordingEvent] = []
+        self._recording_events_received_lock = threading.Lock()
+        self._processing_lock = threading.Lock()
+        self._previous_max_notification_ids: dict[str, int] = {}
 
         # Construct followers.
         for name in self.system.followers:
@@ -569,8 +490,7 @@ class NewSingleThreadedRunner(Runner, RecordingEventReceiver):
             self.apps[name] = single
 
     def start(self) -> None:
-        """
-        Starts the runner.
+        """Starts the runner.
         The applications are constructed, and setup to lead and follow
         each other, according to the system definition.
         The followers are setup to follow the applications they follow
@@ -578,28 +498,26 @@ class NewSingleThreadedRunner(Runner, RecordingEventReceiver):
         leader), and their leaders are setup to lead the runner itself
         (send prompts).
         """
-
         super().start()
 
         # Setup followers to follow leaders.
         for edge in self.system.edges:
             leader_name = edge[0]
             follower_name = edge[1]
-            leader = cast(Leader, self.apps[leader_name])
-            follower = cast(Follower, self.apps[follower_name])
+            leader = cast("Leader", self.apps[leader_name])
+            follower = cast("Follower", self.apps[follower_name])
             assert isinstance(leader, Leader)
             assert isinstance(follower, Follower)
             follower.follow(leader_name, leader.notification_log)
 
         # Setup leaders to notify followers.
         for name in self.system.leaders:
-            leader = cast(Leader, self.apps[name])
+            leader = cast("Leader", self.apps[name])
             assert isinstance(leader, Leader)
             leader.lead(self)
 
-    def receive_recording_event(self, recording_event: RecordingEvent) -> None:
-        """
-        Receives recording event by appending it to list of received recording
+    def receive_recording_event(self, new_recording_event: RecordingEvent) -> None:
+        """Receives recording event by appending it to list of received recording
         events.
 
         Unless this method has previously been called and not yet returned, it
@@ -607,19 +525,19 @@ class NewSingleThreadedRunner(Runner, RecordingEventReceiver):
         events, until there are none remaining.
         """
         with self._recording_events_received_lock:
-            self._recording_events_received.append(recording_event)
+            self._recording_events_received.append(new_recording_event)
 
         if self._processing_lock.acquire(blocking=False):
             try:
                 while True:
                     with self._recording_events_received_lock:
-                        recording_events_received = self._recording_events_received
+                        recording_events = self._recording_events_received
                         self._recording_events_received = []
 
-                        if not recording_events_received:
+                        if not recording_events:
                             break
 
-                    for recording_event in recording_events_received:
+                    for recording_event in recording_events:
                         leader_name = recording_event.application_name
                         previous_max_notification_id = (
                             self._previous_max_notification_ids.get(leader_name, 0)
@@ -642,9 +560,7 @@ class NewSingleThreadedRunner(Runner, RecordingEventReceiver):
                             for follower_name in self.system.leads[leader_name]:
                                 follower = self.apps[follower_name]
                                 assert isinstance(follower, Follower)
-                                start = (
-                                    follower.recorder.max_tracking_id(leader_name) + 1
-                                )
+                                start = follower.recorder.max_tracking_id(leader_name)
                                 stop = recording_event.recordings[0].notification.id - 1
                                 follower.pull_and_process(
                                     leader_name=leader_name,
@@ -656,9 +572,9 @@ class NewSingleThreadedRunner(Runner, RecordingEventReceiver):
                                 follower = self.apps[follower_name]
                                 assert isinstance(follower, Follower)
                                 if (
-                                    follower.follow_topics
+                                    follower.topics
                                     and recording.notification.topic
-                                    not in follower.follow_topics
+                                    not in follower.topics
                                 ):
                                     continue
                                 follower.process_event(
@@ -681,26 +597,23 @@ class NewSingleThreadedRunner(Runner, RecordingEventReceiver):
             app.close()
         self.apps.clear()
 
-    def get(self, cls: Type[TApplication]) -> TApplication:
+    def get(self, cls: type[TApplication]) -> TApplication:
         app = self.apps[cls.name]
         assert isinstance(app, cls)
         return app
 
 
 class MultiThreadedRunner(Runner):
-    """
-    Runs a :class:`System` with one :class:`MultiThreadedRunnerThread`
+    """Runs a :class:`System` with one :class:`MultiThreadedRunnerThread`
     for each :class:`Follower` in the system definition.
     """
 
     def __init__(self, system: System, env: EnvType | None = None):
-        """
-        Initialises runner with the given :class:`System`.
-        """
+        """Initialises runner with the given :class:`System`."""
         super().__init__(system=system, env=env)
-        self.apps: Dict[str, Application] = {}
-        self.threads: Dict[str, MultiThreadedRunnerThread] = {}
-        self.has_errored = Event()
+        self.apps: dict[str, Application] = {}
+        self.threads: dict[str, MultiThreadedRunnerThread] = {}
+        self.has_errored = threading.Event()
 
         # Construct followers.
         for follower_name in self.system.followers:
@@ -722,8 +635,7 @@ class MultiThreadedRunner(Runner):
             self.apps[name] = single
 
     def start(self) -> None:
-        """
-        Starts the runner.
+        """Starts the runner.
         A multi-threaded runner thread is started for each
         'follower' application in the system, and constructs
         an instance of each non-follower leader application in
@@ -736,7 +648,7 @@ class MultiThreadedRunner(Runner):
 
         # Construct followers.
         for follower_name in self.system.followers:
-            follower = cast(Follower, self.apps[follower_name])
+            follower = cast("Follower", self.apps[follower_name])
 
             thread = MultiThreadedRunnerThread(
                 follower=follower,
@@ -751,8 +663,8 @@ class MultiThreadedRunner(Runner):
 
         # Lead and follow.
         for edge in self.system.edges:
-            leader = cast(Leader, self.apps[edge[0]])
-            follower = cast(Follower, self.apps[edge[1]])
+            leader = cast("Leader", self.apps[edge[0]])
+            follower = cast("Follower", self.apps[edge[1]])
             follower.follow(leader.name, leader.notification_log)
             thread = self.threads[follower.name]
             leader.lead(thread)
@@ -778,37 +690,35 @@ class MultiThreadedRunner(Runner):
             if thread.error:
                 raise thread.error
 
-    def get(self, cls: Type[TApplication]) -> TApplication:
+    def get(self, cls: type[TApplication]) -> TApplication:
         app = self.apps[cls.name]
         assert isinstance(app, cls)
         return app
 
 
-class MultiThreadedRunnerThread(RecordingEventReceiver, Thread):
-    """
-    Runs one :class:`~eventsourcing.system.Follower` application in
+class MultiThreadedRunnerThread(RecordingEventReceiver, threading.Thread):
+    """Runs one :class:`~eventsourcing.system.Follower` application in
     a :class:`~eventsourcing.system.MultiThreadedRunner`.
     """
 
     def __init__(
         self,
         follower: Follower,
-        has_errored: Event,
+        has_errored: threading.Event,
     ):
         super().__init__(daemon=True)
         self.follower = follower
         self.has_errored = has_errored
         self.error: Exception | None = None
-        self.is_stopping = Event()
-        self.has_started = Event()
-        self.is_prompted = Event()
-        self.prompted_names: List[str] = []
-        self.prompted_names_lock = Lock()
-        self.is_running = Event()
+        self.is_stopping = threading.Event()
+        self.has_started = threading.Event()
+        self.is_prompted = threading.Event()
+        self.prompted_names: list[str] = []
+        self.prompted_names_lock = threading.Lock()
+        self.is_running = threading.Event()
 
     def run(self) -> None:
-        """
-        Loops forever until stopped. The loop blocks on waiting
+        """Loops forever until stopped. The loop blocks on waiting
         for the 'is_prompted' event to be set, then calls
         :func:`~Follower.pull_and_process` method for each
         prompted name.
@@ -830,12 +740,11 @@ class MultiThreadedRunnerThread(RecordingEventReceiver, Thread):
             self.error.__cause__ = e
             self.has_errored.set()
 
-    def receive_recording_event(self, recording_event: RecordingEvent) -> None:
-        """
-        Receives prompt by appending name of
+    def receive_recording_event(self, new_recording_event: RecordingEvent) -> None:
+        """Receives prompt by appending name of
         leader to list of prompted names.
         """
-        leader_name = recording_event.application_name
+        leader_name = new_recording_event.application_name
         with self.prompted_names_lock:
             if leader_name not in self.prompted_names:
                 self.prompted_names.append(leader_name)
@@ -847,9 +756,7 @@ class MultiThreadedRunnerThread(RecordingEventReceiver, Thread):
 
 
 class NewMultiThreadedRunner(Runner, RecordingEventReceiver):
-    """
-    Runs a :class:`System` with multiple threads in a new way.
-    """
+    """Runs a :class:`System` with multiple threads in a new way."""
 
     QUEUE_MAX_SIZE: int = 0
 
@@ -858,15 +765,13 @@ class NewMultiThreadedRunner(Runner, RecordingEventReceiver):
         system: System,
         env: EnvType | None = None,
     ):
-        """
-        Initialises runner with the given :class:`System`.
-        """
+        """Initialises runner with the given :class:`System`."""
         super().__init__(system=system, env=env)
-        self.apps: Dict[str, Application] = {}
-        self.pulling_threads: Dict[str, List[PullingThread]] = {}
-        self.processing_queues: Dict[str, Queue[List[ProcessingJob] | None]] = {}
-        self.all_threads: List[PullingThread | ConvertingThread | ProcessingThread] = []
-        self.has_errored = Event()
+        self.apps: dict[str, Application] = {}
+        self.pulling_threads: dict[str, list[PullingThread]] = {}
+        self.processing_queues: dict[str, Queue[list[ProcessingJob] | None]] = {}
+        self.all_threads: list[PullingThread | ConvertingThread | ProcessingThread] = []
+        self.has_errored = threading.Event()
 
         # Construct followers.
         for follower_name in self.system.followers:
@@ -888,8 +793,7 @@ class NewMultiThreadedRunner(Runner, RecordingEventReceiver):
             self.apps[name] = single
 
     def start(self) -> None:
-        """
-        Starts the runner.
+        """Starts the runner.
 
         A multi-threaded runner thread is started for each
         'follower' application in the system, and constructs
@@ -903,8 +807,8 @@ class NewMultiThreadedRunner(Runner, RecordingEventReceiver):
 
         # Start the processing threads.
         for follower_name in self.system.followers:
-            follower = cast(Follower, self.apps[follower_name])
-            processing_queue: Queue[List[ProcessingJob] | None] = Queue(
+            follower = cast("Follower", self.apps[follower_name])
+            processing_queue: Queue[list[ProcessingJob] | None] = Queue(
                 maxsize=self.QUEUE_MAX_SIZE
             )
             self.processing_queues[follower_name] = processing_queue
@@ -919,9 +823,9 @@ class NewMultiThreadedRunner(Runner, RecordingEventReceiver):
         for edge in self.system.edges:
             # Set up follower to pull notifications from leader.
             leader_name = edge[0]
-            leader = cast(Leader, self.apps[leader_name])
+            leader = cast("Leader", self.apps[leader_name])
             follower_name = edge[1]
-            follower = cast(Follower, self.apps[follower_name])
+            follower = cast("Follower", self.apps[follower_name])
             follower.follow(leader.name, leader.notification_log)
 
             # Create converting queue.
@@ -957,7 +861,7 @@ class NewMultiThreadedRunner(Runner, RecordingEventReceiver):
 
         # Subscribe for notifications from leaders.
         for leader_name in self.system.leaders:
-            leader = cast(Leader, self.apps[leader_name])
+            leader = cast("Leader", self.apps[leader_name])
             assert isinstance(leader, Leader)
             leader.lead(self)
 
@@ -981,19 +885,20 @@ class NewMultiThreadedRunner(Runner, RecordingEventReceiver):
             if thread.error:
                 raise thread.error
 
-    def get(self, cls: Type[TApplication]) -> TApplication:
+    def get(self, cls: type[TApplication]) -> TApplication:
         app = self.apps[cls.name]
         assert isinstance(app, cls)
         return app
 
-    def receive_recording_event(self, recording_event: RecordingEvent) -> None:
-        for pulling_thread in self.pulling_threads[recording_event.application_name]:
-            pulling_thread.receive_recording_event(recording_event)
+    def receive_recording_event(self, new_recording_event: RecordingEvent) -> None:
+        for pulling_thread in self.pulling_threads[
+            new_recording_event.application_name
+        ]:
+            pulling_thread.receive_recording_event(new_recording_event)
 
 
-class PullingThread(Thread):
-    """
-    Receives or pulls notifications from the given leader, and
+class PullingThread(threading.Thread):
+    """Receives or pulls notifications from the given leader, and
     puts them on a queue for conversion into processing jobs.
     """
 
@@ -1002,19 +907,19 @@ class PullingThread(Thread):
         converting_queue: Queue[ConvertingJob],
         follower: Follower,
         leader_name: str,
-        has_errored: Event,
+        has_errored: threading.Event,
     ):
         super().__init__(daemon=True)
-        self.overflow_event = Event()
+        self.overflow_event = threading.Event()
         self.recording_event_queue: Queue[RecordingEvent | None] = Queue(maxsize=100)
         self.converting_queue = converting_queue
-        self.receive_lock = Lock()
+        self.receive_lock = threading.Lock()
         self.follower = follower
         self.leader_name = leader_name
         self.error: Exception | None = None
         self.has_errored = has_errored
-        self.is_stopping = Event()
-        self.has_started = Event()
+        self.is_stopping = threading.Event()
+        self.has_started = threading.Event()
         self.mapper = self.follower.mappers[self.leader_name]
         self.previous_max_notification_id = self.follower.recorder.max_tracking_id(
             application_name=self.leader_name
@@ -1031,6 +936,7 @@ class PullingThread(Thread):
                 # Ignore recording event if already seen a subsequent.
                 if (
                     recording_event.previous_max_notification_id is not None
+                    and self.previous_max_notification_id is not None
                     and recording_event.previous_max_notification_id
                     < self.previous_max_notification_id
                 ):
@@ -1039,13 +945,17 @@ class PullingThread(Thread):
                 # Catch up if there is a gap in sequence of recording events.
                 if (
                     recording_event.previous_max_notification_id is None
+                    or self.previous_max_notification_id is None
                     or recording_event.previous_max_notification_id
                     > self.previous_max_notification_id
                 ):
-                    start = self.previous_max_notification_id + 1
+                    start = self.previous_max_notification_id
                     stop = recording_event.recordings[0].notification.id - 1
                     for notifications in self.follower.pull_notifications(
-                        self.leader_name, start=start, stop=stop
+                        self.leader_name,
+                        start=start,
+                        stop=stop,
+                        inclusive_of_start=False,
                     ):
                         self.converting_queue.put(notifications)
                         self.previous_max_notification_id = notifications[-1].id
@@ -1069,18 +979,16 @@ class PullingThread(Thread):
         self.recording_event_queue.put(None)
 
 
-class ConvertingThread(Thread):
-    """
-    Converts notifications into processing jobs.
-    """
+class ConvertingThread(threading.Thread):
+    """Converts notifications into processing jobs."""
 
     def __init__(
         self,
         converting_queue: Queue[ConvertingJob],
-        processing_queue: Queue[List[ProcessingJob] | None],
+        processing_queue: Queue[list[ProcessingJob] | None],
         follower: Follower,
         leader_name: str,
-        has_errored: Event,
+        has_errored: threading.Event,
     ):
         super().__init__(daemon=True)
         self.converting_queue = converting_queue
@@ -1089,8 +997,8 @@ class ConvertingThread(Thread):
         self.leader_name = leader_name
         self.error: Exception | None = None
         self.has_errored = has_errored
-        self.is_stopping = Event()
-        self.has_started = Event()
+        self.is_stopping = threading.Event()
+        self.has_started = threading.Event()
         self.mapper = self.follower.mappers[self.leader_name]
 
     def run(self) -> None:
@@ -1111,9 +1019,8 @@ class ConvertingThread(Thread):
                     recording_event = recording_event_or_notifications
                     for recording in recording_event.recordings:
                         if (
-                            self.follower.follow_topics
-                            and recording.notification.topic
-                            not in self.follower.follow_topics
+                            self.follower.topics
+                            and recording.notification.topic not in self.follower.topics
                         ):
                             continue
                         tracking = Tracking(
@@ -1129,7 +1036,7 @@ class ConvertingThread(Thread):
                 if processing_jobs:
                     self.processing_queue.put(processing_jobs)
         except Exception as e:
-            print(traceback.format_exc())
+            print(traceback.format_exc())  # noqa: T201
             self.error = NotificationConvertingError(str(e))
             self.error.__cause__ = e
             self.has_errored.set()
@@ -1139,25 +1046,24 @@ class ConvertingThread(Thread):
         self.converting_queue.put(None)
 
 
-class ProcessingThread(Thread):
-    """
-    A processing thread gets events from a processing queue, and
+class ProcessingThread(threading.Thread):
+    """A processing thread gets events from a processing queue, and
     calls the application's process_event() method.
     """
 
     def __init__(
         self,
-        processing_queue: Queue[List[ProcessingJob] | None],
+        processing_queue: Queue[list[ProcessingJob] | None],
         follower: Follower,
-        has_errored: Event,
+        has_errored: threading.Event,
     ):
         super().__init__(daemon=True)
         self.processing_queue = processing_queue
         self.follower = follower
         self.error: Exception | None = None
         self.has_errored = has_errored
-        self.is_stopping = Event()
-        self.has_started = Event()
+        self.is_stopping = threading.Event()
+        self.has_started = threading.Event()
 
     def run(self) -> None:
         self.has_started.set()
@@ -1180,9 +1086,7 @@ class ProcessingThread(Thread):
 
 
 class NotificationLogReader:
-    """
-    Reads domain event notifications from a notification log.
-    """
+    """Reads domain event notifications from a notification log."""
 
     DEFAULT_SECTION_SIZE = 10
 
@@ -1191,8 +1095,7 @@ class NotificationLogReader:
         notification_log: NotificationLog,
         section_size: int = DEFAULT_SECTION_SIZE,
     ):
-        """
-        Initialises a reader with the given notification log,
+        """Initialises a reader with the given notification log,
         and optionally a section size integer which determines
         the requested number of domain event notifications in
         each section retrieved from the notification log.
@@ -1201,8 +1104,7 @@ class NotificationLogReader:
         self.section_size = section_size
 
     def read(self, *, start: int) -> Iterator[Notification]:
-        """
-        Returns a generator that yields event notifications
+        """Returns a generator that yields event notifications
         from the reader's notification log, starting from
         given start position (a notification ID).
 
@@ -1224,10 +1126,14 @@ class NotificationLogReader:
                 section_id = section.next_id
 
     def select(
-        self, *, start: int, stop: int | None = None, topics: Sequence[str] = ()
-    ) -> Iterator[List[Notification]]:
-        """
-        Returns a generator that yields lists of event notifications
+        self,
+        *,
+        start: int | None,
+        stop: int | None = None,
+        topics: Sequence[str] = (),
+        inclusive_of_start: bool = True,
+    ) -> Iterator[list[Notification]]:
+        """Returns a generator that yields lists of event notifications
         from the reader's notification log, starting from given start
         position (a notification ID).
 
@@ -1240,12 +1146,18 @@ class NotificationLogReader:
         """
         while True:
             notifications = self.notification_log.select(
-                start=start, stop=stop, limit=self.section_size, topics=topics
+                start=start,
+                stop=stop,
+                limit=self.section_size,
+                topics=topics,
+                inclusive_of_start=inclusive_of_start,
             )
             # Stop if zero notifications.
             if len(notifications) == 0:
                 break
 
             # Otherwise, yield and continue.
+            start = notifications[-1].id
+            if inclusive_of_start:
+                start += 1
             yield notifications
-            start = notifications[-1].id + 1