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

eventsourcing/examples/aggregate1/application.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict
+
+from eventsourcing.application import Application
+from eventsourcing.examples.aggregate1.domainmodel import Dog
+
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
+
+class DogSchool(Application):
+    is_snapshotting_enabled = True
+
+    def register_dog(self, name: str) -> UUID:
+        dog = Dog(name)
+        self.save(dog)
+        return dog.id
+
+    def add_trick(self, dog_id: UUID, trick: str) -> None:
+        dog: Dog = self.repository.get(dog_id)
+        dog.add_trick(trick)
+        self.save(dog)
+
+    def get_dog(self, dog_id: UUID) -> Dict[str, Any]:
+        dog: Dog = self.repository.get(dog_id)
+        return {"name": dog.name, "tricks": tuple(dog.tricks)}

eventsourcing/examples/aggregate1/domainmodel.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import List
+
+from eventsourcing.domain import Aggregate, event
+
+
+class Dog(Aggregate):
+    @event("Registered")
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.tricks: List[str] = []
+
+    @event("TrickAdded")
+    def add_trick(self, trick: str) -> None:
+        self.tricks.append(trick)

eventsourcing/examples/aggregate1/test_application.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from unittest import TestCase
+
+from eventsourcing.examples.aggregate1.application import DogSchool
+
+
+class TestDogSchool(TestCase):
+    def test_dog_school(self) -> None:
+        # Construct application object.
+        school = DogSchool()
+
+        # Evolve application state.
+        dog_id = school.register_dog("Fido")
+        school.add_trick(dog_id, "roll over")
+        school.add_trick(dog_id, "play dead")
+
+        # Query application state.
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead")
+
+        # Select notifications.
+        notifications = school.notification_log.select(start=1, limit=10)
+        assert len(notifications) == 3
+
+        # Take snapshot.
+        school.take_snapshot(dog_id, version=3)
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead")
+
+        # Continue with snapshotted aggregate.
+        school.add_trick(dog_id, "fetch ball")
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead", "fetch ball")

eventsourcing/examples/aggregate2/application.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict
+
+from eventsourcing.application import Application
+from eventsourcing.examples.aggregate2.domainmodel import Dog
+
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
+
+class DogSchool(Application):
+    is_snapshotting_enabled = True
+
+    def register_dog(self, name: str) -> UUID:
+        dog = Dog(name)
+        self.save(dog)
+        return dog.id
+
+    def add_trick(self, dog_id: UUID, trick: str) -> None:
+        dog: Dog = self.repository.get(dog_id)
+        dog.add_trick(trick)
+        self.save(dog)
+
+    def get_dog(self, dog_id: UUID) -> Dict[str, Any]:
+        dog: Dog = self.repository.get(dog_id)
+        return {"name": dog.name, "tricks": tuple(dog.tricks)}

eventsourcing/examples/aggregate2/domainmodel.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import List
+
+from eventsourcing.domain import Aggregate, event
+
+
+class Dog(Aggregate):
+    class Registered(Aggregate.Created):
+        name: str
+
+    class TrickAdded(Aggregate.Event):
+        trick: str
+
+    @event(Registered)
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.tricks: List[str] = []
+
+    @event(TrickAdded)
+    def add_trick(self, trick: str) -> None:
+        self.tricks.append(trick)

eventsourcing/examples/aggregate2/test_application.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from unittest import TestCase
+
+from eventsourcing.examples.aggregate2.application import DogSchool
+
+
+class TestDogSchool(TestCase):
+    def test_dog_school(self) -> None:
+        # Construct application object.
+        school = DogSchool()
+
+        # Evolve application state.
+        dog_id = school.register_dog("Fido")
+        school.add_trick(dog_id, "roll over")
+        school.add_trick(dog_id, "play dead")
+
+        # Query application state.
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead")
+
+        # Select notifications.
+        notifications = school.notification_log.select(start=1, limit=10)
+        assert len(notifications) == 3
+
+        # Take snapshot.
+        school.take_snapshot(dog_id, version=3)
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead")
+
+        # Continue with snapshotted aggregate.
+        school.add_trick(dog_id, "fetch ball")
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead", "fetch ball")

eventsourcing/examples/aggregate3/application.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict
+
+from eventsourcing.application import Application
+from eventsourcing.examples.aggregate3.domainmodel import Dog
+
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
+
+class DogSchool(Application):
+    is_snapshotting_enabled = True
+
+    def register_dog(self, name: str) -> UUID:
+        dog = Dog.register(name=name)
+        self.save(dog)
+        return dog.id
+
+    def add_trick(self, dog_id: UUID, trick: str) -> None:
+        dog: Dog = self.repository.get(dog_id)
+        dog.add_trick(trick)
+        self.save(dog)
+
+    def get_dog(self, dog_id: UUID) -> Dict[str, Any]:
+        dog: Dog = self.repository.get(dog_id)
+        return {"name": dog.name, "tricks": tuple(dog.tricks)}

eventsourcing/examples/aggregate3/domainmodel.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import List, cast
+
+from eventsourcing.dispatch import singledispatchmethod
+from eventsourcing.domain import Aggregate
+
+
+class Dog(Aggregate):
+    class Event(Aggregate.Event):
+        def apply(self, aggregate: Aggregate) -> None:
+            cast(Dog, aggregate).apply(self)
+
+    class Registered(Event, Aggregate.Created):
+        name: str
+
+    class TrickAdded(Event):
+        trick: str
+
+    @classmethod
+    def register(cls, name: str) -> Dog:
+        return cls._create(cls.Registered, name=name)
+
+    def add_trick(self, trick: str) -> None:
+        self.trigger_event(self.TrickAdded, trick=trick)
+
+    @singledispatchmethod
+    def apply(self, event: Event) -> None:
+        """Applies event to aggregate."""
+
+    @apply.register
+    def _(self, event: Dog.Registered) -> None:
+        self.name = event.name
+        self.tricks: List[str] = []
+
+    @apply.register
+    def _(self, event: Dog.TrickAdded) -> None:
+        self.tricks.append(event.trick)

eventsourcing/examples/aggregate3/test_application.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from unittest import TestCase
+
+from eventsourcing.examples.aggregate3.application import DogSchool
+
+
+class TestDogSchool(TestCase):
+    def test_dog_school(self) -> None:
+        # Construct application object.
+        school = DogSchool()
+
+        # Evolve application state.
+        dog_id = school.register_dog("Fido")
+        school.add_trick(dog_id, "roll over")
+        school.add_trick(dog_id, "play dead")
+
+        # Query application state.
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead")
+
+        # Select notifications.
+        notifications = school.notification_log.select(start=1, limit=10)
+        assert len(notifications) == 3
+
+        # Take snapshot.
+        school.take_snapshot(dog_id, version=3)
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead")
+
+        # Continue with snapshotted aggregate.
+        school.add_trick(dog_id, "fetch ball")
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead", "fetch ball")

eventsourcing/examples/aggregate4/application.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict
+
+from eventsourcing.application import Application
+from eventsourcing.examples.aggregate4.domainmodel import Dog
+
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
+
+class DogSchool(Application):
+    is_snapshotting_enabled = True
+
+    def register_dog(self, name: str) -> UUID:
+        dog = Dog.register(name)
+        self.save(dog)
+        return dog.id
+
+    def add_trick(self, dog_id: UUID, trick: str) -> None:
+        dog = self.repository.get(dog_id, projector_func=Dog.projector)
+        dog.add_trick(trick)
+        self.save(dog)
+
+    def get_dog(self, dog_id: UUID) -> Dict[str, Any]:
+        dog = self.repository.get(dog_id, projector_func=Dog.projector)
+        return {"name": dog.name, "tricks": tuple(dog.tricks)}

eventsourcing/examples/aggregate4/domainmodel.py

@@ -0,0 +1,128 @@
+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 uuid import UUID, uuid4
+
+from eventsourcing.dispatch import singledispatchmethod
+from eventsourcing.domain import Snapshot
+
+
+@dataclass(frozen=True)
+class DomainEvent:
+    originator_version: int
+    originator_id: UUID
+    timestamp: datetime
+
+    @staticmethod
+    def create_timestamp() -> datetime:
+        return datetime.now(tz=timezone.utc)
+
+
+TAggregate = TypeVar("TAggregate", bound="Aggregate")
+
+
+class Aggregate:
+    id: UUID
+    version: int
+    created_on: datetime
+
+    def __init__(self, event: DomainEvent):
+        self.id = event.originator_id
+        self.version = event.originator_version
+        self.created_on = event.timestamp
+
+    def trigger_event(
+        self,
+        event_class: Type[DomainEvent],
+        **kwargs: Any,
+    ) -> None:
+        kwargs = kwargs.copy()
+        kwargs.update(
+            originator_id=self.id,
+            originator_version=self.version + 1,
+            timestamp=event_class.create_timestamp(),
+        )
+        new_event = event_class(**kwargs)
+        self.apply(new_event)
+        self.pending_events.append(new_event)
+
+    @singledispatchmethod
+    def apply(self, event: DomainEvent) -> None:
+        """Applies event to aggregate."""
+
+    def collect_events(self) -> List[DomainEvent]:
+        events, self.pending_events = self.pending_events, []
+        return events
+
+    @classmethod
+    def projector(
+        cls: Type[TAggregate],
+        _: TAggregate | None,
+        events: Iterable[DomainEvent],
+    ) -> TAggregate | None:
+        aggregate = object.__new__(cls)
+        for event in events:
+            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)
+    class Registered(DomainEvent):
+        name: str
+
+    @dataclass(frozen=True)
+    class TrickAdded(DomainEvent):
+        trick: str
+
+    @classmethod
+    def register(cls, name: str) -> Dog:
+        event = cls.Registered(
+            originator_id=uuid4(),
+            originator_version=1,
+            timestamp=DomainEvent.create_timestamp(),
+            name=name,
+        )
+        dog = cast(Dog, cls.projector(None, [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:
+        """Applies event to aggregate."""
+
+    @apply.register(Registered)
+    def _(self, event: Registered) -> None:
+        super().__init__(event)
+        self.name = event.name
+        self.tricks: List[str] = []
+
+    @apply.register(TrickAdded)
+    def _(self, event: TrickAdded) -> None:
+        self.tricks.append(event.trick)
+        self.version = event.originator_version
+
+    @apply.register(Snapshot)
+    def _(self, event: Snapshot) -> None:
+        self.__dict__.update(event.state)

eventsourcing/examples/aggregate4/test_application.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from unittest import TestCase
+
+from eventsourcing.examples.aggregate4.application import DogSchool
+from eventsourcing.examples.aggregate4.domainmodel import Dog
+
+
+class TestDogSchool(TestCase):
+    def test_dog_school(self) -> None:
+        # Construct application object.
+        school = DogSchool()
+
+        # Evolve application state.
+        dog_id = school.register_dog("Fido")
+        school.add_trick(dog_id, "roll over")
+        school.add_trick(dog_id, "play dead")
+
+        # Query application state.
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead")
+
+        # Select notifications.
+        notifications = school.notification_log.select(start=1, limit=10)
+        assert len(notifications) == 3
+
+        # Take snapshot.
+        school.take_snapshot(dog_id, version=3, projector_func=Dog.projector)
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead")
+
+        # Continue with snapshotted aggregate.
+        school.add_trick(dog_id, "fetch ball")
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead", "fetch ball")

eventsourcing/examples/aggregate5/application.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict
+
+from eventsourcing.application import Application
+from eventsourcing.examples.aggregate5.domainmodel import Dog
+
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
+
+class DogSchool(Application):
+    is_snapshotting_enabled = True
+
+    def register_dog(self, name: str) -> UUID:
+        dog, event = Dog.register(name)
+        self.save(event)
+        return dog.id
+
+    def add_trick(self, dog_id: UUID, trick: str) -> None:
+        dog = self.repository.get(dog_id, projector_func=Dog.projector)
+        dog, event = dog.add_trick(trick)
+        self.save(event)
+
+    def get_dog(self, dog_id: UUID) -> Dict[str, Any]:
+        dog = self.repository.get(dog_id, projector_func=Dog.projector)
+        return {"name": dog.name, "tricks": dog.tricks}

eventsourcing/examples/aggregate5/domainmodel.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Iterable, Tuple, Type, TypeVar
+from uuid import UUID, uuid4
+
+from eventsourcing.dispatch import singledispatchmethod
+from eventsourcing.domain import Snapshot  # noqa: TCH001
+
+
+@dataclass(frozen=True)
+class DomainEvent:
+    originator_id: UUID
+    originator_version: int
+    timestamp: datetime
+
+    @staticmethod
+    def create_timestamp() -> datetime:
+        return datetime.now(tz=timezone.utc)
+
+
+TAggregate = TypeVar("TAggregate", bound="Aggregate")
+
+
+@dataclass(frozen=True)
+class Aggregate:
+    id: UUID
+    version: int
+    created_on: datetime
+    modified_on: datetime
+
+    def trigger_event(
+        self,
+        event_class: Type[DomainEvent],
+        **kwargs: Any,
+    ) -> DomainEvent:
+        kwargs = kwargs.copy()
+        kwargs.update(
+            originator_id=self.id,
+            originator_version=self.version + 1,
+            timestamp=event_class.create_timestamp(),
+        )
+        return event_class(**kwargs)
+
+    @classmethod
+    def projector(
+        cls: Type[TAggregate],
+        aggregate: TAggregate | None,
+        events: Iterable[DomainEvent],
+    ) -> TAggregate | None:
+        for event in events:
+            aggregate = cls.mutate(event, aggregate)
+        return aggregate
+
+    @singledispatchmethod
+    @staticmethod
+    def mutate(event: DomainEvent, aggregate: Any) -> Any:
+        """Mutates aggregate with event."""
+
+
+@dataclass(frozen=True)
+class Dog(Aggregate):
+    name: str
+    tricks: Tuple[str, ...]
+
+    @dataclass(frozen=True)
+    class Registered(DomainEvent):
+        name: str
+
+    @dataclass(frozen=True)
+    class TrickAdded(DomainEvent):
+        trick: str
+
+    @staticmethod
+    def register(name: str) -> Tuple[Dog, DomainEvent]:
+        event = Dog.Registered(
+            originator_id=uuid4(),
+            originator_version=1,
+            timestamp=DomainEvent.create_timestamp(),
+            name=name,
+        )
+        dog = Dog.mutate(event, None)
+        return dog, event
+
+    def add_trick(self, trick: str) -> Tuple[Dog, DomainEvent]:
+        event = self.trigger_event(Dog.TrickAdded, trick=trick)
+        dog = Dog.mutate(event, self)
+        return dog, event
+
+    @singledispatchmethod
+    @classmethod
+    def mutate(cls, event: DomainEvent, aggregate: Dog | None) -> Dog | None:
+        """Mutates aggregate with event."""
+
+    @mutate.register
+    @classmethod
+    def _(cls, event: Dog.Registered, _: Dog | None) -> Dog:
+        return Dog(
+            id=event.originator_id,
+            version=event.originator_version,
+            created_on=event.timestamp,
+            modified_on=event.timestamp,
+            name=event.name,
+            tricks=(),
+        )
+
+    @mutate.register
+    @classmethod
+    def _(cls, event: Dog.TrickAdded, aggregate: Dog | None) -> Dog:
+        assert aggregate is not None
+        return Dog(
+            id=aggregate.id,
+            version=event.originator_version,
+            created_on=aggregate.created_on,
+            modified_on=event.timestamp,
+            name=aggregate.name,
+            tricks=(*aggregate.tricks, event.trick),
+        )
+
+    @mutate.register
+    @classmethod
+    def _(cls, event: Snapshot, _: Dog | None) -> Dog:
+        return Dog(
+            id=event.state["id"],
+            version=event.state["version"],
+            created_on=event.state["created_on"],
+            modified_on=event.state["modified_on"],
+            name=event.state["name"],
+            tricks=tuple(event.state["tricks"]),  # comes back from JSON as a list
+        )

eventsourcing/examples/aggregate5/test_application.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from unittest import TestCase
+
+from eventsourcing.examples.aggregate5.application import DogSchool
+from eventsourcing.examples.aggregate5.domainmodel import Dog
+
+
+class TestDogSchool(TestCase):
+    def test_dog_school(self) -> None:
+        # Construct application object.
+        school = DogSchool()
+
+        # Evolve application state.
+        dog_id = school.register_dog("Fido")
+        school.add_trick(dog_id, "roll over")
+        school.add_trick(dog_id, "play dead")
+
+        # Query application state.
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead")
+
+        # Select notifications.
+        notifications = school.notification_log.select(start=1, limit=10)
+        assert len(notifications) == 3
+
+        # Take snapshot.
+        school.take_snapshot(dog_id, version=3, projector_func=Dog.projector)
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead")
+
+        # Continue with snapshotted aggregate.
+        school.add_trick(dog_id, "fetch ball")
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        assert dog["tricks"] == ("roll over", "play dead", "fetch ball")