eventsourcing 9.4.0b1__py3-none-any.whl → 9.4.0b3__py3-none-any.whl

eventsourcing/tests/application.py

@@ -5,27 +5,30 @@ import sys
 import traceback
 import warnings
 from concurrent.futures import ThreadPoolExecutor
-from datetime import datetime
 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 TYPE_CHECKING, Any, ClassVar
 from unittest import TestCase
 from uuid import UUID, uuid4
 
 from eventsourcing.application import AggregateNotFoundError, Application
-from eventsourcing.domain import Aggregate
+from eventsourcing.domain import Aggregate, datetime_now_with_tzinfo
 from eventsourcing.persistence import (
     InfrastructureFactory,
+    InfrastructureFactoryError,
     IntegrityError,
     JSONTranscoder,
     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))
+if TYPE_CHECKING:
+    from datetime import datetime
+
+TIMEIT_FACTOR = int(os.environ.get("TEST_TIMEIT_FACTOR", default="10"))
 
 
 class ExampleApplicationTestCase(TestCase):
@@ -163,7 +166,7 @@ class ExampleApplicationTestCase(TestCase):
     def print_time(self, test_label: str, duration: float) -> None:
         cls = type(self)
         if cls not in self.started_ats:
-            self.started_ats[cls] = datetime.now()
+            self.started_ats[cls] = datetime_now_with_tzinfo()
             print(f"{cls.__name__: <29} timeit number: {cls.timeit_number}")
             self.counts[cls] = 1
         else:
@@ -178,7 +181,7 @@ class ExampleApplicationTestCase(TestCase):
         )
 
         if self.counts[cls] == 3:
-            cls_duration = datetime.now() - cls.started_ats[cls]
+            cls_duration = datetime_now_with_tzinfo() - cls.started_ats[cls]
             print(f"{cls.__name__: <29} timeit duration: {cls_duration}")
             sys.stdout.flush()
 
@@ -263,7 +266,7 @@ class ApplicationTestCase(TestCase):
         self.assertIsInstance(app.factory, InfrastructureFactory)
 
         # Check exceptions.
-        with self.assertRaises(AssertionError) as cm:
+        with self.assertRaises(InfrastructureFactoryError) as cm:
             Application(env={"PERSISTENCE_MODULE": "eventsourcing.application"})
         self.assertEqual(
             cm.exception.args[0],
@@ -271,14 +274,15 @@ class ApplicationTestCase(TestCase):
             "'eventsourcing.application', expected 1.",
         )
 
-        with self.assertRaises(AssertionError) as cm:
+        with self.assertRaises(InfrastructureFactoryError) as cm:
             Application(
                 env={"PERSISTENCE_MODULE": "eventsourcing.application:Application"}
             )
         self.assertEqual(
+            "Topic 'eventsourcing.application:Application' didn't "
+            "resolve to a persistence module or infrastructure factory class: "
+            "<class 'eventsourcing.application.Application'>",
             cm.exception.args[0],
-            "Not an infrastructure factory class or module: "
-            "eventsourcing.application:Application",
         )
 
     def test_save_returns_recording_event(self) -> None:
@@ -344,96 +348,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 +480,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

@@ -14,9 +14,7 @@ class EmailAddress:
 
 
 class BankAccount(Aggregate):
-    """
-    Aggregate root for bank accounts.
-    """
+    """Aggregate root for bank accounts."""
 
     def __init__(self, full_name: str, email_address: EmailAddress):
         self.full_name = full_name
@@ -27,9 +25,7 @@ class BankAccount(Aggregate):
 
     @classmethod
     def open(cls, full_name: str, email_address: str) -> BankAccount:
-        """
-        Creates new bank account object.
-        """
+        """Creates new bank account object."""
         return cls._create(
             cls.Opened,
             id=uuid4(),
@@ -42,9 +38,7 @@ class BankAccount(Aggregate):
         email_address: str
 
     def append_transaction(self, amount: Decimal) -> None:
-        """
-        Appends given amount as transaction on account.
-        """
+        """Appends given amount as transaction on account."""
         self.check_account_is_not_closed()
         self.check_has_sufficient_funds(amount)
         self.trigger_event(
@@ -62,23 +56,18 @@ class BankAccount(Aggregate):
 
     @dataclass(frozen=True)
     class TransactionAppended(AggregateEvent):
-        """
-        Domain event for when transaction
+        """Domain event for when transaction
         is appended to bank account.
         """
 
         amount: Decimal
 
         def apply(self, aggregate: Aggregate) -> None:
-            """
-            Increments the account balance.
-            """
-            cast(BankAccount, aggregate).balance += self.amount
+            """Increments the account balance."""
+            cast("BankAccount", aggregate).balance += self.amount
 
     def set_overdraft_limit(self, overdraft_limit: Decimal) -> None:
-        """
-        Sets the overdraft limit.
-        """
+        """Sets the overdraft limit."""
         # Check the limit is not a negative value.
         assert overdraft_limit >= Decimal("0.00")
         self.check_account_is_not_closed()
@@ -88,38 +77,29 @@ class BankAccount(Aggregate):
         )
 
     class OverdraftLimitSet(AggregateEvent):
-        """
-        Domain event for when overdraft
+        """Domain event for when overdraft
         limit is set.
         """
 
         overdraft_limit: Decimal
 
         def apply(self, aggregate: Aggregate) -> None:
-            cast(BankAccount, aggregate).overdraft_limit = self.overdraft_limit
+            cast("BankAccount", aggregate).overdraft_limit = self.overdraft_limit
 
     def close(self) -> None:
-        """
-        Closes the bank account.
-        """
+        """Closes the bank account."""
         self.trigger_event(self.Closed)
 
     class Closed(AggregateEvent):
-        """
-        Domain event for when account is closed.
-        """
+        """Domain event for when account is closed."""
 
         def apply(self, aggregate: Aggregate) -> None:
-            cast(BankAccount, aggregate).is_closed = True
+            cast("BankAccount", aggregate).is_closed = True
 
 
 class AccountClosedError(Exception):
-    """
-    Raised when attempting to operate a closed account.
-    """
+    """Raised when attempting to operate a closed account."""
 
 
 class InsufficientFundsError(Exception):
-    """
-    Raised when attempting to go past overdraft limit.
-    """
+    """Raised when attempting to go past overdraft limit."""

eventsourcing/tests/persistence.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-import os
 import traceback
 import zlib
 from abc import ABC, abstractmethod
 from concurrent.futures import ThreadPoolExecutor
-from datetime import datetime
+from pathlib import Path
 from tempfile import NamedTemporaryFile
 from threading import Event, Thread, get_ident
 from time import sleep
@@ -18,7 +17,7 @@ from typing_extensions import TypeVar
 
 from eventsourcing.cipher import AESCipher
 from eventsourcing.compressor import ZlibCompressor
-from eventsourcing.domain import DomainEvent
+from eventsourcing.domain import DomainEvent, datetime_now_with_tzinfo
 from eventsourcing.persistence import (
     AggregateRecorder,
     ApplicationRecorder,
@@ -476,7 +475,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
                 )
                 for i in range(num_events_per_write)
             ]
-            started = datetime.now()
+            started = datetime_now_with_tzinfo()
             # print(f"Thread {thread_num} write beginning #{count + 1}")
             try:
                 recorder.insert_events(stored_events)
@@ -484,16 +483,15 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
             except Exception as e:  # pragma: no cover
                 if errors:
                     return
-                ended = datetime.now()
+                ended = datetime_now_with_tzinfo()
                 duration = (ended - started).total_seconds()
                 print(f"Error after starting {duration}", e)
                 errors.append(e)
             else:
-                ended = datetime.now()
+                ended = datetime_now_with_tzinfo()
                 duration = (ended - started).total_seconds()
                 counts[thread_id] += 1
-                if duration > durations[thread_id]:
-                    durations[thread_id] = duration
+                durations[thread_id] = max(durations[thread_id], duration)
                 sleep(writer_sleep)
 
         stop_reading = Event()
@@ -584,7 +582,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
 
         # Run.
         with ThreadPoolExecutor(max_workers=num_workers) as executor:
-            started = datetime.now()
+            started = datetime_now_with_tzinfo()
             futures = []
             for _ in range(num_jobs):
                 future = executor.submit(insert_events)
@@ -593,7 +591,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
                 future.result()
 
         self.assertFalse(errors_happened.is_set(), "There were errors (see above)")
-        ended = datetime.now()
+        ended = datetime_now_with_tzinfo()
         rate = num_jobs * num_events_per_job / (ended - started).total_seconds()
         print(f"Rate: {rate:.0f} inserts per second")
 
@@ -1099,7 +1097,7 @@ class InfrastructureFactoryTestCase(ABC, TestCase, Generic[_TInfrastrutureFactor
 
     def setUp(self) -> None:
         self.factory = cast(
-            _TInfrastrutureFactory, InfrastructureFactory.construct(self.env)
+            "_TInfrastrutureFactory", InfrastructureFactory.construct(self.env)
         )
         self.assertIsInstance(self.factory, self.expected_factory_class())
         self.transcoder = JSONTranscoder()
@@ -1279,14 +1277,17 @@ class InfrastructureFactoryTestCase(ABC, TestCase, Generic[_TInfrastrutureFactor
 
 def tmpfile_uris() -> Iterator[str]:
     tmp_files = []
-    ram_disk_path = "/Volumes/RAM DISK/"
-    prefix = None
-    if os.path.exists(ram_disk_path):
-        prefix = ram_disk_path
+    ram_disk_path = Path("/Volumes/RAM DISK/")
+    prefix: str | None = None
+    if ram_disk_path.exists():
+        prefix = str(ram_disk_path)
     while True:
-        tmp_file = NamedTemporaryFile(prefix=prefix, suffix="_eventsourcing_test.db")
-        tmp_files.append(tmp_file)
-        yield "file:" + tmp_file.name
+        with NamedTemporaryFile(
+            prefix=prefix,
+            suffix="_eventsourcing_test.db",
+        ) as tmp_file:
+            tmp_files.append(tmp_file)
+            yield "file:" + tmp_file.name
 
 
 class CustomType1:
@@ -1329,6 +1330,8 @@ class MyList(list[_T]):
 
 
 class MyStr(str):
+    __slots__ = ()
+
     def __repr__(self) -> str:
         return f"{type(self).__name__}({super().__repr__()})"
 

eventsourcing/utils.py

@@ -16,9 +16,7 @@ if TYPE_CHECKING:
 
 
 class TopicError(Exception):
-    """
-    Raised when topic doesn't resolve.
-    """
+    """Raised when topic doesn't resolve."""
 
 
 SupportsTopic = Union[type, Callable[..., Any], ModuleType]
@@ -29,8 +27,7 @@ _topic_cache_lock = Lock()
 
 
 def get_topic(obj: SupportsTopic, /) -> str:
-    """
-    Returns a "topic string" that locates the given class
+    """Returns a "topic string" that locates the given class
     in its module. The string is formed by joining the
     module name and the class qualname separated by the
     colon character.
@@ -45,8 +42,7 @@ def get_topic(obj: SupportsTopic, /) -> str:
 
 
 def resolve_topic(topic: str) -> Any:
-    """
-    Returns an object located by the given topic.
+    """Returns an object located by the given topic.
 
     This function can be (is) used to locate domain
     event classes and aggregate classes from the
@@ -101,8 +97,7 @@ def resolve_topic(topic: str) -> Any:
 
 
 def register_topic(topic: str, obj: SupportsTopic) -> None:
-    """
-    Registers a topic with an object, so the object will be
+    """Registers a topic with an object, so the object will be
     returned whenever the topic is resolved.
 
     This function can be used to cache the topic of a class, so
@@ -134,8 +129,7 @@ def retry(
     wait: float = 0,
     stall: float = 0,
 ) -> Callable[[Any], Any]:
-    """
-    Retry decorator.
+    """Retry decorator.
 
     :param exc: List of exceptions that will cause the call to be retried if raised.
     :param max_attempts: Maximum number of attempts to try.
@@ -145,9 +139,9 @@ def retry(
     """
 
     @no_type_check
-    def _retry(func):
+    def _retry(func: Callable) -> Callable:
         @wraps(func)
-        def retry_decorator(*args, **kwargs):
+        def retry_decorator(*args: Any, **kwargs: Any) -> Any:
             if stall:
                 sleep(stall)
             attempts = 0
@@ -236,16 +230,16 @@ class Environment(dict[str, str]):
         self.name = name
 
     @overload  # type: ignore[override]
-    def get(self, __key: str) -> str | None: ...  # pragma: no cover
+    def get(self, __key: str, /) -> str | None: ...  # pragma: no cover
 
     @overload
-    def get(self, __key: str, __default: str) -> str: ...  # pragma: no cover
+    def get(self, __key: str, /, __default: str) -> str: ...  # pragma: no cover
 
     @overload
-    def get(self, __key: str, __default: T) -> str | T: ...  # pragma: no cover
+    def get(self, __key: str, /, __default: T) -> str | T: ...  # pragma: no cover
 
     def get(  # pyright: ignore [reportIncompatibleMethodOverride]
-        self, __key: str, __default: str | T | None = None
+        self, __key: str, /, __default: str | T | None = None
     ) -> str | T | None:
         for _key in self.create_keys(__key):
             value = super().get(_key, None)

{eventsourcing-9.4.0b1.dist-info → eventsourcing-9.4.0b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: eventsourcing
-Version: 9.4.0b1
+Version: 9.4.0b3
 Summary: Event sourcing in Python
 License: BSD 3-Clause
 Keywords: event sourcing,event store,domain driven design,domain-driven design,ddd,cqrs,cqs

eventsourcing-9.4.0b3.dist-info/RECORD

@@ -0,0 +1,26 @@
+eventsourcing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/application.py,sha256=K3M9_Rh2jaYzBDPMvmyemLXHQ4GsGfGsxmMfUeVSqXw,35507
+eventsourcing/cipher.py,sha256=ulTBtX5K9ejRAkdUaUbdIaj4H7anYwDOi7JxOolj2uo,3295
+eventsourcing/compressor.py,sha256=qEYWvsUXFLyhKgfuv-HGNJ6VF4sRw4z0IxbNW9ukOfc,385
+eventsourcing/cryptography.py,sha256=aFZLlJxxSb5seVbh94-T8FA_RIGOe-VFu5SJrbOnwUU,2969
+eventsourcing/dispatch.py,sha256=j03cIVPziq6LFEgJxvQMMIPlixuZ4bB8ynXXdd_Tj8Q,2740
+eventsourcing/domain.py,sha256=Vk7MvA7GsY3krFBcotIxuMoDxYkBPP-EMnEIOj-JTU8,60062
+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=-vhjyOr08D42TGJX9ISeGx8H3sOuyKlIajPGek4aUtM,9775
+eventsourcing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/sqlite.py,sha256=_9ENoxEY7hqHGhOS4HBgElibBXyHI2vJ5nUVAQuffD0,22016
+eventsourcing/system.py,sha256=3mbxQRFLg8wQ8ulThd6y0CKBjtmo6lR3gZf9ZFITNCI,46888
+eventsourcing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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/postgres_utils.py,sha256=0ywklGp6cXZ5PmV8ANVkwSHsZZCl5zTmOk7iG-RmrCE,1548
+eventsourcing/utils.py,sha256=pOnczXzaE5q7UbQbPmgcpWaP660fsmfiDJs6Gmo8QCM,8558
+eventsourcing-9.4.0b3.dist-info/AUTHORS,sha256=8aHOM4UbNZcKlD-cHpFRcM6RWyCqtwtxRev6DeUgVRs,137
+eventsourcing-9.4.0b3.dist-info/LICENSE,sha256=CQEQzcZO8AWXL5i3hIo4yVKrYjh2FBz6hCM7kpXWpw4,1512
+eventsourcing-9.4.0b3.dist-info/METADATA,sha256=EZrHitWWM3yUoXD38I2u0SSNsDutr9zNg8AfFXno8mQ,9796
+eventsourcing-9.4.0b3.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+eventsourcing-9.4.0b3.dist-info/RECORD,,