eventsourcing 9.2.22__py3-none-any.whl → 9.3.0a1__py3-none-any.whl

eventsourcing/examples/searchablecontent/application.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, List, Tuple, cast
+
+from eventsourcing.examples.contentmanagement.application import (
+    ContentManagementApplication,
+    PageDetailsType,
+)
+from eventsourcing.examples.contentmanagement.domainmodel import Page
+from eventsourcing.examples.searchablecontent.persistence import (
+    SearchableContentRecorder,
+)
+
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
+    from eventsourcing.domain import DomainEventProtocol, MutableOrImmutableAggregate
+    from eventsourcing.persistence import Recording
+
+
+class SearchableContentApplication(ContentManagementApplication):
+    def save(
+        self,
+        *objs: MutableOrImmutableAggregate | DomainEventProtocol | None,
+        **kwargs: Any,
+    ) -> List[Recording]:
+        insert_pages: List[Tuple[UUID, str, str, str]] = []
+        update_pages: List[Tuple[UUID, str, str, str]] = []
+        for obj in objs:
+            if isinstance(obj, Page):
+                if obj.version == len(obj.pending_events):
+                    insert_pages.append((obj.id, obj.slug, obj.title, obj.body))
+                else:
+                    update_pages.append((obj.id, obj.slug, obj.title, obj.body))
+        kwargs["insert_pages"] = insert_pages
+        kwargs["update_pages"] = update_pages
+        return super().save(*objs, **kwargs)
+
+    def search(self, query: str) -> List[PageDetailsType]:
+        pages = []
+        recorder = cast(SearchableContentRecorder, self.recorder)
+        for page_id in recorder.search_pages(query):
+            page = self.get_page_by_id(page_id)
+            pages.append(page)
+        return pages

eventsourcing/examples/searchablecontent/persistence.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from typing import TYPE_CHECKING, List, Tuple
+
+from eventsourcing.persistence import AggregateRecorder
+
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
+
+class SearchableContentRecorder(AggregateRecorder):
+    @abstractmethod
+    def search_pages(self, query: str) -> List[UUID]:
+        """
+        Returns IDs for pages that match query.
+        """
+
+    @abstractmethod
+    def select_page(self, page_id: UUID) -> Tuple[str, str, str]:
+        """
+        Returns slug, title and body for given ID.
+        """

