eventsourcing 9.4.0a4__py3-none-any.whl → 9.4.0a6__py3-none-any.whl

eventsourcing/persistence.py

@@ -4,27 +4,15 @@ import json
 import uuid
 from abc import ABC, abstractmethod
 from collections import deque
+from collections.abc import Iterator, Mapping, Sequence
 from dataclasses import dataclass
 from datetime import datetime
 from decimal import Decimal
 from queue import Queue
 from threading import Condition, Event, Lock, Semaphore, Thread, Timer
 from time import monotonic, sleep, time
-from types import ModuleType
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    Generic,
-    Iterator,
-    List,
-    Mapping,
-    Sequence,
-    Type,
-    TypeVar,
-    Union,
-    cast,
-)
+from types import GenericAlias, ModuleType
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, Union, cast
 from uuid import UUID
 from warnings import warn
 
@@ -78,8 +66,8 @@ class JSONTranscoder(Transcoder):
     """
 
     def __init__(self) -> None:
-        self.types: Dict[type, Transcoding] = {}
-        self.names: Dict[str, Transcoding] = {}
+        self.types: dict[type, Transcoding] = {}
+        self.names: dict[str, Transcoding] = {}
         self.encoder = json.JSONEncoder(
             default=self._encode_obj,
             separators=(",", ":"),
@@ -106,7 +94,7 @@ class JSONTranscoder(Transcoder):
         """
         return self.decoder.decode(data.decode("utf8"))
 
-    def _encode_obj(self, o: Any) -> Dict[str, Any]:
+    def _encode_obj(self, o: Any) -> dict[str, Any]:
         try:
             transcoding = self.types[type(o)]
         except KeyError:
@@ -122,7 +110,7 @@ class JSONTranscoder(Transcoder):
                 "_data_": transcoding.encode(o),
             }
 
-    def _decode_obj(self, d: Dict[str, Any]) -> Any:
+    def _decode_obj(self, d: dict[str, Any]) -> Any:
         if len(d) == 2:
             try:
                 _type_ = d["_type_"]
@@ -314,7 +302,7 @@ class Mapper:
             stored_state = self.cipher.decrypt(stored_state)
         if self.compressor:
             stored_state = self.compressor.decompress(stored_state)
-        event_state: Dict[str, Any] = self.transcoder.decode(stored_state)
+        event_state: dict[str, Any] = self.transcoder.decode(stored_state)
         event_state["originator_id"] = stored_event.originator_id
         event_state["originator_version"] = stored_event.originator_version
         cls = resolve_topic(stored_event.topic)
