eventsourcing 9.2.22__py3-none-any.whl → 9.3.0__py3-none-any.whl

eventsourcing/system.py

@@ -8,21 +8,22 @@ from queue import Full, Queue
 from threading import Event, Lock, RLock, Thread
 from types import FrameType, ModuleType
 from typing import (
+    Any,
+    ClassVar,
     Dict,
     Iterable,
     Iterator,
     List,
     Optional,
     Sequence,
-    Set,
     Tuple,
     Type,
     Union,
     cast,
 )
 
-# For backwards compatibility of import statements...
-from eventsourcing.application import ProcessEvent  # noqa: F401
+from typing_extensions import Self
+
 from eventsourcing.application import (
     Application,
     NotificationLog,
@@ -54,10 +55,10 @@ class Follower(Application):
     new domain event notifications through its :func:`policy` method.
     """
 
-    follow_topics: Sequence[str] = []
+    follow_topics: ClassVar[Sequence[str]] = []
     pull_section_size = 10
 
-    def __init__(self, env: Optional[EnvType] = None) -> None:
+    def __init__(self, env: EnvType | None = None) -> None:
         super().__init__(env)
         self.readers: Dict[str, NotificationLogReader] = {}
         self.mappers: Dict[str, Mapper] = {}
@@ -90,7 +91,7 @@ class Follower(Application):
 
     # @retry(IntegrityError, max_attempts=100)
     def pull_and_process(
-        self, leader_name: str, start: Optional[int] = None, stop: Optional[int] = None
+        self, leader_name: str, start: int | None = None, stop: int | None = None
     ) -> None:
         """
         Pull and process new domain event notifications.
@@ -107,7 +108,7 @@ class Follower(Application):
                 self.process_event(domain_event, tracking)
 
     def pull_notifications(
-        self, leader_name: str, start: int, stop: Optional[int] = None
+        self, leader_name: str, start: int, stop: int | None = None
     ) -> Iterator[List[Notification]]:
         """
         Pulls batches of unseen :class:`~eventsourcing.persistence.Notification`
@@ -122,8 +123,7 @@ class Follower(Application):
     ) -> List[Notification]:
         if self.follow_topics:
             return [n for n in notifications if n.topic in self.follow_topics]
-        else:
-            return notifications
+        return notifications
 
     def convert_notifications(
         self, leader_name: str, notifications: Iterable[Notification]
@@ -226,7 +226,7 @@ class Leader(Application):
     domain event notifications to be pulled and processed.
     """
 
-    def __init__(self, env: Optional[EnvType] = None) -> None:
+    def __init__(self, env: EnvType | None = None) -> None:
         super().__init__(env)
         self.followers: List[RecordingEventReceiver] = []
 
@@ -269,7 +269,7 @@ class System:
     Defines a system of applications.
     """
 
-    __caller_modules: Dict[int, ModuleType] = {}
+    __caller_modules: ClassVar[Dict[int, ModuleType]] = {}
 
     def __init__(
         self,
@@ -281,7 +281,7 @@ class System:
         type(self).__caller_modules[id(self)] = module
 
         # Build nodes and edges.
-        self.edges: List[Tuple[str, str]] = list()
+        self.edges: List[Tuple[str, str]] = []
         classes: Dict[str, Type[Application]] = {}
         for pipe in pipes:
             follower_cls = None
@@ -330,7 +330,7 @@ class System:
 
     @property
     def leaders_only(self) -> List[str]:
-        return [name for name in self.leads.keys() if name not in self.follows]
+        return [name for name in self.leads if name not in self.follows]
 
     @property
     def followers(self) -> List[str]:
@@ -338,7 +338,7 @@ class System:
 
     @property
     def processors(self) -> List[str]:
-        return [name for name in self.leads.keys() if name in self.follows]
+        return [name for name in self.leads if name in self.follows]
 
     def get_app_cls(self, name: str) -> Type[Application]:
         cls = resolve_topic(self.nodes[name])
@@ -349,14 +349,9 @@ class System:
         cls = self.get_app_cls(name)
         if issubclass(cls, Leader):
             return cls
-        else:
-            cls = type(
-                cls.name,
-                (Leader, cls),
-                {},
-            )
-            assert issubclass(cls, Leader)
-            return cls
+        cls = type(cls.name, (Leader, cls), {})
+        assert issubclass(cls, Leader)
+        return cls
 
     def follower_cls(self, name: str) -> Type[Follower]:
         cls = self.get_app_cls(name)
@@ -364,11 +359,11 @@ class System:
         return cls
 
     @property
-    def topic(self) -> Optional[str]:
+    def topic(self) -> str | None:
         """
         Returns a topic to the system object, if constructed as a module attribute.
         """
-        topic: Optional[str] = None
+        topic: str | None = None
         module = System.__caller_modules[id(self)]
         for name, value in module.__dict__.items():
             if value is self:
@@ -382,7 +377,7 @@ class Runner(ABC):
     Abstract base class for system runners.
     """
 
-    def __init__(self, system: System, env: Optional[EnvType] = None):
+    def __init__(self, system: System, env: EnvType | None = None):
         self.system = system
         self.env = env
         self.is_started = False
@@ -393,7 +388,7 @@ class Runner(ABC):
         Starts the runner.
         """
         if self.is_started:
-            raise RunnerAlreadyStarted()
+            raise RunnerAlreadyStartedError
         self.is_started = True
 
     @abstractmethod
@@ -409,7 +404,7 @@ class Runner(ABC):
         """
 
 
-class RunnerAlreadyStarted(Exception):
+class RunnerAlreadyStartedError(Exception):
     """
     Raised when runner is already started.
     """
@@ -438,7 +433,7 @@ class SingleThreadedRunner(Runner, RecordingEventReceiver):
     Runs a :class:`System` in a single thread.
     """
 
-    def __init__(self, system: System, env: Optional[EnvType] = None):
+    def __init__(self, system: System, env: EnvType | None = None):
         """
         Initialises runner with the given :class:`System`.
         """
@@ -446,7 +441,7 @@ class SingleThreadedRunner(Runner, RecordingEventReceiver):
         self.apps: Dict[str, Application] = {}
         self._recording_events_received: List[RecordingEvent] = []
         self._prompted_names_lock = Lock()
-        self._prompted_names: Set[str] = set()
+        self._prompted_names: set[str] = set()
         self._processing_lock = Lock()
 
         # Construct followers.
@@ -533,13 +528,20 @@ class SingleThreadedRunner(Runner, RecordingEventReceiver):
         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.
     """
 
-    def __init__(self, system: System, env: Optional[EnvType] = None):
+    def __init__(self, system: System, env: EnvType | None = None):
         """
         Initialises runner with the given :class:`System`.
         """
@@ -665,9 +667,9 @@ class NewSingleThreadedRunner(Runner, RecordingEventReceiver):
                                     ),
                                 )
 
