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

eventsourcing/projection.py

@@ -8,14 +8,15 @@ from abc import ABC, abstractmethod
 from collections.abc import Iterator, Sequence
 from threading import Event, Thread
 from traceback import format_exc
-from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypeVar
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
 from warnings import warn
 
 from eventsourcing.application import Application, ProcessingEvent
 from eventsourcing.dispatch import singledispatchmethod
-from eventsourcing.domain import DomainEventProtocol
+from eventsourcing.domain import DomainEventProtocol, TAggregateID
 from eventsourcing.persistence import (
     InfrastructureFactory,
+    Mapper,
     ProcessRecorder,
     Tracking,
     TrackingRecorder,
@@ -30,7 +31,9 @@ if TYPE_CHECKING:
     from typing_extensions import Self
 
 
-class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
+class ApplicationSubscription(
+    Iterator[tuple[DomainEventProtocol[TAggregateID], Tracking]]
+):
     """An iterator that yields all domain events recorded in an application
     sequence that have notification IDs greater than a given value. The iterator
     will block when all recorded domain events have been yielded, and then
@@ -40,7 +43,7 @@ class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
 
     def __init__(
         self,
-        app: Application,
+        app: Application[TAggregateID],
         gt: int | None = None,
         topics: Sequence[str] = (),
     ):
@@ -49,7 +52,7 @@ class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
         """
         self.name = app.name
         self.recorder = app.recorder
-        self.mapper = app.mapper
+        self.mapper: Mapper[TAggregateID] = app.mapper
         self.subscription = self.recorder.subscribe(gt=gt, topics=topics)
 
     def stop(self) -> None:
@@ -68,7 +71,7 @@ class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
     def __iter__(self) -> Self:
         return self
 
-    def __next__(self) -> tuple[DomainEventProtocol, Tracking]:
+    def __next__(self) -> tuple[DomainEventProtocol[TAggregateID], Tracking]:
         """Returns the next stored event from subscription to the application's
         recorder. Constructs a tracking object that identifies the position of
         the event in the application sequence. Constructs a domain event object
@@ -116,18 +119,18 @@ class Projection(ABC, Generic[TTrackingRecorder]):
     @singledispatchmethod
     @abstractmethod
     def process_event(
-        self, domain_event: DomainEventProtocol, tracking: Tracking
+        self, domain_event: DomainEventProtocol[TAggregateID], tracking: Tracking
     ) -> None:
         """Process a domain event and track it."""
 
 
-class EventSourcedProjection(Application, ABC):
+class EventSourcedProjection(Application[TAggregateID], ABC):
     """Extends the :py:class:`~eventsourcing.application.Application` class
     by using a process recorder as its application recorder, and by
     processing domain events through its :py:func:`policy` method.
     """
 
-    topics: ClassVar[Sequence[str]] = ()
+    topics: Sequence[str] = ()
 
     def __init__(self, env: EnvType | None = None) -> None:
         super().__init__(env)
@@ -141,7 +144,7 @@ class EventSourcedProjection(Application, ABC):
         return self.factory.process_recorder()
 
     def process_event(
-        self, domain_event: DomainEventProtocol, tracking: Tracking
+        self, domain_event: DomainEventProtocol[TAggregateID], tracking: Tracking
     ) -> None:
         """Calls :func:`~eventsourcing.system.Follower.policy` method with the given
         domain event and a new :class:`~eventsourcing.application.ProcessingEvent`
@@ -158,7 +161,7 @@ class EventSourcedProjection(Application, ABC):
         the recordings are passed in a call to
         :py:func:`~eventsourcing.application.Application._notify`.
         """
-        processing_event = ProcessingEvent(tracking=tracking)
+        processing_event = ProcessingEvent[TAggregateID](tracking=tracking)
         self.policy(domain_event, processing_event)
         recordings = self._record(processing_event)
         self._take_snapshots(processing_event)
@@ -168,8 +171,8 @@ class EventSourcedProjection(Application, ABC):
     @singledispatchmethod
     def policy(
         self,
-        domain_event: DomainEventProtocol,
-        processing_event: ProcessingEvent,
+        domain_event: DomainEventProtocol[TAggregateID],
+        processing_event: ProcessingEvent[TAggregateID],
     ) -> None:
         """Abstract domain event processing policy method. Must be
         implemented by event processing applications. When
@@ -183,9 +186,9 @@ class EventSourcedProjection(Application, ABC):
         """
 
 
-TApplication = TypeVar("TApplication", bound=Application)
+TApplication = TypeVar("TApplication", bound=Application[Any])
 TEventSourcedProjection = TypeVar(
-    "TEventSourcedProjection", bound=EventSourcedProjection
+    "TEventSourcedProjection", bound=EventSourcedProjection[Any]
 )
 
 
@@ -193,7 +196,7 @@ class BaseProjectionRunner(Generic[TApplication]):
     def __init__(
         self,
         *,
-        projection: EventSourcedProjection | Projection[Any],
+        projection: EventSourcedProjection[Any] | Projection[Any],
         application_class: type[TApplication],
         tracking_recorder: TrackingRecorder,
         topics: Sequence[str],
@@ -258,7 +261,7 @@ class BaseProjectionRunner(Generic[TApplication]):
 
     @staticmethod
     def _stop_subscription_when_stopping(
-        subscription: ApplicationSubscription,
+        subscription: ApplicationSubscription[TAggregateID],
         is_stopping: Event,
     ) -> None:
         """Stops the application subscription, which
@@ -272,10 +275,12 @@ class BaseProjectionRunner(Generic[TApplication]):
 
     @staticmethod
     def _process_events_loop(
-        subscription: ApplicationSubscription,
-        projection: EventSourcedProjection | Projection[Any],
+        subscription: ApplicationSubscription[TAggregateID],
+        projection: EventSourcedProjection[Any] | Projection[Any],
         is_stopping: Event,
-        runner: weakref.ReferenceType[ProjectionRunner[Application, TrackingRecorder]],
+        runner: weakref.ReferenceType[
+            ProjectionRunner[Application[Any], TrackingRecorder]
+        ],
     ) -> None:
         """Iterates over the subscription and calls process_event()."""
         try:

eventsourcing/sqlite.py

@@ -29,7 +29,7 @@ from eventsourcing.persistence import (
     Tracking,
     TrackingRecorder,
 )
-from eventsourcing.utils import Environment, resolve_topic, strtobool
+from eventsourcing.utils import Environment, EnvType, resolve_topic, strtobool
 
 if TYPE_CHECKING:
     from collections.abc import Iterator, Sequence
@@ -300,7 +300,7 @@ class SQLiteAggregateRecorder(SQLiteRecorder, AggregateRecorder):
         return statements
 
     def insert_events(
-        self, stored_events: list[StoredEvent], **kwargs: Any
+        self, stored_events: Sequence[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         with self.datastore.transaction(commit=True) as c:
             return self._insert_events(c, stored_events, **kwargs)
@@ -308,12 +308,16 @@ class SQLiteAggregateRecorder(SQLiteRecorder, AggregateRecorder):
     def _insert_events(
         self,
         c: SQLiteCursor,
-        stored_events: list[StoredEvent],
+        stored_events: Sequence[StoredEvent],
         **_: Any,
     ) -> Sequence[int] | None:
         params = [
             (
-                s.originator_id.hex,
+                (
+                    s.originator_id.hex
+                    if isinstance(s.originator_id, UUID)
+                    else s.originator_id
+                ),
                 s.originator_version,
                 s.topic,
                 s.state,
@@ -325,15 +329,17 @@ class SQLiteAggregateRecorder(SQLiteRecorder, 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]:
         statement = self.select_events_statement
-        params: list[Any] = [originator_id.hex]
+        params: list[Any] = [
+            originator_id.hex if isinstance(originator_id, UUID) else originator_id
+        ]
         if gt is not None:
             statement += "AND originator_version>? "
             params.append(gt)
@@ -352,7 +358,7 @@ class SQLiteAggregateRecorder(SQLiteRecorder, AggregateRecorder):
             c.execute(statement, params)
             return [
                 StoredEvent(
-                    originator_id=UUID(row["originator_id"]),
+                    originator_id=row["originator_id"],
                     originator_version=row["originator_version"],
                     topic=row["topic"],
                     state=row["state"],
@@ -391,18 +397,22 @@ class SQLiteApplicationRecorder(
     def _insert_events(
         self,
         c: SQLiteCursor,
-        stored_events: list[StoredEvent],
+        stored_events: Sequence[StoredEvent],
         **_: Any,
     ) -> Sequence[int] | None:
         returning = []
-        for stored_event in stored_events:
+        for s in stored_events:
             c.execute(
                 self.insert_events_statement,
                 (
-                    stored_event.originator_id.hex,
-                    stored_event.originator_version,
-                    stored_event.topic,
-                    stored_event.state,
+                    (
+                        s.originator_id.hex
+                        if isinstance(s.originator_id, UUID)
+                        else s.originator_id
+                    ),
+                    s.originator_version,
+                    s.topic,
+                    s.state,
                 ),
             )
             returning.append(c.lastrowid)
@@ -416,7 +426,7 @@ class SQLiteApplicationRecorder(
         topics: Sequence[str] = (),
         *,
         inclusive_of_start: bool = True,
-    ) -> list[Notification]:
+    ) -> Sequence[Notification]:
         """Returns a list of event notifications
         from 'start', limited by 'limit'.
         """
@@ -457,7 +467,7 @@ class SQLiteApplicationRecorder(
             return [
                 Notification(
                     id=row["rowid"],
-                    originator_id=UUID(row["originator_id"]),
+                    originator_id=row["originator_id"],
                     originator_version=row["originator_version"],
                     topic=row["topic"],
                     state=row["state"],
@@ -650,7 +660,7 @@ class SQLiteProcessRecorder(
     def _insert_events(
         self,
         c: SQLiteCursor,
-        stored_events: list[StoredEvent],
+        stored_events: Sequence[StoredEvent],
         **kwargs: Any,
     ) -> Sequence[int] | None:
         returning = super()._insert_events(c, stored_events, **kwargs)
@@ -671,7 +681,7 @@ class SQLiteFactory(InfrastructureFactory[SQLiteTrackingRecorder]):
     tracking_recorder_class = SQLiteTrackingRecorder
     process_recorder_class = SQLiteProcessRecorder
 
-    def __init__(self, env: Environment):
+    def __init__(self, env: Environment | EnvType | None):
         super().__init__(env)
         db_name = self.env.get(self.SQLITE_DBNAME)
         if not db_name: