eventsourcing 9.4.4__py3-none-any.whl → 9.4.6__py3-none-any.whl

eventsourcing/interface.py

@@ -57,7 +57,11 @@ class NotificationLogJSONService(NotificationLogInterface, Generic[TApplication]
                 "items": [
                     {
                         "id": item.id,
-                        "originator_id": item.originator_id.hex,
+                        "originator_id": (
+                            item.originator_id.hex
+                            if isinstance(item.originator_id, UUID)
+                            else item.originator_id
+                        ),
                         "originator_version": item.originator_version,
                         "topic": item.topic,
                         "state": b64encode(item.state).decode("utf8"),
@@ -85,7 +89,11 @@ class NotificationLogJSONService(NotificationLogInterface, Generic[TApplication]
             [
                 {
                     "id": notification.id,
-                    "originator_id": notification.originator_id.hex,
+                    "originator_id": (
+                        notification.originator_id.hex
+                        if isinstance(notification.originator_id, UUID)
+                        else notification.originator_id
+                    ),
                     "originator_version": notification.originator_version,
                     "topic": notification.topic,
                     "state": b64encode(notification.state).decode("utf8"),

eventsourcing/persistence.py

@@ -1,25 +1,32 @@
 from __future__ import annotations
 
 import json
-import uuid
+import typing
 from abc import ABC, abstractmethod
 from collections import deque
-from collections.abc import Iterator, Mapping, Sequence
+from collections.abc import Hashable, Iterator, Mapping, Sequence
 from dataclasses import dataclass
 from datetime import datetime
 from decimal import Decimal
+from functools import lru_cache
 from queue import Queue
 from threading import Condition, Event, Lock, Semaphore, Thread, Timer
 from time import monotonic, sleep, time
 from types import GenericAlias, ModuleType
-from typing import TYPE_CHECKING, Any, Generic, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Generic, Union, cast
 from uuid import UUID
 
 from typing_extensions import TypeVar
 
-from eventsourcing.domain import DomainEventProtocol, EventSourcingError
+from eventsourcing.domain import (
+    DomainEventProtocol,
+    EventSourcingError,
+    HasOriginatorIDVersion,
+    TAggregateID,
+)
 from eventsourcing.utils import (
     Environment,
+    EnvType,
     TopicError,
     get_topic,
     resolve_topic,
@@ -178,7 +185,7 @@ class StoredEvent:
     objects and :class:`~eventsourcing.domain.Snapshot` objects.
     """
 
-    originator_id: uuid.UUID
+    originator_id: UUID | str
     """ID of the originating aggregate."""
     originator_version: int
     """Position in an aggregate sequence."""
@@ -220,7 +227,10 @@ class MapperDeserialisationError(EventSourcingError, ValueError):
     """Raised when deserialization fails in a Mapper."""
 
 
-class Mapper:
+TAggregateIDType = TypeVar("TAggregateIDType", type[UUID], type[str])
+
+
+class Mapper(Generic[TAggregateID]):
     """Converts between domain event objects and :class:`StoredEvent` objects.
 
     Uses a :class:`Transcoder`, and optionally a cryptographic cipher and compressor.
@@ -236,7 +246,9 @@ class Mapper:
         self.compressor = compressor
         self.cipher = cipher
 
-    def to_stored_event(self, domain_event: DomainEventProtocol) -> StoredEvent:
+    def to_stored_event(
+        self, domain_event: DomainEventProtocol[TAggregateID]
+    ) -> StoredEvent:
         """Converts the given domain event to a :class:`StoredEvent` object."""
         topic = get_topic(domain_event.__class__)
         event_state = domain_event.__dict__.copy()
@@ -257,8 +269,12 @@ class Mapper:
             state=stored_state,
         )
 
-    def to_domain_event(self, stored_event: StoredEvent) -> DomainEventProtocol:
+    def to_domain_event(
+        self, stored_event: StoredEvent
+    ) -> DomainEventProtocol[TAggregateID]:
         """Converts the given :class:`StoredEvent` to a domain event object."""
+        cls = resolve_topic(stored_event.topic)
+
         stored_state = stored_event.state
         try:
             if self.cipher:
@@ -275,9 +291,12 @@ class Mapper:
             )
             raise MapperDeserialisationError(msg) from e
 
-        event_state["originator_id"] = stored_event.originator_id
+        id_convertor = find_id_convertor(
+            cls, cast(Hashable, type(stored_event.originator_id))
+        )
+        # print("ID of convertor:", id(convertor))
+        event_state["originator_id"] = id_convertor(stored_event.originator_id)
         event_state["originator_version"] = stored_event.originator_version
-        cls = resolve_topic(stored_event.topic)
         class_version = getattr(cls, "class_version", 1)
         from_version = event_state.pop("class_version", 1)
         while from_version < class_version:
@@ -289,6 +308,66 @@ class Mapper:
         return domain_event
 
 
+@lru_cache
+def find_id_convertor(
+    domain_event_cls: type[object], originator_id_cls: type[UUID | str]
+) -> Callable[[UUID | str], UUID | str]:
+    # Try to find the originator_id type.
+    if issubclass(domain_event_cls, HasOriginatorIDVersion):
+        # For classes that inherit CanMutateAggregate, and don't use a different
+        # mapper, then assume they aren't overriding __init_subclass__ is a way
+        # that prevents 'originator_id_type' being found from type arguments and
+        # set on the class.
+        # TODO: Write a test where a custom class does override __init_subclass__
+        #  so that the next line will cause an AssertionError. Then fix this code.
+        if domain_event_cls.originator_id_type is None:
+            msg = "originator_id_type cannot be None"
+            raise TypeError(msg)
+        originator_id_type = domain_event_cls.originator_id_type
+    else:
+        # Otherwise look for annotations.
+        for cls in domain_event_cls.__mro__:
+            try:
+                annotation = cls.__annotations__["originator_id"]
+            except (KeyError, AttributeError):  # noqa: PERF203
+                continue
+            else:
+                valid_annotations = {
+                    str: str,
+                    UUID: UUID,
+                    "str": str,
+                    "UUID": UUID,
+                    "uuid.UUID": UUID,
+                }
+                if annotation not in valid_annotations:
+                    msg = f"originator_id annotation on {cls} is not either UUID or str"
+                    raise TypeError(msg)
+                assert annotation in valid_annotations, annotation
+                originator_id_type = valid_annotations[annotation]
+                break
+        else:
+            msg = (
+                f"Neither event class {domain_event_cls}"
+                f"nor its bases have an originator_id annotation"
+            )
+            raise TypeError(msg)
+
+    if originator_id_cls is str and originator_id_type is UUID:
+        convertor = str_to_uuid_convertor
+    else:
+        convertor = pass_through_convertor
+    return convertor
+
+
+def str_to_uuid_convertor(originator_id: UUID | str) -> UUID | str:
+    assert isinstance(originator_id, str)
+    return UUID(originator_id)
+
+
+def pass_through_convertor(originator_id: UUID | str) -> UUID | str:
+    return originator_id
+
+
 class RecordConflictError(EventSourcingError):
     """Legacy exception, replaced with IntegrityError."""
 
@@ -366,20 +445,20 @@ class AggregateRecorder(Recorder, ABC):
 
     @abstractmethod
     def insert_events(
-        self, stored_events: list[StoredEvent], **kwargs: Any
+        self, stored_events: Sequence[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         """Writes stored events into database."""
 
     @abstractmethod
     def select_events(
         self,
-        originator_id: UUID,
+        originator_id: UUID | str,
         *,
         gt: int | None = None,
         lte: int | None = None,
         desc: bool = False,
         limit: int | None = None,
-    ) -> list[StoredEvent]:
+    ) -> Sequence[StoredEvent]:
         """Reads stored events from database."""
 
 
@@ -405,7 +484,7 @@ class ApplicationRecorder(AggregateRecorder):
         topics: Sequence[str] = (),
         *,
         inclusive_of_start: bool = True,
-    ) -> list[Notification]:
+    ) -> Sequence[Notification]:
         """Returns a list of Notification objects representing events from an
         application sequence. If `inclusive_of_start` is True (the default),
         the returned Notification objects will have IDs greater than or equal
@@ -510,29 +589,29 @@ class ProcessRecorder(TrackingRecorder, ApplicationRecorder, ABC):
 
 
 @dataclass(frozen=True)
-class Recording:
+class Recording(Generic[TAggregateID]):
     """Represents the recording of a domain event."""
 
-    domain_event: DomainEventProtocol
+    domain_event: DomainEventProtocol[TAggregateID]
     """The domain event that has been recorded."""
     notification: Notification
     """A Notification that represents the domain event in the application sequence."""
 
 
-class EventStore:
+class EventStore(Generic[TAggregateID]):
     """Stores and retrieves domain events."""
 
     def __init__(
         self,
-        mapper: Mapper,
+        mapper: Mapper[TAggregateID],
         recorder: AggregateRecorder,
     ):
-        self.mapper = mapper
+        self.mapper: Mapper[TAggregateID] = mapper
         self.recorder = recorder
 
     def put(
-        self, domain_events: Sequence[DomainEventProtocol], **kwargs: Any
-    ) -> list[Recording]:
+        self, domain_events: Sequence[DomainEventProtocol[TAggregateID]], **kwargs: Any
+    ) -> list[Recording[TAggregateID]]:
         """Stores domain events in aggregate sequence."""
         stored_events = list(map(self.mapper.to_stored_event, domain_events))
         recordings = []
@@ -556,13 +635,13 @@ class EventStore:
 
     def get(
         self,
-        originator_id: UUID,
+        originator_id: TAggregateID,
         *,
         gt: int | None = None,
         lte: int | None = None,
         desc: bool = False,
         limit: int | None = None,
-    ) -> Iterator[DomainEventProtocol]:
+    ) -> Iterator[DomainEventProtocol[TAggregateID]]:
         """Retrieves domain events from aggregate sequence."""
         return map(
             self.mapper.to_domain_event,
@@ -671,9 +750,9 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
             raise InfrastructureFactoryError(msg)
         return factory_cls(env=env)
 
-    def __init__(self, env: Environment):
+    def __init__(self, env: Environment | EnvType | None):
         """Initialises infrastructure factory object with given application name."""
-        self.env = env
+        self.env = env if isinstance(env, Environment) else Environment(env=env)
 
     def transcoder(
         self,
@@ -689,14 +768,23 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
     def mapper(
         self,
         transcoder: Transcoder | None = None,
-        mapper_class: type[Mapper] | None = None,
-    ) -> Mapper:
+        mapper_class: type[Mapper[TAggregateID]] | None = None,
+    ) -> Mapper[TAggregateID]:
         """Constructs a mapper."""
+        # Resolve MAPPER_TOPIC if no given class.
         if mapper_class is None:
             mapper_topic = self.env.get(self.MAPPER_TOPIC)
-            mapper_class = resolve_topic(mapper_topic) if mapper_topic else Mapper
+            mapper_class = (
+                resolve_topic(mapper_topic) if mapper_topic else Mapper[TAggregateID]
+            )
+
+        # Check we have a mapper class.
+        assert mapper_class is not None
+        origin_mapper_class = typing.get_origin(mapper_class) or mapper_class
+        assert isinstance(origin_mapper_class, type), mapper_class
+        assert issubclass(origin_mapper_class, Mapper), mapper_class
 
-        assert isinstance(mapper_class, type) and issubclass(mapper_class, Mapper)
+        # Construct and return a mapper.
         return mapper_class(
             transcoder=transcoder or self.transcoder(),
             cipher=self.cipher(),
@@ -738,9 +826,9 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
 
     def event_store(
         self,
-        mapper: Mapper | None = None,
+        mapper: Mapper[TAggregateID] | None = None,
         recorder: AggregateRecorder | None = None,
-    ) -> EventStore:
+    ) -> EventStore[TAggregateID]:
         """Constructs an event store."""
         return EventStore(
             mapper=mapper or self.mapper(),
@@ -1258,9 +1346,9 @@ class ListenNotifySubscription(Subscription[TApplicationRecorder_co]):
     ) -> None:
         super().__init__(recorder=recorder, gt=gt, topics=topics)
         self._select_limit = 500
-        self._notifications: list[Notification] = []
+        self._notifications: Sequence[Notification] = []
         self._notifications_index: int = 0
-        self._notifications_queue: Queue[list[Notification]] = Queue(maxsize=10)
+        self._notifications_queue: Queue[Sequence[Notification]] = Queue(maxsize=10)
         self._has_been_notified = Event()
         self._thread_error: BaseException | None = None
         self._pull_thread = Thread(target=self._loop_on_pull)

eventsourcing/popo.py

@@ -34,26 +34,28 @@ class POPOAggregateRecorder(POPORecorder, AggregateRecorder):
     def __init__(self) -> None:
         super().__init__()
         self._stored_events: list[StoredEvent] = []
-        self._stored_events_index: dict[UUID, dict[int, int]] = defaultdict(dict)
+        self._stored_events_index: dict[str, dict[int, int]] = defaultdict(dict)
 
     def insert_events(
-        self, stored_events: list[StoredEvent], **kwargs: Any
+        self, stored_events: Sequence[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         self._insert_events(stored_events, **kwargs)
         return None
 
     def _insert_events(
-        self, stored_events: list[StoredEvent], **kwargs: Any
+        self, stored_events: Sequence[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         with self._database_lock:
             self._assert_uniqueness(stored_events, **kwargs)
             return self._update_table(stored_events, **kwargs)
 
-    def _assert_uniqueness(self, stored_events: list[StoredEvent], **_: Any) -> None:
+    def _assert_uniqueness(
+        self, stored_events: Sequence[StoredEvent], **_: Any
+    ) -> None:
         new = set()
         for s in stored_events:
             # Check events don't already exist.
-            if s.originator_version in self._stored_events_index[s.originator_id]:
+            if s.originator_version in self._stored_events_index[str(s.originator_id)]:
                 msg = f"Stored event already recorded: {s}"
                 raise IntegrityError(msg)
             new.add((s.originator_id, s.originator_version))
@@ -63,12 +65,12 @@ class POPOAggregateRecorder(POPORecorder, AggregateRecorder):
             raise IntegrityError(msg)
 
     def _update_table(
-        self, stored_events: list[StoredEvent], **_: Any
+        self, stored_events: Sequence[StoredEvent], **_: Any
     ) -> Sequence[int] | None:
         notification_ids = []
         for s in stored_events:
             self._stored_events.append(s)
-            self._stored_events_index[s.originator_id][s.originator_version] = (
+            self._stored_events_index[str(s.originator_id)][s.originator_version] = (
                 len(self._stored_events) - 1
             )
             notification_ids.append(len(self._stored_events))
@@ -76,17 +78,17 @@ class POPOAggregateRecorder(POPORecorder, AggregateRecorder):
 
     def select_events(
         self,
-        originator_id: UUID,
+        originator_id: UUID | str,
         *,
         gt: int | None = None,
         lte: int | None = None,
         desc: bool = False,
         limit: int | None = None,
-    ) -> list[StoredEvent]:
+    ) -> Sequence[StoredEvent]:
         with self._database_lock:
             results = []
 
-            index = self._stored_events_index[originator_id]
+            index = self._stored_events_index[str(originator_id)]
             positions: Iterable[int]
             positions = reversed_keys(index) if desc else index.keys()
             for p in positions:
@@ -107,7 +109,7 @@ class POPOApplicationRecorder(POPOAggregateRecorder, ApplicationRecorder):
         self._listeners: set[Event] = set()
 
     def insert_events(
-        self, stored_events: list[StoredEvent], **kwargs: Any
+        self, stored_events: Sequence[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         notification_ids = self._insert_events(stored_events, **kwargs)
         self._notify_listeners()
@@ -121,7 +123,7 @@ class POPOApplicationRecorder(POPOAggregateRecorder, ApplicationRecorder):
         topics: Sequence[str] = (),
         *,
         inclusive_of_start: bool = True,
-    ) -> list[Notification]:
+    ) -> Sequence[Notification]:
         with self._database_lock:
             results = []
             if start is None:
@@ -221,7 +223,7 @@ class POPOProcessRecorder(
     POPOTrackingRecorder, POPOApplicationRecorder, ProcessRecorder
 ):
     def _assert_uniqueness(
-        self, stored_events: list[StoredEvent], **kwargs: Any
+        self, stored_events: Sequence[StoredEvent], **kwargs: Any
     ) -> None:
         super()._assert_uniqueness(stored_events, **kwargs)
         t: Tracking | None = kwargs.get("tracking")
@@ -229,7 +231,7 @@ class POPOProcessRecorder(
             self._assert_tracking_uniqueness(t)
 
     def _update_table(
-        self, stored_events: list[StoredEvent], **kwargs: Any
+        self, stored_events: Sequence[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         notification_ids = super()._update_table(stored_events, **kwargs)
         t: Tracking | None = kwargs.get("tracking")

eventsourcing/postgres.py

@@ -37,7 +37,7 @@ from eventsourcing.persistence import (
     Tracking,
     TrackingRecorder,
 )
-from eventsourcing.utils import Environment, resolve_topic, retry, strtobool
+from eventsourcing.utils import Environment, EnvType, resolve_topic, retry, strtobool
 
 if TYPE_CHECKING:
     from collections.abc import Iterator, Sequence
@@ -46,8 +46,8 @@ if TYPE_CHECKING:
     from psycopg.abc import Query
     from typing_extensions import Self
 
-logging.getLogger("psycopg.pool").setLevel(logging.CRITICAL)
-logging.getLogger("psycopg").setLevel(logging.CRITICAL)
+logging.getLogger("psycopg.pool").setLevel(logging.ERROR)
+logging.getLogger("psycopg").setLevel(logging.ERROR)
 
 # Copy of "private" psycopg.errors._NO_TRACEBACK (in case it changes)
 # From psycopg: "Don't show a complete traceback upon raising these exception.
@@ -83,16 +83,16 @@ class PostgresDatastore:
         user: str,
         password: str,
         *,
-        connect_timeout: int = 30,
-        idle_in_transaction_session_timeout: int = 0,
-        pool_size: int = 2,
-        max_overflow: int = 2,
+        connect_timeout: float = 5.0,
+        idle_in_transaction_session_timeout: float = 0,
+        pool_size: int = 1,
+        max_overflow: int = 0,
         max_waiting: int = 0,
         conn_max_age: float = 60 * 60.0,
         pre_ping: bool = False,
         lock_timeout: int = 0,
         schema: str = "",
-        pool_open_timeout: int | None = None,
+        pool_open_timeout: float | None = None,
         get_password_func: Callable[[], str] | None = None,
         single_row_tracking: bool = True,
     ):
@@ -126,8 +126,8 @@ class PostgresDatastore:
         self.schema = schema.strip() or "public"
 
     def after_connect_func(self) -> Callable[[Connection[Any]], None]:
-        statement = SQL("SET idle_in_transaction_session_timeout = '{0}s'").format(
-            self.idle_in_transaction_session_timeout
+        statement = SQL("SET idle_in_transaction_session_timeout = '{0}ms'").format(
+            int(self.idle_in_transaction_session_timeout * 1000)
         )
 
         def after_connect(conn: Connection[DictRow]) -> None:
@@ -271,7 +271,7 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
     def insert_events(
-        self, stored_events: list[StoredEvent], **kwargs: Any
+        self, stored_events: Sequence[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         exc: Exception | None = None
         notification_ids: Sequence[int] | None = None
@@ -302,7 +302,7 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
     def _insert_events(
         self,
         curs: Cursor[DictRow],
-        stored_events: list[StoredEvent],
+        stored_events: Sequence[StoredEvent],
         **_: Any,
     ) -> None:
         pass
@@ -310,7 +310,7 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
     def _insert_stored_events(
         self,
         curs: Cursor[DictRow],
-        stored_events: list[StoredEvent],
+        stored_events: Sequence[StoredEvent],
         **_: Any,
     ) -> None:
         # Only do something if there is something to do.
@@ -343,7 +343,7 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
     def _fetch_ids_after_insert_events(
         self,
         curs: Cursor[DictRow],
-        stored_events: list[StoredEvent],
+        stored_events: Sequence[StoredEvent],
         **kwargs: Any,
     ) -> Sequence[int] | None:
         return None
@@ -351,13 +351,13 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
     def select_events(
         self,
-        originator_id: UUID,
+        originator_id: UUID | str,
         *,
         gt: int | None = None,
         lte: int | None = None,
         desc: bool = False,
         limit: int | None = None,
-    ) -> list[StoredEvent]:
+    ) -> Sequence[StoredEvent]:
         statement = self.select_events_statement
         params: list[Any] = [originator_id]
         if gt is not None:
@@ -451,7 +451,7 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
         topics: Sequence[str] = (),
         *,
         inclusive_of_start: bool = True,
-    ) -> list[Notification]:
+    ) -> Sequence[Notification]:
         """Returns a list of event notifications
         from 'start', limited by 'limit'.
         """
@@ -548,7 +548,7 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
     def _fetch_ids_after_insert_events(
         self,
         curs: Cursor[DictRow],
-        stored_events: list[StoredEvent],
+        stored_events: Sequence[StoredEvent],
         **kwargs: Any,
     ) -> Sequence[int] | None:
         notification_ids: list[int] = []
@@ -845,7 +845,7 @@ class PostgresProcessRecorder(
     def _insert_events(
         self,
         curs: Cursor[DictRow],
-        stored_events: list[StoredEvent],
+        stored_events: Sequence[StoredEvent],
         **kwargs: Any,
     ) -> None:
         tracking: Tracking | None = kwargs.get("tracking")
@@ -880,7 +880,7 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
     tracking_recorder_class = PostgresTrackingRecorder
     process_recorder_class = PostgresProcessRecorder
 
-    def __init__(self, env: Environment):
+    def __init__(self, env: Environment | EnvType | None):
         super().__init__(env)
         dbname = self.env.get(self.POSTGRES_DBNAME)
         if dbname is None: