eventsourcing 9.3.4__py3-none-any.whl → 9.4.0a1__py3-none-any.whl

eventsourcing/tests/persistence.py

@@ -26,11 +26,14 @@ from eventsourcing.persistence import (
     IntegrityError,
     JSONTranscoder,
     Mapper,
+    Notification,
     ProcessRecorder,
     StoredEvent,
     Tracking,
+    TrackingRecorder,
     Transcoding,
     UUIDAsHex,
+    WaitInterruptedError,
 )
 from eventsourcing.utils import Environment, get_topic
 
@@ -206,6 +209,7 @@ class AggregateRecorderTestCase(TestCase, ABC):
 
 class ApplicationRecorderTestCase(TestCase, ABC):
     INITIAL_VERSION = 1
+    EXPECT_CONTIGUOUS_NOTIFICATION_IDS = True
 
     @abstractmethod
     def create_recorder(self) -> ApplicationRecorder:
@@ -215,26 +219,15 @@ class ApplicationRecorderTestCase(TestCase, ABC):
         # Construct the recorder.
         recorder = self.create_recorder()
 
-        max_notification_id = recorder.max_notification_id()
-
         # Check notifications methods work when there aren't any.
+        self.assertEqual(len(recorder.select_notifications(start=None, limit=3)), 0)
         self.assertEqual(
-            recorder.max_notification_id(),
-            max_notification_id,
-        )
-        self.assertEqual(
-            len(recorder.select_notifications(max_notification_id + 1, 3)),
-            0,
-        )
-        self.assertEqual(
-            len(
-                recorder.select_notifications(
-                    max_notification_id + 1, 3, topics=["topic1"]
-                )
-            ),
+            len(recorder.select_notifications(start=None, limit=3, topics=["topic1"])),
             0,
         )
 
+        self.assertIsNone(recorder.max_notification_id())
+
         # Write two stored events.
         originator_id1 = uuid4()
         originator_id2 = uuid4()
@@ -253,9 +246,7 @@ class ApplicationRecorderTestCase(TestCase, ABC):
         )
 
         notification_ids = recorder.insert_events([stored_event1, stored_event2])
-        self.assertEqual(
-            notification_ids, [max_notification_id + 1, max_notification_id + 2]
-        )
+        self.assertEqual(notification_ids, [1, 2])
 
         # Store a third event.
         stored_event3 = StoredEvent(
@@ -265,7 +256,7 @@ class ApplicationRecorderTestCase(TestCase, ABC):
             state=b"state3",
         )
         notification_ids = recorder.insert_events([stored_event3])
-        self.assertEqual(notification_ids, [max_notification_id + 3])
+        self.assertEqual(notification_ids, [3])
 
         stored_events1 = recorder.select_events(originator_id1)
         stored_events2 = recorder.select_events(originator_id2)
@@ -279,111 +270,158 @@ class ApplicationRecorderTestCase(TestCase, ABC):
             recorder.insert_events([stored_event3])
 
         sleep(1)  # Added to make eventsourcing-axon tests work, perhaps not necessary.
-        notifications = recorder.select_notifications(max_notification_id + 1, 3)
+        notifications = recorder.select_notifications(start=None, limit=10)
         self.assertEqual(len(notifications), 3)
-        self.assertEqual(notifications[0].id, max_notification_id + 1)
+        self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
         self.assertEqual(notifications[0].topic, "topic1")
         self.assertEqual(notifications[0].state, b"state1")
-        self.assertEqual(notifications[1].id, max_notification_id + 2)
+        self.assertEqual(notifications[1].id, 2)
         self.assertEqual(notifications[1].originator_id, originator_id1)
         self.assertEqual(notifications[1].topic, "topic2")
         self.assertEqual(notifications[1].state, b"state2")
-        self.assertEqual(notifications[2].id, max_notification_id + 3)
+        self.assertEqual(notifications[2].id, 3)
         self.assertEqual(notifications[2].originator_id, originator_id2)
         self.assertEqual(notifications[2].topic, "topic3")
         self.assertEqual(notifications[2].state, b"state3")
 
-        notifications = recorder.select_notifications(
-            max_notification_id + 1, 3, topics=["topic1", "topic2", "topic3"]
-        )
+        notifications = recorder.select_notifications(start=1, limit=10)
         self.assertEqual(len(notifications), 3)
-        self.assertEqual(notifications[0].id, max_notification_id + 1)
+        self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
         self.assertEqual(notifications[0].topic, "topic1")
         self.assertEqual(notifications[0].state, b"state1")
-        self.assertEqual(notifications[1].id, max_notification_id + 2)
+        self.assertEqual(notifications[1].id, 2)
         self.assertEqual(notifications[1].originator_id, originator_id1)
         self.assertEqual(notifications[1].topic, "topic2")
         self.assertEqual(notifications[1].state, b"state2")
-        self.assertEqual(notifications[2].id, max_notification_id + 3)
+        self.assertEqual(notifications[2].id, 3)
         self.assertEqual(notifications[2].originator_id, originator_id2)
         self.assertEqual(notifications[2].topic, "topic3")
         self.assertEqual(notifications[2].state, b"state3")
 
-        notifications = recorder.select_notifications(
-            max_notification_id + 1, 3, topics=["topic1"]
-        )
-        self.assertEqual(len(notifications), 1)
-        self.assertEqual(notifications[0].id, max_notification_id + 1)
+        notifications = recorder.select_notifications(start=None, stop=2, limit=10)
+        self.assertEqual(len(notifications), 2)
+        self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
         self.assertEqual(notifications[0].topic, "topic1")
         self.assertEqual(notifications[0].state, b"state1")
+        self.assertEqual(notifications[1].id, 2)
+        self.assertEqual(notifications[1].originator_id, originator_id1)
+        self.assertEqual(notifications[1].topic, "topic2")
+        self.assertEqual(notifications[1].state, b"state2")
 
         notifications = recorder.select_notifications(
-            max_notification_id + 1, 3, topics=["topic2"]
+            start=1, limit=10, inclusive_of_start=False
         )
-        self.assertEqual(len(notifications), 1)
-        self.assertEqual(notifications[0].id, max_notification_id + 2)
+        self.assertEqual(len(notifications), 2)
+        self.assertEqual(notifications[0].id, 2)
         self.assertEqual(notifications[0].originator_id, originator_id1)
         self.assertEqual(notifications[0].topic, "topic2")
         self.assertEqual(notifications[0].state, b"state2")
+        self.assertEqual(notifications[1].id, 3)
+        self.assertEqual(notifications[1].originator_id, originator_id2)
+        self.assertEqual(notifications[1].topic, "topic3")
+        self.assertEqual(notifications[1].state, b"state3")
 
         notifications = recorder.select_notifications(
-            max_notification_id + 1, 3, topics=["topic3"]
+            start=2, limit=10, inclusive_of_start=False
         )
         self.assertEqual(len(notifications), 1)
-        self.assertEqual(notifications[0].id, max_notification_id + 3)
+        self.assertEqual(notifications[0].id, 3)
         self.assertEqual(notifications[0].originator_id, originator_id2)
         self.assertEqual(notifications[0].topic, "topic3")
         self.assertEqual(notifications[0].state, b"state3")
 
         notifications = recorder.select_notifications(
-            max_notification_id + 1, 3, topics=["topic1", "topic3"]
+            start=None, limit=10, topics=["topic1", "topic2", "topic3"]
         )
+        self.assertEqual(len(notifications), 3)
+        self.assertEqual(notifications[0].id, 1)
+        self.assertEqual(notifications[0].originator_id, originator_id1)
+        self.assertEqual(notifications[0].topic, "topic1")
+        self.assertEqual(notifications[0].state, b"state1")
+        self.assertEqual(notifications[1].id, 2)
+        self.assertEqual(notifications[1].originator_id, originator_id1)
+        self.assertEqual(notifications[1].topic, "topic2")
+        self.assertEqual(notifications[1].state, b"state2")
+        self.assertEqual(notifications[2].id, 3)
+        self.assertEqual(notifications[2].originator_id, originator_id2)
+        self.assertEqual(notifications[2].topic, "topic3")
+        self.assertEqual(notifications[2].state, b"state3")
+
+        notifications = recorder.select_notifications(1, 10, topics=["topic1"])
+        self.assertEqual(len(notifications), 1)
+        self.assertEqual(notifications[0].id, 1)
+        self.assertEqual(notifications[0].originator_id, originator_id1)
+        self.assertEqual(notifications[0].topic, "topic1")
+        self.assertEqual(notifications[0].state, b"state1")
+
+        notifications = recorder.select_notifications(1, 3, topics=["topic2"])
+        self.assertEqual(len(notifications), 1)
+        self.assertEqual(notifications[0].id, 2)
+        self.assertEqual(notifications[0].originator_id, originator_id1)
+        self.assertEqual(notifications[0].topic, "topic2")
+        self.assertEqual(notifications[0].state, b"state2")
+
+        notifications = recorder.select_notifications(1, 3, topics=["topic3"])
+        self.assertEqual(len(notifications), 1)
+        self.assertEqual(notifications[0].id, 3)
+        self.assertEqual(notifications[0].originator_id, originator_id2)
+        self.assertEqual(notifications[0].topic, "topic3")
+        self.assertEqual(notifications[0].state, b"state3")
+
+        notifications = recorder.select_notifications(1, 3, topics=["topic1", "topic3"])
         self.assertEqual(len(notifications), 2)
-        self.assertEqual(notifications[0].id, max_notification_id + 1)
+        self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
         self.assertEqual(notifications[0].topic, "topic1")
         self.assertEqual(notifications[0].state, b"state1")
-        self.assertEqual(notifications[1].id, max_notification_id + 3)
+        self.assertEqual(notifications[1].id, 3)
         self.assertEqual(notifications[1].topic, "topic3")
         self.assertEqual(notifications[1].state, b"state3")
 
-        self.assertEqual(
-            recorder.max_notification_id(),
-            max_notification_id + 3,
-        )
+        self.assertEqual(recorder.max_notification_id(), 3)
+
+        # Check limit is working
+        notifications = recorder.select_notifications(None, 1)
+        self.assertEqual(len(notifications), 1)
+        self.assertEqual(notifications[0].id, 1)
 
-        notifications = recorder.select_notifications(max_notification_id + 1, 1)
+        notifications = recorder.select_notifications(2, 1)
         self.assertEqual(len(notifications), 1)
-        self.assertEqual(notifications[0].id, max_notification_id + 1)
+        self.assertEqual(notifications[0].id, 2)
 
-        notifications = recorder.select_notifications(max_notification_id + 2, 1)
+        notifications = recorder.select_notifications(1, 1, inclusive_of_start=False)
         self.assertEqual(len(notifications), 1)
-        self.assertEqual(notifications[0].id, max_notification_id + 2)
+        self.assertEqual(notifications[0].id, 2)
 
-        notifications = recorder.select_notifications(max_notification_id + 2, 2)
+        notifications = recorder.select_notifications(2, 2)
         self.assertEqual(len(notifications), 2)
-        self.assertEqual(notifications[0].id, max_notification_id + 2)
-        self.assertEqual(notifications[1].id, max_notification_id + 3)
+        self.assertEqual(notifications[0].id, 2)
+        self.assertEqual(notifications[1].id, 3)
 
-        notifications = recorder.select_notifications(max_notification_id + 3, 1)
+        notifications = recorder.select_notifications(3, 1)
         self.assertEqual(len(notifications), 1)
-        self.assertEqual(notifications[0].id, max_notification_id + 3)
+        self.assertEqual(notifications[0].id, 3)
 
-        notifications = recorder.select_notifications(
-            start=max_notification_id + 2, limit=10, stop=max_notification_id + 2
-        )
+        notifications = recorder.select_notifications(3, 1, inclusive_of_start=False)
+        self.assertEqual(len(notifications), 0)
+
+        notifications = recorder.select_notifications(start=2, limit=10, stop=2)
         self.assertEqual(len(notifications), 1)
-        self.assertEqual(notifications[0].id, max_notification_id + 2)
+        self.assertEqual(notifications[0].id, 2)
+
+        notifications = recorder.select_notifications(start=1, limit=10, stop=2)
+        self.assertEqual(len(notifications), 2, len(notifications))
+        self.assertEqual(notifications[0].id, 1)
+        self.assertEqual(notifications[1].id, 2)
 
         notifications = recorder.select_notifications(
-            start=max_notification_id + 1, limit=10, stop=max_notification_id + 2
+            start=1, limit=10, stop=2, inclusive_of_start=False
         )
-        self.assertEqual(len(notifications), 2, len(notifications))
-        self.assertEqual(notifications[0].id, max_notification_id + 1)
-        self.assertEqual(notifications[1].id, max_notification_id + 2)
+        self.assertEqual(len(notifications), 1, len(notifications))
+        self.assertEqual(notifications[0].id, 2)
 
     def test_concurrent_no_conflicts(self) -> None:
         print(self)
@@ -430,7 +468,7 @@ class ApplicationRecorderTestCase(TestCase, ABC):
             try:
                 recorder.insert_events(stored_events)
 
-            except Exception as e:  # pragma: nocover
+            except Exception as e:  # pragma: no cover
                 if errors:
                     return
                 ended = datetime.now()
@@ -451,7 +489,7 @@ class ApplicationRecorderTestCase(TestCase, ABC):
             while not stop_reading.is_set():
                 try:
                     recorder.select_notifications(0, 10)
-                except Exception as e:  # pragma: nocover
+                except Exception as e:  # pragma: no cover
                     errors.append(e)
                     return
                 # else:
@@ -466,22 +504,22 @@ class ApplicationRecorderTestCase(TestCase, ABC):
         with ThreadPoolExecutor(max_workers=num_writers) as executor:
             futures = []
             for _ in range(num_writes_per_writer):
-                if errors:  # pragma: nocover
+                if errors:  # pragma: no cover
                     break
                 future = executor.submit(insert_events)
                 futures.append(future)
             for future in futures:
-                if errors:  # pragma: nocover
+                if errors:  # pragma: no cover
                     break
                 try:
                     future.result()
-                except Exception as e:  # pragma: nocover
+                except Exception as e:  # pragma: no cover
                     errors.append(e)
                     break
 
         stop_reading.set()
 
-        if errors:  # pragma: nocover
+        if errors:  # pragma: no cover
             raise errors[0]
 
         for thread_id, thread_num in threads.items():
@@ -529,7 +567,7 @@ class ApplicationRecorderTestCase(TestCase, ABC):
             try:
                 recorder.insert_events(stored_events)
 
-            except Exception:  # pragma: nocover
+            except Exception:  # pragma: no cover
                 errors_happened.set()
                 tb = traceback.format_exc()
                 print(tb)
@@ -555,10 +593,174 @@ class ApplicationRecorderTestCase(TestCase, ABC):
         rate = num_jobs * num_events / (ended - started).total_seconds()
         print(f"Rate: {rate:.0f} inserts per second")
 
+    def optional_test_insert_subscribe(self) -> None:
+
+        recorder = self.create_recorder()
+
+        # Get the max notification ID.
+        max_notification_id1 = recorder.max_notification_id()
+
+        # Write two stored events.
+        originator_id1 = uuid4()
+        originator_id2 = uuid4()
+
+        stored_event1 = StoredEvent(
+            originator_id=originator_id1,
+            originator_version=self.INITIAL_VERSION,
+            topic="topic1",
+            state=b"state1",
+        )
+        stored_event2 = StoredEvent(
+            originator_id=originator_id1,
+            originator_version=self.INITIAL_VERSION + 1,
+            topic="topic2",
+            state=b"state2",
+        )
+
+        notification_ids = recorder.insert_events([stored_event1, stored_event2])
+        if self.EXPECT_CONTIGUOUS_NOTIFICATION_IDS:
+            self.assertEqual(notification_ids, [1, 2])
+
+        # Get the max notification ID.
+        max_notification_id2 = recorder.max_notification_id()
+
+        # Start a subscription with default value for 'start'.
+        with recorder.subscribe() as subscription:
+
+            # Receive events from the subscription.
+            for _ in subscription:
+                break
+
+        # Start a subscription with None value for 'start'.
+        with recorder.subscribe(gt=None) as subscription:
+
+            # Receive events from the subscription.
+            for _ in subscription:
+                break
+
+        # Start a subscription with int value for 'start'.
+        with recorder.subscribe(gt=max_notification_id1) as subscription:
+
+            # Receive events from the subscription.
+            notifications: List[Notification] = []
+            for notification in subscription:
+                notifications.append(notification)
+                if len(notifications) == 2:
+                    break
+
+            # Check the events we received are the ones that were written.
+            self.assertEqual(
+                stored_event1.originator_id, notifications[0].originator_id
+            )
+            self.assertEqual(
+                stored_event1.originator_version, notifications[0].originator_version
+            )
+            self.assertEqual(
+                stored_event2.originator_id, notifications[1].originator_id
+            )
+            self.assertEqual(
+                stored_event2.originator_version, notifications[1].originator_version
+            )
+            if self.EXPECT_CONTIGUOUS_NOTIFICATION_IDS:
+                self.assertEqual(1, notifications[0].id)
+                self.assertEqual(2, notifications[1].id)
+
+            # Store a third event.
+            stored_event3 = StoredEvent(
+                originator_id=originator_id2,
+                originator_version=self.INITIAL_VERSION,
+                topic="topic3",
+                state=b"state3",
+            )
+            notification_ids = recorder.insert_events([stored_event3])
+            if self.EXPECT_CONTIGUOUS_NOTIFICATION_IDS:
+                self.assertEqual(notification_ids, [3])
+
+            # Receive events from the subscription.
+            for notification in subscription:
+                notifications.append(notification)
+                if len(notifications) == 3:
+                    break
+
+            # Check the events we received are the ones that were written.
+            self.assertEqual(
+                stored_event3.originator_id, notifications[2].originator_id
+            )
+            self.assertEqual(
+                stored_event3.originator_version, notifications[2].originator_version
+            )
+            if self.EXPECT_CONTIGUOUS_NOTIFICATION_IDS:
+                self.assertEqual(3, notifications[2].id)
+
+        # Start a subscription with int value for 'start'.
+        with recorder.subscribe(gt=max_notification_id2) as subscription:
+
+            # Receive events from the subscription.
+            notifications: List[Notification] = []
+            for notification in subscription:
+                notifications.append(notification)
+                if len(notifications) == 1:
+                    break
+
+            # Check the events we received are the ones that were written.
+            self.assertEqual(
+                stored_event3.originator_id, notifications[0].originator_id
+            )
+
     def close_db_connection(self, *args: Any) -> None:
         """"""
 
 
