eventsourcing 9.3.4__py3-none-any.whl → 9.4.0a1__py3-none-any.whl

eventsourcing/projection.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import os
+import weakref
+from abc import ABC, abstractmethod
+from threading import Event, Thread
+from traceback import format_exc
+from typing import TYPE_CHECKING, Any, Dict, Generic, Type, TypeVar
+from warnings import warn
+
+from eventsourcing.application import Application
+from eventsourcing.dispatch import singledispatchmethod
+from eventsourcing.persistence import (
+    InfrastructureFactory,
+    Tracking,
+    TrackingRecorder,
+    TTrackingRecorder,
+    WaitInterruptedError,
+)
+from eventsourcing.utils import Environment, EnvType
+
+if TYPE_CHECKING:  # pragma: no cover
+    from typing_extensions import Self
+
+    from eventsourcing.application import ApplicationSubscription
+    from eventsourcing.domain import DomainEventProtocol
+
+
+class Projection(ABC, Generic[TTrackingRecorder]):
+    name: str = ""
+
+    def __init__(
+        self,
+        tracking_recorder: TTrackingRecorder,
+    ):
+        self.tracking_recorder = tracking_recorder
+
+    @singledispatchmethod
+    @abstractmethod
+    def process_event(
+        self, domain_event: DomainEventProtocol, tracking: Tracking
+    ) -> None:
+        """
+        Process a domain event and track it.
+        """
+
+
+TProjection = TypeVar("TProjection", bound=Projection[Any])
+TApplication = TypeVar("TApplication", bound=Application)
+
+
+class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
+    def __init__(
+        self,
+        *,
+        application_class: Type[TApplication],
+        projection_class: Type[Projection[TTrackingRecorder]],
+        tracking_recorder_class: Type[TTrackingRecorder] | None = None,
+        env: EnvType | None = None,
+    ):
+        self.app: TApplication = application_class(env)
+
+        projection_environment = self._construct_env(
+            name=projection_class.name or projection_class.__name__, env=env
+        )
+        self.projection_factory: InfrastructureFactory[TTrackingRecorder] = (
+            InfrastructureFactory.construct(env=projection_environment)
+        )
+        self.tracking_recorder: TTrackingRecorder = (
+            self.projection_factory.tracking_recorder(tracking_recorder_class)
+        )
+
+        self.subscription = self.app.subscribe(
+            gt=self.tracking_recorder.max_tracking_id(self.app.name)
+        )
+        self.projection = projection_class(
+            tracking_recorder=self.tracking_recorder,
+        )
+        self._has_error = Event()
+        self.thread_error: BaseException | None = None
+        self.processing_thread = Thread(
+            target=self._process_events_loop,
+            kwargs={
+                "subscription": self.subscription,
+                "projection": self.projection,
+                "has_error": self._has_error,
+                "runner": weakref.ref(self),
+            },
+        )
+        self.processing_thread.start()
+
+    def _construct_env(self, name: str, env: EnvType | None = None) -> Environment:
+        """
+        Constructs environment from which projection will be configured.
+        """
+        _env: Dict[str, str] = {}
+        _env.update(os.environ)
+        if env is not None:
+            _env.update(env)
+        return Environment(name, _env)
+
+    def stop(self) -> None:
+        self.subscription.subscription.stop()
+
+    @staticmethod
+    def _process_events_loop(
+        subscription: ApplicationSubscription,
+        projection: Projection[TrackingRecorder],
+        has_error: Event,
+        runner: weakref.ReferenceType[ProjectionRunner[Application, TrackingRecorder]],
+    ) -> None:
+        try:
+            with subscription:
+                for domain_event, tracking in subscription:
+                    projection.process_event(domain_event, tracking)
+        except BaseException as e:
+            _runner = runner()  # get reference from weakref
+            if _runner is not None:
+                _runner.thread_error = e
+            else:
+                msg = "ProjectionRunner was deleted before error could be assigned:\n"
+                msg += format_exc()
+                warn(
+                    msg,
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
+
+            has_error.set()
+            subscription.subscription.stop()
+
+    def run_forever(self, timeout: float | None = None) -> None:
+        if self._has_error.wait(timeout=timeout):
+            assert self.thread_error is not None  # for mypy
+            raise self.thread_error
+
+    def wait(self, notification_id: int, timeout: float = 1.0) -> None:
+        try:
+            self.projection.tracking_recorder.wait(
+                application_name=self.subscription.name,
+                notification_id=notification_id,
+                timeout=timeout,
+                interrupt=self._has_error,
+            )
+        except WaitInterruptedError:
+            assert self.thread_error is not None  # for mypy
+            raise self.thread_error from None
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *args: object, **kwargs: Any) -> None:
+        self.stop()
+        self.processing_thread.join()
+
+    def __del__(self) -> None:
+        self.stop()

eventsourcing/sqlite.py

@@ -23,12 +23,15 @@ from eventsourcing.persistence import (
     PersistenceError,
     ProcessRecorder,
     ProgrammingError,
+    Recorder,
     StoredEvent,
+    Subscription,
     Tracking,
+    TrackingRecorder,
 )
-from eventsourcing.utils import Environment, strtobool
+from eventsourcing.utils import Environment, resolve_topic, strtobool
 
-if TYPE_CHECKING:  # pragma: nocover
+if TYPE_CHECKING:  # pragma: no cover
     from types import TracebackType
 
 SQLITE3_DEFAULT_LOCK_TIMEOUT = 5
@@ -242,16 +245,32 @@ class SQLiteDatastore:
         self.close()
 
 
-class SQLiteAggregateRecorder(AggregateRecorder):
+class SQLiteRecorder(Recorder):
     def __init__(
         self,
         datastore: SQLiteDatastore,
-        events_table_name: str = "stored_events",
     ):
         assert isinstance(datastore, SQLiteDatastore)
         self.datastore = datastore
-        self.events_table_name = events_table_name
         self.create_table_statements = self.construct_create_table_statements()
+
+    def construct_create_table_statements(self) -> List[str]:
+        return []
+
+    def create_table(self) -> None:
+        with self.datastore.transaction(commit=True) as c:
+            for statement in self.create_table_statements:
+                c.execute(statement)
+
+
+class SQLiteAggregateRecorder(SQLiteRecorder, AggregateRecorder):
+    def __init__(
+        self,
+        datastore: SQLiteDatastore,
+        events_table_name: str = "stored_events",
+    ):
+        self.events_table_name = events_table_name
+        super().__init__(datastore)
         self.insert_events_statement = (
             f"INSERT INTO {self.events_table_name} VALUES (?,?,?,?)"
         )
@@ -260,7 +279,8 @@ class SQLiteAggregateRecorder(AggregateRecorder):
         )
 
     def construct_create_table_statements(self) -> List[str]:
