eventsourcing 9.4.0b4__py3-none-any.whl → 9.4.1__py3-none-any.whl

eventsourcing/postgres.py

@@ -766,6 +766,10 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
                 "in environment with key "
                 f"'{self.POSTGRES_DBNAME}'"
             )
+            # TODO: Indicate both keys here, also for other environment variables.
+            # ) + " or ".join(
+            #   [f"'{key}'" for key in self.env.create_keys(self.POSTGRES_DBNAME)]
+            # )
             raise OSError(msg)
 
         host = self.env.get(self.POSTGRES_HOST)

eventsourcing/projection.py

@@ -2,19 +2,22 @@ from __future__ import annotations
 
 import contextlib
 import os
+import threading
 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, Generic, TypeVar
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypeVar
 from warnings import warn
 
-from eventsourcing.application import Application
+from eventsourcing.application import Application, ProcessingEvent
 from eventsourcing.dispatch import singledispatchmethod
 from eventsourcing.domain import DomainEventProtocol
 from eventsourcing.persistence import (
     InfrastructureFactory,
+    IntegrityError,
+    ProcessRecorder,
     Tracking,
     TrackingRecorder,
     TTrackingRecorder,
@@ -43,7 +46,7 @@ class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
         topics: Sequence[str] = (),
     ):
         """
-        Starts subscription to application's stored events using application's recorder.
+        Starts a subscription to application's recorder.
         """
         self.name = app.name
         self.recorder = app.recorder
@@ -51,7 +54,7 @@ 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 subscription to the application's recorder."""
         self.subscription.stop()
 
     def __enter__(self) -> Self:
@@ -67,10 +70,11 @@ class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
         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.
+        """Returns the next stored event from subscription to the application's
+        recorder. Constructs a tracking object that identifies the position of
+        the event in the application sequence. Constructs a domain event object
+        from the stored event object using the application's mapper. Returns a
+        tuple of the domain event object and the tracking object.
         """
         notification = next(self.subscription)
         tracking = Tracking(self.name, notification.id)
@@ -91,14 +95,18 @@ class Projection(ABC, Generic[TTrackingRecorder]):
     """
     topics: tuple[str, ...] = ()
     """
