eventsourcing 9.4.0a8__py3-none-any.whl → 9.4.0b2__py3-none-any.whl

eventsourcing/projection.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import os
 import weakref
 from abc import ABC, abstractmethod
@@ -22,6 +23,8 @@ from eventsourcing.persistence import (
 from eventsourcing.utils import Environment, EnvType
 
 if TYPE_CHECKING:
+    from types import TracebackType
+
     from typing_extensions import Self
 
 
@@ -40,39 +43,65 @@ class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
         gt: int | None = None,
         topics: Sequence[str] = (),
     ):
+        """
+        Starts subscription to application's stored events using application's recorder.
+        """
         self.name = app.name
         self.recorder = app.recorder
         self.mapper = app.mapper
         self.subscription = self.recorder.subscribe(gt=gt, topics=topics)
 
+    def stop(self) -> None:
+        """
+        Stops the stored event subscription.
+        """
+        self.subscription.stop()
+
     def __enter__(self) -> Self:
+        """
+        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.
+        """
         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.
+        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.
+        """
         notification = next(self.subscription)
         tracking = Tracking(self.name, notification.id)
         domain_event = self.mapper.to_domain_event(notification)
         return domain_event, tracking
 
     def __del__(self) -> None:
+        """
+        Stops the stored event subscription.
+        """
         self.stop()
 
-    def stop(self) -> None:
-        self.subscription.stop()
-
 
 class Projection(ABC, Generic[TTrackingRecorder]):
     name: str = ""
-    """Name of projection, used to pick prefixed environment variables."""
-    topics: Sequence[str] = ()
-    """Filter events in database when subscribing to an application."""
+    """
+    Name of projection, used to pick prefixed environment
+    variables and define database table names.
+    """
+    topics: tuple[str, ...] = ()
+    """
+    Filter events in database when subscribing to an application.
+    """
 
     def __init__(
         self,
@@ -104,10 +133,22 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         self,
         *,
         application_class: type[TApplication],
-        view_class: type[TTrackingRecorder],
         projection_class: type[Projection[TTrackingRecorder]],
+        view_class: type[TTrackingRecorder],
         env: EnvType | None = None,
     ):
+        """
+        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.
+        Starts a subscription to application and, in a separate event-processing
+        thread, calls projection's process_event() method for each event and tracking
+        object pair received from the subscription.
+        """
+        self._is_interrupted = Event()
+        self._has_called_stop = False
+
         self.app: TApplication = application_class(env)
 
         self.view = (
@@ -128,18 +169,29 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
             gt=self.view.max_tracking_id(self.app.name),
             topics=self.projection.topics,
         )
-        self._is_stopping = Event()
-        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:
         """
@@ -152,8 +204,25 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         return Environment(name, _env)
 
     def stop(self) -> None:
-        self._is_stopping.set()
-        self.subscription.stop()
+        """
+        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.
+        """
+        try:
+            is_stopping.wait()
+        finally:
+            is_stopping.set()
+            subscription.stop()
 
     @staticmethod
     def _process_events_loop(
@@ -169,7 +238,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
             else:
                 msg = "ProjectionRunner was deleted before error could be assigned:\n"
                 msg += format_exc()
@@ -178,32 +247,66 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
                     RuntimeWarning,
                     stacklevel=2,
                 )
-
+        finally:
             is_stopping.set()
-            subscription.subscription.stop()
 
     def run_forever(self, timeout: float | None = None) -> None:
-        if self._is_stopping.wait(timeout=timeout) and self.thread_error is not None:
-            raise self.thread_error
+        """
+        Blocks until timeout, or until the runner is stopped or errors. Re-raises
+        any error otherwise exits normally
+        """
+        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
+        object that is greater than or equal to the given notification ID.
+        """
         try:
             self.projection.view.wait(
                 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:
+    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:
-        self.stop()
+        """
+        Calls stop().
+        """
+        with contextlib.suppress(AttributeError):
+            self.stop()

eventsourcing/system.py

@@ -7,12 +7,11 @@ from abc import ABC, abstractmethod
 from collections import defaultdict
 from queue import Full, Queue
 from types import FrameType, ModuleType
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator, Sequence
     from typing_extensions import Self
-    from eventsourcing.dispatch import singledispatchmethod
 
 from eventsourcing.application import (
     Application,
@@ -22,6 +21,7 @@ from eventsourcing.application import (
     Section,
     TApplication,
 )
+from eventsourcing.dispatch import singledispatchmethod
 from eventsourcing.domain import DomainEventProtocol, MutableOrImmutableAggregate
 from eventsourcing.persistence import (
     IntegrityError,
@@ -198,11 +198,8 @@ class Follower(Application):
                 self.notify(processing_event.events)
                 self._notify(recordings)
 
-    policy: (
-        Callable[[DomainEventProtocol, ProcessingEvent], None] | singledispatchmethod
-    )
-
-    def policy(  # type: ignore[no-redef]
+    @singledispatchmethod
+    def policy(
         self,
         domain_event: DomainEventProtocol,
         processing_event: ProcessingEvent,

eventsourcing/tests/application.py

@@ -10,7 +10,7 @@ from decimal import Decimal
 from threading import Event, get_ident
 from time import sleep
 from timeit import timeit
-from typing import ClassVar
+from typing import Any, ClassVar
 from unittest import TestCase
 from uuid import UUID, uuid4
 
@@ -23,7 +23,7 @@ from eventsourcing.persistence import (
     Transcoding,
 )
 from eventsourcing.tests.domain import BankAccount, EmailAddress
-from eventsourcing.utils import get_topic
+from eventsourcing.utils import EnvType, get_topic
 
 TIMEIT_FACTOR = int(os.environ.get("TEST_TIMEIT_FACTOR", default=10))
 
@@ -344,96 +344,131 @@ class ApplicationTestCase(TestCase):
         app.repository.get(aggregate.id)
         self.assertEqual(aggregate, app.repository.cache.get(aggregate.id))
 
-    def test_application_fastforward_skipping_during_contention(self) -> None:
-        app = Application(
+    def test_check_aggregate_fastforwarding_nonblocking(self) -> None:
+        self._check_aggregate_fastforwarding_during_contention(
             env={
                 "AGGREGATE_CACHE_MAXSIZE": "10",
                 "AGGREGATE_CACHE_FASTFORWARD_SKIPPING": "y",
             }
         )
 
-        aggregate = Aggregate()
-        aggregate_id = aggregate.id
-        app.save(aggregate)
+    def test_check_aggregate_fastforwarding_blocking(self) -> None:
+        self._check_aggregate_fastforwarding_during_contention(
+            env={"AGGREGATE_CACHE_MAXSIZE": "10"}
+        )
+
+    def _check_aggregate_fastforwarding_during_contention(self, env: EnvType) -> None:
+        app = Application(env=env)
+
+        self.assertEqual(len(app.repository._fastforward_locks_inuse), 0)
+
+        # Create one aggregate.
+        original_aggregate = Aggregate()
+        app.save(original_aggregate)
+        obj_ids = set()
+
+        # Prime the cache.
+        app.repository.get(original_aggregate.id)
+
+        # Remember the aggregate ID.
+        aggregate_id = original_aggregate.id
 
         stopped = Event()
+        errors: list[BaseException] = []
+        successful_thread_ids = set()
 
-        # Trigger, save, get, check.
         def trigger_save_get_check() -> None:
             while not stopped.is_set():
                 try:
+                    # Get the aggregate.
                     aggregate: Aggregate = app.repository.get(aggregate_id)
+                    original_version = aggregate.version
+
+                    # Try to record a new event.
                     aggregate.trigger_event(Aggregate.Event)
-                    saved_version = aggregate.version
+                    # Give other threads a chance.
                     try:
                         app.save(aggregate)
                     except IntegrityError:
+                        # Start again if we didn't record a new event.
+                        # print("Got integrity error")
+                        sleep(0.001)
                         continue
-                    cached: Aggregate = app.repository.get(aggregate_id)
-                    if saved_version > cached.version:
-                        print(f"Skipped fast-forwarding at version {saved_version}")
-                        stopped.set()
-                    if aggregate.version % 1000 == 0:
-                        print("Version:", aggregate.version, get_ident())
-                    sleep(0.00)
-                except BaseException:
-                    print(traceback.format_exc())
-                    raise
 
-        executor = ThreadPoolExecutor(max_workers=100)
-        for _ in range(100):
-            executor.submit(trigger_save_get_check)
+                    # Get the aggregate from the cache.
+                    assert app.repository.cache is not None
+                    cached: Any = app.repository.cache.get(aggregate_id)
+                    obj_ids.add(id(cached))
 
-        if not stopped.wait(timeout=100):
-            stopped.set()
-            self.fail("Didn't skip fast forwarding before test timed out...")
-        executor.shutdown()
+                    if len(obj_ids) > 1:
+                        stopped.set()
+                        continue
 
-    def test_application_fastforward_blocking_during_contention(self) -> None:
-        app = Application(
-            env={
-                "AGGREGATE_CACHE_MAXSIZE": "10",
-            }
-        )
+                    # Fast-forward the cached aggregate.
+                    fastforwarded: Aggregate = app.repository.get(aggregate_id)
 
-        aggregate = Aggregate()
-        aggregate_id = aggregate.id
-        app.save(aggregate)
+                    # Check cached aggregate was fast-forwarded with recorded event.
+                    if fastforwarded.version < original_version:
+                        try:
+                            self.fail(
+                                f"Failed to fast-forward at version {original_version}"
+                            )
+                        except AssertionError as e:
+                            errors.append(e)
+                            stopped.set()
+                            continue
 
-        stopped = Event()
+                    # Monitor number of threads getting involved.
+                    thread_id = get_ident()
+                    successful_thread_ids.add(thread_id)
 
-        # Trigger, save, get, check.
-        def trigger_save_get_check() -> None:
-            while not stopped.is_set():
-                try:
-                    aggregate: Aggregate = app.repository.get(aggregate_id)
-                    aggregate.trigger_event(Aggregate.Event)
-                    saved_version = aggregate.version
-                    try:
-                        app.save(aggregate)
-                    except IntegrityError:
-                        continue
-                    cached: Aggregate = app.repository.get(aggregate_id)
-                    if saved_version > cached.version:
-                        print(f"Skipped fast-forwarding at version {saved_version}")
+                    # print("Version:", aggregate.version, thread_id)
+
+                    # See if we have done enough.
+                    if len(successful_thread_ids) > 10 and aggregate.version >= 25:
                         stopped.set()
-                    if aggregate.version % 1000 == 0:
-                        print("Version:", aggregate.version, get_ident())
-                    sleep(0.00)
-                except BaseException:
+                        continue
+
+                    sleep(0.0001)
+                    # sleep(0.001)
+                except BaseException as e:
+                    errors.append(e)
+                    stopped.set()
                     print(traceback.format_exc())
                     raise
 
         executor = ThreadPoolExecutor(max_workers=100)
+        futures = []
         for _ in range(100):
-            executor.submit(trigger_save_get_check)
-
-        if not stopped.wait(timeout=3):
-            stopped.set()
-        else:
-            self.fail("Wrongly skipped fast forwarding")
+            f = executor.submit(trigger_save_get_check)
+            futures.append(f)
+
+        # Run for three seconds.
+        stopped.wait(timeout=10)
+        for f in futures:
+            f.result()
+        # print("Got all results, shutting down executor")
         executor.shutdown()
 
+        try:
+            if errors:
+                raise errors[0]
+            if len(obj_ids) > 1:
+                self.fail(f"More than one instance used in the cache: {len(obj_ids)}")
+            if len(successful_thread_ids) < 3:
+                self.fail("Insufficient sharing across contentious threads")
+
+            final_aggregate: Aggregate = app.repository.get(aggregate_id)
+            # print("Final aggregate version:", final_aggregate.version)
+            if final_aggregate.version < 25:
+                self.fail(f"Insufficient version increment: {final_aggregate.version}")
+
+            self.assertEqual(len(app.repository._fastforward_locks_inuse), 0)
+
+        finally:
+            # print("Closing application")
+            app.close()
+
     def test_application_with_cached_aggregates_not_fastforward(self) -> None:
         app = Application(
             env={
@@ -441,13 +476,37 @@ class ApplicationTestCase(TestCase):
                 "AGGREGATE_CACHE_FASTFORWARD": "f",
             }
         )
-        aggregate = Aggregate()
-        app.save(aggregate)
+        aggregate1 = Aggregate()
+        app.save(aggregate1)
+        aggregate_id = aggregate1.id
+
         # Should put the aggregate in the cache.
         assert app.repository.cache is not None  # for mypy
-        self.assertEqual(aggregate, app.repository.cache.get(aggregate.id))
-        app.repository.get(aggregate.id)
-        self.assertEqual(aggregate, app.repository.cache.get(aggregate.id))
+        self.assertEqual(aggregate1, app.repository.cache.get(aggregate_id))
+        app.repository.get(aggregate_id)
+        self.assertEqual(aggregate1, app.repository.cache.get(aggregate_id))
+
+        aggregate2 = Aggregate()
+        aggregate2._id = aggregate_id
+        aggregate2.trigger_event(Aggregate.Event)
+
+        # This will replace object in cache.
+        app.save(aggregate2)
+
+        self.assertEqual(aggregate2.version, aggregate1.version + 1)
+        aggregate3: Aggregate = app.repository.get(aggregate_id)
+        self.assertEqual(aggregate3.version, aggregate3.version)
+        self.assertEqual(id(aggregate3.version), id(aggregate3.version))
+
+        # This will mess things up because the cache has a stale aggregate.
+        aggregate3.trigger_event(Aggregate.Event)
+        app.events.put(aggregate3.collect_events())
+
+        # And so using the aggregate to record new events will cause an IntegrityError.
+        aggregate4: Aggregate = app.repository.get(aggregate_id)
+        aggregate4.trigger_event(Aggregate.Event)
+        with self.assertRaises(IntegrityError):
+            app.save(aggregate4)
 
     def test_application_with_deepcopy_from_cache_arg(self) -> None:
         app = Application(

eventsourcing/tests/domain.py

@@ -69,11 +69,11 @@ class BankAccount(Aggregate):
 
         amount: Decimal
 
-        def apply(self, account: Aggregate) -> None:
+        def apply(self, aggregate: Aggregate) -> None:
             """
             Increments the account balance.
             """
-            cast(BankAccount, account).balance += self.amount
+            cast(BankAccount, aggregate).balance += self.amount
 
     def set_overdraft_limit(self, overdraft_limit: Decimal) -> None:
         """
