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

eventsourcing/application.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import os
 from abc import ABC, abstractmethod
 from collections.abc import Iterable, Iterator, Sequence
@@ -26,6 +27,7 @@ from eventsourcing.domain import (
     DomainEventProtocol,
     EventSourcingError,
     MutableOrImmutableAggregate,
+    SDomainEvent,
     Snapshot,
     SnapshotProtocol,
     TDomainEvent,
@@ -352,19 +354,18 @@ class Repository:
         return aggregate
 
     def _use_fastforward_lock(self, aggregate_id: UUID) -> Lock:
+        lock: Lock | None = None
         with self._fastforward_locks_lock:
-            try:
+            num_users = 0
+            with contextlib.suppress(KeyError):
                 lock, num_users = self._fastforward_locks_inuse[aggregate_id]
-            except KeyError:
-                try:
+            if lock is None:
+                with contextlib.suppress(KeyError):
                     lock = self._fastforward_locks_cache.get(aggregate_id, evict=True)
-                except KeyError:
-                    lock = Lock()
-                finally:
-                    num_users = 0
-            finally:
-                num_users += 1
-                self._fastforward_locks_inuse[aggregate_id] = (lock, num_users)
+            if lock is None:
+                lock = Lock()
+            num_users += 1
+            self._fastforward_locks_inuse[aggregate_id] = (lock, num_users)
             return lock
 
     def _disuse_fastforward_lock(self, aggregate_id: UUID) -> None:
@@ -610,12 +611,10 @@ class Application:
     name = "Application"
     env: ClassVar[dict[str, str]] = {}
     is_snapshotting_enabled: bool = False
-    snapshotting_intervals: ClassVar[
-        dict[type[MutableOrImmutableAggregate], int] | None
-    ] = None
+    snapshotting_intervals: ClassVar[dict[type[MutableOrImmutableAggregate], int]] = {}
     snapshotting_projectors: ClassVar[
-        dict[type[MutableOrImmutableAggregate], ProjectorFunction[Any, Any]] | None
-    ] = None
+        dict[type[MutableOrImmutableAggregate], ProjectorFunction[Any, Any]]
+    ] = {}
     snapshot_class: type[SnapshotProtocol] = Snapshot
     log_section_size = 10
     notify_topics: Sequence[str] = []
@@ -817,12 +816,9 @@ class Application:
                     continue
                 interval = self.snapshotting_intervals.get(type(aggregate))
                 if interval is not None and event.originator_version % interval == 0:
-                    if (
-                        self.snapshotting_projectors
-                        and type(aggregate) in self.snapshotting_projectors
-                    ):
+                    try:
                         projector_func = self.snapshotting_projectors[type(aggregate)]
-                    else:
+                    except KeyError:
                         projector_func = project_aggregate
                     if projector_func is project_aggregate and not isinstance(
                         event, CanMutateProtocol
@@ -947,10 +943,10 @@ class EventSourcedLog(Generic[TDomainEvent]):
 
     def _trigger_event(
         self,
-        logged_cls: type[T] | None,
+        logged_cls: type[SDomainEvent],
         next_originator_version: int | None = None,
         **kwargs: Any,
-    ) -> T:
+    ) -> SDomainEvent:
         """
         Constructs and returns a new log event.
         """
@@ -961,7 +957,7 @@ class EventSourcedLog(Generic[TDomainEvent]):
             else:
                 next_originator_version = last_logged.originator_version + 1
 