-    Filter events in database when subscribing to an application.
+    Event topics, used to filter events in database when subscribing to an application.
     """
 
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        if "name" not in cls.__dict__:
+            cls.name = cls.__name__
+
     def __init__(
         self,
         view: TTrackingRecorder,
     ):
-        """Initialises a projection instance."""
+        """Initialises the view property with the given view argument."""
         self._view = view
 
     @property
@@ -114,63 +122,130 @@ class Projection(ABC, Generic[TTrackingRecorder]):
         """Process a domain event and track it."""
 
 
+class EventSourcedProjection(Application, ABC):
+    """Extends the :py:class:`~eventsourcing.application.Application` class
+    by using a process recorder as its application recorder, and by
+    processing domain events through its :py:func:`policy` method.
+    """
+
+    topics: ClassVar[Sequence[str]] = ()
+
+    def __init__(self, env: EnvType | None = None) -> None:
+        super().__init__(env)
+        self.recorder: ProcessRecorder
+        self.processing_lock = threading.Lock()
+
+    def construct_recorder(self) -> ProcessRecorder:
+        """Constructs and returns a :class:`~eventsourcing.persistence.ProcessRecorder`
+        for the application to use as its application recorder.
+        """
+        return self.factory.process_recorder()
+
+    def process_event(
+        self, domain_event: DomainEventProtocol, tracking: Tracking
+    ) -> None:
+        """Calls :func:`~eventsourcing.system.Follower.policy` method with
+        the given :class:`~eventsourcing.domain.AggregateEvent` and a
+        new :class:`~eventsourcing.application.ProcessingEvent` created from
+        the given :class:`~eventsourcing.persistence.Tracking` object.
+
+        The policy will collect any new aggregate events on the process
+        event object.
+
+        After the policy method returns, the process event object will
+        then be recorded by calling
+        :func:`~eventsourcing.application.Application.record`, which
+        will return new notifications.
+
+        After calling
+        :func:`~eventsourcing.application.Application.take_snapshots`,
+        the new notifications are passed to the
+        :func:`~eventsourcing.application.Application.notify` method.
+        """
+        processing_event = ProcessingEvent(tracking=tracking)
+        self.policy(domain_event, processing_event)
+        try:
+            recordings = self._record(processing_event)
+        except IntegrityError:
+            if self.recorder.has_tracking_id(
+                tracking.application_name,
+                tracking.notification_id,
+            ):
+                pass
+            else:
+                raise
+        else:
+            self._take_snapshots(processing_event)
+            self.notify(processing_event.events)
+            self._notify(recordings)
+
+    @singledispatchmethod
+    def policy(
+        self,
+        domain_event: DomainEventProtocol,
+        processing_event: ProcessingEvent,
+    ) -> None:
+        """Abstract domain event processing policy method. Must be
+        implemented by event processing applications. When
+        processing the given domain event, event processing
+        applications must use the :func:`~ProcessingEvent.collect_events`
+        method of the given :py:class:`~ProcessingEvent` object (not
+        the application's :func:`~eventsourcing.application.Application.save`
+        method) so that the new domain events will be recorded atomically
+        and uniquely with tracking information about the position of the processed
+        event in its application sequence.
+        """
+
+
 TApplication = TypeVar("TApplication", bound=Application)
+TEventSourcedProjection = TypeVar(
+    "TEventSourcedProjection", bound=EventSourcedProjection
+)
 
 
-class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
+class BaseProjectionRunner(Generic[TApplication]):
     def __init__(
         self,
         *,
+        projection: EventSourcedProjection | Projection[Any],
         application_class: type[TApplication],
-        projection_class: type[Projection[TTrackingRecorder]],
-        view_class: type[TTrackingRecorder],
+        tracking_recorder: TrackingRecorder,
+        topics: Sequence[str],
         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.
-        """
+    ) -> None:
+        self._projection = projection
         self._is_interrupted = Event()
         self._has_called_stop = False
 
+        # Construct the application.
         self.app: TApplication = application_class(env)
 
-        self.view = (
-            InfrastructureFactory[TTrackingRecorder]
-            .construct(
-                env=self._construct_env(
-                    name=projection_class.name or projection_class.__name__, env=env
-                )
-            )
-            .tracking_recorder(view_class)
-        )
+        self._tracking_recorder = tracking_recorder
 
-        self.projection = projection_class(
-            view=self.view,
-        )
-        self.subscription = ApplicationSubscription(
+        # Subscribe to the application.
+        self._subscription = ApplicationSubscription(
             app=self.app,
-            gt=self.view.max_tracking_id(self.app.name),
-            topics=self.projection.topics,
+            gt=self._tracking_recorder.max_tracking_id(self.app.name),
+            topics=topics,
         )
+
+        # Start a thread to stop the subscription when the runner is interrupted.
         self._thread_error: BaseException | None = None
         self._stop_thread = Thread(
             target=self._stop_subscription_when_stopping,
             kwargs={
-                "subscription": self.subscription,
+                "subscription": self._subscription,
                 "is_stopping": self._is_interrupted,
             },
         )
         self._stop_thread.start()
+
+        # Start a thread to iterate over the subscription.
         self._processing_thread = Thread(
             target=self._process_events_loop,
             kwargs={
-                "subscription": self.subscription,
-                "projection": self.projection,
+                "subscription": self._subscription,
+                "projection": self._projection,
                 "is_stopping": self._is_interrupted,
                 "runner": weakref.ref(self),
             },
@@ -181,7 +256,8 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
     def is_interrupted(self) -> Event:
         return self._is_interrupted
 
-    def _construct_env(self, name: str, env: EnvType | None = None) -> Environment:
+    @staticmethod
+    def _construct_env(name: str, env: EnvType | None = None) -> Environment:
         """Constructs environment from which projection will be configured."""
         _env: dict[str, str] = {}
         _env.update(os.environ)
@@ -211,10 +287,11 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
     @staticmethod
     def _process_events_loop(
         subscription: ApplicationSubscription,
-        projection: Projection[TrackingRecorder],
+        projection: EventSourcedProjection | Projection[Any],
         is_stopping: Event,
         runner: weakref.ReferenceType[ProjectionRunner[Application, TrackingRecorder]],
     ) -> None:
+        """Iterates over the subscription and calls process_event()."""
         try:
             with subscription:
                 for domain_event, tracking in subscription:
@@ -251,8 +328,8 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         object that is greater than or equal to the given notification ID.
         """
         try:
-            self.projection.view.wait(
-                application_name=self.subscription.name,
+            self._tracking_recorder.wait(
+                application_name=self.app.name,
                 notification_id=notification_id,
                 timeout=timeout,
                 interrupt=self._is_interrupted,
@@ -288,3 +365,64 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         """Calls stop()."""
         with contextlib.suppress(AttributeError):
             self.stop()
+
+
+class ProjectionRunner(
+    BaseProjectionRunner[TApplication], Generic[TApplication, TTrackingRecorder]
+):
+    def __init__(
+        self,
+        *,
+        application_class: type[TApplication],
+        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.
+        """
+        # Construct the materialised view using an infrastructure factory.
+        self.view = (
+            InfrastructureFactory[TTrackingRecorder]
+            .construct(env=self._construct_env(name=projection_class.name, env=env))
+            .tracking_recorder(view_class)
+        )
+
+        # Construct the projection using the materialised view.
+        self.projection = projection_class(view=self.view)
+
+        super().__init__(
+            projection=self.projection,
+            application_class=application_class,
+            tracking_recorder=self.view,
+            topics=self.projection.topics,
+            env=env,
+        )
+
+
+class EventSourcedProjectionRunner(
+    BaseProjectionRunner[TApplication], Generic[TApplication, TEventSourcedProjection]
+):
+    def __init__(
+        self,
+        *,
+        application_class: type[TApplication],
+        projection_class: type[TEventSourcedProjection],
+        env: EnvType | None = None,
+    ):
+        self.projection: TEventSourcedProjection = projection_class(
+            env=self._construct_env(name=projection_class.name, env=env)
+        )
+
+        super().__init__(
+            projection=self.projection,
+            application_class=application_class,
+            tracking_recorder=self.projection.recorder,
+            topics=self.projection.topics,
+            env=env,
+        )

eventsourcing/sqlite.py

@@ -472,6 +472,7 @@ class SQLiteApplicationRecorder(
     def subscribe(
         self, gt: int | None = None, topics: Sequence[str] = ()
     ) -> Subscription[ApplicationRecorder]:
+        """This method is not implemented on this class."""
         msg = f"The {type(self).__qualname__} recorder does not support subscriptions"
         raise NotImplementedError(msg)
 

eventsourcing/system.py

@@ -6,26 +6,25 @@ import traceback
 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, ClassVar, Optional, Union, cast
 
+from eventsourcing.projection import EventSourcedProjection
+
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator, Sequence
-    from types import FrameType, ModuleType
 
     from typing_extensions import Self
 
 from eventsourcing.application import (
     Application,
     NotificationLog,
-    ProcessingEvent,
     ProgrammingError,
     Section,
     TApplication,
 )
-from eventsourcing.dispatch import singledispatchmethod
 from eventsourcing.domain import DomainEventProtocol, MutableOrImmutableAggregate
 from eventsourcing.persistence import (
-    IntegrityError,
     Mapper,
     Notification,
     ProcessRecorder,
@@ -52,29 +51,25 @@ class RecordingEvent:
 ConvertingJob = Optional[Union[RecordingEvent, list[Notification]]]
 
 
-class Follower(Application):
-    """Extends the :class:`~eventsourcing.application.Application` class
-    by using a process recorder as its application recorder, by keeping
-    track of the applications it is following, and pulling and processing
-    new domain event notifications through its :func:`policy` method.
+class Follower(EventSourcedProjection):
+    """Extends the :class:`~eventsourcing.projection.EventSourcedProjection` class
+    by pulling notification objects from its notification log readers, by converting
+    the notification objects to domain events and tracking objects and by processing
+    the reconstructed domain event objects.
     """
 
-    follow_topics: ClassVar[Sequence[str]] = []
     pull_section_size = 10
 
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        super().__init_subclass__(**kwargs)
+        # for backwards compatibility, set "topics" if has "follow_topics".
+        cls.topics = getattr(cls, "follow_topics", cls.topics)
+
     def __init__(self, env: EnvType | None = None) -> None:
         super().__init__(env)
         self.readers: dict[str, NotificationLogReader] = {}
         self.mappers: dict[str, Mapper] = {}
-        self.recorder: ProcessRecorder
         self.is_threading_enabled = False
-        self.processing_lock = threading.Lock()
-
-    def construct_recorder(self) -> ProcessRecorder:
-        """Constructs and returns a :class:`~eventsourcing.persistence.ProcessRecorder`
-        for the application to use as its application recorder.
-        """
-        return self.factory.process_recorder()
 
     def follow(self, name: str, log: NotificationLog) -> None:
         """Constructs a notification log reader and a mapper for
@@ -107,6 +102,12 @@ class Follower(Application):
             ):
                 self.process_event(domain_event, tracking)
 
+    def process_event(
+        self, domain_event: DomainEventProtocol, tracking: Tracking
+    ) -> None:
+        with self.processing_lock:
+            super().process_event(domain_event, tracking)
+
     def pull_notifications(
         self,
         leader_name: str,
@@ -121,15 +122,15 @@ class Follower(Application):
         return self.readers[leader_name].select(
             start=start,
             stop=stop,
-            topics=self.follow_topics,
+            topics=self.topics,
             inclusive_of_start=inclusive_of_start,
         )
 
     def filter_received_notifications(
         self, notifications: list[Notification]
     ) -> list[Notification]:
-        if self.follow_topics:
-            return [n for n in notifications if n.topic in self.follow_topics]
+        if self.topics:
+            return [n for n in notifications if n.topic in self.topics]
         return notifications
 
     def convert_notifications(
@@ -151,64 +152,6 @@ class Follower(Application):
             processing_jobs.append((domain_event, tracking))
         return processing_jobs
 
-    # @retry(IntegrityError, max_attempts=50000, wait=0.01)
-    def process_event(
-        self, domain_event: DomainEventProtocol, tracking: Tracking
-    ) -> None:
-        """Calls :func:`~eventsourcing.system.Follower.policy` method with
-        the given :class:`~eventsourcing.domain.AggregateEvent` and a
-        new :class:`~eventsourcing.application.ProcessingEvent` created from
-        the given :class:`~eventsourcing.persistence.Tracking` object.
-
-        The policy will collect any new aggregate events on the process
-        event object.
-
-        After the policy method returns, the process event object will
-        then be recorded by calling
-        :func:`~eventsourcing.application.Application.record`, which
-        will return new notifications.
-
-        After calling
-        :func:`~eventsourcing.application.Application.take_snapshots`,
-        the new notifications are passed to the
-        :func:`~eventsourcing.application.Application.notify` method.
-        """
-        processing_event = ProcessingEvent(tracking=tracking)
-        with self.processing_lock:
-            self.policy(domain_event, processing_event)
-            try:
-                recordings = self._record(processing_event)
-            except IntegrityError:
-                if self.recorder.has_tracking_id(
-                    tracking.application_name,
-                    tracking.notification_id,
-                ):
-                    pass
-                else:
-                    raise
-            else:
-                self._take_snapshots(processing_event)
-                self.notify(processing_event.events)
-                self._notify(recordings)
-
-    @singledispatchmethod
-    def policy(
-        self,
-        domain_event: DomainEventProtocol,
-        processing_event: ProcessingEvent,
-    ) -> None:
-        """Abstract domain event processing policy method. Must be
-        implemented by event processing applications. When
-        processing the given domain event, event processing
-        applications must use the :func:`~ProcessingEvent.collect_events`
-        method of the given process event object (instead of
-        the application's :func:`~eventsourcing.application.Application.save`
-        method) to collect pending events from changed aggregates,
-        so that the new domain events will be recorded atomically
-        with tracking information about the position of the given
-        domain event's notification.
-        """
-
 
 class RecordingEventReceiver(ABC):
     """Abstract base class for objects that may receive recording events."""
@@ -279,8 +222,8 @@ class System:
         pipes: Iterable[Iterable[type[Application]]],
     ):
         # Remember the caller frame's module, so that we might identify a topic.
-        caller_frame = cast("FrameType", inspect.currentframe()).f_back
-        module = cast("ModuleType", inspect.getmodule(caller_frame))
+        caller_frame = cast(FrameType, inspect.currentframe()).f_back
+        module = cast(ModuleType, inspect.getmodule(caller_frame))
         type(self).__caller_modules[id(self)] = module  # noqa: SLF001
 
         # Build nodes and edges.
@@ -629,9 +572,9 @@ class NewSingleThreadedRunner(Runner, RecordingEventReceiver):
                                 follower = self.apps[follower_name]
                                 assert isinstance(follower, Follower)
                                 if (
-                                    follower.follow_topics
+                                    follower.topics
                                     and recording.notification.topic
-                                    not in follower.follow_topics
+                                    not in follower.topics
                                 ):
                                     continue
                                 follower.process_event(
@@ -1076,9 +1019,8 @@ class ConvertingThread(threading.Thread):
                     recording_event = recording_event_or_notifications
                     for recording in recording_event.recordings:
                         if (
-                            self.follower.follow_topics
-                            and recording.notification.topic
-                            not in self.follower.follow_topics
+                            self.follower.topics
+                            and recording.notification.topic not in self.follower.topics
                         ):
                             continue
                         tracking = Tracking(

eventsourcing/tests/persistence.py

@@ -450,8 +450,8 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         num_writers = 10
         num_writes_per_writer = 100
         num_events_per_write = 100
-        reader_sleep = 0.0
-        writer_sleep = 0.0
+        reader_sleep = 0.0001
+        writer_sleep = 0.0001
 
         def insert_events() -> None:
             thread_id = get_ident()

{eventsourcing-9.4.0b4.dist-info → eventsourcing-9.4.1.dist-info}/METADATA

@@ -1,33 +1,32 @@
 Metadata-Version: 2.3
 Name: eventsourcing
-Version: 9.4.0b4
+Version: 9.4.1
 Summary: Event sourcing in Python
-License: BSD 3-Clause
+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 :: 4 - Beta
+Requires-Python: >=3.9.2
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: BSD License
-Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Provides-Extra: crypto
 Provides-Extra: cryptography
 Provides-Extra: postgres
-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: cryptography (>=44.0,<45.0) ; extra == "cryptography"
+Requires-Dist: psycopg[pool] (>=3.2,<3.3) ; extra == "postgres"
+Requires-Dist: pycryptodome (>=3.22,<4.0) ; extra == "crypto"
 Requires-Dist: typing_extensions
 Project-URL: Homepage, https://github.com/pyeventsourcing/eventsourcing
 Project-URL: Repository, https://github.com/pyeventsourcing/eventsourcing
@@ -43,7 +42,10 @@ Description-Content-Type: text/markdown
 
 # Event Sourcing in Python
 
-A library for event sourcing in Python.
+This project is a comprehensive Python library for implementing event sourcing, a design pattern where all
+changes to application state are stored as a sequence of events. This library provides a solid foundation
+for building event-sourced applications in Python, with a focus on reliability, performance, and developer
+experience. Please [read the docs](https://eventsourcing.readthedocs.io/). See also [extension projects](https://github.com/pyeventsourcing).
 
 *"totally amazing and a pleasure to use"*
 
@@ -51,8 +53,6 @@ A library for event sourcing in Python.
 
 *"a huge help and time saver"*
 
-Please [read the docs](https://eventsourcing.readthedocs.io/). See also [extension projects](https://github.com/pyeventsourcing).
-
 
 ## Installation
 

{eventsourcing-9.4.0b4.dist-info → eventsourcing-9.4.1.dist-info}/RECORD

@@ -8,19 +8,19 @@ eventsourcing/domain.py,sha256=bIELG5g8O4KhBBJMa9A0YeUe9EIuHul4LvCvGBuUhls,62962
 eventsourcing/interface.py,sha256=-VLoqcd9a0PXpD_Bv0LjCiG21xLREG6tXK6phgtShOw,5035
 eventsourcing/persistence.py,sha256=y_1o3LNi9tkOTqkvjgsGF4un4XPXEgxzt0Iwhk7UzEI,46340
 eventsourcing/popo.py,sha256=xZD6mig7bVwAoHe-UdraXvuu2iL5a8b2b41cEcBHlBU,9642
-eventsourcing/postgres.py,sha256=lcbLvHCiUCYyHeIn4Fh7RHEjrbdmIrZC9XwfTOH4t4Q,37544
-eventsourcing/projection.py,sha256=-iTNb8nFUKeKEle8lih-n8vp_G5F98W08XgJKFDMk8Y,9829
+eventsourcing/postgres.py,sha256=LGEsfAN_cUOL6xX0NT4gxVcu2Btma95WLqtYcEzdPSA,37757
+eventsourcing/projection.py,sha256=2qkagy2o1sts22LqndYZzsDV7AJK28oGkPrFH1ECnYM,15069
 eventsourcing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-eventsourcing/sqlite.py,sha256=_9ENoxEY7hqHGhOS4HBgElibBXyHI2vJ5nUVAQuffD0,22016
-eventsourcing/system.py,sha256=3mbxQRFLg8wQ8ulThd6y0CKBjtmo6lR3gZf9ZFITNCI,46888
+eventsourcing/sqlite.py,sha256=1DRQgDE1S7lz7Mnz9QH6WZ4luMjI9tof1YpH5qrK9u8,22076
+eventsourcing/system.py,sha256=WCfuSc45A9A1fFO7zpDum_ddh4pU7x-vEcpVZ_ycAyE,44358
 eventsourcing/tests/__init__.py,sha256=FtOyuj-L-oSisYeByTIrnUw-XzsctSbq76XmjPy5fMc,102
 eventsourcing/tests/application.py,sha256=pAn9Cugp_1rjOtj_nruGhh7PxdrQWibDlrnOAlOKXwo,20614
 eventsourcing/tests/domain.py,sha256=yN-F6gMRumeX6nIXIcZGxAR3RrUslzmEMM8JksnkI8Q,3227
-eventsourcing/tests/persistence.py,sha256=DVSKySk86iRW-QKGgs-4ca1C956N1LoGhYEXXesBF6k,58648
+eventsourcing/tests/persistence.py,sha256=jy_aMQwRGKQKohw8Ji7oBf1aFIdcHLHiSrHxH6yHvzw,58654
 eventsourcing/tests/postgres_utils.py,sha256=0ywklGp6cXZ5PmV8ANVkwSHsZZCl5zTmOk7iG-RmrCE,1548
 eventsourcing/utils.py,sha256=pOnczXzaE5q7UbQbPmgcpWaP660fsmfiDJs6Gmo8QCM,8558
-eventsourcing-9.4.0b4.dist-info/AUTHORS,sha256=8aHOM4UbNZcKlD-cHpFRcM6RWyCqtwtxRev6DeUgVRs,137
-eventsourcing-9.4.0b4.dist-info/LICENSE,sha256=CQEQzcZO8AWXL5i3hIo4yVKrYjh2FBz6hCM7kpXWpw4,1512
-eventsourcing-9.4.0b4.dist-info/METADATA,sha256=ue7kdW9BT-cgWYdlTkULnlBwCKxr1_xzPGyoVcrb7-I,9796
-eventsourcing-9.4.0b4.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-eventsourcing-9.4.0b4.dist-info/RECORD,,
+eventsourcing-9.4.1.dist-info/AUTHORS,sha256=8aHOM4UbNZcKlD-cHpFRcM6RWyCqtwtxRev6DeUgVRs,137
+eventsourcing-9.4.1.dist-info/LICENSE,sha256=CQEQzcZO8AWXL5i3hIo4yVKrYjh2FBz6hCM7kpXWpw4,1512
+eventsourcing-9.4.1.dist-info/METADATA,sha256=c_uEtz47qhAkUkxw8RE5xfPV5K4GufPon70MObdblXw,9959
+eventsourcing-9.4.1.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+eventsourcing-9.4.1.dist-info/RECORD,,