-        statement = (
+        statements = super().construct_create_table_statements()
+        statements.append(
             "CREATE TABLE IF NOT EXISTS "
             f"{self.events_table_name} ("
             "originator_id TEXT, "
@@ -271,12 +291,7 @@ class SQLiteAggregateRecorder(AggregateRecorder):
             "(originator_id, originator_version)) "
             "WITHOUT ROWID"
         )
-        return [statement]
-
-    def create_table(self) -> None:
-        with self.datastore.transaction(commit=True) as c:
-            for statement in self.create_table_statements:
-                c.execute(statement)
+        return statements
 
     def insert_events(
         self, stored_events: List[StoredEvent], **kwargs: Any
@@ -389,25 +404,45 @@ class SQLiteApplicationRecorder(
 
     def select_notifications(
         self,
-        start: int,
+        start: int | None,
         limit: int,
         stop: int | None = None,
         topics: Sequence[str] = (),
+        *,
+        inclusive_of_start: bool = True,
     ) -> List[Notification]:
         """
         Returns a list of event notifications
         from 'start', limited by 'limit'.
         """
-        params: List[int | str] = [start]
-        statement = f"SELECT rowid, * FROM {self.events_table_name} WHERE rowid>=? "
+        params: List[int | str] = []
+        statement = f"SELECT rowid, * FROM {self.events_table_name} "
+        has_where = False
+        if start is not None:
+            has_where = True
+            statement += "WHERE "
+            params.append(start)
+            if inclusive_of_start:
+                statement += "rowid>=? "
+            else:
+                statement += "rowid>? "
 
         if stop is not None:
+            if not has_where:
+                has_where = True
+                statement += "WHERE "
+            else:
+                statement += "AND "
             params.append(stop)
-            statement += "AND rowid<=? "
+            statement += "rowid<=? "
 
         if topics:
+            if not has_where:
+                statement += "WHERE "
+            else:
+                statement += "AND "
             params += list(topics)
-            statement += "AND topic IN (%s) " % ",".join("?" * len(topics))
+            statement += "topic IN (%s) " % ",".join("?" * len(topics))
 
         params.append(limit)
         statement += "ORDER BY rowid LIMIT ?"
@@ -434,19 +469,20 @@ class SQLiteApplicationRecorder(
 
     def _max_notification_id(self, c: SQLiteCursor) -> int:
         c.execute(self.select_max_notification_id_statement)
-        return c.fetchone()[0] or 0
+        return c.fetchone()[0]
 
+    def subscribe(self, gt: int | None = None) -> Subscription[ApplicationRecorder]:
+        msg = f"The {type(self).__qualname__} recorder does not support subscriptions"
+        raise NotImplementedError(msg)
 
-class SQLiteProcessRecorder(
-    SQLiteApplicationRecorder,
-    ProcessRecorder,
-):
+
+class SQLiteTrackingRecorder(SQLiteRecorder, TrackingRecorder):
     def __init__(
         self,
         datastore: SQLiteDatastore,
-        events_table_name: str = "stored_events",
+        **kwargs: Any,
     ):
-        super().__init__(datastore, events_table_name)
+        super().__init__(datastore, **kwargs)
         self.insert_tracking_statement = "INSERT INTO tracking VALUES (?,?)"
         self.select_max_tracking_id_statement = (
             "SELECT MAX(notification_id) FROM tracking WHERE application_name=?"
@@ -468,11 +504,28 @@ class SQLiteProcessRecorder(
         )
         return statements
 
-    def max_tracking_id(self, application_name: str) -> int:
+    def insert_tracking(self, tracking: Tracking) -> None:
+        with self.datastore.transaction(commit=True) as c:
+            self._insert_tracking(c, tracking)
+
+    def _insert_tracking(
+        self,
+        c: SQLiteCursor,
+        tracking: Tracking,
+    ) -> None:
+        c.execute(
+            self.insert_tracking_statement,
+            (
+                tracking.application_name,
+                tracking.notification_id,
+            ),
+        )
+
+    def max_tracking_id(self, application_name: str) -> int | None:
         params = [application_name]
         with self.datastore.transaction(commit=False) as c:
             c.execute(self.select_max_tracking_id_statement, params)
-            return c.fetchone()[0] or 0
+            return c.fetchone()[0]
 
     def has_tracking_id(self, application_name: str, notification_id: int) -> bool:
         params = [application_name, notification_id]
@@ -480,6 +533,20 @@ class SQLiteProcessRecorder(
             c.execute(self.count_tracking_id_statement, params)
             return bool(c.fetchone()[0])
 
+
+class SQLiteProcessRecorder(
+    SQLiteTrackingRecorder,
+    SQLiteApplicationRecorder,
+    ProcessRecorder,
+):
+    def __init__(
+        self,
+        datastore: SQLiteDatastore,
+        *,
+        events_table_name: str = "stored_events",
+    ):
+        super().__init__(datastore, events_table_name=events_table_name)
+
     def _insert_events(
         self,
         c: SQLiteCursor,
@@ -489,23 +556,18 @@ class SQLiteProcessRecorder(
         returning = super()._insert_events(c, stored_events, **kwargs)
         tracking: Tracking | None = kwargs.get("tracking", None)
         if tracking is not None:
-            c.execute(
-                self.insert_tracking_statement,
-                (
-                    tracking.application_name,
-                    tracking.notification_id,
-                ),
-            )
+            self._insert_tracking(c, tracking)
         return returning
 
 
-class Factory(InfrastructureFactory):
+class SQLiteFactory(InfrastructureFactory[SQLiteTrackingRecorder]):
     SQLITE_DBNAME = "SQLITE_DBNAME"
     SQLITE_LOCK_TIMEOUT = "SQLITE_LOCK_TIMEOUT"
     CREATE_TABLE = "CREATE_TABLE"
 
     aggregate_recorder_class = SQLiteAggregateRecorder
     application_recorder_class = SQLiteApplicationRecorder
+    tracking_recorder_class = SQLiteTrackingRecorder
     process_recorder_class = SQLiteProcessRecorder
 
     def __init__(self, env: Environment):
@@ -549,13 +611,55 @@ class Factory(InfrastructureFactory):
         return recorder
 
     def application_recorder(self) -> ApplicationRecorder:
-        recorder = self.application_recorder_class(datastore=self.datastore)
+        application_recorder_topic = self.env.get(self.APPLICATION_RECORDER_TOPIC)
+
+        if application_recorder_topic:
+            application_recorder_class: Type[SQLiteApplicationRecorder] = resolve_topic(
+                application_recorder_topic
+            )
+            assert issubclass(application_recorder_class, SQLiteApplicationRecorder)
+        else:
+            application_recorder_class = self.application_recorder_class
+
+        recorder = application_recorder_class(datastore=self.datastore)
+
+        if self.env_create_table():
+            recorder.create_table()
+        return recorder
+
+    def tracking_recorder(
+        self, tracking_recorder_class: Type[SQLiteTrackingRecorder] | None = None
+    ) -> SQLiteTrackingRecorder:
+        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 = self.tracking_recorder_class
+
+        assert tracking_recorder_class is not None
+        assert issubclass(tracking_recorder_class, SQLiteTrackingRecorder)
+
+        recorder = tracking_recorder_class(datastore=self.datastore)
+
         if self.env_create_table():
             recorder.create_table()
         return recorder
 
     def process_recorder(self) -> ProcessRecorder:
-        recorder = self.process_recorder_class(datastore=self.datastore)
+        process_recorder_topic = self.env.get(self.PROCESS_RECORDER_TOPIC)
+
+        if process_recorder_topic:
+            process_recorder_class: Type[SQLiteProcessRecorder] = resolve_topic(
+                process_recorder_topic
+            )
+            assert issubclass(process_recorder_class, SQLiteProcessRecorder)
+        else:
+            process_recorder_class = self.process_recorder_class
+
+        recorder = process_recorder_class(datastore=self.datastore)
+
         if self.env_create_table():
             recorder.create_table()
         return recorder
@@ -566,3 +670,6 @@ class Factory(InfrastructureFactory):
 
     def close(self) -> None:
         self.datastore.close()
+
+
+Factory = SQLiteFactory