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

eventsourcing/persistence.py

@@ -12,9 +12,10 @@ 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, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Any, Generic, Union, cast
 from uuid import UUID
-from warnings import warn
+
+from typing_extensions import TypeVar
 
 from eventsourcing.domain import DomainEventProtocol, EventSourcingError
 from eventsourcing.utils import (
@@ -284,15 +285,6 @@ class Mapper:
             state=stored_state,
         )
 
-    def from_domain_event(self, domain_event: DomainEventProtocol) -> StoredEvent:
-        warn(
-            "'from_domain_event()' is deprecated, use 'to_stored_event()' instead",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        return self.to_stored_event(domain_event)
-
     def to_domain_event(self, stored_event: StoredEvent) -> DomainEventProtocol:
         """
         Converts the given :class:`StoredEvent` to a domain event object.
@@ -508,16 +500,19 @@ class TrackingRecorder(Recorder, ABC):
         """
 
     @abstractmethod
-    def has_tracking_id(self, application_name: str, notification_id: int) -> bool:
+    def has_tracking_id(
+        self, application_name: str, notification_id: int | None
+    ) -> bool:
         """
         Returns True if a tracking object with the given application name
-        and notification ID has been recorded, otherwise returns False.
+        and notification ID has been recorded, and True if given notification_id is
+        None, otherwise returns False.
         """
 
     def wait(
         self,
         application_name: str,
-        notification_id: int,
+        notification_id: int | None,
         timeout: float = 1.0,
         interrupt: Event | None = None,
     ) -> None:
@@ -634,12 +629,10 @@ class EventStore:
         )
 
 
-TInfrastructureFactory = TypeVar(
-    "TInfrastructureFactory", bound="InfrastructureFactory[Any]"
+TTrackingRecorder = TypeVar(
+    "TTrackingRecorder", bound=TrackingRecorder, default=TrackingRecorder
 )
 
-TTrackingRecorder = TypeVar("TTrackingRecorder", bound=TrackingRecorder)
-
 
 class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
     """
@@ -658,14 +651,15 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
 
     @classmethod
     def construct(
-        cls: type[TInfrastructureFactory], env: Environment | None = None
-    ) -> TInfrastructureFactory:
+        cls: type[InfrastructureFactory[TTrackingRecorder]],
+        env: Environment | None = None,
+    ) -> InfrastructureFactory[TTrackingRecorder]:
         """
         Constructs concrete infrastructure factory for given
         named application. Reads and resolves persistence
         topic from environment variable 'PERSISTENCE_MODULE'.
         """
-        factory_cls: type[InfrastructureFactory[TrackingRecorder]]
+        factory_cls: type[InfrastructureFactory[TTrackingRecorder]]
         if env is None:
             env = Environment()
         topic = (
@@ -684,7 +678,7 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
             or "eventsourcing.popo"
         )
         try:
-            obj: type[InfrastructureFactory[TrackingRecorder]] | ModuleType = (
+            obj: type[InfrastructureFactory[TTrackingRecorder]] | ModuleType = (
                 resolve_topic(topic)
             )
         except TopicError as e:
@@ -697,7 +691,7 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
 
         if isinstance(obj, ModuleType):
             # Find the factory in the module.
-            factory_classes: list[type[InfrastructureFactory[TrackingRecorder]]] = []
+            factory_classes: list[type[InfrastructureFactory[TTrackingRecorder]]] = []
             for member in obj.__dict__.values():
                 if (
                     member is not InfrastructureFactory
@@ -724,7 +718,7 @@ class InfrastructureFactory(ABC, Generic[TTrackingRecorder]):
         else:
             msg = f"Not an infrastructure factory class or module: {topic}"
             raise AssertionError(msg)
-        return cast(TInfrastructureFactory, factory_cls(env=env))
+        return factory_cls(env=env)
 
     def __init__(self, env: Environment):
         """

eventsourcing/popo.py

@@ -219,7 +219,11 @@ class POPOTrackingRecorder(POPORecorder, TrackingRecorder):
         with self._database_lock:
             return self._max_tracking_ids[application_name]
 
-    def has_tracking_id(self, application_name: str, notification_id: int) -> bool:
+    def has_tracking_id(
+        self, application_name: str, notification_id: int | None
+    ) -> bool:
+        if notification_id is None:
+            return True
         with self._database_lock:
             return notification_id in self._tracking_table[application_name]
 

eventsourcing/postgres.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import logging
 from asyncio import CancelledError
 from contextlib import contextmanager
@@ -180,6 +181,9 @@ class PostgresDatastore:
     def __exit__(self, *args: object, **kwargs: Any) -> None:
         self.close()
 
+    def __del__(self) -> None:
+        self.close()
+
 
 class PostgresRecorder:
     """Base class for recorders that use PostgreSQL."""
@@ -194,9 +198,8 @@ class PostgresRecorder:
     def construct_create_table_statements(self) -> list[str]:
         return []
 
-    @staticmethod
-    def check_table_name_length(table_name: str, schema_name: str) -> None:
-        schema_prefix = schema_name + "."
+    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:
@@ -219,7 +222,7 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
         events_table_name: str = "stored_events",
     ):
         super().__init__(datastore)
