eventsourcing 9.3.2__py3-none-any.whl → 9.3.4__py3-none-any.whl

eventsourcing/examples/searchablecontent/test_recorder.py

@@ -1,68 +0,0 @@
-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:
-        with PostgresDatastore(
-            os.environ["POSTGRES_DBNAME"],
-            os.environ["POSTGRES_HOST"],
-            os.environ["POSTGRES_PORT"],
-            os.environ["POSTGRES_USER"],
-            os.environ["POSTGRES_PASSWORD"],
-        ) as datastore:
-            drop_postgres_table(datastore, "public.searchablecontentapplication_events")
-            drop_postgres_table(datastore, "public.pages_projection_example")
-
-
-del SearchableContentRecorderTestCase

eventsourcing/examples/searchabletimestamps/application.py

@@ -1,32 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

eventsourcing/examples/searchabletimestamps/sqlite.py

@@ -1,99 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime
-from typing import TYPE_CHECKING, Any, List, Sequence, Tuple, cast
-from uuid import UUID
-
-from eventsourcing.domain import Aggregate
-from eventsourcing.examples.searchabletimestamps.persistence import (
-    SearchableTimestampsRecorder,
-)
-from eventsourcing.sqlite import (
-    Factory,
-    SQLiteApplicationRecorder,
-    SQLiteCursor,
-    SQLiteDatastore,
-)
-
-if TYPE_CHECKING:  # pragma: nocover
-    from eventsourcing.persistence import ApplicationRecorder, StoredEvent
-
-
-class SearchableTimestampsApplicationRecorder(
-    SearchableTimestampsRecorder, SQLiteApplicationRecorder
-):
-    def __init__(
-        self,
-        datastore: SQLiteDatastore,
-        events_table_name: str = "stored_events",
-        event_timestamps_table_name: str = "event_timestamps",
-    ):
-        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 (?, ?, ?)"
-        )
-        self.select_event_timestamp_statement = (
-            f"SELECT originator_version FROM {self.event_timestamps_table_name} WHERE "
-            "originator_id = ? AND "
-            "timestamp <= ? "
-            "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 TEXT, "
-            "timestamp timestamp, "
-            "originator_version INTEGER, "
-            "PRIMARY KEY "
-            "(originator_id, timestamp))"
-        )
-        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)
-
-        # Insert event timestamps.
-        event_timestamps_data = cast(
-            List[Tuple[UUID, datetime, int]], kwargs["event_timestamps_data"]
-        )
-        for originator_id, timestamp, originator_version in event_timestamps_data:
-            c.execute(
-                self.insert_event_timestamp_statement,
-                (originator_id.hex, timestamp, originator_version),
-            )
-
-        return notification_ids
-
-    def get_version_at_timestamp(
-        self, originator_id: UUID, timestamp: datetime
-    ) -> int | None:
-        with self.datastore.transaction(commit=False) as c:
-            c.execute(
-                self.select_event_timestamp_statement, (originator_id.hex, timestamp)
-            )
-            for row in c.fetchall():
-                version = row["originator_version"]
-                break
-            else:
-                version = Aggregate.INITIAL_VERSION - 1
-            return version
-
-
-class SearchableTimestampsInfrastructureFactory(Factory):
-    def application_recorder(self) -> ApplicationRecorder:
-        recorder = SearchableTimestampsApplicationRecorder(datastore=self.datastore)
-        recorder.create_table()
-        return recorder
-
-
-del Factory

eventsourcing/examples/searchabletimestamps/test_searchabletimestamps.py