eventsourcing/examples/searchablecontent/postgres.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, List, Sequence, Tuple
+
+from eventsourcing.examples.contentmanagement.application import PageNotFoundError
+from eventsourcing.examples.searchablecontent.persistence import (
+    SearchableContentRecorder,
+)
+from eventsourcing.postgres import (
+    Factory,
+    PostgresAggregateRecorder,
+    PostgresApplicationRecorder,
+)
+
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
+    from psycopg import Cursor
+    from psycopg.rows import DictRow
+
+    from eventsourcing.persistence import StoredEvent
+
+
+class PostgresSearchableContentRecorder(
+    SearchableContentRecorder,
+    PostgresAggregateRecorder,
+):
+    pages_table_name = "pages_projection_example"
+    select_page_statement = (
+        f"SELECT page_slug, page_title, page_body FROM {pages_table_name}"
+        " WHERE page_id = %s"
+    )
+
+    insert_page_statement = f"INSERT INTO {pages_table_name} VALUES (%s, %s, %s, %s)"
+
+    update_page_statement = (
+        f"UPDATE {pages_table_name}"
+        " SET page_slug = %s, page_title = %s, page_body = %s WHERE page_id = %s"
+    )
+
+    search_pages_statement = (
+        f"SELECT page_id FROM {pages_table_name} WHERE"
+        " to_tsvector('english', page_body) @@ websearch_to_tsquery('english', %s)"
+    )
+
+    def construct_create_table_statements(self) -> List[str]:
+        statements = super().construct_create_table_statements()
+        statements.append(
+            "CREATE TABLE IF NOT EXISTS "
+            f"{self.pages_table_name} ("
+            "page_id uuid, "
+            "page_slug text, "
+            "page_title text, "
+            "page_body text, "
+            "PRIMARY KEY "
+            "(page_id))"
+        )
+        statements.append(
+            f"CREATE INDEX IF NOT EXISTS {self.pages_table_name}_idx "
+            f"ON {self.pages_table_name} "
+            "USING GIN (to_tsvector('english', page_body))"
+        )
+        return statements
+
+    def _insert_events(
+        self,
+        c: Cursor[DictRow],
+        stored_events: List[StoredEvent],
+        **kwargs: Any,
+    ) -> None:
+        self._insert_pages(c, **kwargs)
+        self._update_pages(c, **kwargs)
+        super()._insert_events(c, stored_events, **kwargs)
+
+    def _insert_pages(
+        self,
+        c: Cursor[DictRow],
+        insert_pages: Sequence[Tuple[UUID, str, str, str]] = (),
+        **_: Any,
+    ) -> None:
+        for params in insert_pages:
+            c.execute(self.insert_page_statement, params, prepare=True)
+
+    def _update_pages(
+        self,
+        c: Cursor[DictRow],
+        update_pages: Sequence[Tuple[UUID, str, str, str]] = (),
+        **_: Any,
+    ) -> None:
+        for page_id, page_slug, page_title, page_body in update_pages:
+            params = (page_slug, page_title, page_body, page_id)
+            c.execute(self.update_page_statement, params, prepare=True)
+
+    def search_pages(self, query: str) -> List[UUID]:
+        with self.datastore.transaction(commit=False) as curs:
+            curs.execute(self.search_pages_statement, [query], prepare=True)
+            return [row["page_id"] for row in curs.fetchall()]
+
+    def select_page(self, page_id: UUID) -> Tuple[str, str, str]:
+        with self.datastore.transaction(commit=False) as curs:
+            curs.execute(self.select_page_statement, [str(page_id)], prepare=True)
+            for row in curs.fetchall():
+                return row["page_slug"], row["page_title"], row["page_body"]
+        msg = f"Page ID {page_id} not found"
+        raise PageNotFoundError(msg)
+
+
+class SearchableContentApplicationRecorder(
+    PostgresSearchableContentRecorder, PostgresApplicationRecorder
+):
+    pass
+
+
+class SearchableContentInfrastructureFactory(Factory):
+    application_recorder_class = SearchableContentApplicationRecorder
+
+
+del Factory

eventsourcing/examples/searchablecontent/sqlite.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, List, Sequence, Tuple
+from uuid import UUID
+
+from eventsourcing.examples.contentmanagement.application import PageNotFoundError
+from eventsourcing.examples.searchablecontent.persistence import (
+    SearchableContentRecorder,
+)
+from eventsourcing.sqlite import (
+    Factory,
+    SQLiteAggregateRecorder,
+    SQLiteApplicationRecorder,
+    SQLiteCursor,
+)
+
+if TYPE_CHECKING:  # pragma: nocover
+    from eventsourcing.persistence import StoredEvent
+
+
+class SQLiteSearchableContentRecorder(
+    SearchableContentRecorder, SQLiteAggregateRecorder
+):
+    pages_table_name = "pages_projection_example"
+    pages_virtual_table_name = pages_table_name + "_fts"
+    select_page_statement = (
+        "SELECT page_slug, page_title, page_body FROM "
+        f"{pages_table_name} WHERE page_id = ?"
+    )
+    insert_page_statement = f"INSERT INTO {pages_table_name} VALUES (?, ?, ?, ?)"
+    update_page_statement = (
+        f"UPDATE {pages_table_name} "
+        "SET page_slug = ?, page_title = ?, page_body = ? WHERE page_id = ?"
+    )
+    search_pages_statement = (
+        f"SELECT page_id FROM {pages_virtual_table_name} WHERE page_body MATCH ?"
+    )
+
+    def construct_create_table_statements(self) -> List[str]:
+        statements = super().construct_create_table_statements()
+        statements.append(
+            "CREATE TABLE IF NOT EXISTS "
+            f"{self.pages_table_name} ("
+            "page_id TEXT, "
+            "page_slug TEXT, "
+            "page_title TEXT, "
+            "page_body TEXT, "
+            "PRIMARY KEY "
+            "(page_id)) "
+        )
+        statements.append(
+            f"CREATE VIRTUAL TABLE {self.pages_virtual_table_name} USING fts5("
+            f"page_id, page_body, content='{self.pages_table_name}')"
+        )
+        statements.append(
+            "CREATE TRIGGER projection_ai AFTER INSERT ON "
+            f"{self.pages_table_name} BEGIN "
+            f"INSERT INTO {self.pages_virtual_table_name} "
+            "(rowid, page_id, page_body) "
+            "VALUES (new.rowid, new.page_id, new.page_body); "
+            "END"
+        )
+        statements.append(
+            "CREATE TRIGGER projection_au AFTER UPDATE ON "
+            f"{self.pages_table_name} "
+            "BEGIN "
+            f"INSERT INTO {self.pages_virtual_table_name} "
+            f"({self.pages_virtual_table_name}, rowid, page_id, page_body) "
+            "VALUES ('delete', old.rowid, old.page_id, old.page_body);"
+            f"INSERT INTO {self.pages_virtual_table_name} "
+            "(rowid, page_id, page_body) "
+            "VALUES (new.rowid, new.page_id, new.page_body); "
+            "END"
+        )
+        return statements
+
+    def _insert_events(
+        self,
+        c: SQLiteCursor,
+        stored_events: List[StoredEvent],
+        **kwargs: Any,
+    ) -> Sequence[int] | None:
+        notification_ids = super()._insert_events(c, stored_events, **kwargs)
+        self._insert_pages(c, **kwargs)
+        self._update_pages(c, **kwargs)
+        return notification_ids
+
+    def _insert_pages(
+        self,
+        c: SQLiteCursor,
+        insert_pages: Sequence[Tuple[UUID, str, str, str]] = (),
+        **_: Any,
+    ) -> None:
+        for page_id, page_slug, page_title, page_body in insert_pages:
+            c.execute(
+                self.insert_page_statement,
+                (str(page_id), page_slug, page_title, page_body),
+            )
+
+    def _update_pages(
+        self,
+        c: SQLiteCursor,
+        update_pages: Sequence[Tuple[UUID, str, str, str]] = (),
+        **_: Any,
+    ) -> None:
+        for page_id, page_slug, page_title, page_body in update_pages:
+            c.execute(
+                self.update_page_statement,
+                (page_slug, page_title, page_body, str(page_id)),
+            )
+
+    def search_pages(self, query: str) -> List[UUID]:
+        with self.datastore.transaction(commit=False) as c:
+            c.execute(self.search_pages_statement, [query])
+            return [UUID(row["page_id"]) for row in c.fetchall()]
+
+    def select_page(self, page_id: UUID) -> Tuple[str, str, str]:
+        with self.datastore.transaction(commit=False) as c:
+            c.execute(self.select_page_statement, [str(page_id)])
+            for row in c.fetchall():
+                return row["page_slug"], row["page_title"], row["page_body"]
+        msg = f"Page ID {page_id} not found"
+        raise PageNotFoundError(msg)
+
+
+class SearchableContentApplicationRecorder(
+    SQLiteSearchableContentRecorder, SQLiteApplicationRecorder
+):
+    pass
+
+
+class SearchableContentInfrastructureFactory(Factory):
+    application_recorder_class = SearchableContentApplicationRecorder
+
+
+del Factory

