eventsourcing 9.4.0b1__py3-none-any.whl → 9.4.0b3__py3-none-any.whl

eventsourcing/popo.py

@@ -235,7 +235,7 @@ class POPOProcessRecorder(
         self, stored_events: list[StoredEvent], **kwargs: Any
     ) -> None:
         super()._assert_uniqueness(stored_events, **kwargs)
-        t: Tracking | None = kwargs.get("tracking", None)
+        t: Tracking | None = kwargs.get("tracking")
         if t:
             self._assert_tracking_uniqueness(t)
 
@@ -243,7 +243,7 @@ class POPOProcessRecorder(
         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)
+        t: Tracking | None = kwargs.get("tracking")
         if t:
             self._insert_tracking(t)
         return notification_ids

eventsourcing/postgres.py

@@ -75,7 +75,7 @@ class ConnectionPool(psycopg_pool.ConnectionPool[Any]):
 
 
 class PostgresDatastore:
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         dbname: str,
         host: str,
@@ -440,11 +440,9 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
         *,
         inclusive_of_start: bool = True,
     ) -> list[Notification]:
-        """
-        Returns a list of event notifications
+        """Returns a list of event notifications
         from 'start', limited by 'limit'.
         """
-
         params: list[int | str | Sequence[str]] = []
         statement = SQL("SELECT * FROM {0}.{1}").format(
             Identifier(self.datastore.schema),
@@ -501,9 +499,7 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
     def max_notification_id(self) -> int | None:
-        """
-        Returns the maximum notification ID.
-        """
+        """Returns the maximum notification ID."""
         with self.datastore.get_connection() as conn, conn.cursor() as curs:
             curs.execute(self.max_notification_id_statement)
             fetchone = curs.fetchone()
@@ -553,7 +549,7 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
                     notification_ids.append(row["notification_id"])
             if len(notification_ids) != len(stored_events):
                 msg = "Couldn't get all notification IDs "
-                msg += f"(got {len(notification_ids)}, expected {len(stored_events)}"
+                msg += f"(got {len(notification_ids)}, expected {len(stored_events)})"
                 raise ProgrammingError(msg)
         return notification_ids
 
@@ -730,7 +726,7 @@ class PostgresProcessRecorder(
         stored_events: list[StoredEvent],
         **kwargs: Any,
     ) -> None:
-        tracking: Tracking | None = kwargs.get("tracking", None)
+        tracking: Tracking | None = kwargs.get("tracking")
         if tracking is not None:
             self._insert_tracking(curs, tracking=tracking)
         super()._insert_events(curs, stored_events, **kwargs)
@@ -974,7 +970,8 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
                 tracking_recorder_class = resolve_topic(tracking_recorder_topic)
             else:
                 tracking_recorder_class = cast(
-                    type[TPostgresTrackingRecorder], type(self).tracking_recorder_class
+                    "type[TPostgresTrackingRecorder]",
+                    type(self).tracking_recorder_class,
                 )
         assert tracking_recorder_class is not None
         assert issubclass(tracking_recorder_class, PostgresTrackingRecorder)

eventsourcing/projection.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import os
 import weakref
 from abc import ABC, abstractmethod
@@ -22,12 +23,13 @@ from eventsourcing.persistence import (
 from eventsourcing.utils import Environment, EnvType
 
 if TYPE_CHECKING:
+    from types import TracebackType
+
     from typing_extensions import Self
 
 
 class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
-    """
-    An iterator that yields all domain events recorded in an application
+    """An iterator that yields all domain events recorded in an application
     sequence that have notification IDs greater than a given value. The iterator
     will block when all recorded domain events have been yielded, and then
     continue when new events are recorded. Domain events are returned along
@@ -49,30 +51,23 @@ class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
         self.subscription = self.recorder.subscribe(gt=gt, topics=topics)
 
     def stop(self) -> None:
-        """
-        Stops the stored event subscription.
-        """
+        """Stops the stored event subscription."""
         self.subscription.stop()
 
     def __enter__(self) -> Self:
-        """
-        Calls __enter__ on the stored event subscription.
-        """
+        """Calls __enter__ on the stored event subscription."""
         self.subscription.__enter__()
         return self
 
     def __exit__(self, *args: object, **kwargs: Any) -> None:
-        """
-        Calls __exit__ on the stored event subscription.
-        """
+        """Calls __exit__ on the stored event subscription."""
         self.subscription.__exit__(*args, **kwargs)
 
     def __iter__(self) -> Self:
         return self
 
     def __next__(self) -> tuple[DomainEventProtocol, Tracking]:
-        """
-        Returns the next stored event from the stored event subscription.
+        """Returns the next stored event from the stored event subscription.
         Constructs a tracking object that identifies the position of
         the event in the application sequence, and reconstructs a domain
         event object from the stored event object.
@@ -83,9 +78,7 @@ class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
         return domain_event, tracking
 
     def __del__(self) -> None:
-        """
-        Stops the stored event subscription.
-        """
+        """Stops the stored event subscription."""
         self.stop()
 
 
@@ -117,9 +110,7 @@ class Projection(ABC, Generic[TTrackingRecorder]):
     def process_event(
         self, domain_event: DomainEventProtocol, tracking: Tracking
     ) -> None:
-        """
-        Process a domain event and track it.
-        """
+        """Process a domain event and track it."""
 
 
 TApplication = TypeVar("TApplication", bound=Application)
@@ -134,8 +125,7 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         view_class: type[TTrackingRecorder],
         env: EnvType | None = None,
     ):
-        """
-        Constructs application from given application class with given environment.
+        """Constructs application from given application class with given environment.
         Also constructs a materialised view from given class using an infrastructure
         factory constructed with an environment named after the projection. Also
         constructs a projection with the constructed materialised view object.
@@ -143,7 +133,8 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         thread, calls projection's process_event() method for each event and tracking
         object pair received from the subscription.
         """