@@ -1,94 +0,0 @@
-from __future__ import annotations
-
-import os
-from datetime import timedelta
-from time import sleep
-from typing import ClassVar, Dict
-from unittest import TestCase
-
-from eventsourcing.application import AggregateNotFoundError
-from eventsourcing.domain import create_utc_datetime_now
-from eventsourcing.examples.cargoshipping.domainmodel import Location
-from eventsourcing.examples.searchabletimestamps.application import (
-    SearchableTimestampsApplication,
-)
-from eventsourcing.postgres import PostgresDatastore
-from eventsourcing.tests.postgres_utils import drop_postgres_table
-
-
-class SearchableTimestampsTestCase(TestCase):
-    env: ClassVar[Dict[str, str]]
-
-    def test(self) -> None:
-        # Construct application.
-        app = SearchableTimestampsApplication(env=self.env)
-        timestamp0 = create_utc_datetime_now()
-        sleep(1e-5)
-
-        # Book new cargo.
-        tracking_id = app.book_new_cargo(
-            origin=Location["NLRTM"],
-            destination=Location["USDAL"],
-            arrival_deadline=create_utc_datetime_now() + timedelta(weeks=3),
-        )
-        timestamp1 = create_utc_datetime_now()
-        sleep(1e-5)
-
-        # Change destination.
-        app.change_destination(tracking_id, destination=Location["AUMEL"])
-        timestamp2 = create_utc_datetime_now()
-        sleep(1e-5)
-
-        # View the state of the cargo tracking at particular times.
-        with self.assertRaises(AggregateNotFoundError):
-            app.get_cargo_at_timestamp(tracking_id, timestamp0)
-
-        cargo_at_timestamp1 = app.get_cargo_at_timestamp(tracking_id, timestamp1)
-        self.assertEqual(cargo_at_timestamp1.destination, Location["USDAL"])
-
-        cargo_at_timestamp2 = app.get_cargo_at_timestamp(tracking_id, timestamp2)
-        self.assertEqual(cargo_at_timestamp2.destination, Location["AUMEL"])
-
-
-class WithSQLite(SearchableTimestampsTestCase):
-    env: ClassVar[Dict[str, str]] = {
-        "PERSISTENCE_MODULE": "eventsourcing.examples.searchabletimestamps.sqlite",
-        "SQLITE_DBNAME": ":memory:",
-    }
-
-
-class WithPostgreSQL(SearchableTimestampsTestCase):
-    env: ClassVar[Dict[str, str]] = {
-        "PERSISTENCE_MODULE": "eventsourcing.examples.searchabletimestamps.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:
-        with PostgresDatastore(
-            os.environ["POSTGRES_DBNAME"],
-            os.environ["POSTGRES_HOST"],
-            os.environ["POSTGRES_PORT"],
-            os.environ["POSTGRES_USER"],
-            os.environ["POSTGRES_PASSWORD"],
-        ) as datastore:
-            drop_postgres_table(
-                datastore, "public.searchabletimestampsapplication_events"
-            )
-            drop_postgres_table(
-                datastore, "public.searchabletimestampsapplication_timestamps"
-            )
-
-
-del SearchableTimestampsTestCase

eventsourcing/examples/test_invoice.py

@@ -1,176 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from decimal import Decimal
-from enum import Enum
-from typing import TYPE_CHECKING, Any, Dict, cast
-from unittest import TestCase
-
-from eventsourcing.application import Application
-from eventsourcing.domain import Aggregate, Snapshot, event
-from eventsourcing.persistence import Transcoding
-
-if TYPE_CHECKING:  # pragma: nocover
-    from datetime import datetime
-
-
-class Status(Enum):
-    INITIATED = 1
-    ISSUED = 2
-    SENT = 3
-
-
-class SendMethod(Enum):
-    EMAIL = 1
-    POST = 2
-
-
-@dataclass
-class Person:
-    name: str
-    address: str
-
-
-class Invoice(Aggregate):
-    @event("Initiated")
-    def __init__(
-        self,
-        number: str,
-        amount: Decimal,
-        issued_to: Person,
-        timestamp: datetime | Any = None,
-    ):
-        self._number = number
-        self._amount = amount
-        self.issued_to = issued_to
-        self.initiated_at = timestamp
-        self.status = Status.INITIATED
-
-    def _get_number(self) -> str:
-        return self._number
-
-    @event
-    def _number_updated(self, value: str) -> None:
-        assert self.status == Status.INITIATED
-        self._number = value
-
-    number = property(_get_number, _number_updated)
-
-    def _get_amount(self) -> Decimal:
-        return self._amount
-
-    @event("AmountUpdated")
-    def _set_amount(self, value: Decimal) -> None:
-        assert self.status == Status.INITIATED
-        self._amount = value
-
-    amount = property(_get_amount, _set_amount)
-
-    @event("Issued")
-    def issue(self, issued_by: str, timestamp: datetime | Any = None) -> None:
-        self.issued_by = issued_by
-        self.issued_on = timestamp
-        self.status = Status.ISSUED
-
-    @event("Sent")
-    def send(self, sent_via: SendMethod, timestamp: datetime | Any = None) -> None:
-        self.sent_via = sent_via
-        self.sent_at = timestamp
-        self.status = Status.SENT
-
-
-class PersonAsDict(Transcoding):
-    name = "person_as_dict"
-    type = Person
-
-    def encode(self, obj: Person) -> Dict[str, Any]:
-        return obj.__dict__
-
-    def decode(self, data: Dict[str, Any]) -> Person:
-        return Person(**data)
-
-
-class SendMethodAsStr(Transcoding):
-    name = "send_method_str"
-    type = SendMethod
-
-    def encode(self, obj: SendMethod) -> str:
-        return obj.name
-
-    def decode(self, data: str) -> SendMethod:
-        return getattr(SendMethod, data)
-
-
-class StatusAsStr(Transcoding):
-    name = "status_str"
-    type = Status
-
-    def encode(self, obj: Status) -> str:
-        return obj.name
-
-    def decode(self, data: str) -> Status:
-        return getattr(Status, data)
-
-
-class TestInvoice(TestCase):
-    def test(self) -> None:
-        invoice = Invoice(
-            number="INV/2021/11/01",
-            amount=Decimal("34.20"),
-            issued_to=Person("Oscar the Grouch", "123 Sesame Street"),
-        )
-        self.assertEqual(invoice.number, "INV/2021/11/01")
-        self.assertEqual(invoice.amount, Decimal("34.20"))
-        self.assertEqual(
-            invoice.issued_to, Person("Oscar the Grouch", "123 Sesame Street")
-        )
-        self.assertEqual(invoice.status, Status.INITIATED)
-
-        invoice.number = "INV/2021/11/02"
-        self.assertEqual(invoice.number, "INV/2021/11/02")
-
-        invoice.amount = Decimal("43.20")
-        self.assertEqual(invoice.number, "INV/2021/11/02")
-
-        invoice.issue(issued_by="Cookie Monster")
-        self.assertEqual(invoice.issued_by, "Cookie Monster")
-        self.assertEqual(invoice.status, Status.ISSUED)
-
-        with self.assertRaises(AssertionError):
-            invoice.number = "INV/2021/11/03"
-
-        with self.assertRaises(AssertionError):
-            invoice.amount = Decimal("54.20")
-
-        invoice.send(sent_via=SendMethod.EMAIL)
-        self.assertEqual(invoice.sent_via, SendMethod.EMAIL)
-        self.assertEqual(invoice.status, Status.SENT)
-
-        app: Application = Application(env={"IS_SNAPSHOTTING_ENABLED": "y"})
-        app.mapper.transcoder.register(PersonAsDict())
-        app.mapper.transcoder.register(SendMethodAsStr())
-        app.mapper.transcoder.register(StatusAsStr())
-
-        app.save(invoice)
-
-        copy: Invoice = app.repository.get(invoice.id)
-        self.assertEqual(invoice, copy)
-
-        assert app.snapshots is not None
-        snapshots = list(app.snapshots.get(invoice.id))
-        self.assertEqual(len(snapshots), 0)
-
-        app.take_snapshot(invoice.id)
-
-        copy = app.repository.get(invoice.id)
-        self.assertEqual(invoice, copy)
-
-        copy = app.repository.get(invoice.id, version=1)
-        self.assertNotEqual(invoice, copy)
-
-        snapshots = list(app.snapshots.get(invoice.id))
-        self.assertEqual(len(snapshots), 1)
-
-        snapshot = cast(Snapshot, snapshots[0])
-        copy2 = cast(Invoice, snapshot.mutate(None))
-        self.assertEqual(invoice, copy2)