@@ -95,8 +95,8 @@ class BankAccount(Aggregate):
 
         overdraft_limit: Decimal
 
-        def apply(self, account: Aggregate) -> None:
-            cast(BankAccount, account).overdraft_limit = self.overdraft_limit
+        def apply(self, aggregate: Aggregate) -> None:
+            cast(BankAccount, aggregate).overdraft_limit = self.overdraft_limit
 
     def close(self) -> None:
         """
@@ -109,8 +109,8 @@ class BankAccount(Aggregate):
         Domain event for when account is closed.
         """
 
-        def apply(self, account: Aggregate) -> None:
-            cast(BankAccount, account).is_closed = True
+        def apply(self, aggregate: Aggregate) -> None:
+            cast(BankAccount, aggregate).is_closed = True
 
 
 class AccountClosedError(Exception):

eventsourcing/tests/persistence.py

@@ -793,8 +793,16 @@ class TrackingRecorderTestCase(TestCase, ABC):
 
     def test_wait(self) -> None:
         tracking_recorder = self.create_recorder()
+
+        tracking_recorder.wait("upstream1", None)
+
+        with self.assertRaises(TimeoutError):
+            tracking_recorder.wait("upstream1", 21, timeout=0.1)
+
         tracking1 = Tracking(notification_id=21, application_name="upstream1")
         tracking_recorder.insert_tracking(tracking=tracking1)