eventsourcing/examples/searchablecontent/test_application.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import os
+from typing import ClassVar, Dict
+from unittest import TestCase
+from uuid import uuid4
+
+from eventsourcing.examples.contentmanagement.domainmodel import user_id_cvar
+from eventsourcing.examples.searchablecontent.application import (
+    SearchableContentApplication,
+)
+from eventsourcing.postgres import PostgresDatastore
+from eventsourcing.tests.postgres_utils import drop_postgres_table
+
+
+class SearchableContentApplicationTestCase(TestCase):
+    env: ClassVar[Dict[str, str]] = {}
+
+    def test_app(self) -> None:
+        app = SearchableContentApplication(env=self.env)
+
+        # Set user_id context variable.
+        user_id = uuid4()
+        user_id_cvar.set(user_id)
+
+        # Create empty pages.
+        app.create_page(title="Animals", slug="animals")
+        app.create_page(title="Plants", slug="plants")
+        app.create_page(title="Minerals", slug="minerals")
+
+        # Search, expect no results.
+        self.assertEqual(0, len(app.search("dog")))
+        self.assertEqual(0, len(app.search("rose")))
+        self.assertEqual(0, len(app.search("zinc")))
+
+        # Update the pages.
+        app.update_body(slug="animals", body="cat dog zebra")
+        app.update_body(slug="plants", body="bluebell rose jasmine")
+        app.update_body(slug="minerals", body="iron zinc calcium")
+
+        # Search for single words, expect results.
+        pages = app.search("dog")
+        self.assertEqual(1, len(pages))
+        self.assertEqual(pages[0]["slug"], "animals")
+        self.assertEqual(pages[0]["body"], "cat dog zebra")
+
+        pages = app.search("rose")
+        self.assertEqual(1, len(pages))
+        self.assertEqual(pages[0]["slug"], "plants")
+        self.assertEqual(pages[0]["body"], "bluebell rose jasmine")
+
+        pages = app.search("zinc")
+        self.assertEqual(1, len(pages))
+        self.assertEqual(pages[0]["slug"], "minerals")
+        self.assertEqual(pages[0]["body"], "iron zinc calcium")
+
+        # Search for multiple words in same page.
+        pages = app.search("dog cat")
+        self.assertEqual(1, len(pages))
+        self.assertEqual(pages[0]["slug"], "animals")
+        self.assertEqual(pages[0]["body"], "cat dog zebra")
+
+        # Search for multiple words in same page, expect no results.
+        pages = app.search("rose zebra")
+        self.assertEqual(0, len(pages))
+
+        # Search for alternative words, expect two results.
+        pages = app.search("rose OR zebra")
+        self.assertEqual(2, len(pages))
+        self.assertEqual(["animals", "plants"], sorted(p["slug"] for p in pages))
+
+
+class TestWithSQLite(SearchableContentApplicationTestCase):
+    env: ClassVar[Dict[str, str]] = {
+        "PERSISTENCE_MODULE": "eventsourcing.examples.searchablecontent.sqlite",
+        "SQLITE_DBNAME": ":memory:",
+    }
+
+
+class TestWithPostgres(SearchableContentApplicationTestCase):
+    env: ClassVar[Dict[str, str]] = {
+        "PERSISTENCE_MODULE": "eventsourcing.examples.searchablecontent.postgres"
+    }
+
+    def setUp(self) -> None:
+        super().setUp()
+        os.environ["POSTGRES_DBNAME"] = "eventsourcing"
+        os.environ["POSTGRES_HOST"] = "127.0.0.1"
+        os.environ["POSTGRES_PORT"] = "5432"
+        os.environ["POSTGRES_USER"] = "eventsourcing"
+        os.environ["POSTGRES_PASSWORD"] = "eventsourcing"  # noqa: S105
+        self.drop_tables()
+
+    def tearDown(self) -> None:
+        self.drop_tables()
+        super().tearDown()
+
+    def drop_tables(self) -> None:
+        db = 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()
+
+
+del SearchableContentApplicationTestCase