-                        self._previous_max_notification_ids[
-                            leader_name
-                        ] = recording_event.recordings[-1].notification.id
+                        self._previous_max_notification_ids[leader_name] = (
+                            recording_event.recordings[-1].notification.id
+                        )
 
             finally:
                 self._processing_lock.release()
@@ -689,7 +691,7 @@ class MultiThreadedRunner(Runner):
     for each :class:`Follower` in the system definition.
     """
 
-    def __init__(self, system: System, env: Optional[EnvType] = None):
+    def __init__(self, system: System, env: EnvType | None = None):
         """
         Initialises runner with the given :class:`System`.
         """
@@ -753,7 +755,7 @@ class MultiThreadedRunner(Runner):
             thread = self.threads[follower.name]
             leader.lead(thread)
 
-    def watch_for_errors(self, timeout: Optional[float] = None) -> bool:
+    def watch_for_errors(self, timeout: float | None = None) -> bool:
         if self.has_errored.wait(timeout=timeout):
             self.stop()
         return self.has_errored.is_set()
@@ -794,7 +796,7 @@ class MultiThreadedRunnerThread(RecordingEventReceiver, Thread):
         super().__init__(daemon=True)
         self.follower = follower
         self.has_errored = has_errored
-        self.error: Optional[Exception] = None
+        self.error: Exception | None = None
         self.is_stopping = Event()
         self.has_started = Event()
         self.is_prompted = Event()
@@ -852,7 +854,7 @@ class NewMultiThreadedRunner(Runner, RecordingEventReceiver):
     def __init__(
         self,
         system: System,
-        env: Optional[EnvType] = None,
+        env: EnvType | None = None,
     ):
         """
         Initialises runner with the given :class:`System`.
