eventsourcing 9.4.0a3__tar.gz → 9.4.0a5__tar.gz

{eventsourcing-9.4.0a3 → eventsourcing-9.4.0a5}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: eventsourcing
-Version: 9.4.0a3
+Version: 9.4.0a5
 Summary: Event sourcing in Python
-Home-page: https://github.com/pyeventsourcing/eventsourcing
 License: BSD 3-Clause
 Keywords: event sourcing,event store,domain driven design,domain-driven design,ddd,cqrs,cqs
 Author: John Bywater
@@ -32,6 +31,7 @@ Requires-Dist: cryptography (>=44.0,<44.1) ; extra == "cryptography"
 Requires-Dist: psycopg[pool] (<=3.2.99999) ; extra == "postgres"
 Requires-Dist: pycryptodome (>=3.22,<3.23) ; extra == "crypto"
 Requires-Dist: typing_extensions
+Project-URL: Homepage, https://github.com/pyeventsourcing/eventsourcing
 Project-URL: Repository, https://github.com/pyeventsourcing/eventsourcing
 Description-Content-Type: text/markdown
 

{eventsourcing-9.4.0a3 → eventsourcing-9.4.0a5}/eventsourcing/persistence.py

@@ -486,7 +486,9 @@ class ApplicationRecorder(AggregateRecorder):
         """
 
     @abstractmethod
-    def subscribe(self, gt: int | None = None) -> Subscription[ApplicationRecorder]:
+    def subscribe(
+        self, gt: int | None = None, topics: Sequence[str] = ()
+    ) -> Subscription[ApplicationRecorder]:
         """
         Returns an iterator of Notification objects representing events from an
         application sequence.
@@ -1311,10 +1313,14 @@ TApplicationRecorder_co = TypeVar(
 
 class Subscription(Iterator[Notification], Generic[TApplicationRecorder_co]):
     def __init__(
-        self, recorder: TApplicationRecorder_co, gt: int | None = None
+        self,
+        recorder: TApplicationRecorder_co,
+        gt: int | None = None,
+        topics: Sequence[str] = (),
     ) -> None:
         self._recorder = recorder
         self._last_notification_id = gt
+        self._topics = topics
         self._has_been_entered = False
         self._has_been_stopped = False
 
@@ -1349,9 +1355,12 @@ class Subscription(Iterator[Notification], Generic[TApplicationRecorder_co]):
 
 class ListenNotifySubscription(Subscription[TApplicationRecorder_co]):
     def __init__(
-        self, recorder: TApplicationRecorder_co, gt: int | None = None
+        self,
+        recorder: TApplicationRecorder_co,
+        gt: int | None = None,
+        topics: Sequence[str] = (),
     ) -> None:
-        super().__init__(recorder=recorder, gt=gt)
+        super().__init__(recorder=recorder, gt=gt, topics=topics)
         self._select_limit = 500
         self._notifications: List[Notification] = []
         self._notifications_index: int = 0
@@ -1410,6 +1419,7 @@ class ListenNotifySubscription(Subscription[TApplicationRecorder_co]):
             notifications = self._recorder.select_notifications(
                 start=self._last_notification_id or 0,
                 limit=self._select_limit,
+                topics=self._topics,
                 inclusive_of_start=False,
             )
             if len(notifications) > 0:

{eventsourcing-9.4.0a3 → eventsourcing-9.4.0a5}/eventsourcing/popo.py

@@ -14,6 +14,7 @@ from eventsourcing.persistence import (
     Notification,
     ProcessRecorder,
     StoredEvent,
+    Subscription,
     Tracking,
     TrackingRecorder,
 )
@@ -155,8 +156,10 @@ class POPOApplicationRecorder(POPOAggregateRecorder, ApplicationRecorder):
         with self._database_lock:
             return len(self._stored_events) or None
 
-    def subscribe(self, gt: int | None = None) -> POPOSubscription:
-        return POPOSubscription(self, gt)
+    def subscribe(
+        self, gt: int | None = None, topics: Sequence[str] = ()
+    ) -> Subscription[ApplicationRecorder]:
+        return POPOSubscription(recorder=self, gt=gt, topics=topics)
 
     def listen(self, event: Event) -> None:
         self._listeners.add(event)
@@ -172,10 +175,13 @@ class POPOApplicationRecorder(POPOAggregateRecorder, ApplicationRecorder):
 
 class POPOSubscription(ListenNotifySubscription[POPOApplicationRecorder]):
     def __init__(
-        self, recorder: POPOApplicationRecorder, gt: int | None = None
+        self,
+        recorder: POPOApplicationRecorder,
+        gt: int | None = None,
+        topics: Sequence[str] = (),
     ) -> None:
         assert isinstance(recorder, POPOApplicationRecorder)
-        super().__init__(recorder=recorder, gt=gt)
+        super().__init__(recorder=recorder, gt=gt, topics=topics)
         self._recorder.listen(self._has_been_notified)
 
     def stop(self) -> None:

{eventsourcing-9.4.0a3 → eventsourcing-9.4.0a5}/eventsourcing/postgres.py

@@ -30,6 +30,7 @@ from eventsourcing.persistence import (
     ProcessRecorder,
     ProgrammingError,
     StoredEvent,
+    Subscription,
     Tracking,
     TrackingRecorder,
 )
@@ -524,16 +525,21 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
                 raise ProgrammingError(msg)
         return notification_ids
 
-    def subscribe(self, gt: int | None = None) -> PostgresSubscription:
-        return PostgresSubscription(self, gt)
+    def subscribe(
+        self, gt: int | None = None, topics: Sequence[str] = ()
+    ) -> Subscription[ApplicationRecorder]:
+        return PostgresSubscription(recorder=self, gt=gt, topics=topics)
 
 
 class PostgresSubscription(ListenNotifySubscription[PostgresApplicationRecorder]):
     def __init__(
-        self, recorder: PostgresApplicationRecorder, gt: int | None = None
+        self,
+        recorder: PostgresApplicationRecorder,
+        gt: int | None = None,
+        topics: Sequence[str] = (),
     ) -> None:
         assert isinstance(recorder, PostgresApplicationRecorder)
-        super().__init__(recorder=recorder, gt=gt)
+        super().__init__(recorder=recorder, gt=gt, topics=topics)
         self._listen_thread = Thread(target=self._listen)
         self._listen_thread.start()
 

{eventsourcing-9.4.0a3 → eventsourcing-9.4.0a5}/eventsourcing/projection.py

@@ -5,7 +5,17 @@ import weakref
 from abc import ABC, abstractmethod
 from threading import Event, Thread
 from traceback import format_exc
-from typing import TYPE_CHECKING, Any, Dict, Generic, Iterator, Tuple, Type, TypeVar
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Generic,
+    Iterator,
+    Sequence,
+    Tuple,
+    Type,
+    TypeVar,
+)
 from warnings import warn
 
 from eventsourcing.application import Application