-        self._is_stopping = Event()
+        self._is_interrupted = Event()
+        self._has_called_stop = False
 
         self.app: TApplication = application_class(env)
 
@@ -165,22 +156,32 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
             gt=self.view.max_tracking_id(self.app.name),
             topics=self.projection.topics,
         )
-        self.thread_error: BaseException | None = None
-        self.processing_thread = Thread(
+        self._thread_error: BaseException | None = None
+        self._stop_thread = Thread(
+            target=self._stop_subscription_when_stopping,
+            kwargs={
+                "subscription": self.subscription,
+                "is_stopping": self._is_interrupted,
+            },
+        )
+        self._stop_thread.start()
+        self._processing_thread = Thread(
             target=self._process_events_loop,
             kwargs={
                 "subscription": self.subscription,
                 "projection": self.projection,
-                "is_stopping": self._is_stopping,
+                "is_stopping": self._is_interrupted,
                 "runner": weakref.ref(self),
             },
         )
-        self.processing_thread.start()
+        self._processing_thread.start()
+
+    @property
+    def is_interrupted(self) -> Event:
+        return self._is_interrupted
 
     def _construct_env(self, name: str, env: EnvType | None = None) -> Environment:
-        """
-        Constructs environment from which projection will be configured.
-        """
+        """Constructs environment from which projection will be configured."""
         _env: dict[str, str] = {}
         _env.update(os.environ)
         if env is not None:
@@ -188,11 +189,23 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         return Environment(name, _env)
 
     def stop(self) -> None:
+        """Sets the "interrupted" event."""
+        self._has_called_stop = True
+        self._is_interrupted.set()
+
+    @staticmethod
+    def _stop_subscription_when_stopping(
+        subscription: ApplicationSubscription,
+        is_stopping: Event,
+    ) -> None:
+        """Stops the application subscription, which
+        will stop the event-processing thread.
         """
-        Stops the application subscription, which will stop the event-processing thread.
-        """
-        self._is_stopping.set()
-        self.subscription.stop()
+        try:
+            is_stopping.wait()
+        finally:
+            is_stopping.set()
+            subscription.stop()
 
     @staticmethod
     def _process_events_loop(
@@ -208,7 +221,7 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         except BaseException as e:
             _runner = runner()  # get reference from weakref
             if _runner is not None:
-                _runner.thread_error = e
+                _runner._thread_error = e  # noqa: SLF001
             else:
                 msg = "ProjectionRunner was deleted before error could be assigned:\n"
                 msg += format_exc()
@@ -217,21 +230,23 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
                     RuntimeWarning,
                     stacklevel=2,
                 )
-
+        finally:
             is_stopping.set()
-            subscription.stop()
 
     def run_forever(self, timeout: float | None = None) -> None:
-        """
-        Blocks until timeout, or until the runner is stopped or errors. Re-raises
+        """Blocks until timeout, or until the runner is stopped or errors. Re-raises
         any error otherwise exits normally
         """
-        if self._is_stopping.wait(timeout=timeout) and self.thread_error is not None:
-            raise self.thread_error
+        if (
+            self._is_interrupted.wait(timeout=timeout)
+            and self._thread_error is not None
+        ):
+            error = self._thread_error
+            self._thread_error = None
+            raise error
 
     def wait(self, notification_id: int | None, timeout: float = 1.0) -> None:
-        """
-        Blocks until timeout, or until the materialised view has recorded a tracking
+        """Blocks until timeout, or until the materialised view has recorded a tracking
         object that is greater than or equal to the given notification ID.
         """
         try:
@@ -239,24 +254,36 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
                 application_name=self.subscription.name,
                 notification_id=notification_id,
                 timeout=timeout,
-                interrupt=self._is_stopping,
+                interrupt=self._is_interrupted,
             )
         except WaitInterruptedError:
-            if self.thread_error is not None:
-                raise self.thread_error from None
+            if self._thread_error:
+                error = self._thread_error
+                self._thread_error = None
+                raise error from None
+            if self._has_called_stop:
+                return
+            raise
 
     def __enter__(self) -> Self:
         return self
 
-    def __exit__(self, *args: object, **kwargs: Any) -> None:
-        """
-        Calls stop() and waits for the event-processing thread to exit.
-        """
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Calls stop() and waits for the event-processing thread to exit."""
         self.stop()
-        self.processing_thread.join()
+        self._stop_thread.join()
+        self._processing_thread.join()
+        if self._thread_error:
+            error = self._thread_error
+            self._thread_error = None
+            raise error
 
     def __del__(self) -> None:
-        """
-        Calls stop().
-        """
-        self.stop()
+        """Calls stop()."""
+        with contextlib.suppress(AttributeError):
+            self.stop()

eventsourcing/sqlite.py

@@ -412,8 +412,7 @@ class SQLiteApplicationRecorder(
         *,
         inclusive_of_start: bool = True,
     ) -> list[Notification]:
-        """
-        Returns a list of event notifications
+        """Returns a list of event notifications
         from 'start', limited by 'limit'.
         """
         params: list[int | str] = []
@@ -443,7 +442,7 @@ class SQLiteApplicationRecorder(
             else:
                 statement += "AND "
             params += list(topics)
-            statement += "topic IN (%s) " % ",".join("?" * len(topics))
+            statement += f"topic IN ({','.join('?' * len(topics))}) "
 
         params.append(limit)
         statement += "ORDER BY rowid LIMIT ?"
@@ -462,9 +461,7 @@ class SQLiteApplicationRecorder(
             ]
 
     def max_notification_id(self) -> int:
-        """
-        Returns the maximum notification ID.
-        """
+        """Returns the maximum notification ID."""
         with self.datastore.transaction(commit=False) as c:
             return self._max_notification_id(c)
 
@@ -561,7 +558,7 @@ class SQLiteProcessRecorder(
         **kwargs: Any,
     ) -> Sequence[int] | None:
         returning = super()._insert_events(c, stored_events, **kwargs)
-        tracking: Tracking | None = kwargs.get("tracking", None)
+        tracking: Tracking | None = kwargs.get("tracking")
         if tracking is not None:
             self._insert_tracking(c, tracking)
         return returning