@@ -860,10 +862,8 @@ class NewMultiThreadedRunner(Runner, RecordingEventReceiver):
         super().__init__(system=system, env=env)
         self.apps: Dict[str, Application] = {}
         self.pulling_threads: Dict[str, List[PullingThread]] = {}
-        self.processing_queues: Dict[str, "Queue[Optional[List[ProcessingJob]]]"] = {}
-        self.all_threads: List[
-            Union[PullingThread, ConvertingThread, ProcessingThread]
-        ] = []
+        self.processing_queues: Dict[str, Queue[List[ProcessingJob] | None]] = {}
+        self.all_threads: List[PullingThread | ConvertingThread | ProcessingThread] = []
         self.has_errored = Event()
 
         # Construct followers.
@@ -902,7 +902,7 @@ 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[Optional[List[ProcessingJob]]] = Queue(
+            processing_queue: Queue[List[ProcessingJob] | None] = Queue(
                 maxsize=self.QUEUE_MAX_SIZE
             )
             self.processing_queues[follower_name] = processing_queue
@@ -959,7 +959,7 @@ class NewMultiThreadedRunner(Runner, RecordingEventReceiver):
             assert isinstance(leader, Leader)
             leader.lead(self)
 
-    def watch_for_errors(self, timeout: Optional[float] = None) -> bool:
+    def watch_for_errors(self, timeout: float | None = None) -> bool:
         if self.has_errored.wait(timeout=timeout):
             self.stop()
         return self.has_errored.is_set()
@@ -1004,12 +1004,12 @@ class PullingThread(Thread):
     ):
         super().__init__(daemon=True)
         self.overflow_event = Event()
-        self.recording_event_queue: Queue[Optional[RecordingEvent]] = Queue(maxsize=100)
+        self.recording_event_queue: Queue[RecordingEvent | None] = Queue(maxsize=100)
         self.converting_queue = converting_queue
         self.receive_lock = Lock()
         self.follower = follower
         self.leader_name = leader_name
-        self.error: Optional[Exception] = None
+        self.error: Exception | None = None
         self.has_errored = has_errored
         self.is_stopping = Event()
         self.has_started = Event()
