eventsourcing 9.3.5__py3-none-any.whl → 9.4.0a2__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:
     from types import FunctionType, WrapperDescriptorType
 
 

{eventsourcing-9.3.5.dist-info → eventsourcing-9.4.0a2.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.5.dist-info → eventsourcing-9.4.0a2.dist-info}/METADATA

@@ -1,14 +1,14 @@
 Metadata-Version: 2.1
 Name: eventsourcing
-Version: 9.3.5
+Version: 9.4.0a2
 Summary: Event sourcing in Python
 Home-page: https://github.com/pyeventsourcing/eventsourcing
 License: BSD 3-Clause
 Keywords: event sourcing,event store,domain driven design,domain-driven design,ddd,cqrs,cqs
 Author: John Bywater
 Author-email: john.bywater@appropriatesoftware.net
-Requires-Python: >=3.8,<4.0
-Classifier: Development Status :: 5 - Production/Stable
+Requires-Python: >=3.8, !=2.7.*, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*
+Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research
@@ -18,22 +18,24 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 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: Topic :: Software Development :: Libraries :: Python Modules
 Provides-Extra: crypto
+Provides-Extra: cryptography
 Provides-Extra: postgres
 Requires-Dist: backports.zoneinfo ; python_version < "3.9"
-Requires-Dist: psycopg[c,pool] (<=3.2.99999) ; extra == "postgres"
-Requires-Dist: pycryptodome (>=3.21,<3.22) ; extra == "crypto"
+Requires-Dist: cryptography (>=44.0,<44.1) ; extra == "cryptography"
+Requires-Dist: psycopg[pool] (<=3.2.99999) ; extra == "postgres"
+Requires-Dist: pycryptodome (>=3.22,<3.23) ; extra == "crypto"
 Requires-Dist: typing_extensions
 Project-URL: Repository, https://github.com/pyeventsourcing/eventsourcing
 Description-Content-Type: text/markdown
 
-[![Build Status](https://github.com/pyeventsourcing/eventsourcing/actions/workflows/runtests.yaml/badge.svg?branch=main)](https://github.com/pyeventsourcing/eventsourcing/tree/main)
+[![Build Status](https://github.com/pyeventsourcing/eventsourcing/actions/workflows/runtests.yaml/badge.svg)](https://github.com/pyeventsourcing/eventsourcing)
 [![Coverage Status](https://coveralls.io/repos/github/pyeventsourcing/eventsourcing/badge.svg?branch=main)](https://coveralls.io/github/pyeventsourcing/eventsourcing?branch=main)
 [![Documentation Status](https://readthedocs.org/projects/eventsourcing/badge/?version=stable)](https://eventsourcing.readthedocs.io/en/stable/)
 [![Latest Release](https://badge.fury.io/py/eventsourcing.svg)](https://pypi.org/project/eventsourcing/)

eventsourcing-9.4.0a2.dist-info/RECORD

@@ -0,0 +1,26 @@
+eventsourcing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/application.py,sha256=eV_R00f5z7u6E5ou2-QpLJnJ2LzjGMxG1WP6Qm_mVfk,36214
+eventsourcing/cipher.py,sha256=AjgOlOv9FF6xyXiFnHwcK6NX5IJ3nPHFL5GzIyWozyg,3265
+eventsourcing/compressor.py,sha256=IdvrJUB9B2td871oifInv4lGXmHwYL9d69MbHHCr7uI,421
+eventsourcing/cryptography.py,sha256=ZsQFyeyMZysADqKy38ECV71j6EMMSbo3VQO7oRnC1h0,2994
+eventsourcing/dispatch.py,sha256=yYSpT-jqc6l_wTdqEnfPJJfvsZN2Ta8g2anrVPWIcqQ,1412
+eventsourcing/domain.py,sha256=pNetJA4uKf1chgfNFKWv1Fke3_V5g0ygRv63WT7nsUc,58208
+eventsourcing/interface.py,sha256=LIFI9AZhoVWUAq4YjKosGCpinf51jmVLqw1Ii4npSHo,5079
+eventsourcing/persistence.py,sha256=h5laiUP4mc6Ur1PoDnNBLXRcl8V-2-ife_hYktlCmmM,45732
+eventsourcing/popo.py,sha256=4q4-l8iuEueqvYzGMzyFEiZaT8dm_PJNosmGwzRt1oo,9393
+eventsourcing/postgres.py,sha256=h4ETgjzZtj9a-otJkMfzHZSxD_hOUWyVTIVuESVI7y0,36138
+eventsourcing/projection.py,sha256=6UNNF_iVYR3nmOfoysgvhtjwYnEBTvsHkQM2gzXPTbQ,6489
+eventsourcing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/sqlite.py,sha256=3bezfl3H9I366NnIwLpn4cz_L3fk0pHNiOSO_Hrq6Xw,21909
+eventsourcing/system.py,sha256=7cM3FBdvr64ZK_xItks1MW2yg1o0OZ1vtKtznFFB_4g,47114
+eventsourcing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/tests/application.py,sha256=Q_NFgRSRWovMcyQOZ8U1AoiIsnEHf_zCpHcP0ADaYvs,17369
+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=QPlHhltgEcL80RWcPJ_PTygzDwhfIowUS3Z5taw0_cA,8228
+eventsourcing-9.4.0a2.dist-info/AUTHORS,sha256=8aHOM4UbNZcKlD-cHpFRcM6RWyCqtwtxRev6DeUgVRs,137
+eventsourcing-9.4.0a2.dist-info/LICENSE,sha256=CQEQzcZO8AWXL5i3hIo4yVKrYjh2FBz6hCM7kpXWpw4,1512
+eventsourcing-9.4.0a2.dist-info/METADATA,sha256=NE7vnBA04-Huk9ZpUL8f3E-W2_BJhFm4V_uX7ZLvX_o,9874
+eventsourcing-9.4.0a2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+eventsourcing-9.4.0a2.dist-info/RECORD,,