eventsourcing 9.3.0b1__py3-none-any.whl → 9.3.1__py3-none-any.whl

eventsourcing/application.py

@@ -25,6 +25,8 @@ from typing import (
 )
 from warnings import warn
 
+from typing_extensions import deprecated
+
 from eventsourcing.domain import (
     Aggregate,
     CanMutateProtocol,
@@ -908,7 +910,12 @@ class Application:
 TApplication = TypeVar("TApplication", bound=Application)
 
 
-class AggregateNotFoundError(EventSourcingError):
+@deprecated("AggregateNotFound is deprecated, use AggregateNotFoundError instead")
+class AggregateNotFound(EventSourcingError):  # noqa: N818
+    pass
+
+
+class AggregateNotFoundError(AggregateNotFound):
     """
     Raised when an :class:`~eventsourcing.domain.Aggregate`
     object is not found in a :class:`Repository`.

eventsourcing/examples/aggregate4/domainmodel.py

@@ -1,10 +1,8 @@
 from __future__ import annotations
 
-import contextlib
-from collections import defaultdict
 from dataclasses import dataclass
 from datetime import datetime, timezone
-from typing import Any, ClassVar, Dict, Iterable, List, Type, TypeVar, cast
+from typing import Any, Iterable, List, Type, TypeVar, cast
 from uuid import UUID, uuid4
 
 from eventsourcing.dispatch import singledispatchmethod
@@ -29,6 +27,7 @@ class Aggregate:
     id: UUID
     version: int
     created_on: datetime
+    _pending_events: List[DomainEvent]
 
     def __init__(self, event: DomainEvent):
         self.id = event.originator_id
@@ -47,15 +46,15 @@ class Aggregate:
             timestamp=event_class.create_timestamp(),
         )
         new_event = event_class(**kwargs)
-        self.apply(new_event)
-        self.pending_events.append(new_event)
+        self._apply(new_event)
+        self._pending_events.append(new_event)
 
     @singledispatchmethod
-    def apply(self, event: DomainEvent) -> None:
+    def _apply(self, event: DomainEvent) -> None:
         """Applies event to aggregate."""
 
     def collect_events(self) -> List[DomainEvent]:
-        events, self.pending_events = self.pending_events, []
+        events, self._pending_events = self._pending_events, []
         return events
 
     @classmethod
@@ -64,25 +63,12 @@ class Aggregate:
         _: TAggregate | None,
         events: Iterable[DomainEvent],
     ) -> TAggregate | None:
-        aggregate = object.__new__(cls)
+        aggregate: TAggregate = object.__new__(cls)
+        aggregate._pending_events = []
         for event in events:
-            aggregate.apply(event)
+            aggregate._apply(event)
         return aggregate
 
-    @property
-    def pending_events(self) -> List[DomainEvent]:
-        return type(self).__pending_events[id(self)]
-
-    @pending_events.setter
-    def pending_events(self, pending_events: List[DomainEvent]) -> None:
-        type(self).__pending_events[id(self)] = pending_events
-
-    __pending_events: ClassVar[Dict[int, List[DomainEvent]]] = defaultdict(list)
-
-    def __del__(self) -> None:
-        with contextlib.suppress(KeyError):
-            type(self).__pending_events.pop(id(self))
-
 
 class Dog(Aggregate):
     @dataclass(frozen=True)
@@ -102,27 +88,27 @@ class Dog(Aggregate):
             name=name,
         )
         dog = cast(Dog, cls.projector(None, [event]))
-        dog.pending_events.append(event)
+        dog._pending_events.append(event)
         return dog
 
     def add_trick(self, trick: str) -> None:
         self.trigger_event(self.TrickAdded, trick=trick)
 
     @singledispatchmethod
-    def apply(self, event: DomainEvent) -> None:
+    def _apply(self, event: DomainEvent) -> None:
         """Applies event to aggregate."""
 
-    @apply.register(Registered)
+    @_apply.register(Registered)
     def _(self, event: Registered) -> None:
         super().__init__(event)
         self.name = event.name
         self.tricks: List[str] = []
 
-    @apply.register(TrickAdded)
+    @_apply.register(TrickAdded)
     def _(self, event: TrickAdded) -> None:
         self.tricks.append(event.trick)
         self.version = event.originator_version
 
-    @apply.register(Snapshot)
+    @_apply.register(Snapshot)
     def _(self, event: Snapshot) -> None:
         self.__dict__.update(event.state)

eventsourcing/examples/contentmanagementsystem/test_system.py

@@ -23,112 +23,119 @@ class ContentManagementSystemTestCase(TestCase):
     env: ClassVar[Dict[str, str]] = {}
 
     def test_system(self) -> None:
-        runner = SingleThreadedRunner(system=ContentManagementSystem(), env=self.env)
-        runner.start()
-
-        content_management_app = runner.get(ContentManagementApplication)
-        search_index_app = runner.get(SearchIndexApplication)
-
-        # Set user_id context variable.
-        user_id = uuid4()
-        user_id_cvar.set(user_id)
-
-        # Create empty pages.
-        content_management_app.create_page(title="Animals", slug="animals")
-        content_management_app.create_page(title="Plants", slug="plants")
-        content_management_app.create_page(title="Minerals", slug="minerals")
-
-        # Search, expect no results.
-        self.assertEqual(0, len(search_index_app.search("cat")))
-        self.assertEqual(0, len(search_index_app.search("rose")))
-        self.assertEqual(0, len(search_index_app.search("calcium")))
-
-        # Update the pages.
-        content_management_app.update_body(slug="animals", body="cat")
-        content_management_app.update_body(slug="plants", body="rose")
-        content_management_app.update_body(slug="minerals", body="calcium")
-
-        # Search for single words.
-        page_ids = search_index_app.search("cat")
-        self.assertEqual(1, len(page_ids))
-        page = content_management_app.get_page_by_id(page_ids[0])
-        self.assertEqual(page["slug"], "animals")
-        self.assertEqual(page["body"], "cat")
-
-        page_ids = search_index_app.search("rose")
-        self.assertEqual(1, len(page_ids))
-        page = content_management_app.get_page_by_id(page_ids[0])
-        self.assertEqual(page["slug"], "plants")
-        self.assertEqual(page["body"], "rose")
-
-        page_ids = search_index_app.search("calcium")
-        self.assertEqual(1, len(page_ids))
-        page = content_management_app.get_page_by_id(page_ids[0])
-        self.assertEqual(page["slug"], "minerals")
-        self.assertEqual(page["body"], "calcium")
-
-        self.assertEqual(len(search_index_app.search("dog")), 0)
-        self.assertEqual(len(search_index_app.search("bluebell")), 0)
-        self.assertEqual(len(search_index_app.search("zinc")), 0)
-
-        # Update the pages again.
-        content_management_app.update_body(slug="animals", body="cat dog zebra")
-        content_management_app.update_body(slug="plants", body="bluebell rose jasmine")
-        content_management_app.update_body(slug="minerals", body="iron zinc calcium")
-
-        # Search for single words.
-        page_ids = search_index_app.search("cat")
-        self.assertEqual(1, len(page_ids))
-        page = content_management_app.get_page_by_id(page_ids[0])
-        self.assertEqual(page["slug"], "animals")
-        self.assertEqual(page["body"], "cat dog zebra")
-
-        page_ids = search_index_app.search("rose")
-        self.assertEqual(1, len(page_ids))
-        page = content_management_app.get_page_by_id(page_ids[0])
-        self.assertEqual(page["slug"], "plants")
-        self.assertEqual(page["body"], "bluebell rose jasmine")
-
-        page_ids = search_index_app.search("calcium")
-        self.assertEqual(1, len(page_ids))
-        page = content_management_app.get_page_by_id(page_ids[0])
-        self.assertEqual(page["slug"], "minerals")
-        self.assertEqual(page["body"], "iron zinc calcium")
-
-        page_ids = search_index_app.search("dog")
-        self.assertEqual(1, len(page_ids))
-        page = content_management_app.get_page_by_id(page_ids[0])
-        self.assertEqual(page["slug"], "animals")
-        self.assertEqual(page["body"], "cat dog zebra")
-
-        page_ids = search_index_app.search("bluebell")
-        self.assertEqual(1, len(page_ids))
-        page = content_management_app.get_page_by_id(page_ids[0])
-        self.assertEqual(page["slug"], "plants")
-        self.assertEqual(page["body"], "bluebell rose jasmine")
-
-        page_ids = search_index_app.search("zinc")
-        self.assertEqual(1, len(page_ids))
-        page = content_management_app.get_page_by_id(page_ids[0])
-        self.assertEqual(page["slug"], "minerals")
-        self.assertEqual(page["body"], "iron zinc calcium")
-
-        # Search for multiple words in same page.
-        page_ids = search_index_app.search("dog cat")
-        self.assertEqual(1, len(page_ids))
-        page = content_management_app.get_page_by_id(page_ids[0])
-        self.assertEqual(page["slug"], "animals")
-        self.assertEqual(page["body"], "cat dog zebra")
-
-        # Search for multiple words in same page, expect no results.
-        page_ids = search_index_app.search("rose zebra")
-        self.assertEqual(0, len(page_ids))
-
-        # Search for alternative words, expect two results.
-        page_ids = search_index_app.search("rose OR zebra")
-        pages = [content_management_app.get_page_by_id(page_id) for page_id in page_ids]
-        self.assertEqual(2, len(pages))
-        self.assertEqual(["animals", "plants"], sorted(p["slug"] for p in pages))
+        with SingleThreadedRunner(
+            system=ContentManagementSystem(), env=self.env
+        ) as runner:
+
+            content_management_app = runner.get(ContentManagementApplication)
+            search_index_app = runner.get(SearchIndexApplication)
+
+            # Set user_id context variable.
+            user_id = uuid4()
+            user_id_cvar.set(user_id)
+
+            # Create empty pages.
+            content_management_app.create_page(title="Animals", slug="animals")
+            content_management_app.create_page(title="Plants", slug="plants")
+            content_management_app.create_page(title="Minerals", slug="minerals")
+
+            # Search, expect no results.
+            self.assertEqual(0, len(search_index_app.search("cat")))
+            self.assertEqual(0, len(search_index_app.search("rose")))
+            self.assertEqual(0, len(search_index_app.search("calcium")))
+
+            # Update the pages.
+            content_management_app.update_body(slug="animals", body="cat")
+            content_management_app.update_body(slug="plants", body="rose")
+            content_management_app.update_body(slug="minerals", body="calcium")
+
+            # Search for single words.
+            page_ids = search_index_app.search("cat")
+            self.assertEqual(1, len(page_ids))
+            page = content_management_app.get_page_by_id(page_ids[0])
+            self.assertEqual(page["slug"], "animals")
+            self.assertEqual(page["body"], "cat")
+
+            page_ids = search_index_app.search("rose")
+            self.assertEqual(1, len(page_ids))
+            page = content_management_app.get_page_by_id(page_ids[0])
+            self.assertEqual(page["slug"], "plants")
+            self.assertEqual(page["body"], "rose")
+
+            page_ids = search_index_app.search("calcium")
+            self.assertEqual(1, len(page_ids))
+            page = content_management_app.get_page_by_id(page_ids[0])
+            self.assertEqual(page["slug"], "minerals")
+            self.assertEqual(page["body"], "calcium")
+
+            self.assertEqual(len(search_index_app.search("dog")), 0)
+            self.assertEqual(len(search_index_app.search("bluebell")), 0)
+            self.assertEqual(len(search_index_app.search("zinc")), 0)
+
+            # Update the pages again.
+            content_management_app.update_body(slug="animals", body="cat dog zebra")
+            content_management_app.update_body(
+                slug="plants", body="bluebell rose jasmine"
+            )
+            content_management_app.update_body(
+                slug="minerals", body="iron zinc calcium"
+            )
+
+            # Search for single words.
+            page_ids = search_index_app.search("cat")
+            self.assertEqual(1, len(page_ids))
+            page = content_management_app.get_page_by_id(page_ids[0])
+            self.assertEqual(page["slug"], "animals")
+            self.assertEqual(page["body"], "cat dog zebra")
+
+            page_ids = search_index_app.search("rose")
+            self.assertEqual(1, len(page_ids))
+            page = content_management_app.get_page_by_id(page_ids[0])
+            self.assertEqual(page["slug"], "plants")
+            self.assertEqual(page["body"], "bluebell rose jasmine")
+
+            page_ids = search_index_app.search("calcium")
+            self.assertEqual(1, len(page_ids))
+            page = content_management_app.get_page_by_id(page_ids[0])
+            self.assertEqual(page["slug"], "minerals")
+            self.assertEqual(page["body"], "iron zinc calcium")
+
+            page_ids = search_index_app.search("dog")
+            self.assertEqual(1, len(page_ids))
+            page = content_management_app.get_page_by_id(page_ids[0])
+            self.assertEqual(page["slug"], "animals")
+            self.assertEqual(page["body"], "cat dog zebra")
+
+            page_ids = search_index_app.search("bluebell")
+            self.assertEqual(1, len(page_ids))
+            page = content_management_app.get_page_by_id(page_ids[0])
+            self.assertEqual(page["slug"], "plants")
+            self.assertEqual(page["body"], "bluebell rose jasmine")
+
+            page_ids = search_index_app.search("zinc")
+            self.assertEqual(1, len(page_ids))
+            page = content_management_app.get_page_by_id(page_ids[0])
+            self.assertEqual(page["slug"], "minerals")
+            self.assertEqual(page["body"], "iron zinc calcium")
+
+            # Search for multiple words in same page.
+            page_ids = search_index_app.search("dog cat")
+            self.assertEqual(1, len(page_ids))
+            page = content_management_app.get_page_by_id(page_ids[0])
+            self.assertEqual(page["slug"], "animals")
+            self.assertEqual(page["body"], "cat dog zebra")
+
+            # Search for multiple words in same page, expect no results.
+            page_ids = search_index_app.search("rose zebra")
+            self.assertEqual(0, len(page_ids))
+
+            # Search for alternative words, expect two results.
+            page_ids = search_index_app.search("rose OR zebra")
+            pages = [
+                content_management_app.get_page_by_id(page_id) for page_id in page_ids
+            ]
+            self.assertEqual(2, len(pages))
+            self.assertEqual(["animals", "plants"], sorted(p["slug"] for p in pages))
 
 
 class TestWithSQLite(ContentManagementSystemTestCase):
@@ -157,18 +164,17 @@ class TestWithPostgres(ContentManagementSystemTestCase):
         super().tearDown()
 
     def drop_tables(self) -> None:
-        db = PostgresDatastore(
+        with PostgresDatastore(
             self.env["POSTGRES_DBNAME"],
             self.env["POSTGRES_HOST"],
             self.env["POSTGRES_PORT"],
             self.env["POSTGRES_USER"],
             self.env["POSTGRES_PASSWORD"],
-        )
-        drop_postgres_table(db, "public.contentmanagementapplication_events")
-        drop_postgres_table(db, "public.pages_projection_example")
-        drop_postgres_table(db, "public.searchindexapplication_events")
-        drop_postgres_table(db, "public.searchindexapplication_tracking")
-        db.close()
+        ) as datastore:
+            drop_postgres_table(datastore, "public.contentmanagementapplication_events")
+            drop_postgres_table(datastore, "public.pages_projection_example")
+            drop_postgres_table(datastore, "public.searchindexapplication_events")
+            drop_postgres_table(datastore, "public.searchindexapplication_tracking")
 
 
 del ContentManagementSystemTestCase

eventsourcing/examples/searchablecontent/test_application.py

@@ -96,16 +96,15 @@ class TestWithPostgres(SearchableContentApplicationTestCase):
         super().tearDown()
 
     def drop_tables(self) -> None:
-        db = PostgresDatastore(
+        with PostgresDatastore(
             os.environ["POSTGRES_DBNAME"],
             os.environ["POSTGRES_HOST"],
             os.environ["POSTGRES_PORT"],
             os.environ["POSTGRES_USER"],
             os.environ["POSTGRES_PASSWORD"],
-        )
-        drop_postgres_table(db, "public.searchablecontentapplication_events")
-        drop_postgres_table(db, "public.pages_projection_example")
-        db.close()
+        ) as datastore:
+            drop_postgres_table(datastore, "public.searchablecontentapplication_events")
+            drop_postgres_table(datastore, "public.pages_projection_example")
 
 
 del SearchableContentApplicationTestCase

eventsourcing/examples/searchablecontent/test_recorder.py

@@ -54,16 +54,15 @@ class TestWithPostgres(SearchableContentRecorderTestCase):
         super().tearDown()
 
     def drop_tables(self) -> None:
-        db = PostgresDatastore(
+        with PostgresDatastore(
             os.environ["POSTGRES_DBNAME"],
             os.environ["POSTGRES_HOST"],
             os.environ["POSTGRES_PORT"],
             os.environ["POSTGRES_USER"],
             os.environ["POSTGRES_PASSWORD"],
-        )
-        drop_postgres_table(db, "public.searchablecontentapplication_events")
-        drop_postgres_table(db, "public.pages_projection_example")
-        db.close()
+        ) as datastore:
+            drop_postgres_table(datastore, "public.searchablecontentapplication_events")
+            drop_postgres_table(datastore, "public.pages_projection_example")
 
 
 del SearchableContentRecorderTestCase

eventsourcing/examples/searchabletimestamps/test_searchabletimestamps.py

@@ -76,16 +76,19 @@ class WithPostgreSQL(SearchableTimestampsTestCase):
         super().tearDown()
 
     def drop_tables(self) -> None:
-        db = PostgresDatastore(
+        with PostgresDatastore(
             os.environ["POSTGRES_DBNAME"],
             os.environ["POSTGRES_HOST"],
             os.environ["POSTGRES_PORT"],
             os.environ["POSTGRES_USER"],
             os.environ["POSTGRES_PASSWORD"],
-        )
-        drop_postgres_table(db, "public.searchabletimestampsapplication_events")
-        drop_postgres_table(db, "public.searchabletimestampsapplication_timestamps")
-        db.close()
+        ) as datastore:
+            drop_postgres_table(
+                datastore, "public.searchabletimestampsapplication_events"
+            )
+            drop_postgres_table(
+                datastore, "public.searchabletimestampsapplication_timestamps"
+            )
 
 
 del SearchableTimestampsTestCase

eventsourcing/postgres.py

@@ -2,13 +2,14 @@ from __future__ import annotations
 
 import logging
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Sequence
+from typing import TYPE_CHECKING, Any, Callable, Iterator, List, Sequence
 
 import psycopg
 import psycopg.errors
 import psycopg_pool
 from psycopg import Connection, Cursor
 from psycopg.rows import DictRow, dict_row
+from typing_extensions import Self
 
 from eventsourcing.persistence import (
     AggregateRecorder,
@@ -62,11 +63,11 @@ class PostgresDatastore:
         user: str,
         password: str,
         *,
-        connect_timeout: int = 5,
+        connect_timeout: int = 30,
         idle_in_transaction_session_timeout: int = 0,
         pool_size: int = 2,
         max_overflow: int = 2,
-        pool_timeout: float = 5.0,
+        max_waiting: int = 0,
         conn_max_age: float = 60 * 60.0,
         pre_ping: bool = False,
         lock_timeout: int = 0,
@@ -79,7 +80,6 @@ class PostgresDatastore:
         self.pool_open_timeout = pool_open_timeout
 
         check = ConnectionPool.check_connection if pre_ping else None
-        kwargs: Dict[str, Any] = {"check": check}
         self.pool = ConnectionPool(
             get_password_func=get_password_func,
             connection_class=Connection[DictRow],
@@ -96,9 +96,9 @@ class PostgresDatastore:
             open=False,
             configure=self.after_connect,
             timeout=connect_timeout,
-            max_waiting=round(pool_timeout),
+            max_waiting=max_waiting,
             max_lifetime=conn_max_age,
-            **kwargs,  # use the 'check' argument when no longer supporting Python 3.7
+            check=check,
         )
         self.lock_timeout = lock_timeout
         self.schema = schema.strip()
@@ -156,6 +156,12 @@ class PostgresDatastore:
     def __del__(self) -> None:
         self.close()
 
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *args: object, **kwargs: Any) -> None:
+        self.close()
+
 
 class PostgresAggregateRecorder(AggregateRecorder):
     def __init__(
@@ -558,10 +564,10 @@ class Factory(InfrastructureFactory):
     POSTGRES_CONNECT_TIMEOUT = "POSTGRES_CONNECT_TIMEOUT"
     POSTGRES_CONN_MAX_AGE = "POSTGRES_CONN_MAX_AGE"
     POSTGRES_PRE_PING = "POSTGRES_PRE_PING"
-    POSTGRES_POOL_TIMEOUT = "POSTGRES_POOL_TIMEOUT"
+    POSTGRES_MAX_WAITING = "POSTGRES_MAX_WAITING"
     POSTGRES_LOCK_TIMEOUT = "POSTGRES_LOCK_TIMEOUT"
     POSTGRES_POOL_SIZE = "POSTGRES_POOL_SIZE"
-    POSTGRES_POOL_MAX_OVERFLOW = "POSTGRES_POOL_MAX_OVERFLOW"
+    POSTGRES_MAX_OVERFLOW = "POSTGRES_MAX_OVERFLOW"
     POSTGRES_IDLE_IN_TRANSACTION_SESSION_TIMEOUT = (
         "POSTGRES_IDLE_IN_TRANSACTION_SESSION_TIMEOUT"
     )
@@ -618,7 +624,7 @@ class Factory(InfrastructureFactory):
             get_password_func = resolve_topic(get_password_topic)
             password = ""
 
-        connect_timeout = 5
+        connect_timeout = 30
         connect_timeout_str = self.env.get(self.POSTGRES_CONNECT_TIMEOUT)
         if connect_timeout_str:
             try:
@@ -664,30 +670,30 @@ class Factory(InfrastructureFactory):
                 raise OSError(msg) from None
 
         pool_max_overflow = 10
-        pool_max_overflow_str = self.env.get(self.POSTGRES_POOL_MAX_OVERFLOW)
+        pool_max_overflow_str = self.env.get(self.POSTGRES_MAX_OVERFLOW)
         if pool_max_overflow_str:
             try:
                 pool_max_overflow = int(pool_max_overflow_str)
             except ValueError:
                 msg = (
                     "Postgres environment value for key "
-                    f"'{self.POSTGRES_POOL_MAX_OVERFLOW}' is invalid. "
+                    f"'{self.POSTGRES_MAX_OVERFLOW}' is invalid. "
                     "If set, an integer or empty string is expected: "
                     f"'{pool_max_overflow_str}'"
                 )
                 raise OSError(msg) from None
 
-        pool_timeout = 30.0
-        pool_timeout_str = self.env.get(self.POSTGRES_POOL_TIMEOUT)
-        if pool_timeout_str:
+        max_waiting = 0
+        max_waiting_str = self.env.get(self.POSTGRES_MAX_WAITING)
+        if max_waiting_str:
             try:
-                pool_timeout = float(pool_timeout_str)
+                max_waiting = int(max_waiting_str)
             except ValueError:
                 msg = (
                     "Postgres environment value for key "
-                    f"'{self.POSTGRES_POOL_TIMEOUT}' is invalid. "
-                    "If set, a float or empty string is expected: "
-                    f"'{pool_timeout_str}'"
+                    f"'{self.POSTGRES_MAX_WAITING}' is invalid. "
+                    "If set, an integer or empty string is expected: "
+                    f"'{max_waiting_str}'"
                 )
                 raise OSError(msg) from None
 
@@ -733,13 +739,16 @@ class Factory(InfrastructureFactory):
             idle_in_transaction_session_timeout=idle_in_transaction_session_timeout,
             pool_size=pool_size,
             max_overflow=pool_max_overflow,
-            pool_timeout=pool_timeout,
+            max_waiting=max_waiting,
             conn_max_age=conn_max_age,
             pre_ping=pre_ping,
             lock_timeout=lock_timeout,
             schema=schema,
         )
 
+    def env_create_table(self) -> bool:
+        return strtobool(self.env.get(self.CREATE_TABLE) or "yes")
+
     def aggregate_recorder(self, purpose: str = "events") -> AggregateRecorder:
         prefix = self.env.name.lower() or "stored"
         events_table_name = prefix + "_" + purpose
@@ -783,9 +792,6 @@ class Factory(InfrastructureFactory):
             recorder.create_table()
         return recorder
 
-    def env_create_table(self) -> bool:
-        return strtobool(self.env.get(self.CREATE_TABLE) or "yes")
-
     def close(self) -> None:
         if hasattr(self, "datastore"):
             self.datastore.close()

eventsourcing/system.py

@@ -8,6 +8,7 @@ from queue import Full, Queue
 from threading import Event, Lock, RLock, Thread
 from types import FrameType, ModuleType
 from typing import (
+    Any,
     ClassVar,
     Dict,
     Iterable,
@@ -21,6 +22,8 @@ from typing import (
     cast,
 )
 
+from typing_extensions import Self
+
 from eventsourcing.application import (
     Application,
     NotificationLog,
@@ -525,6 +528,13 @@ 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):
     """