@@ -1075,7 +1075,7 @@ class ConvertingThread(Thread):
     def __init__(
         self,
         converting_queue: Queue[ConvertingJob],
-        processing_queue: Queue[Optional[List[ProcessingJob]]],
+        processing_queue: Queue[List[ProcessingJob] | None],
         follower: Follower,
         leader_name: str,
         has_errored: Event,
@@ -1085,7 +1085,7 @@ class ConvertingThread(Thread):
         self.processing_queue = processing_queue
         self.follower = follower
         self.leader_name = leader_name
-        self.error: Optional[Exception] = None
+        self.error: Exception | None = None
         self.has_errored = has_errored
         self.is_stopping = Event()
         self.has_started = Event()
@@ -1145,14 +1145,14 @@ class ProcessingThread(Thread):
 
     def __init__(
         self,
-        processing_queue: Queue[Optional[List[ProcessingJob]]],
+        processing_queue: Queue[List[ProcessingJob] | None],
         follower: Follower,
         has_errored: Event,
     ):
         super().__init__(daemon=True)
         self.processing_queue = processing_queue
         self.follower = follower
-        self.error: Optional[Exception] = None
+        self.error: Exception | None = None
         self.has_errored = has_errored
         self.is_stopping = Event()
         self.has_started = Event()
@@ -1212,22 +1212,17 @@ class NotificationLogReader:
         event notifications in the notification log from the start position
         have been yielded.
         """
-        section_id = "{},{}".format(start, start + self.section_size - 1)
+        section_id = f"{start},{start + self.section_size - 1}"
         while True:
             section: Section = self.notification_log[section_id]
-            for item in section.items:
-                # Todo: Reintroduce if supporting
-                #  sections with regular alignment?
-                # if item.id < start:
-                #     continue
-                yield item
+            yield from section.items
             if section.next_id is None:
                 break
             else:
                 section_id = section.next_id
 
     def select(
-        self, *, start: int, stop: Optional[int] = None, topics: Sequence[str] = ()
+        self, *, start: int, stop: int | None = None, topics: Sequence[str] = ()
     ) -> Iterator[List[Notification]]:
         """
         Returns a generator that yields lists of event notifications

eventsourcing/tests/application.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import sys
 import traceback
@@ -8,15 +10,11 @@ from decimal import Decimal
 from threading import Event, get_ident
 from time import sleep
 from timeit import timeit
+from typing import ClassVar, Dict, Type
 from unittest import TestCase
 from uuid import UUID, uuid4
 
-from eventsourcing.application import (
-    AggregateNotFound,
-    Application,
-    ProcessEvent,
-    ProcessingEvent,
-)
+from eventsourcing.application import AggregateNotFoundError, Application
 from eventsourcing.domain import Aggregate
 from eventsourcing.persistence import (
     InfrastructureFactory,
@@ -31,9 +29,9 @@ TIMEIT_FACTOR = int(os.environ.get("TEST_TIMEIT_FACTOR", default=10))
 
 
 class ExampleApplicationTestCase(TestCase):
-    timeit_number = TIMEIT_FACTOR
-    started_ats = {}
-    counts = {}
+    timeit_number: ClassVar[int] = TIMEIT_FACTOR
+    started_ats: ClassVar[Dict[Type[TestCase], datetime]] = {}
+    counts: ClassVar[Dict[Type[TestCase], int]] = {}
     expected_factory_topic: str
 
     def test_example_application(self):
@@ -137,7 +135,7 @@ class ExampleApplicationTestCase(TestCase):
     def test__get_performance_without_snapshotting_enabled(self):
         self._test_get_performance(is_snapshotting_enabled=False)
 
-    def _test_get_performance(self, is_snapshotting_enabled: bool):
+    def _test_get_performance(self, *, is_snapshotting_enabled: bool):
         app = BankAccounts(
             env={"IS_SNAPSHOTTING_ENABLED": "y" if is_snapshotting_enabled else "n"}
         )
@@ -201,7 +199,7 @@ class BankAccounts(Application):
     is_snapshotting_enabled = True
 
     def register_transcodings(self, transcoder: Transcoder) -> None:
-        super(BankAccounts, self).register_transcodings(transcoder)
+        super().register_transcodings(transcoder)
         transcoder.register(EmailAddressAsStr())
 
     def open_account(self, full_name, email_address):
@@ -224,8 +222,8 @@ class BankAccounts(Application):
     def get_account(self, account_id: UUID) -> BankAccount:
         try:
             aggregate = self.repository.get(account_id)
-        except AggregateNotFound:
-            raise self.AccountNotFoundError(account_id)
+        except AggregateNotFoundError:
+            raise self.AccountNotFoundError(account_id) from None
         else:
             assert isinstance(aggregate, BankAccount)
             return aggregate
@@ -270,10 +268,8 @@ class ApplicationTestCase(TestCase):
             Application(env={"PERSISTENCE_MODULE": "eventsourcing.application"})
         self.assertEqual(
             cm.exception.args[0],
-            (
-                "Found 0 infrastructure factory classes in "
-                "'eventsourcing.application', expected 1."
-            ),
+            "Found 0 infrastructure factory classes in "
+            "'eventsourcing.application', expected 1.",
         )
 
         with self.assertRaises(AssertionError) as cm:
@@ -282,10 +278,8 @@ class ApplicationTestCase(TestCase):
             )
         self.assertEqual(
             cm.exception.args[0],
-            (
-                "Not an infrastructure factory class or module: "
-                "eventsourcing.application:Application"
-            ),
+            "Not an infrastructure factory class or module: "
+            "eventsourcing.application:Application",
         )
 
     def test_save_returns_recording_event(self):
@@ -318,13 +312,11 @@ class ApplicationTestCase(TestCase):
             app.take_snapshot(uuid4())
         self.assertEqual(
             cm.exception.args[0],
-            (
-                "Can't take snapshot without snapshots store. Please "
-                "set environment variable IS_SNAPSHOTTING_ENABLED to "
-                "a true value (e.g. 'y'), or set 'is_snapshotting_enabled' "
-                "on application class, or set 'snapshotting_intervals' on "
-                "application class."
-            ),
+            "Can't take snapshot without snapshots store. Please "
+            "set environment variable IS_SNAPSHOTTING_ENABLED to "
+            "a true value (e.g. 'y'), or set 'is_snapshotting_enabled' "
+            "on application class, or set 'snapshotting_intervals' on "
+            "application class.",
         )
 
     def test_application_with_cached_aggregates_and_fastforward(self):
@@ -502,7 +494,3 @@ class ApplicationTestCase(TestCase):
         self.assertEqual(
             "'log' is deprecated, use 'notifications' instead", w[-1].message.args[0]
         )
-
-    def test_process_event_class(self):
-        # Check the old 'ProcessEvent' class still works.
-        self.assertTrue(issubclass(ProcessEvent, ProcessingEvent))

eventsourcing/tests/application_tests/test_application_with_automatic_snapshotting.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import ClassVar, Dict, Type
+from unittest import TestCase
+
+from eventsourcing.domain import Aggregate, MutableOrImmutableAggregate
+from eventsourcing.tests.application import BankAccounts
+from eventsourcing.tests.domain import BankAccount
+
+
+class BankAccountsWithAutomaticSnapshotting(BankAccounts):
+    is_snapshotting_enabled = False
+    snapshotting_intervals: ClassVar[
+        Dict[Type[MutableOrImmutableAggregate], int] | None
+    ] = {BankAccount: 5}
+
+
+class TestApplicationWithAutomaticSnapshotting(TestCase):
+    def test(self):
+        app = BankAccountsWithAutomaticSnapshotting()
+
+        # Check snapshotting is enabled by setting snapshotting_intervals only.
+        self.assertTrue(app.snapshots)
+
+        # Open an account.
+        account_id = app.open_account("Alice", "alice@example.com")
+
+        # Check there are no snapshots.
+        snapshots = list(app.snapshots.get(account_id))
+        self.assertEqual(len(snapshots), 0)
+
+        # Trigger twelve more events.
+        for _ in range(12):
+            app.credit_account(account_id, Decimal("10.00"))
+
+        # Check the account is at version 13.
+        account = app.get_account(account_id)
+        self.assertEqual(account.version, 13)
+
+        # Check snapshots have been taken at regular intervals.
+        snapshots = list(app.snapshots.get(account_id))
+        self.assertEqual(len(snapshots), 2)
+        self.assertEqual(snapshots[0].originator_version, 5)
+        self.assertEqual(snapshots[1].originator_version, 10)
+
+        # Check another type of aggregate is not snapshotted.
+        aggregate = Aggregate()
+        for _ in range(10):
+            aggregate.trigger_event(Aggregate.Event)
+        app.save(aggregate)
+
+        # Check snapshots have not been taken at regular intervals.
+        snapshots = list(app.snapshots.get(aggregate.id))
+        self.assertEqual(len(snapshots), 0)

eventsourcing/tests/application_tests/test_application_with_popo.py

@@ -0,0 +1,22 @@
+from eventsourcing.tests.application import (
+    TIMEIT_FACTOR,
+    ApplicationTestCase,
+    ExampleApplicationTestCase,
+)
+
+
+class TestApplicationWithPOPO(ApplicationTestCase):
+    def test_application_fastforward_skipping_during_contention(self):
+        self.skipTest("POPO is too fast for this test to work")
+
+    def test_application_fastforward_blocking_during_contention(self):
+        self.skipTest("POPO is too fast for this test to make sense")
+
+
+class TestExampleApplicationWithPOPO(ExampleApplicationTestCase):
+    timeit_number = 100 * TIMEIT_FACTOR
+    expected_factory_topic = "eventsourcing.popo:Factory"
+
+
+del ApplicationTestCase
+del ExampleApplicationTestCase

eventsourcing/tests/application_tests/test_application_with_postgres.py

@@ -0,0 +1,75 @@
+import os
+from unittest import TestCase
+
+from eventsourcing.postgres import PostgresDatastore
+from eventsourcing.tests.application import (
+    TIMEIT_FACTOR,
+    ApplicationTestCase,
+    ExampleApplicationTestCase,
+)
+from eventsourcing.tests.postgres_utils import drop_postgres_table
+
+
+class WithPostgres(TestCase):
+    timeit_number = 5 * TIMEIT_FACTOR
+    expected_factory_topic = "eventsourcing.postgres:Factory"
+
+    def setUp(self) -> None:
+        super().setUp()
+
+        os.environ["PERSISTENCE_MODULE"] = "eventsourcing.postgres"
+        os.environ["CREATE_TABLE"] = "y"
+        os.environ["POSTGRES_DBNAME"] = "eventsourcing"
+        os.environ["POSTGRES_HOST"] = "127.0.0.1"
+        os.environ["POSTGRES_PORT"] = "5432"
+        os.environ["POSTGRES_USER"] = "eventsourcing"
+        os.environ["POSTGRES_PASSWORD"] = "eventsourcing"  # noqa: S105
+        os.environ["POSTGRES_SCHEMA"] = "public"
+
+        db = PostgresDatastore(
+            os.getenv("POSTGRES_DBNAME"),
+            os.getenv("POSTGRES_HOST"),
+            os.getenv("POSTGRES_PORT"),
+            os.getenv("POSTGRES_USER"),
+            os.getenv("POSTGRES_PASSWORD"),
+        )
+        drop_postgres_table(db, "public.bankaccounts_events")
+        drop_postgres_table(db, "public.bankaccounts_snapshots")
+        db.close()
+
+    def tearDown(self) -> None:
+        db = PostgresDatastore(
+            os.getenv("POSTGRES_DBNAME"),
+            os.getenv("POSTGRES_HOST"),
+            os.getenv("POSTGRES_PORT"),
+            os.getenv("POSTGRES_USER"),
+            os.getenv("POSTGRES_PASSWORD"),
+        )
+        drop_postgres_table(db, "public.bankaccounts_events")
+        drop_postgres_table(db, "public.bankaccounts_snapshots")
+
+        del os.environ["PERSISTENCE_MODULE"]
+        del os.environ["CREATE_TABLE"]
+        del os.environ["POSTGRES_DBNAME"]
+        del os.environ["POSTGRES_HOST"]
+        del os.environ["POSTGRES_PORT"]
+        del os.environ["POSTGRES_USER"]
+        del os.environ["POSTGRES_PASSWORD"]
+        del os.environ["POSTGRES_SCHEMA"]
+        db.close()
+
+        super().tearDown()
+
+
+class TestApplicationWithPostgres(ApplicationTestCase, WithPostgres):
+    pass
+
+
+class TestExampleApplicationWithPostgres(ExampleApplicationTestCase, WithPostgres):
+    timeit_number = 5 * TIMEIT_FACTOR
+    expected_factory_topic = "eventsourcing.postgres:Factory"
+
+
+del ApplicationTestCase
+del ExampleApplicationTestCase
+del WithPostgres