@@ -37,11 +47,12 @@ class ApplicationSubscription(Iterator[Tuple[DomainEventProtocol, Tracking]]):
         self,
         app: Application,
         gt: int | None = None,
+        topics: Sequence[str] = (),
     ):
         self.name = app.name
         self.recorder = app.recorder
         self.mapper = app.mapper
-        self.subscription = self.recorder.subscribe(gt=gt)
+        self.subscription = self.recorder.subscribe(gt=gt, topics=topics)
 
     def __enter__(self) -> Self:
         self.subscription.__enter__()
@@ -68,6 +79,9 @@ class ApplicationSubscription(Iterator[Tuple[DomainEventProtocol, Tracking]]):
 
 class Projection(ABC, Generic[TTrackingRecorder]):
     name: str = ""
+    """Name of projection, used to pick prefixed environment variables."""
+    topics: Sequence[str] = ()
+    """Event topics, used to filter events in database."""
 
     def __init__(
         self,
@@ -112,21 +126,22 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
             self.projection_factory.tracking_recorder(tracking_recorder_class)
         )
 
+        self.projection = projection_class(
+            tracking_recorder=self.tracking_recorder,
+        )
         self.subscription = ApplicationSubscription(
             app=self.app,
             gt=self.tracking_recorder.max_tracking_id(self.app.name),
+            topics=self.projection.topics,
         )
-        self.projection = projection_class(
-            tracking_recorder=self.tracking_recorder,
-        )
-        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),
             },
         )
@@ -143,13 +158,14 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         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:
@@ -169,12 +185,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:
@@ -183,11 +198,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

{eventsourcing-9.4.0a3 → eventsourcing-9.4.0a5}/eventsourcing/sqlite.py

@@ -471,7 +471,9 @@ class SQLiteApplicationRecorder(
         c.execute(self.select_max_notification_id_statement)
         return c.fetchone()[0]
 
-    def subscribe(self, gt: int | None = None) -> Subscription[ApplicationRecorder]:
+    def subscribe(
+        self, gt: int | None = None, topics: Sequence[str] = ()
+    ) -> Subscription[ApplicationRecorder]:
         msg = f"The {type(self).__qualname__} recorder does not support subscriptions"
         raise NotImplementedError(msg)
 

{eventsourcing-9.4.0a3 → eventsourcing-9.4.0a5}/eventsourcing/tests/persistence.py

@@ -734,6 +734,18 @@ class ApplicationRecorderTestCase(TestCase, ABC):
                 # Shouldn't get here...
                 self.fail("Got here")
 
+        # Start a subscription with topics.
+        subscription = recorder.subscribe(gt=None, topics=["topic3"])
+        with subscription:
+            for notification in subscription:
+                self.assertEqual(notification.topic, "topic3")
+                if (
+                    notification.originator_id == stored_event3.originator_id
+                    and notification.originator_version
+                    == stored_event3.originator_version
+                ):
+                    break
+
     def close_db_connection(self, *args: Any) -> None:
         """"""
 

{eventsourcing-9.4.0a3 → eventsourcing-9.4.0a5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "eventsourcing"
-version = "9.4.0a3"
+version = "9.4.0a5"
 
 description = "Event sourcing in Python"
 authors = [