eventsourcing/examples/searchablecontent/test_recorder.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import os
+from typing import ClassVar, Dict, cast
+from unittest import TestCase
+from uuid import uuid4
+
+from eventsourcing.examples.contentmanagement.application import PageNotFoundError
+from eventsourcing.examples.searchablecontent.application import (
+    SearchableContentApplication,
+)
+from eventsourcing.examples.searchablecontent.persistence import (
+    SearchableContentRecorder,
+)
+from eventsourcing.postgres import PostgresDatastore
+from eventsourcing.tests.postgres_utils import drop_postgres_table
+
+
+class SearchableContentRecorderTestCase(TestCase):
+    env: ClassVar[Dict[str, str]] = {}
+
+    def test_recorder(self) -> None:
+        app = SearchableContentApplication(env=self.env)
+
+        # Need to cover the case where select_page() raises PageNotFound.
+        recorder = cast(SearchableContentRecorder, app.recorder)
+        with self.assertRaises(PageNotFoundError):
+            recorder.select_page(uuid4())
+
+
+class TestWithSQLite(SearchableContentRecorderTestCase):
+    env: ClassVar[Dict[str, str]] = {
+        "PERSISTENCE_MODULE": "eventsourcing.examples.searchablecontent.sqlite",
+        "SQLITE_DBNAME": ":memory:",
+    }
+
+
+class TestWithPostgres(SearchableContentRecorderTestCase):
+    env: ClassVar[Dict[str, str]] = {
+        "PERSISTENCE_MODULE": "eventsourcing.examples.searchablecontent.postgres"
+    }
+
+    def setUp(self) -> None:
+        super().setUp()
+        os.environ["POSTGRES_DBNAME"] = "eventsourcing"
+        os.environ["POSTGRES_HOST"] = "127.0.0.1"
+        os.environ["POSTGRES_PORT"] = "5432"
+        os.environ["POSTGRES_USER"] = "eventsourcing"
+        os.environ["POSTGRES_PASSWORD"] = "eventsourcing"  # noqa: S105
+        self.drop_tables()
+
+    def tearDown(self) -> None:
+        self.drop_tables()
+        super().tearDown()
+
+    def drop_tables(self) -> None:
+        db = 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()
+
+
+del SearchableContentRecorderTestCase

eventsourcing/examples/searchabletimestamps/application.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, cast
+
+from eventsourcing.examples.cargoshipping.application import BookingApplication
+from eventsourcing.examples.cargoshipping.domainmodel import Cargo
+from eventsourcing.examples.searchabletimestamps.persistence import (
+    SearchableTimestampsRecorder,
+)
+
+if TYPE_CHECKING:  # pragma: nocover
+    from datetime import datetime
+    from uuid import UUID
+
+    from eventsourcing.application import ProcessingEvent
+    from eventsourcing.persistence import Recording
+
+
+class SearchableTimestampsApplication(BookingApplication):
+    def _record(self, processing_event: ProcessingEvent) -> List[Recording]:
+        event_timestamps_data = [
+            (e.originator_id, e.timestamp, e.originator_version)
+            for e in processing_event.events
+            if isinstance(e, Cargo.Event)
+        ]
+        processing_event.saved_kwargs["event_timestamps_data"] = event_timestamps_data
+        return super()._record(processing_event)
+
+    def get_cargo_at_timestamp(self, tracking_id: UUID, timestamp: datetime) -> Cargo:
+        recorder = cast(SearchableTimestampsRecorder, self.recorder)
+        version = recorder.get_version_at_timestamp(tracking_id, timestamp)
+        return cast(Cargo, self.repository.get(tracking_id, version=version))

eventsourcing/examples/searchabletimestamps/persistence.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from typing import TYPE_CHECKING
+
+from eventsourcing.persistence import ApplicationRecorder
+
+if TYPE_CHECKING:  # pragma: nocover
+    from datetime import datetime
+    from uuid import UUID
+
+
+class SearchableTimestampsRecorder(ApplicationRecorder):
+    @abstractmethod
+    def get_version_at_timestamp(
+        self, originator_id: UUID, timestamp: datetime
+    ) -> int | None:
+        """
+        Returns originator version at timestamp for given originator ID.
+        """