+        tracking_recorder.wait("upstream1", None)
+        tracking_recorder.wait("upstream1", 10)
         tracking_recorder.wait("upstream1", 21)
         with self.assertRaises(TimeoutError):
             tracking_recorder.wait("upstream1", 22, timeout=0.1)

eventsourcing/tests/postgres_utils.py

@@ -1,4 +1,5 @@
 import psycopg
+from psycopg.sql import SQL, Identifier
 
 from eventsourcing.persistence import PersistenceError
 from eventsourcing.postgres import PostgresDatastore
@@ -43,7 +44,10 @@ def pg_close_all_connections(
 
 
 def drop_postgres_table(datastore: PostgresDatastore, table_name: str) -> None:
-    statement = f"DROP TABLE {table_name}"
+    statement = SQL("DROP TABLE {0}.{1}").format(
+        Identifier(datastore.schema), Identifier(table_name)
+    )
+    # print(f"Dropping table {datastore.schema}.{table_name}")
     try:
         with datastore.transaction(commit=True) as curs:
             curs.execute(statement, prepare=False)

eventsourcing/utils.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import importlib
 import sys
-from collections.abc import Iterator, Mapping, Sequence
+from collections.abc import Iterator, Mapping
 from functools import wraps
 from inspect import isfunction
 from random import random
@@ -129,7 +129,7 @@ def clear_topic_cache() -> None:
 
 
 def retry(
-    exc: type[Exception] | Sequence[type[Exception]] = Exception,
+    exc: type[Exception] | tuple[type[Exception], ...] = Exception,
     max_attempts: int = 1,
     wait: float = 0,
     stall: float = 0,
@@ -235,18 +235,23 @@ class Environment(dict[str, str]):
         super().__init__(env or {})
         self.name = name
 
+    @overload  # type: ignore[override]
+    def get(self, __key: str) -> str | None: ...  # pragma: no cover
+
     @overload
-    def get(self, key: str) -> str | None: ...  # pragma: no cover
+    def get(self, __key: str, __default: str) -> str: ...  # pragma: no cover
 
     @overload
-    def get(self, key: str, default: str | T) -> str | T: ...  # pragma: no cover
+    def get(self, __key: str, __default: T) -> str | T: ...  # pragma: no cover
 
-    def get(self, key: str, default: str | T | None = None) -> str | T | None:
-        for _key in self.create_keys(key):
+    def get(  # pyright: ignore [reportIncompatibleMethodOverride]
+        self, __key: str, __default: str | T | None = None
+    ) -> str | T | None:
+        for _key in self.create_keys(__key):
             value = super().get(_key, None)
             if value is not None:
                 return value
-        return default
+        return __default
 
     def create_keys(self, key: str) -> list[str]:
         keys = []

{eventsourcing-9.4.0a8.dist-info → eventsourcing-9.4.0b2.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.3
 Name: eventsourcing
-Version: 9.4.0a8
+Version: 9.4.0b2
 Summary: Event sourcing in Python
 License: BSD 3-Clause
 Keywords: event sourcing,event store,domain driven design,domain-driven design,ddd,cqrs,cqs
 Author: John Bywater
 Author-email: john.bywater@appropriatesoftware.net
 Requires-Python: >=3.9, !=2.7.*, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*, !=3.8.*
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research