-        return logged_cls(  # type: ignore
+        return logged_cls(
             originator_id=self.originator_id,
             originator_version=next_originator_version,
             timestamp=datetime_now_with_tzinfo(),

eventsourcing/cipher.py

@@ -5,7 +5,9 @@ from base64 import b64decode, b64encode
 from typing import TYPE_CHECKING
 
 from Crypto.Cipher import AES
-from Crypto.Cipher._mode_gcm import GcmMode
+from Crypto.Cipher._mode_gcm import (
+    GcmMode,  # pyright: ignore [reportPrivateImportUsage]
+)
 from Crypto.Cipher.AES import key_size
 
 from eventsourcing.persistence import Cipher

eventsourcing/dispatch.py

@@ -1,14 +1,50 @@
 from __future__ import annotations
 
-from functools import singledispatchmethod as _singledispatchmethod
+import functools
+from typing import TYPE_CHECKING, Any, Callable, Generic, TypeVar, cast, overload
 
+_T = TypeVar("_T")
+_S = TypeVar("_S")
 
-class singledispatchmethod(_singledispatchmethod):  # noqa: N801
-    def __init__(self, func):
+if TYPE_CHECKING:
+
+    class _singledispatchmethod(functools.singledispatchmethod[_T]):  # noqa: N801
+        pass
+
+else:
+
+    class _singledispatchmethod(  # noqa: N801
+        functools.singledispatchmethod, Generic[_T]
+    ):
+        pass
+
+
+class singledispatchmethod(_singledispatchmethod[_T]):  # noqa: N801
+    def __init__(self, func: Callable[..., _T]) -> None:
         super().__init__(func)
-        self.deferred_registrations = []
+        self.deferred_registrations: list[
+            tuple[type[Any] | Callable[..., _T], Callable[..., _T] | None]
+        ] = []
+
+    @overload
+    def register(
+        self, cls: type[Any], method: None = None
+    ) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ...  # pragma: no cover
+    @overload
+    def register(
+        self, cls: Callable[..., _T], method: None = None
+    ) -> Callable[..., _T]: ...  # pragma: no cover
+
+    @overload
+    def register(
+        self, cls: type[Any], method: Callable[..., _T]
+    ) -> Callable[..., _T]: ...  # pragma: no cover
 
-    def register(self, cls, method=None):
+    def register(
+        self,
+        cls: type[Any] | Callable[..., _T],
+        method: Callable[..., _T] | None = None,
+    ) -> Callable[[Callable[..., _T]], Callable[..., _T]] | Callable[..., _T]:
         """generic_method.register(cls, func) -> func
 
         Registers a new implementation for the given *cls* on a *generic_method*.
@@ -22,17 +58,22 @@ class singledispatchmethod(_singledispatchmethod):  # noqa: N801
 
             # for globals in typing.get_type_hints() in Python 3.8 and 3.9
             if not hasattr(cls, "__wrapped__"):
-                cls.__wrapped__ = cls.__func__
+                cls.__dict__["__wrapped__"] = cls.__func__
+                # cls.__wrapped__ = cls.__func__
 
         try:
-            return self.dispatcher.register(cls, func=method)
+            return self.dispatcher.register(cast(type[Any], cls), func=method)
         except NameError:
-            self.deferred_registrations.append([cls, method])
+            self.deferred_registrations.append(
+                (cls, method)  # pyright: ignore [reportArgumentType]
+            )
             # TODO: Fix this....
-            return method or cls
+            return method or cls  # pyright: ignore [reportReturnType]
 
-    def __get__(self, obj, cls=None):
+    def __get__(self, obj: _S, cls: type[_S] | None = None) -> Callable[..., _T]:
         for registered_cls, registered_method in self.deferred_registrations:
-            self.dispatcher.register(registered_cls, func=registered_method)
+            self.dispatcher.register(
+                cast(type[Any], registered_cls), func=registered_method
+            )
         self.deferred_registrations = []
         return super().__get__(obj, cls=cls)

eventsourcing/domain.py

@@ -88,20 +88,26 @@ class DomainEventProtocol(Protocol):
     kinds of domain event classes, such as Pydantic classes.
     """
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        pass  # pragma: no cover
+
     @property
     def originator_id(self) -> UUID:
         """
         UUID identifying an aggregate to which the event belongs.
         """
+        raise NotImplementedError  # pragma: no cover
 
     @property
     def originator_version(self) -> int:
         """
         Integer identifying the version of the aggregate when the event occurred.
         """
+        raise NotImplementedError  # pragma: no cover
 
 
 TDomainEvent = TypeVar("TDomainEvent", bound=DomainEventProtocol)
+SDomainEvent = TypeVar("SDomainEvent", bound=DomainEventProtocol)
 
 
 class MutableAggregateProtocol(Protocol):
@@ -120,18 +126,21 @@ class MutableAggregateProtocol(Protocol):
         """
         Mutable aggregates have a read-only ID that is a UUID.
         """
+        raise NotImplementedError  # pragma: no cover
 
     @property
     def version(self) -> int:
         """
         Mutable aggregates have a read-write version that is an int.
         """
+        raise NotImplementedError  # pragma: no cover
 
     @version.setter
     def version(self, value: int) -> None:
         """
         Mutable aggregates have a read-write version that is an int.
         """
+        raise NotImplementedError  # pragma: no cover
 
 
 class ImmutableAggregateProtocol(Protocol):
@@ -150,12 +159,14 @@ class ImmutableAggregateProtocol(Protocol):
         """
         Immutable aggregates have a read-only ID that is a UUID.
         """
+        raise NotImplementedError  # pragma: no cover
 
     @property
     def version(self) -> int:
         """
         Immutable aggregates have a read-only version that is an int.
         """
+        raise NotImplementedError  # pragma: no cover
 
 
 MutableOrImmutableAggregate = Union[
@@ -180,6 +191,7 @@ class CollectEventsProtocol(Protocol):
         """
         Returns a sequence of events.
         """
+        raise NotImplementedError  # pragma: no cover
 
 
 @runtime_checkable
@@ -233,7 +245,7 @@ class CanCreateTimestamp:
         return datetime_now_with_tzinfo()
 
 
-TAggregate = TypeVar("TAggregate", bound="Aggregate")
+TAggregate = TypeVar("TAggregate", bound="BaseAggregate")
 
 
 class HasOriginatorIDVersion:
@@ -300,7 +312,7 @@ class CanMutateAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
         # Return the mutated aggregate.
         return aggregate
 
-    def apply(self, aggregate: Aggregate) -> None:
+    def apply(self, aggregate: Any) -> None:
         """
         Applies the domain event to its aggregate.
 
@@ -934,9 +946,9 @@ def _raise_missing_names_type_error(missing_names: list[str], msg: str) -> None:
     raise TypeError(msg)
 
 
-_annotations_mention_id: set[type[Aggregate]] = set()
-_init_mentions_id: set[type[Aggregate]] = set()
-_create_id_param_names: dict[type[Aggregate], list[str]] = defaultdict(list)
+_annotations_mention_id: set[type[BaseAggregate]] = set()
+_init_mentions_id: set[type[BaseAggregate]] = set()
+_create_id_param_names: dict[type[BaseAggregate], list[str]] = defaultdict(list)
 
 
 class MetaAggregate(EventsourcingType, Generic[TAggregate], type):
@@ -1011,19 +1023,13 @@ class MetaAggregate(EventsourcingType, Generic[TAggregate], type):
     _created_event_class: type[CanInitAggregate]
 
 
-class Aggregate(metaclass=MetaAggregate):
+class BaseAggregate(metaclass=MetaAggregate):
     """
     Base class for aggregates.
     """
 
     INITIAL_VERSION = 1
 
-    class Event(AggregateEvent):
-        pass
-
-    class Created(Event, AggregateCreated):
-        pass
-
     @staticmethod
     def create_id(*_: Any, **__: Any) -> UUID:
         """
@@ -1081,7 +1087,7 @@ class Aggregate(metaclass=MetaAggregate):
 
         assert agg is not None
         # Append the domain event to pending list.
-        agg.pending_events.append(created_event)
+        agg._pending_events.append(created_event)
         # Return the aggregate.
         return agg
 
@@ -1197,7 +1203,7 @@ class Aggregate(metaclass=MetaAggregate):
         return f"{type(self).__name__}({', '.join(attrs)})"
 
     def __init_subclass__(
-        cls: type[Aggregate], *, created_event_name: str | None = None
+        cls: type[BaseAggregate], *, created_event_name: str | None = None
     ) -> None:
         """
         Initialises aggregate subclass by defining __init__ method and event classes.
@@ -1211,8 +1217,10 @@ class Aggregate(metaclass=MetaAggregate):
         except KeyError:
             pass
 
-        if class_annotations or any(
-            dataclasses.is_dataclass(base) for base in cls.__bases__
+        if (
+            class_annotations
+            or cls in _annotations_mention_id
+            or any(dataclasses.is_dataclass(base) for base in cls.__bases__)
         ):
             dataclasses.dataclass(eq=False, repr=False)(cls)
 
@@ -1223,7 +1231,9 @@ class Aggregate(metaclass=MetaAggregate):
             base_event_cls = cls.__dict__[base_event_name]
         except KeyError:
             base_event_cls = cls._define_event_class(
-                base_event_name, (cls.Event,), None
+                name=base_event_name,
+                bases=(getattr(cls, base_event_name, AggregateEvent),),
+                apply_method=None,
             )
             setattr(cls, base_event_name, base_event_cls)
 
@@ -1482,9 +1492,12 @@ class Aggregate(metaclass=MetaAggregate):
                     setattr(cls, name, sub_class)
 
 
-# Special case for the Aggregate class because
-# it's not processed by Aggregate.__init_subclass__.
-_created_event_classes[Aggregate] = [Aggregate.Created]
+class Aggregate(BaseAggregate):
+    class Event(AggregateEvent):
+        pass
+
+    class Created(Event, AggregateCreated):
+        pass
 
 
 @overload
@@ -1578,6 +1591,7 @@ class SnapshotProtocol(DomainEventProtocol, Protocol):
         """
         Snapshots have a read-only 'state'.
         """
+        raise NotImplementedError  # pragma: no cover
 
     # TODO: Improve on this 'Any'.
     @classmethod
@@ -1594,6 +1608,16 @@ class CanSnapshotAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
     topic: str
     state: Any
 
+    def __init__(
+        self,
+        originator_id: UUID,
+        originator_version: int,
+        timestamp: datetime,
+        topic: str,
+        state: Any,
+    ) -> None:
+        raise NotImplementedError  # pragma: no cover
+
     @classmethod
     def take(
         cls: type[TCanSnapshotAggregate],
@@ -1610,7 +1634,7 @@ class CanSnapshotAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
             aggregate_state.pop("_id")
             aggregate_state.pop("_version")
             aggregate_state.pop("_pending_events")
-        return cls(  # type: ignore
+        return cls(
             originator_id=aggregate.id,
             originator_version=aggregate.version,
             timestamp=cls.create_timestamp(),

eventsourcing/interface.py

@@ -141,7 +141,7 @@ class NotificationLogJSONClient(NotificationLog):
         self,
         start: int | None,
         limit: int,
-        _: int | None = None,
+        stop: int | None = None,
         topics: Sequence[str] = (),
         *,
         inclusive_of_start: bool = True,

eventsourcing/persistence.py

@@ -517,10 +517,10 @@ class TrackingRecorder(Recorder, ABC):
         interrupt: Event | None = None,
     ) -> None:
         """
-        Block until a tracking object with the given application name and
-        notification ID has been recorded.
+        Block until a tracking object with the given application name and a
+        notification ID greater than equal to the given value has been recorded.
 
-        Polls has_tracking_id() with exponential backoff until the timeout
+        Polls max_tracking_id() with exponential backoff until the timeout
         is reached, or until the optional interrupt event is set.
 
         The timeout argument should be a floating point number specifying a
@@ -534,7 +534,10 @@ class TrackingRecorder(Recorder, ABC):
         deadline = monotonic() + timeout
         delay_ms = 1.0
         while True:
-            if self.has_tracking_id(application_name, notification_id):
+            max_tracking_id = self.max_tracking_id(application_name)
+            if notification_id is None or (
+                max_tracking_id is not None and max_tracking_id >= notification_id
+            ):
                 break
             if interrupt:
                 if interrupt.wait(timeout=delay_ms / 1000):
@@ -751,6 +754,7 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
             mapper_topic = self.env.get(self.MAPPER_TOPIC)
             mapper_class = resolve_topic(mapper_topic) if mapper_topic else Mapper
 
+        assert isinstance(mapper_class, type) and issubclass(mapper_class, Mapper)
         return mapper_class(
             transcoder=transcoder or self.transcoder(),
             cipher=self.cipher(),

eventsourcing/postgres.py

@@ -5,7 +5,7 @@ import logging
 from asyncio import CancelledError
 from contextlib import contextmanager
 from threading import Thread
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any, Callable, cast
 
 import psycopg
 import psycopg.errors
@@ -13,6 +13,8 @@ import psycopg_pool
 from psycopg import Connection, Cursor, Error
 from psycopg.generators import notifies
 from psycopg.rows import DictRow, dict_row
+from psycopg.sql import SQL, Composed, Identifier
+from typing_extensions import TypeVar
 
 from eventsourcing.persistence import (
     AggregateRecorder,
@@ -41,6 +43,7 @@ if TYPE_CHECKING:
     from collections.abc import Iterator, Sequence
     from uuid import UUID
 
+    from psycopg.abc import Query
     from typing_extensions import Self
 
 logging.getLogger("psycopg.pool").setLevel(logging.CRITICAL)
@@ -118,12 +121,11 @@ class PostgresDatastore:
             check=check,
         )
         self.lock_timeout = lock_timeout
-        self.schema = schema.strip()
+        self.schema = schema.strip() or "public"
 
     def after_connect_func(self) -> Callable[[Connection[Any]], None]:
-        statement = (
-            "SET idle_in_transaction_session_timeout = "
-            f"'{self.idle_in_transaction_session_timeout}s'"
+        statement = SQL("SET idle_in_transaction_session_timeout = '{0}s'").format(
+            self.idle_in_transaction_session_timeout
         )
 
         def after_connect(conn: Connection[DictRow]) -> None:
@@ -168,7 +170,6 @@ class PostgresDatastore:
 
     @contextmanager
     def transaction(self, *, commit: bool = False) -> Iterator[Cursor[DictRow]]:
-        conn: Connection[DictRow]
         with self.get_connection() as conn, conn.transaction(force_rollback=not commit):
             yield conn.cursor()
 
@@ -195,17 +196,12 @@ class PostgresRecorder:
         self.datastore = datastore
         self.create_table_statements = self.construct_create_table_statements()
 
-    def construct_create_table_statements(self) -> list[str]:
+    def construct_create_table_statements(self) -> list[Composed]:
         return []
 
     def check_table_name_length(self, table_name: str) -> None:
-        schema_prefix = self.datastore.schema + "."
-        if table_name.startswith(schema_prefix):
-            unqualified_table_name = table_name[len(schema_prefix) :]
-        else:
-            unqualified_table_name = table_name
-        if len(unqualified_table_name) > 63:
-            msg = f"Table name too long: {unqualified_table_name}"
+        if len(table_name) > 63:
+            msg = f"Table name too long: {table_name}"
             raise ProgrammingError(msg)
 
     def create_table(self) -> None:
@@ -226,38 +222,45 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
         self.events_table_name = events_table_name
         # Index names can't be qualified names, but
         # are created in the same schema as the table.
-        if "." in self.events_table_name:
-            unqualified_table_name = self.events_table_name.split(".")[-1]
-        else:
-            unqualified_table_name = self.events_table_name
         self.notification_id_index_name = (
-            f"{unqualified_table_name}_notification_id_idx "
+            f"{self.events_table_name}_notification_id_idx"
         )
         self.create_table_statements.append(
-            "CREATE TABLE IF NOT EXISTS "
-            f"{self.events_table_name} ("
-            "originator_id uuid NOT NULL, "
-            "originator_version bigint NOT NULL, "
-            "topic text, "
-            "state bytea, "
-            "PRIMARY KEY "
-            "(originator_id, originator_version)) "
-            "WITH (autovacuum_enabled=false)"
+            SQL(
+                "CREATE TABLE IF NOT EXISTS {0}.{1} ("
+                "originator_id uuid NOT NULL, "
+                "originator_version bigint NOT NULL, "
+                "topic text, "
+                "state bytea, "
+                "PRIMARY KEY "
+                "(originator_id, originator_version)) "
+                "WITH (autovacuum_enabled=false)"
+            ).format(
+                Identifier(self.datastore.schema),
+                Identifier(self.events_table_name),
+            )
         )
 
-        self.insert_events_statement = (
-            f"INSERT INTO {self.events_table_name} VALUES (%s, %s, %s, %s)"
+        self.insert_events_statement = SQL(
+            "INSERT INTO {0}.{1} VALUES (%s, %s, %s, %s)"
+        ).format(
+            Identifier(self.datastore.schema),
+            Identifier(self.events_table_name),
         )
-        self.select_events_statement = (
-            f"SELECT * FROM {self.events_table_name} WHERE originator_id = %s"
+
+        self.select_events_statement = SQL(
+            "SELECT * FROM {0}.{1} WHERE originator_id = %s"
+        ).format(
+            Identifier(self.datastore.schema),
+            Identifier(self.events_table_name),
         )
-        self.lock_table_statements: list[str] = []
+
+        self.lock_table_statements: list[Query] = []
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
     def insert_events(
         self, stored_events: list[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
-        conn: Connection[DictRow]
         exc: Exception | None = None
         notification_ids: Sequence[int] | None = None
         with self.datastore.get_connection() as conn:
@@ -316,7 +319,7 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
                     )
                     for stored_event in stored_events
                 ],
-                returning="RETURNING" in self.insert_events_statement,
+                returning="RETURNING" in self.insert_events_statement.as_string(),
             )
 
     def _lock_table(self, curs: Cursor[DictRow]) -> None:
@@ -347,18 +350,18 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
         params: list[Any] = [originator_id]
         if gt is not None:
             params.append(gt)
-            statement += " AND originator_version > %s"
+            statement += SQL(" AND originator_version > %s")
         if lte is not None:
             params.append(lte)
-            statement += " AND originator_version <= %s"
-        statement += " ORDER BY originator_version"
+            statement += SQL(" AND originator_version <= %s")
+        statement += SQL(" ORDER BY originator_version")
         if desc is False:
-            statement += " ASC"
+            statement += SQL(" ASC")
         else:
-            statement += " DESC"
+            statement += SQL(" DESC")
         if limit is not None:
             params.append(limit)
-            statement += " LIMIT %s"
+            statement += SQL(" LIMIT %s")
 
         with self.datastore.get_connection() as conn, conn.cursor() as curs:
             curs.execute(statement, params, prepare=True)
@@ -381,9 +384,8 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
         events_table_name: str = "stored_events",
     ):
         super().__init__(datastore, events_table_name=events_table_name)
-        self.create_table_statements[-1] = (
-            "CREATE TABLE IF NOT EXISTS "
-            f"{self.events_table_name} ("
+        self.create_table_statements[-1] = SQL(
+            "CREATE TABLE IF NOT EXISTS {0}.{1} ("
             "originator_id uuid NOT NULL, "
             "originator_version bigint NOT NULL, "
             "topic text, "
@@ -392,20 +394,40 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
             "PRIMARY KEY "
             "(originator_id, originator_version)) "
             "WITH (autovacuum_enabled=false)"
+        ).format(
+            Identifier(self.datastore.schema),
+            Identifier(self.events_table_name),
         )
+
         self.create_table_statements.append(
-            "CREATE UNIQUE INDEX IF NOT EXISTS "
-            f"{self.notification_id_index_name}"
-            f"ON {self.events_table_name} (notification_id ASC);"
+            SQL(
+                "CREATE UNIQUE INDEX IF NOT EXISTS {0} "
+                "ON {1}.{2} (notification_id ASC);"
+            ).format(
+                Identifier(self.notification_id_index_name),
+                Identifier(self.datastore.schema),
+                Identifier(self.events_table_name),
+            )
         )
+
         self.channel_name = self.events_table_name.replace(".", "_")
-        self.insert_events_statement += " RETURNING notification_id"
-        self.max_notification_id_statement = (
-            f"SELECT MAX(notification_id) FROM {self.events_table_name}"
+        self.insert_events_statement = self.insert_events_statement + SQL(
+            " RETURNING notification_id"
+        )
+
+        self.max_notification_id_statement = SQL(
+            "SELECT MAX(notification_id) FROM {0}.{1}"
+        ).format(
+            Identifier(self.datastore.schema),
+            Identifier(self.events_table_name),
         )
+
         self.lock_table_statements = [
-            f"SET LOCAL lock_timeout = '{self.datastore.lock_timeout}s'",
-            f"LOCK TABLE {self.events_table_name} IN EXCLUSIVE MODE",
+            SQL("SET LOCAL lock_timeout = '{0}s'").format(self.datastore.lock_timeout),
+            SQL("LOCK TABLE {0}.{1} IN EXCLUSIVE MODE").format(
+                Identifier(self.datastore.schema),
+                Identifier(self.events_table_name),
+            ),
         ]
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
@@ -424,37 +446,44 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
         """
 
         params: list[int | str | Sequence[str]] = []
-        statement = f"SELECT * FROM {self.events_table_name}"
+        statement = SQL("SELECT * FROM {0}.{1}").format(
+            Identifier(self.datastore.schema),
+            Identifier(self.events_table_name),
+        )
         has_where = False
         if start is not None:
-            statement += " WHERE"
+            statement += SQL(" WHERE")
             has_where = True
             params.append(start)
             if inclusive_of_start:
-                statement += " notification_id>=%s"
+                statement += SQL(" notification_id>=%s")
             else:
-                statement += " notification_id>%s"
+                statement += SQL(" notification_id>%s")
 
         if stop is not None:
             if not has_where:
                 has_where = True
-                statement += " WHERE"
+                statement += SQL(" WHERE")
             else:
-                statement += " AND"
+                statement += SQL(" AND")
 
             params.append(stop)
-            statement += " notification_id <= %s"
+            statement += SQL(" notification_id <= %s")
 
         if topics:
+            # Check sequence and ensure list of strings.
+            assert isinstance(topics, (tuple, list)), topics
+            topics = list(topics) if isinstance(topics, tuple) else topics
+            assert all(isinstance(t, str) for t in topics), topics
             if not has_where:
-                statement += " WHERE"
+                statement += SQL(" WHERE")
             else:
-                statement += " AND"
+                statement += SQL(" AND")
             params.append(topics)
-            statement += " topic = ANY(%s)"
+            statement += SQL(" topic = ANY(%s)")
 
         params.append(limit)
-        statement += " ORDER BY notification_id LIMIT %s"
+        statement += SQL(" ORDER BY notification_id LIMIT %s")
 
         connection = self.datastore.get_connection()
         with connection as conn, conn.cursor() as curs:
@@ -475,7 +504,6 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
         """
         Returns the maximum notification ID.
         """
-        conn: Connection[DictRow]
         with self.datastore.get_connection() as conn, conn.cursor() as curs:
             curs.execute(self.max_notification_id_statement)
             fetchone = curs.fetchone()
@@ -507,7 +535,7 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
             curs.execute(lock_statement, prepare=True)
 
     def _notify_channel(self, curs: Cursor[DictRow]) -> None:
-        curs.execute("NOTIFY " + self.channel_name)
+        curs.execute(SQL("NOTIFY {0}").format(Identifier(self.channel_name)))
 
     def _fetch_ids_after_insert_events(
         self,
@@ -554,7 +582,9 @@ class PostgresSubscription(ListenNotifySubscription[PostgresApplicationRecorder]
     def _listen(self) -> None:
         try:
             with self._recorder.datastore.get_connection() as conn:
-                conn.execute("LISTEN " + self._recorder.channel_name)
+                conn.execute(
+                    SQL("LISTEN {0}").format(Identifier(self._recorder.channel_name))
+                )
                 while not self._has_been_stopped and not self._thread_error:
                     # This block simplifies psycopg's conn.notifies(), because
                     # we aren't interested in the actual notify messages, and
@@ -585,30 +615,42 @@ class PostgresTrackingRecorder(PostgresRecorder, TrackingRecorder):
         self.check_table_name_length(tracking_table_name)
         self.tracking_table_name = tracking_table_name
         self.create_table_statements.append(
-            "CREATE TABLE IF NOT EXISTS "
-            f"{self.tracking_table_name} ("
-            "application_name text, "
-            "notification_id bigint, "
-            "PRIMARY KEY "
-            "(application_name, notification_id))"
+            SQL(
+                "CREATE TABLE IF NOT EXISTS {0}.{1} ("
+                "application_name text, "
+                "notification_id bigint, "
+                "PRIMARY KEY "
+                "(application_name, notification_id))"
+            ).format(
+                Identifier(self.datastore.schema),
+                Identifier(self.tracking_table_name),
+            )
         )
-        self.insert_tracking_statement = (
-            f"INSERT INTO {self.tracking_table_name} VALUES (%s, %s)"
+
+        self.insert_tracking_statement = SQL(
+            "INSERT INTO {0}.{1} VALUES (%s, %s)"
+        ).format(
+            Identifier(self.datastore.schema),
+            Identifier(self.tracking_table_name),
         )
-        self.max_tracking_id_statement = (
-            "SELECT MAX(notification_id) "
-            f"FROM {self.tracking_table_name} "
-            "WHERE application_name=%s"
+
+        self.max_tracking_id_statement = SQL(
+            "SELECT MAX(notification_id) FROM {0}.{1} WHERE application_name=%s"
+        ).format(
+            Identifier(self.datastore.schema),
+            Identifier(self.tracking_table_name),
         )
-        self.count_tracking_id_statement = (
-            "SELECT COUNT(*) "
-            f"FROM {self.tracking_table_name} "
+
+        self.count_tracking_id_statement = SQL(
+            "SELECT COUNT(*) FROM {0}.{1} "
             "WHERE application_name=%s AND notification_id=%s"
+        ).format(
+            Identifier(self.datastore.schema),
+            Identifier(self.tracking_table_name),
         )
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
     def insert_tracking(self, tracking: Tracking) -> None:
-        conn: Connection[DictRow]
         with (
             self.datastore.get_connection() as conn,
             conn.transaction(),
@@ -648,7 +690,6 @@ class PostgresTrackingRecorder(PostgresRecorder, TrackingRecorder):
     ) -> bool:
         if notification_id is None:
             return True
-        conn: Connection[DictRow]
         with self.datastore.get_connection() as conn, conn.cursor() as curs:
             curs.execute(
                 query=self.count_tracking_id_statement,
@@ -660,6 +701,13 @@ class PostgresTrackingRecorder(PostgresRecorder, TrackingRecorder):
             return bool(fetchone["count"])
 
 
+TPostgresTrackingRecorder = TypeVar(
+    "TPostgresTrackingRecorder",
+    bound=PostgresTrackingRecorder,
+    default=PostgresTrackingRecorder,
+)
+
+
 class PostgresProcessRecorder(
     PostgresTrackingRecorder, PostgresApplicationRecorder, ProcessRecorder
 ):
@@ -887,8 +935,6 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
     def aggregate_recorder(self, purpose: str = "events") -> AggregateRecorder:
         prefix = self.env.name.lower() or "stored"
         events_table_name = prefix + "_" + purpose
-        if self.datastore.schema:
-            events_table_name = f"{self.datastore.schema}.{events_table_name}"
         recorder = type(self).aggregate_recorder_class(
             datastore=self.datastore,
             events_table_name=events_table_name,
@@ -900,9 +946,6 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
     def application_recorder(self) -> ApplicationRecorder:
         prefix = self.env.name.lower() or "stored"
         events_table_name = prefix + "_events"
-        if self.datastore.schema:
-            events_table_name = f"{self.datastore.schema}.{events_table_name}"
-
         application_recorder_topic = self.env.get(self.APPLICATION_RECORDER_TOPIC)
         if application_recorder_topic:
             application_recorder_class: type[PostgresApplicationRecorder] = (
@@ -921,18 +964,18 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
         return recorder
 
     def tracking_recorder(
-        self, tracking_recorder_class: type[PostgresTrackingRecorder] | None = None
-    ) -> PostgresTrackingRecorder:
+        self, tracking_recorder_class: type[TPostgresTrackingRecorder] | None = None
+    ) -> TPostgresTrackingRecorder:
         prefix = self.env.name.lower() or "notification"
         tracking_table_name = prefix + "_tracking"
-        if self.datastore.schema:
-            tracking_table_name = f"{self.datastore.schema}.{tracking_table_name}"
         if tracking_recorder_class is None:
             tracking_recorder_topic = self.env.get(self.TRACKING_RECORDER_TOPIC)
             if tracking_recorder_topic:
                 tracking_recorder_class = resolve_topic(tracking_recorder_topic)
             else:
-                tracking_recorder_class = type(self).tracking_recorder_class
+                tracking_recorder_class = cast(
+                    type[TPostgresTrackingRecorder], type(self).tracking_recorder_class
+                )
         assert tracking_recorder_class is not None
         assert issubclass(tracking_recorder_class, PostgresTrackingRecorder)
         recorder = tracking_recorder_class(
@@ -948,10 +991,6 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
         events_table_name = prefix + "_events"
         prefix = self.env.name.lower() or "notification"
         tracking_table_name = prefix + "_tracking"
-        if self.datastore.schema:
-            events_table_name = f"{self.datastore.schema}.{events_table_name}"
-            tracking_table_name = f"{self.datastore.schema}.{tracking_table_name}"
-
         process_recorder_topic = self.env.get(self.PROCESS_RECORDER_TOPIC)
         if process_recorder_topic:
             process_recorder_class: type[PostgresTrackingRecorder] = resolve_topic(

eventsourcing/projection.py

@@ -40,39 +40,65 @@ class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
         gt: int | None = None,
         topics: Sequence[str] = (),
     ):
+        """
+        Starts subscription to application's stored events using application's recorder.
+        """
         self.name = app.name
         self.recorder = app.recorder
         self.mapper = app.mapper
         self.subscription = self.recorder.subscribe(gt=gt, topics=topics)
 
+    def stop(self) -> None:
+        """
+        Stops the stored event subscription.
+        """
+        self.subscription.stop()
+
     def __enter__(self) -> Self:
+        """
+        Calls __enter__ on the stored event subscription.
+        """
         self.subscription.__enter__()
         return self
 
     def __exit__(self, *args: object, **kwargs: Any) -> None:
+        """
+        Calls __exit__ on the stored event subscription.
+        """
         self.subscription.__exit__(*args, **kwargs)
 
     def __iter__(self) -> Self:
         return self
 
     def __next__(self) -> tuple[DomainEventProtocol, Tracking]:
+        """
+        Returns the next stored event from the stored event subscription.
+        Constructs a tracking object that identifies the position of
+        the event in the application sequence, and reconstructs a domain
+        event object from the stored event object.
+        """
         notification = next(self.subscription)
         tracking = Tracking(self.name, notification.id)
         domain_event = self.mapper.to_domain_event(notification)
         return domain_event, tracking
 
     def __del__(self) -> None:
+        """
+        Stops the stored event subscription.
+        """
         self.stop()
 
-    def stop(self) -> None:
-        self.subscription.stop()
-
 
 class Projection(ABC, Generic[TTrackingRecorder]):
     name: str = ""
-    """Name of projection, used to pick prefixed environment variables."""
-    topics: Sequence[str] = ()
-    """Filter events in database when subscribing to an application."""
+    """
+    Name of projection, used to pick prefixed environment
+    variables and define database table names.
+    """
+    topics: tuple[str, ...] = ()
+    """
+    Filter events in database when subscribing to an application.
+    """
 
     def __init__(
         self,
@@ -104,10 +130,21 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         self,
         *,
         application_class: type[TApplication],
-        view_class: type[TTrackingRecorder],
         projection_class: type[Projection[TTrackingRecorder]],
+        view_class: type[TTrackingRecorder],
         env: EnvType | None = None,
     ):
+        """
+        Constructs application from given application class with given environment.
+        Also constructs a materialised view from given class using an infrastructure
+        factory constructed with an environment named after the projection. Also
+        constructs a projection with the constructed materialised view object.
+        Starts a subscription to application and, in a separate event-processing
+        thread, calls projection's process_event() method for each event and tracking
+        object pair received from the subscription.
+        """
+        self._is_stopping = Event()
+
         self.app: TApplication = application_class(env)
 
         self.view = (
@@ -128,7 +165,6 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
             gt=self.view.max_tracking_id(self.app.name),
             topics=self.projection.topics,
         )
-        self._is_stopping = Event()
         self.thread_error: BaseException | None = None
         self.processing_thread = Thread(
             target=self._process_events_loop,
@@ -152,6 +188,9 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         return Environment(name, _env)
 
     def stop(self) -> None:
+        """
+        Stops the application subscription, which will stop the event-processing thread.
+        """
         self._is_stopping.set()
         self.subscription.stop()
 
@@ -180,13 +219,21 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
                 )
 
             is_stopping.set()
-            subscription.subscription.stop()
+            subscription.stop()
 
     def run_forever(self, timeout: float | None = None) -> None:
+        """
+        Blocks until timeout, or until the runner is stopped or errors. Re-raises
+        any error otherwise exits normally
+        """
         if self._is_stopping.wait(timeout=timeout) and self.thread_error is not None:
             raise self.thread_error
 
     def wait(self, notification_id: int | None, timeout: float = 1.0) -> None:
+        """
+        Blocks until timeout, or until the materialised view has recorded a tracking
+        object that is greater than or equal to the given notification ID.
+        """
         try:
             self.projection.view.wait(
                 application_name=self.subscription.name,
@@ -202,8 +249,14 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         return self
 
     def __exit__(self, *args: object, **kwargs: Any) -> None:
+        """
+        Calls stop() and waits for the event-processing thread to exit.
+        """
         self.stop()
         self.processing_thread.join()
 
     def __del__(self) -> None:
+        """
+        Calls stop().
+        """
         self.stop()

eventsourcing/system.py

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

eventsourcing/tests/domain.py

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

eventsourcing/tests/persistence.py

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

eventsourcing/tests/postgres_utils.py

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

eventsourcing/utils.py

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

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

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

eventsourcing-9.4.0b1.dist-info/RECORD

@@ -0,0 +1,26 @@
+eventsourcing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/application.py,sha256=lVgKXCeGA36CsUW7qgkkABX0mCUBvUH-QGQFtOYwmUw,35796
+eventsourcing/cipher.py,sha256=R6bvq7Zcsd7NvV1o8WghdBcnqu0IDkOxlfxUSk1txeQ,3320
+eventsourcing/compressor.py,sha256=IdvrJUB9B2td871oifInv4lGXmHwYL9d69MbHHCr7uI,421
+eventsourcing/cryptography.py,sha256=ZsQFyeyMZysADqKy38ECV71j6EMMSbo3VQO7oRnC1h0,2994
+eventsourcing/dispatch.py,sha256=3eVnGCagnn_CENSnTKonMt2kZ1eoHm8abdK7YRVONbU,2736
+eventsourcing/domain.py,sha256=WwDwo-IxYrC3fEXu_5E2x-Vk4s1Ye9IaZSQLcUGhQqw,59889
+eventsourcing/interface.py,sha256=uCoV9ARAu229SGwp169yeSLbB8wDLKDwWcnQdvOXOQM,5141
+eventsourcing/persistence.py,sha256=hCS1vCtS5X_LUtycuDpF6d6Os7zjQ3qTnGf7W39DWV4,46139
+eventsourcing/popo.py,sha256=xBUnnPuQ_wdF0ErU9AApRPwlkB0CJePMbWCz6qn3U1M,9654
+eventsourcing/postgres.py,sha256=hHYpzvZc7nANXE1uQZ3gA-XKk5X9rB6nJ_zouOkpidk,37537
+eventsourcing/projection.py,sha256=niCF9L5LsdeA0kgbKC3sE7p65rOF5du-YpdibkAhNU0,8588
+eventsourcing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/sqlite.py,sha256=UVgG0JCmYr7xN8HHnoiMPpZtZ3d5NTfB-iq0MlZGax4,22051
+eventsourcing/system.py,sha256=tyqGaGUE6CUGPWUZf27_26-Zl3PLsm3vK017Wxn7IM0,47279
+eventsourcing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/tests/application.py,sha256=DEncXtCsX0X6Udua9GbGpua0xTGshnDPIThFfzuiBog,18025
+eventsourcing/tests/domain.py,sha256=LkvGFYFc6jJR0PYjO2hAGPw0TNW8vUzdTuR8K5xDEQ0,3385
+eventsourcing/tests/persistence.py,sha256=DePUevT4uYNTcIzVZoO6uzyyrUI2sOK6CSioiJRcD6I,58518
+eventsourcing/tests/postgres_utils.py,sha256=0ywklGp6cXZ5PmV8ANVkwSHsZZCl5zTmOk7iG-RmrCE,1548
+eventsourcing/utils.py,sha256=1mG24CXb4oRaumB6NMaH3QqxtHEiWTiJEWzFDRBf6nc,8537
+eventsourcing-9.4.0b1.dist-info/AUTHORS,sha256=8aHOM4UbNZcKlD-cHpFRcM6RWyCqtwtxRev6DeUgVRs,137
+eventsourcing-9.4.0b1.dist-info/LICENSE,sha256=CQEQzcZO8AWXL5i3hIo4yVKrYjh2FBz6hCM7kpXWpw4,1512
+eventsourcing-9.4.0b1.dist-info/METADATA,sha256=Q4NfLZMDdQ9EKyxbXmk3_exmsHcD2PfOcSh-ldO3R-8,9796
+eventsourcing-9.4.0b1.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+eventsourcing-9.4.0b1.dist-info/RECORD,,

eventsourcing-9.4.0a8.dist-info/RECORD

@@ -1,26 +0,0 @@
-eventsourcing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-eventsourcing/application.py,sha256=YF1CAUZrqb51vzT95mk6mC0tWCHdR_N6-rn1s6SKL8g,35909
-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=FUvCklB-8BGEzoalk3IcuEeyDZrRzPhzgI96L4I9OxM,58980
-eventsourcing/interface.py,sha256=kObA7ouzLD4YpJMjhfPVmRUcDzhbK0bbFKXy75EscHU,5138
-eventsourcing/persistence.py,sha256=zsd_RL_H_gc64Ka45Vapd92eVZXrwfanrGNE36zp9tg,45877
-eventsourcing/popo.py,sha256=xBUnnPuQ_wdF0ErU9AApRPwlkB0CJePMbWCz6qn3U1M,9654
-eventsourcing/postgres.py,sha256=mMdorzwSbDDNjK5KQDNVLy48JrI_18KoRUkDtOI8_wM,36506
-eventsourcing/projection.py,sha256=pmSywj7DkUFIoOMuo8RJv7snB5jNdODSupMgQikEZto,6677
-eventsourcing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-eventsourcing/sqlite.py,sha256=UVgG0JCmYr7xN8HHnoiMPpZtZ3d5NTfB-iq0MlZGax4,22051
-eventsourcing/system.py,sha256=UgIwaU35drvaq9Nvs16zsZ4UMPjZ_PlFclvEhIWIVFA,47400
-eventsourcing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-eventsourcing/tests/application.py,sha256=DEncXtCsX0X6Udua9GbGpua0xTGshnDPIThFfzuiBog,18025
-eventsourcing/tests/domain.py,sha256=1FTpfG5w-UMbqh_R-6LKDZY0JKb_nZtOIEGrdYDEUyY,3373
-eventsourcing/tests/persistence.py,sha256=mb29R8-CJCNroSmrfYYxsN354zmJKQ--ROrjPDhjKTc,58256
-eventsourcing/tests/postgres_utils.py,sha256=jS1Ac5Yj4IPx-bsL2IRlytcd5oa0l6SiFcprHxqWdVQ,1371
-eventsourcing/utils.py,sha256=0DlFnDmvGwCSWiEQ_h5GLgyjAgHJbsVtdf-GLQvoH7I,8350
-eventsourcing-9.4.0a8.dist-info/AUTHORS,sha256=8aHOM4UbNZcKlD-cHpFRcM6RWyCqtwtxRev6DeUgVRs,137
-eventsourcing-9.4.0a8.dist-info/LICENSE,sha256=CQEQzcZO8AWXL5i3hIo4yVKrYjh2FBz6hCM7kpXWpw4,1512
-eventsourcing-9.4.0a8.dist-info/METADATA,sha256=22EfMdqFS1lzyD7ZDa4t3tfgl1b3mgeBwhXMYkzTCJg,9797
-eventsourcing-9.4.0a8.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-eventsourcing-9.4.0a8.dist-info/RECORD,,