eventsourcing/examples/searchabletimestamps/postgres.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, List, Tuple, cast
+from uuid import UUID
+
+from eventsourcing.domain import Aggregate
+from eventsourcing.examples.searchabletimestamps.persistence import (
+    SearchableTimestampsRecorder,
+)
+from eventsourcing.postgres import (
+    Factory,
+    PostgresApplicationRecorder,
+    PostgresDatastore,
+)
+
+if TYPE_CHECKING:  # pragma: nocover
+    from psycopg import Cursor
+    from psycopg.rows import DictRow
+
+    from eventsourcing.persistence import ApplicationRecorder, StoredEvent
+
+
+class SearchableTimestampsApplicationRecorder(
+    SearchableTimestampsRecorder, PostgresApplicationRecorder
+):
+    def __init__(
+        self,
+        datastore: PostgresDatastore,
+        events_table_name: str = "stored_events",
+        event_timestamps_table_name: str = "event_timestamps",
+    ):
+        self.check_table_name_length(event_timestamps_table_name, datastore.schema)
+        self.event_timestamps_table_name = event_timestamps_table_name
+        super().__init__(datastore, events_table_name)
+        self.insert_event_timestamp_statement = (
+            f"INSERT INTO {self.event_timestamps_table_name} VALUES (%s, %s, %s)"
+        )
+        self.select_event_timestamp_statement = (
+            f"SELECT originator_version FROM {self.event_timestamps_table_name} WHERE "
+            "originator_id = %s AND "
+            "timestamp <= %s "
+            "ORDER BY originator_version DESC "
+            "LIMIT 1"
+        )
+
+    def construct_create_table_statements(self) -> List[str]:
+        statements = super().construct_create_table_statements()
+        statements.append(
+            "CREATE TABLE IF NOT EXISTS "
+            f"{self.event_timestamps_table_name} ("
+            "originator_id uuid NOT NULL, "
+            "timestamp timestamp with time zone, "
+            "originator_version bigint NOT NULL, "
+            "PRIMARY KEY "
+            "(originator_id, timestamp))"
+        )
+        return statements
+
+    def _insert_events(
+        self,
+        c: Cursor[DictRow],
+        stored_events: List[StoredEvent],
+        **kwargs: Any,
+    ) -> None:
+        # Insert event timestamps.
+        event_timestamps_data = cast(
+            List[Tuple[UUID, datetime, int]], kwargs.get("event_timestamps_data")
+        )
+        for event_timestamp_data in event_timestamps_data:
+            c.execute(
+                query=self.insert_event_timestamp_statement,
+                params=event_timestamp_data,
+                prepare=True,
+            )
+        super()._insert_events(c, stored_events, **kwargs)
+
+    def get_version_at_timestamp(
+        self, originator_id: UUID, timestamp: datetime
+    ) -> int | None:
+        with self.datastore.transaction(commit=False) as curs:
+            curs.execute(
+                query=self.select_event_timestamp_statement,
+                params=(originator_id, timestamp),
+                prepare=True,
+            )
+            for row in curs.fetchall():
+                version = row["originator_version"]
+                break
+            else:
+                version = Aggregate.INITIAL_VERSION - 1
+            return version
+
+
+class SearchableTimestampsInfrastructureFactory(Factory):
+    def application_recorder(self) -> ApplicationRecorder:
+        prefix = (self.datastore.schema + ".") if self.datastore.schema else ""
+        prefix += self.env.name.lower() or "stored"
+        events_table_name = prefix + "_events"
+        event_timestamps_table_name = prefix + "_timestamps"
+        recorder = SearchableTimestampsApplicationRecorder(
+            datastore=self.datastore,
+            events_table_name=events_table_name,
+            event_timestamps_table_name=event_timestamps_table_name,
+        )
+        recorder.create_table()
+        return recorder
+
+
+del Factory