@@ -422,7 +410,7 @@ class AggregateRecorder(ABC):
 
     @abstractmethod
     def insert_events(
-        self, stored_events: List[StoredEvent], **kwargs: Any
+        self, stored_events: list[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         """
         Writes stored events into database.
@@ -437,7 +425,7 @@ class AggregateRecorder(ABC):
         lte: int | None = None,
         desc: bool = False,
         limit: int | None = None,
-    ) -> List[StoredEvent]:
+    ) -> list[StoredEvent]:
         """
         Reads stored events from database.
         """
@@ -468,7 +456,7 @@ class ApplicationRecorder(AggregateRecorder):
         topics: Sequence[str] = (),
         *,
         inclusive_of_start: bool = True,
-    ) -> List[Notification]:
+    ) -> list[Notification]:
         """
         Returns a list of Notification objects representing events from an
         application sequence. If `inclusive_of_start` is True (the default),
@@ -598,7 +586,7 @@ class EventStore:
 
     def put(
         self, domain_events: Sequence[DomainEventProtocol], **kwargs: Any
-    ) -> List[Recording]:
+    ) -> list[Recording]:
         """
         Stores domain events in aggregate sequence.
         """
@@ -670,14 +658,14 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
 
     @classmethod
     def construct(
-        cls: Type[TInfrastructureFactory], env: Environment | None = None
+        cls: type[TInfrastructureFactory], env: Environment | None = None
     ) -> TInfrastructureFactory:
         """
         Constructs concrete infrastructure factory for given
         named application. Reads and resolves persistence
         topic from environment variable 'PERSISTENCE_MODULE'.
         """
-        factory_cls: Type[InfrastructureFactory[TrackingRecorder]]
+        factory_cls: type[InfrastructureFactory[TrackingRecorder]]
         if env is None:
             env = Environment()
         topic = (
@@ -696,7 +684,7 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
             or "eventsourcing.popo"
         )
         try:
-            obj: Type[InfrastructureFactory[TrackingRecorder]] | ModuleType = (
+            obj: type[InfrastructureFactory[TrackingRecorder]] | ModuleType = (
                 resolve_topic(topic)
             )
         except TopicError as e:
@@ -709,15 +697,20 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
 
         if isinstance(obj, ModuleType):
             # Find the factory in the module.
-            factory_classes: List[Type[InfrastructureFactory[TrackingRecorder]]] = []
+            factory_classes: list[type[InfrastructureFactory[TrackingRecorder]]] = []
             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)
+
             if len(factory_classes) == 1:
                 factory_cls = factory_classes[0]
             else:
@@ -747,7 +740,7 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
         """
         transcoder_topic = self.env.get(self.TRANSCODER_TOPIC)
         if transcoder_topic:
-            transcoder_class: Type[Transcoder] = resolve_topic(transcoder_topic)
+            transcoder_class: type[Transcoder] = resolve_topic(transcoder_topic)
         else:
             transcoder_class = JSONTranscoder
         return transcoder_class()
@@ -755,7 +748,7 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
     def mapper(
         self,
         transcoder: Transcoder | None = None,
-        mapper_class: Type[Mapper] | None = None,
+        mapper_class: type[Mapper] | None = None,
     ) -> Mapper:
         """
         Constructs a mapper.
@@ -783,7 +776,7 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
             cipher_topic = default_cipher_topic
 
         if cipher_topic:
-            cipher_cls: Type[Cipher] = resolve_topic(cipher_topic)
+            cipher_cls: type[Cipher] = resolve_topic(cipher_topic)
             cipher = cipher_cls(self.env)
 
         return cipher
@@ -796,7 +789,7 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
         compressor: Compressor | None = None
         compressor_topic = self.env.get(self.COMPRESSOR_TOPIC)
         if compressor_topic:
-            compressor_cls: Type[Compressor] | Compressor = resolve_topic(
+            compressor_cls: type[Compressor] | Compressor = resolve_topic(
                 compressor_topic
             )
             if isinstance(compressor_cls, type):
@@ -832,7 +825,7 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
 
     @abstractmethod
     def tracking_recorder(
-        self, tracking_recorder_class: Type[TTrackingRecorder] | None = None
+        self, tracking_recorder_class: type[TTrackingRecorder] | None = None
     ) -> TTrackingRecorder:
         """
         Constructs a tracking recorder.
@@ -1013,7 +1006,7 @@ class ConnectionPool(ABC, Generic[TConnection]):
         self.max_age = max_age
         self.pre_ping = pre_ping
         self._pool: deque[TConnection] = deque()
-        self._in_use: Dict[int, TConnection] = {}
+        self._in_use: dict[int, TConnection] = {}
         self._get_semaphore = Semaphore()
         self._put_condition = Condition()
         self._no_readers = Condition()
@@ -1362,9 +1355,9 @@ class ListenNotifySubscription(Subscription[TApplicationRecorder_co]):
     ) -> None:
         super().__init__(recorder=recorder, gt=gt, topics=topics)
         self._select_limit = 500
-        self._notifications: List[Notification] = []
+        self._notifications: list[Notification] = []
         self._notifications_index: int = 0
-        self._notifications_queue: Queue[List[Notification]] = Queue(maxsize=10)
+        self._notifications_queue: Queue[list[Notification]] = Queue(maxsize=10)
         self._has_been_notified = Event()
         self._thread_error: BaseException | None = None
         self._pull_thread = Thread(target=self._loop_on_pull)

eventsourcing/popo.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import contextlib
 from collections import defaultdict
 from threading import Event, Lock
-from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Sequence, Set, Type
+from typing import TYPE_CHECKING, Any
 
 from eventsourcing.persistence import (
     AggregateRecorder,
@@ -21,6 +21,7 @@ from eventsourcing.persistence import (
 from eventsourcing.utils import resolve_topic, reversed_keys
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable, Sequence
     from uuid import UUID
 
 
@@ -32,23 +33,23 @@ class POPORecorder:
 class POPOAggregateRecorder(POPORecorder, AggregateRecorder):
     def __init__(self) -> None:
         super().__init__()
-        self._stored_events: List[StoredEvent] = []
-        self._stored_events_index: Dict[UUID, Dict[int, int]] = defaultdict(dict)
+        self._stored_events: list[StoredEvent] = []
+        self._stored_events_index: dict[UUID, dict[int, int]] = defaultdict(dict)
 
     def insert_events(
-        self, stored_events: List[StoredEvent], **kwargs: Any
+        self, stored_events: list[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         self._insert_events(stored_events, **kwargs)
         return None
 
     def _insert_events(
-        self, stored_events: List[StoredEvent], **kwargs: Any
+        self, stored_events: list[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         with self._database_lock:
             self._assert_uniqueness(stored_events, **kwargs)
             return self._update_table(stored_events, **kwargs)
 
-    def _assert_uniqueness(self, stored_events: List[StoredEvent], **_: Any) -> None:
+    def _assert_uniqueness(self, stored_events: list[StoredEvent], **_: Any) -> None:
         new = set()
         for s in stored_events:
             # Check events don't already exist.
@@ -62,7 +63,7 @@ class POPOAggregateRecorder(POPORecorder, AggregateRecorder):
             raise IntegrityError(msg)
 
     def _update_table(
-        self, stored_events: List[StoredEvent], **_: Any
+        self, stored_events: list[StoredEvent], **_: Any
     ) -> Sequence[int] | None:
         notification_ids = []
         for s in stored_events:
@@ -81,7 +82,7 @@ class POPOAggregateRecorder(POPORecorder, AggregateRecorder):
         lte: int | None = None,
         desc: bool = False,
         limit: int | None = None,
-    ) -> List[StoredEvent]:
+    ) -> list[StoredEvent]:
         with self._database_lock:
             results = []
 
@@ -103,10 +104,10 @@ class POPOAggregateRecorder(POPORecorder, AggregateRecorder):
 class POPOApplicationRecorder(POPOAggregateRecorder, ApplicationRecorder):
     def __init__(self) -> None:
         super().__init__()
-        self._listeners: Set[Event] = set()
+        self._listeners: set[Event] = set()
 
     def insert_events(
-        self, stored_events: List[StoredEvent], **kwargs: Any
+        self, stored_events: list[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         notification_ids = self._insert_events(stored_events, **kwargs)
         self._notify_listeners()
@@ -120,7 +121,7 @@ class POPOApplicationRecorder(POPOAggregateRecorder, ApplicationRecorder):
         topics: Sequence[str] = (),
         *,
         inclusive_of_start: bool = True,
-    ) -> List[Notification]:
+    ) -> list[Notification]:
         with self._database_lock:
             results = []
             if start is None:
@@ -192,8 +193,8 @@ class POPOSubscription(ListenNotifySubscription[POPOApplicationRecorder]):
 class POPOTrackingRecorder(POPORecorder, TrackingRecorder):
     def __init__(self) -> None:
         super().__init__()
-        self._tracking_table: Dict[str, set[int]] = defaultdict(set)
-        self._max_tracking_ids: Dict[str, int | None] = defaultdict(lambda: None)
+        self._tracking_table: dict[str, set[int]] = defaultdict(set)
+        self._max_tracking_ids: dict[str, int | None] = defaultdict(lambda: None)
 
     def _assert_tracking_uniqueness(self, tracking: Tracking) -> None:
         if tracking.notification_id in self._tracking_table[tracking.application_name]:
@@ -227,7 +228,7 @@ class POPOProcessRecorder(
     POPOTrackingRecorder, POPOApplicationRecorder, ProcessRecorder
 ):
     def _assert_uniqueness(
-        self, stored_events: List[StoredEvent], **kwargs: Any
+        self, stored_events: list[StoredEvent], **kwargs: Any
     ) -> None:
         super()._assert_uniqueness(stored_events, **kwargs)
         t: Tracking | None = kwargs.get("tracking", None)
@@ -235,7 +236,7 @@ class POPOProcessRecorder(
             self._assert_tracking_uniqueness(t)
 
     def _update_table(
-        self, stored_events: List[StoredEvent], **kwargs: Any
+        self, stored_events: list[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         notification_ids = super()._update_table(stored_events, **kwargs)
         t: Tracking | None = kwargs.get("tracking", None)
@@ -252,7 +253,7 @@ class POPOFactory(InfrastructureFactory[POPOTrackingRecorder]):
         return POPOApplicationRecorder()
 
     def tracking_recorder(
-        self, tracking_recorder_class: Type[POPOTrackingRecorder] | None = None
+        self, tracking_recorder_class: type[POPOTrackingRecorder] | None = None
     ) -> POPOTrackingRecorder:
         if tracking_recorder_class is None:
             tracking_recorder_topic = self.env.get(self.TRACKING_RECORDER_TOPIC)

eventsourcing/postgres.py

@@ -4,7 +4,7 @@ import logging
 from asyncio import CancelledError
 from contextlib import contextmanager
 from threading import Thread
-from typing import TYPE_CHECKING, Any, Callable, Iterator, List, Sequence, Type
+from typing import TYPE_CHECKING, Any, Callable
 
 import psycopg
 import psycopg.errors
@@ -37,6 +37,7 @@ from eventsourcing.persistence import (
 from eventsourcing.utils import Environment, resolve_topic, retry, strtobool
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
     from uuid import UUID
 
     from typing_extensions import Self
@@ -190,7 +191,7 @@ class PostgresRecorder:
         self.datastore = datastore
         self.create_table_statements = self.construct_create_table_statements()
 
-    def construct_create_table_statements(self) -> List[str]:
+    def construct_create_table_statements(self) -> list[str]:
         return []
 
     @staticmethod
@@ -247,11 +248,11 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
         self.select_events_statement = (
             f"SELECT * FROM {self.events_table_name} WHERE originator_id = %s"
         )
-        self.lock_table_statements: List[str] = []
+        self.lock_table_statements: list[str] = []
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
     def insert_events(
-        self, stored_events: List[StoredEvent], **kwargs: Any
+        self, stored_events: list[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         conn: Connection[DictRow]
         exc: Exception | None = None
@@ -283,7 +284,7 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
     def _insert_events(
         self,
         c: Cursor[DictRow],
-        stored_events: List[StoredEvent],
+        stored_events: list[StoredEvent],
         **_: Any,
     ) -> None:
         pass
@@ -291,7 +292,7 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
     def _insert_stored_events(
         self,
         c: Cursor[DictRow],
-        stored_events: List[StoredEvent],
+        stored_events: list[StoredEvent],
         **_: Any,
     ) -> None:
         # Only do something if there is something to do.
@@ -324,7 +325,7 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
     def _fetch_ids_after_insert_events(
         self,
         c: Cursor[DictRow],
-        stored_events: List[StoredEvent],
+        stored_events: list[StoredEvent],
         **kwargs: Any,
     ) -> Sequence[int] | None:
         return None
@@ -338,9 +339,9 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
         lte: int | None = None,
         desc: bool = False,
         limit: int | None = None,
-    ) -> List[StoredEvent]:
+    ) -> list[StoredEvent]:
         statement = self.select_events_statement
-        params: List[Any] = [originator_id]
+        params: list[Any] = [originator_id]
         if gt is not None:
             params.append(gt)
             statement += " AND originator_version > %s"
@@ -413,13 +414,13 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
         topics: Sequence[str] = (),
         *,
         inclusive_of_start: bool = True,
-    ) -> List[Notification]:
+    ) -> list[Notification]:
         """
         Returns a list of event notifications
         from 'start', limited by 'limit'.
         """
 
-        params: List[int | str | Sequence[str]] = []
+        params: list[int | str | Sequence[str]] = []
         statement = f"SELECT * FROM {self.events_table_name}"
         has_where = False
         if start is not None:
@@ -508,10 +509,10 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
     def _fetch_ids_after_insert_events(
         self,
         c: Cursor[DictRow],
-        stored_events: List[StoredEvent],
+        stored_events: list[StoredEvent],
         **kwargs: Any,
     ) -> Sequence[int] | None:
-        notification_ids: List[int] = []
+        notification_ids: list[int] = []
         len_events = len(stored_events)
         if len_events:
             while c.nextset() and len(notification_ids) != len_events:
@@ -667,7 +668,7 @@ class PostgresProcessRecorder(
     def _insert_events(
         self,
         c: Cursor[DictRow],
-        stored_events: List[StoredEvent],
+        stored_events: list[StoredEvent],
         **kwargs: Any,
     ) -> None:
         tracking: Tracking | None = kwargs.get("tracking", None)
@@ -893,7 +894,7 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
 
         application_recorder_topic = self.env.get(self.APPLICATION_RECORDER_TOPIC)
         if application_recorder_topic:
-            application_recorder_class: Type[PostgresApplicationRecorder] = (
+            application_recorder_class: type[PostgresApplicationRecorder] = (
                 resolve_topic(application_recorder_topic)
             )
             assert issubclass(application_recorder_class, PostgresApplicationRecorder)
@@ -909,7 +910,7 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
         return recorder
 
     def tracking_recorder(
-        self, tracking_recorder_class: Type[PostgresTrackingRecorder] | None = None
+        self, tracking_recorder_class: type[PostgresTrackingRecorder] | None = None
     ) -> PostgresTrackingRecorder:
         prefix = self.env.name.lower() or "notification"
         tracking_table_name = prefix + "_tracking"
@@ -942,7 +943,7 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
 
         process_recorder_topic = self.env.get(self.PROCESS_RECORDER_TOPIC)
         if process_recorder_topic:
-            process_recorder_class: Type[PostgresTrackingRecorder] = resolve_topic(
+            process_recorder_class: type[PostgresTrackingRecorder] = resolve_topic(
                 process_recorder_topic
             )
             assert issubclass(process_recorder_class, PostgresProcessRecorder)

eventsourcing/projection.py

@@ -3,19 +3,10 @@ from __future__ import annotations
 import os
 import weakref
 from abc import ABC, abstractmethod
+from collections.abc import Iterator, Sequence
 from threading import Event, Thread
 from traceback import format_exc
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    Generic,
-    Iterator,
-    Sequence,
-    Tuple,
-    Type,
-    TypeVar,
-)
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
 from warnings import warn
 
 from eventsourcing.application import Application
@@ -34,7 +25,7 @@ if TYPE_CHECKING:
     from typing_extensions import Self
 
 
-class ApplicationSubscription(Iterator[Tuple[DomainEventProtocol, Tracking]]):
+class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
     """
     An iterator that yields all domain events recorded in an application
     sequence that have notification IDs greater than a given value. The iterator
@@ -64,7 +55,7 @@ class ApplicationSubscription(Iterator[Tuple[DomainEventProtocol, Tracking]]):
     def __iter__(self) -> Self:
         return self
 
-    def __next__(self) -> Tuple[DomainEventProtocol, Tracking]:
+    def __next__(self) -> tuple[DomainEventProtocol, Tracking]:
         notification = next(self.subscription)
         tracking = Tracking(self.name, notification.id)
         domain_event = self.mapper.to_domain_event(notification)
@@ -109,9 +100,9 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
     def __init__(
         self,
         *,
-        application_class: Type[TApplication],
-        projection_class: Type[Projection[TTrackingRecorder]],
-        tracking_recorder_class: Type[TTrackingRecorder] | None = None,
+        application_class: type[TApplication],
+        projection_class: type[Projection[TTrackingRecorder]],
+        tracking_recorder_class: type[TTrackingRecorder] | None = None,
         env: EnvType | None = None,
     ):
         self.app: TApplication = application_class(env)
@@ -134,14 +125,14 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
             gt=self.tracking_recorder.max_tracking_id(self.app.name),
             topics=self.projection.topics,
         )
-        self._has_error = Event()
+        self._is_stopping = Event()
         self.thread_error: BaseException | None = None
         self.processing_thread = Thread(
             target=self._process_events_loop,
             kwargs={
                 "subscription": self.subscription,
                 "projection": self.projection,
-                "has_error": self._has_error,
+                "is_stopping": self._is_stopping,
                 "runner": weakref.ref(self),
             },
         )
@@ -151,20 +142,21 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         """
         Constructs environment from which projection will be configured.
         """
-        _env: Dict[str, str] = {}
+        _env: dict[str, str] = {}
         _env.update(os.environ)
         if env is not None:
             _env.update(env)
         return Environment(name, _env)
 
     def stop(self) -> None:
+        self._is_stopping.set()
         self.subscription.stop()
 
     @staticmethod
     def _process_events_loop(
         subscription: ApplicationSubscription,
         projection: Projection[TrackingRecorder],
-        has_error: Event,
+        is_stopping: Event,
         runner: weakref.ReferenceType[ProjectionRunner[Application, TrackingRecorder]],
     ) -> None:
         try:
@@ -184,12 +176,11 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
                     stacklevel=2,
                 )
 
-            has_error.set()
+            is_stopping.set()
             subscription.subscription.stop()
 
     def run_forever(self, timeout: float | None = None) -> None:
-        if self._has_error.wait(timeout=timeout):
-            assert self.thread_error is not None  # for mypy
+        if self._is_stopping.wait(timeout=timeout) and self.thread_error is not None:
             raise self.thread_error
 
     def wait(self, notification_id: int, timeout: float = 1.0) -> None:
@@ -198,11 +189,11 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
                 application_name=self.subscription.name,
                 notification_id=notification_id,
                 timeout=timeout,
-                interrupt=self._has_error,
+                interrupt=self._is_stopping,
             )
         except WaitInterruptedError:
-            assert self.thread_error is not None  # for mypy
-            raise self.thread_error from None
+            if self.thread_error is not None:
+                raise self.thread_error from None
 
     def __enter__(self) -> Self:
         return self