-        self.check_table_name_length(events_table_name, datastore.schema)
+        self.check_table_name_length(events_table_name)
         self.events_table_name = events_table_name
         # Index names can't be qualified names, but
         # are created in the same schema as the table.
@@ -283,7 +286,7 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
 
     def _insert_events(
         self,
-        c: Cursor[DictRow],
+        curs: Cursor[DictRow],
         stored_events: list[StoredEvent],
         **_: Any,
     ) -> None:
@@ -291,18 +294,18 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
 
     def _insert_stored_events(
         self,
-        c: Cursor[DictRow],
+        curs: Cursor[DictRow],
         stored_events: list[StoredEvent],
         **_: Any,
     ) -> None:
         # Only do something if there is something to do.
         if len(stored_events) > 0:
-            self._lock_table(c)
+            self._lock_table(curs)
 
-            self._notify_channel(c)
+            self._notify_channel(curs)
 
             # Insert events.
-            c.executemany(
+            curs.executemany(
                 query=self.insert_events_statement,
                 params_seq=[
                     (
@@ -316,15 +319,15 @@ class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
                 returning="RETURNING" in self.insert_events_statement,
             )
 
-    def _lock_table(self, c: Cursor[DictRow]) -> None:
+    def _lock_table(self, curs: Cursor[DictRow]) -> None:
         pass
 
-    def _notify_channel(self, c: Cursor[DictRow]) -> None:
+    def _notify_channel(self, curs: Cursor[DictRow]) -> None:
         pass
 
     def _fetch_ids_after_insert_events(
         self,
-        c: Cursor[DictRow],
+        curs: Cursor[DictRow],
         stored_events: list[StoredEvent],
         **kwargs: Any,
     ) -> Sequence[int] | None:
@@ -479,7 +482,7 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
             assert fetchone is not None
             return fetchone["max"]
 
-    def _lock_table(self, c: Cursor[DictRow]) -> None:
+    def _lock_table(self, curs: Cursor[DictRow]) -> None:
         # Acquire "EXCLUSIVE" table lock, to serialize transactions that insert
         # stored events, so that readers don't pass over gaps that are filled in
         # later. We want each transaction that will be issued with notifications
@@ -501,23 +504,23 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
         # https://stackoverflow.com/questions/45866187/guarantee-monotonicity-of
         # -postgresql-serial-column-values-by-commit-order
         for lock_statement in self.lock_table_statements:
-            c.execute(lock_statement, prepare=True)
+            curs.execute(lock_statement, prepare=True)
 
-    def _notify_channel(self, c: Cursor[DictRow]) -> None:
-        c.execute("NOTIFY " + self.channel_name)
+    def _notify_channel(self, curs: Cursor[DictRow]) -> None:
+        curs.execute("NOTIFY " + self.channel_name)
 
     def _fetch_ids_after_insert_events(
         self,
-        c: Cursor[DictRow],
+        curs: Cursor[DictRow],
         stored_events: list[StoredEvent],
         **kwargs: Any,
     ) -> Sequence[int] | None:
         notification_ids: list[int] = []
         len_events = len(stored_events)
         if len_events:
-            while c.nextset() and len(notification_ids) != len_events:
-                if c.statusmessage and c.statusmessage.startswith("INSERT"):
-                    row = c.fetchone()
+            while curs.nextset() and len(notification_ids) != len_events:
+                if curs.statusmessage and curs.statusmessage.startswith("INSERT"):
+                    row = curs.fetchone()
                     assert row is not None
                     notification_ids.append(row["notification_id"])
             if len(notification_ids) != len(stored_events):
@@ -579,7 +582,7 @@ class PostgresTrackingRecorder(PostgresRecorder, TrackingRecorder):
         **kwargs: Any,
     ):
         super().__init__(datastore, **kwargs)
-        self.check_table_name_length(tracking_table_name, datastore.schema)
+        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 "
@@ -605,16 +608,20 @@ class PostgresTrackingRecorder(PostgresRecorder, TrackingRecorder):
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
     def insert_tracking(self, tracking: Tracking) -> None:
-        c: Connection[DictRow]
-        with self.datastore.get_connection() as c, c.transaction(), c.cursor() as curs:
+        conn: Connection[DictRow]
+        with (
+            self.datastore.get_connection() as conn,
+            conn.transaction(),
+            conn.cursor() as curs,
+        ):
             self._insert_tracking(curs, tracking)
 
     def _insert_tracking(
         self,
-        c: Cursor[DictRow],
+        curs: Cursor[DictRow],
         tracking: Tracking,
     ) -> None:
-        c.execute(
+        curs.execute(
             query=self.insert_tracking_statement,
             params=(
                 tracking.application_name,
@@ -636,7 +643,11 @@ class PostgresTrackingRecorder(PostgresRecorder, TrackingRecorder):
             return fetchone["max"]
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
-    def has_tracking_id(self, application_name: str, notification_id: int) -> bool:
+    def has_tracking_id(
+        self, application_name: str, notification_id: int | None
+    ) -> bool:
+        if notification_id is None:
+            return True
         conn: Connection[DictRow]
         with self.datastore.get_connection() as conn, conn.cursor() as curs:
             curs.execute(
@@ -667,14 +678,14 @@ class PostgresProcessRecorder(
 
     def _insert_events(
         self,
-        c: Cursor[DictRow],
+        curs: Cursor[DictRow],
         stored_events: list[StoredEvent],
         **kwargs: Any,
     ) -> None:
         tracking: Tracking | None = kwargs.get("tracking", None)
         if tracking is not None:
-            self._insert_tracking(c, tracking=tracking)
-        super()._insert_events(c, stored_events, **kwargs)
+            self._insert_tracking(curs, tracking=tracking)
+        super()._insert_events(curs, stored_events, **kwargs)
 
 
 class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
@@ -960,11 +971,8 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
         return recorder
 
     def close(self) -> None:
-        if hasattr(self, "datastore"):
+        with contextlib.suppress(AttributeError):
             self.datastore.close()
 
-    def __del__(self) -> None:
-        self.close()
-
 
 Factory = PostgresFactory

eventsourcing/projection.py

@@ -72,13 +72,19 @@ class Projection(ABC, Generic[TTrackingRecorder]):
     name: str = ""
     """Name of projection, used to pick prefixed environment variables."""
     topics: Sequence[str] = ()
-    """Event topics, used to filter events in database."""
+    """Filter events in database when subscribing to an application."""
 
     def __init__(
         self,
-        tracking_recorder: TTrackingRecorder,
+        view: TTrackingRecorder,
     ):
-        self.tracking_recorder = tracking_recorder
+        """Initialises a projection instance."""
+        self._view = view
+
+    @property
+    def view(self) -> TTrackingRecorder:
+        """Materialised view of an event-sourced application."""
+        return self._view
 
     @singledispatchmethod
     @abstractmethod
@@ -90,9 +96,6 @@ class Projection(ABC, Generic[TTrackingRecorder]):
         """
 
 
-TProjection = TypeVar("TProjection", bound=Projection[Any])
-
-
 TApplication = TypeVar("TApplication", bound=Application)
 
 
@@ -101,28 +104,28 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         self,
         *,
         application_class: type[TApplication],
+        view_class: type[TTrackingRecorder],
         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.view = (
+            InfrastructureFactory[TTrackingRecorder]
+            .construct(
+                env=self._construct_env(
+                    name=projection_class.name or projection_class.__name__, env=env
+                )
+            )
+            .tracking_recorder(view_class)
         )
 
         self.projection = projection_class(
-            tracking_recorder=self.tracking_recorder,
+            view=self.view,
         )
         self.subscription = ApplicationSubscription(
             app=self.app,
-            gt=self.tracking_recorder.max_tracking_id(self.app.name),
+            gt=self.view.max_tracking_id(self.app.name),
             topics=self.projection.topics,
         )
         self._is_stopping = Event()
@@ -183,9 +186,9 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         if self._is_stopping.wait(timeout=timeout) and self.thread_error is not None:
             raise self.thread_error
 
-    def wait(self, notification_id: int, timeout: float = 1.0) -> None:
+    def wait(self, notification_id: int | None, timeout: float = 1.0) -> None:
         try:
-            self.projection.tracking_recorder.wait(
+            self.projection.view.wait(
                 application_name=self.subscription.name,
                 notification_id=notification_id,
                 timeout=timeout,

eventsourcing/sqlite.py

@@ -530,7 +530,11 @@ class SQLiteTrackingRecorder(SQLiteRecorder, TrackingRecorder):
             c.execute(self.select_max_tracking_id_statement, params)
             return c.fetchone()[0]
 
-    def has_tracking_id(self, application_name: str, notification_id: int) -> bool:
+    def has_tracking_id(
+        self, application_name: str, notification_id: int | None
+    ) -> bool:
+        if notification_id is None:
+            return True
         params = [application_name, notification_id]
         with self.datastore.transaction(commit=False) as c:
             c.execute(self.count_tracking_id_statement, params)

eventsourcing/system.py

@@ -7,16 +7,18 @@ 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, ClassVar, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, 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,
     NotificationLog,
     ProcessingEvent,
+    ProgrammingError,
     Section,
     TApplication,
 )
@@ -196,8 +198,11 @@ class Follower(Application):
                 self.notify(processing_event.events)
                 self._notify(recordings)
 
-    @abstractmethod
-    def policy(
+    policy: (
+        Callable[[DomainEventProtocol, ProcessingEvent], None] | singledispatchmethod
+    )
+
+    def policy(  # type: ignore[no-redef]
         self,
         domain_event: DomainEventProtocol,
         processing_event: ProcessingEvent,
@@ -379,7 +384,7 @@ class System:
         return cls
 
     @property
-    def topic(self) -> str | None:
+    def topic(self) -> str:
         """
         Returns a topic to the system object, if constructed as a module attribute.
         """
@@ -389,6 +394,9 @@ class System:
             if value is self:
                 topic = module.__name__ + ":" + name
                 assert resolve_topic(topic) is self
+        if topic is None:
+            msg = "Unable to compute topic for system object: %s" % self
+            raise ProgrammingError(msg)
         return topic
 
 
@@ -423,6 +431,13 @@ class Runner(ABC):
         Returns an application instance for given application class.
         """
 
+    def __enter__(self) -> Self:
+        self.start()
+        return self
+
+    def __exit__(self, *args: object, **kwargs: Any) -> None:
+        self.stop()
+
 
 class RunnerAlreadyStartedError(Exception):
     """
@@ -548,13 +563,6 @@ class SingleThreadedRunner(Runner, RecordingEventReceiver):
         assert isinstance(app, cls)
         return app
 
-    def __enter__(self) -> Self:
-        self.start()
-        return self
-
-    def __exit__(self, *args: object, **kwargs: Any) -> None:
-        self.stop()
-
 
 class NewSingleThreadedRunner(Runner, RecordingEventReceiver):
     """