+class TrackingRecorderTestCase(TestCase, ABC):
+    @abstractmethod
+    def create_recorder(self) -> ProcessRecorder:
+        """"""
+
+    def test_insert_tracking(self):
+        tracking_recorder = self.create_recorder()
+
+        # Construct tracking objects.
+        tracking1 = Tracking(notification_id=21, application_name="upstream1")
+        tracking2 = Tracking(notification_id=22, application_name="upstream1")
+        tracking3 = Tracking(notification_id=21, application_name="upstream2")
+
+        # Insert tracking objects.
+        tracking_recorder.insert_tracking(tracking=tracking1)
+        tracking_recorder.insert_tracking(tracking=tracking2)
+        tracking_recorder.insert_tracking(tracking=tracking3)
+
+        # Fail to insert same tracking object twice.
+        with self.assertRaises(IntegrityError):
+            tracking_recorder.insert_tracking(tracking=tracking1)
+        with self.assertRaises(IntegrityError):
+            tracking_recorder.insert_tracking(tracking=tracking2)
+        with self.assertRaises(IntegrityError):
+            tracking_recorder.insert_tracking(tracking=tracking3)
+
+        # Get latest tracked position.
+        self.assertEqual(tracking_recorder.max_tracking_id("upstream1"), 22)
+        self.assertEqual(tracking_recorder.max_tracking_id("upstream2"), 21)
+        self.assertIsNone(tracking_recorder.max_tracking_id("upstream3"))
+
+        # Check if an event notification has been processed.
+        assert tracking_recorder.has_tracking_id("upstream1", 21)
+        assert tracking_recorder.has_tracking_id("upstream1", 22)
+        assert tracking_recorder.has_tracking_id("upstream2", 21)
+        assert not tracking_recorder.has_tracking_id("upstream2", 22)
+
+    def test_wait(self):
+        tracking_recorder = self.create_recorder()
+        tracking1 = Tracking(notification_id=21, application_name="upstream1")
+        tracking_recorder.insert_tracking(tracking=tracking1)
+        tracking_recorder.wait("upstream1", 21)
+        with self.assertRaises(TimeoutError):
+            tracking_recorder.wait("upstream1", 22, timeout=0.1)
+        with self.assertRaises(WaitInterruptedError):
+            interrupt = Event()
+            interrupt.set()
+            tracking_recorder.wait("upstream1", 22, interrupt=interrupt)
+
+
 class ProcessRecorderTestCase(TestCase, ABC):
     @abstractmethod
     def create_recorder(self) -> ProcessRecorder:
@@ -569,10 +771,7 @@ class ProcessRecorderTestCase(TestCase, ABC):
         recorder = self.create_recorder()
 
         # Get current position.
-        self.assertEqual(
-            recorder.max_tracking_id("upstream_app"),
-            0,
-        )
+        self.assertIsNone(recorder.max_tracking_id("upstream_app"))
 
         # Write two stored events.
         originator_id1 = uuid4()
@@ -775,7 +974,9 @@ class NonInterleavingNotificationIDsBaseCase(ABC, TestCase):
 
         sleep(1)  # Added to make eventsourcing-axon tests work, perhaps not necessary.
         notifications = recorder.select_notifications(
-            start=max_notification_id + 1, limit=2 * self.insert_num
+            start=max_notification_id,
+            limit=2 * self.insert_num,
+            inclusive_of_start=False,
         )
         ids_for_sequence1 = [
             e.id for e in notifications if e.originator_id == originator1_id
@@ -827,6 +1028,14 @@ class InfrastructureFactoryTestCase(ABC, TestCase):
     def expected_application_recorder_class(self):
         pass
 
+    @abstractmethod
+    def expected_tracking_recorder_class(self):
+        pass
+
+    @abstractmethod
+    def tracking_recorder_subclass(self):
+        pass
+
     @abstractmethod
     def expected_process_recorder_class(self):
         pass
@@ -978,6 +1187,26 @@ class InfrastructureFactoryTestCase(ABC, TestCase):
         recorder = self.factory.application_recorder()
         self.assertEqual(type(recorder), self.expected_application_recorder_class())
 
+    def test_create_tracking_recorder(self):
+        recorder = self.factory.tracking_recorder()
+        self.assertEqual(type(recorder), self.expected_tracking_recorder_class())
+        self.assertIsInstance(recorder, TrackingRecorder)
+
+        # Exercise code path where table is not created.
+        self.env["CREATE_TABLE"] = "f"
+        recorder = self.factory.tracking_recorder()
+        self.assertEqual(type(recorder), self.expected_tracking_recorder_class())
+
+        # Exercise code path where tracking recorder class is specified as arg.
+        subclass = self.tracking_recorder_subclass()
+        recorder = self.factory.tracking_recorder(subclass)
+        self.assertEqual(type(recorder), subclass)
+
+        # Exercise code path where tracking recorder class is specified as topic.
+        self.factory.env[self.factory.TRACKING_RECORDER_TOPIC] = get_topic(subclass)
+        recorder = self.factory.tracking_recorder()
+        self.assertEqual(type(recorder), subclass)
+
     def test_create_process_recorder(self):
         recorder = self.factory.process_recorder()
         self.assertEqual(type(recorder), self.expected_process_recorder_class())

eventsourcing/utils.py

@@ -22,7 +22,7 @@ from typing import (
     overload,
 )
 
-if TYPE_CHECKING:  # pragma: nocover
+if TYPE_CHECKING:  # pragma: no cover
     from types import FunctionType, WrapperDescriptorType
 
 

{eventsourcing-9.3.4.dist-info → eventsourcing-9.4.0a1.dist-info}/LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2023, John Bywater
+Copyright (c) 2025, John Bywater
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

{eventsourcing-9.3.4.dist-info → eventsourcing-9.4.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eventsourcing
-Version: 9.3.4
+Version: 9.4.0a1
 Summary: Event sourcing in Python
 Home-page: https://github.com/pyeventsourcing/eventsourcing
 License: BSD 3-Clause
@@ -8,7 +8,7 @@ Keywords: event sourcing,event store,domain driven design,domain-driven design,d
 Author: John Bywater
 Author-email: john.bywater@appropriatesoftware.net
 Requires-Python: >=3.8,<4.0
-Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research

eventsourcing-9.4.0a1.dist-info/RECORD

@@ -0,0 +1,25 @@
+eventsourcing/__init__.py,sha256=st2H3shrhTk5rqoUeZHUW8XD9iOX9tGGtQFWr2HGYmo,26
+eventsourcing/application.py,sha256=YuZEE7le3GX3kVBje16stGziSIoUt6pUEBdlCDwkXf8,37847
+eventsourcing/cipher.py,sha256=S43YMycOCoEnzvWSanClv_MzMwDU5nBu5RU72G8BpYA,3201
+eventsourcing/compressor.py,sha256=IdvrJUB9B2td871oifInv4lGXmHwYL9d69MbHHCr7uI,421
+eventsourcing/dispatch.py,sha256=yYSpT-jqc6l_wTdqEnfPJJfvsZN2Ta8g2anrVPWIcqQ,1412
+eventsourcing/domain.py,sha256=b25jDhgP0aWsSEXXOxzN7plLi0TmDpoW7iZ5UHLTd8w,58339
+eventsourcing/interface.py,sha256=LIFI9AZhoVWUAq4YjKosGCpinf51jmVLqw1Ii4npSHo,5079
+eventsourcing/persistence.py,sha256=q4iJ_mFWiHgWVuJHYScXZQPvVMIdl-FvRlBruYH9SKE,45752
+eventsourcing/popo.py,sha256=FQmD7zJXoIyt3t-4RFADQ7UAhGWo1c7Cp0AkTQUjIW8,9413
+eventsourcing/postgres.py,sha256=tOCHY1xCMzEwDZ_JOMtWS5C8OXsbCrBOYaX-fz1oxA4,36158
+eventsourcing/projection.py,sha256=I1YrhMt5TyLdZru4ojtppo1W1r8fTrFZJ3VB61lzk-s,5158
+eventsourcing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/sqlite.py,sha256=pbiuBU8x1J5uJqjqB1P9LshzDQqINYaZ-oBaYYNvo2s,21929
+eventsourcing/system.py,sha256=8FaI7LlwiAQGP2dULFbDwby30eUpnAePcOdmqGlm4EQ,47134
+eventsourcing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/tests/application.py,sha256=s7GA3FEi6IV_wHk2lNZKJ25A1T3PkkfJo4AVVW6-cnc,19009
+eventsourcing/tests/domain.py,sha256=lHSlY6jIoSeqlcPSbrrozEPUJGvJ8bgPrznlmzTxn2w,3254
+eventsourcing/tests/persistence.py,sha256=uink4W_CjeAlaSfzqRBuaDH2fYKAlZ1rvL7lhyUobp8,55553
+eventsourcing/tests/postgres_utils.py,sha256=xymcGYasUXeZTBenkHz-ykD8HtrFjVM1Z7-qRrH6OQk,1364
+eventsourcing/utils.py,sha256=cGS_R5gZt9mp9Sj4qzXwJKvDkVvRUcFyQbUQfNLoy4M,8248
+eventsourcing-9.4.0a1.dist-info/AUTHORS,sha256=8aHOM4UbNZcKlD-cHpFRcM6RWyCqtwtxRev6DeUgVRs,137
+eventsourcing-9.4.0a1.dist-info/LICENSE,sha256=CQEQzcZO8AWXL5i3hIo4yVKrYjh2FBz6hCM7kpXWpw4,1512
+eventsourcing-9.4.0a1.dist-info/METADATA,sha256=HvyZX_hguCQdfvYovDJLfkgm2YMTNl3nDmCX_21Q0e8,9724
+eventsourcing-9.4.0a1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+eventsourcing-9.4.0a1.dist-info/RECORD,,

eventsourcing-9.3.4.dist-info/RECORD

@@ -1,24 +0,0 @@
-eventsourcing/__init__.py,sha256=st2H3shrhTk5rqoUeZHUW8XD9iOX9tGGtQFWr2HGYmo,26
-eventsourcing/application.py,sha256=c5aTi86mBOiQicmqEUsqseAeL7CwDie3G9e0Y8kWLYM,36324
-eventsourcing/cipher.py,sha256=NJcVfZdSlCER6xryM4zVoY3cmKstF-iSSniB4jmpaKg,3200
-eventsourcing/compressor.py,sha256=IdvrJUB9B2td871oifInv4lGXmHwYL9d69MbHHCr7uI,421
-eventsourcing/dispatch.py,sha256=yYSpT-jqc6l_wTdqEnfPJJfvsZN2Ta8g2anrVPWIcqQ,1412
-eventsourcing/domain.py,sha256=rvm4Sv2MmLcha8_5wqJ13AjmqyWvuzkquYsexUaePIg,57264
-eventsourcing/interface.py,sha256=KzDWLeIkREf-TAFl5AFHtKJwJFA-IthqMKClFkUFqdc,4676
-eventsourcing/persistence.py,sha256=TJseAtsWwdC33XLvcoyHdgwTv6s6KsvQS8XLKIq472s,37672
-eventsourcing/popo.py,sha256=AApSGneHuXa8yHOWdDfsFTMVDI-9ivEpuKTX1BSOXr8,6547
-eventsourcing/postgres.py,sha256=NatfdA-YQQPB1qWsQg23Uhyy6R-hcGNOJHJ1bKmFuKQ,29772
-eventsourcing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-eventsourcing/sqlite.py,sha256=jz7SZk26Gcsjw88KL1xnr4-1tStTW16f1NR6TjMsZnQ,18466
-eventsourcing/system.py,sha256=il05rAzPtKaxragIktMBOEyWGhz16VK0F7cEBlsl4_Q,45561
-eventsourcing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-eventsourcing/tests/application.py,sha256=wBanhWzAZvL3fYxCFe5cloN-Up7uLw6KcdRQ2dhKVAg,17586
-eventsourcing/tests/domain.py,sha256=lHSlY6jIoSeqlcPSbrrozEPUJGvJ8bgPrznlmzTxn2w,3254
-eventsourcing/tests/persistence.py,sha256=giLWEZDdViXY8_SHCJerJ0sYVbJUP3UkLKaEbel9sqs,45777
-eventsourcing/tests/postgres_utils.py,sha256=xymcGYasUXeZTBenkHz-ykD8HtrFjVM1Z7-qRrH6OQk,1364
-eventsourcing/utils.py,sha256=PIWDvoGiKCXsNbR5DirkoJ_svopg80SoH37bqxOcjkU,8247
-eventsourcing-9.3.4.dist-info/AUTHORS,sha256=8aHOM4UbNZcKlD-cHpFRcM6RWyCqtwtxRev6DeUgVRs,137
-eventsourcing-9.3.4.dist-info/LICENSE,sha256=bSE_F-T6cQPmMY5LuJC27km_pGB1XCVuUFx1uY0Nueg,1512
-eventsourcing-9.3.4.dist-info/METADATA,sha256=zGQTtZA_1u5kZOUW7wy5a86JHQoVU4j5tJR1OaIaLFo,9734
-eventsourcing-9.3.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-eventsourcing-9.3.4.dist-info/RECORD,,