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

eventsourcing/examples/aggregate7/test_application.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from unittest import TestCase
+
+from eventsourcing.examples.aggregate7.application import DogSchool
+from eventsourcing.examples.aggregate7.domainmodel import project_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)
+        self.assertEqual(dog["name"], "Fido")
+        self.assertEqual(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=project_dog)
+        dog = school.get_dog(dog_id)
+        self.assertEqual(dog["name"], "Fido")
+        self.assertEqual(dog["tricks"], ("roll over", "play dead"))
+
+        # Continue with snapshotted aggregate.
+        school.add_trick(dog_id, "fetch ball")
+        dog = school.get_dog(dog_id)
+        self.assertEqual(dog["name"], "Fido")
+        self.assertEqual(dog["tricks"], ("roll over", "play dead", "fetch ball"))

eventsourcing/examples/aggregate7/test_compression_and_encryption.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from unittest import TestCase
+
+from eventsourcing.cipher import AESCipher
+from eventsourcing.examples.aggregate7.application import DogSchool
+from eventsourcing.examples.aggregate7.domainmodel import project_dog
+
+
+class TestDogSchool(TestCase):
+    def test_dog_school(self) -> None:
+        # Construct application object.
+        school = DogSchool(
+            env={
+                "COMPRESSOR_TOPIC": "eventsourcing.compressor:ZlibCompressor",
+                "CIPHER_TOPIC": "eventsourcing.cipher:AESCipher",
+                "CIPHER_KEY": AESCipher.create_key(num_bytes=32),
+            }
+        )
+
+        # 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"
+        self.assertEqual(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=project_dog)
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        self.assertEqual(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"
+        self.assertEqual(dog["tricks"], ("roll over", "play dead", "fetch ball"))

eventsourcing/examples/aggregate7/test_snapshotting_intervals.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar, Dict, Type, cast
+from unittest import TestCase
+
+from eventsourcing.domain import MutableOrImmutableAggregate, ProgrammingError
+from eventsourcing.examples.aggregate7.application import DogSchool
+from eventsourcing.examples.aggregate7.domainmodel import (
+    Dog,
+    Trick,
+    add_trick,
+    project_dog,
+    register_dog,
+)
+
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
+
+class SubDogSchool(DogSchool):
+    snapshotting_intervals: ClassVar[
+        Dict[Type[MutableOrImmutableAggregate], int] | None
+    ] = {Dog: 1}
+
+    def register_dog(self, name: str) -> UUID:
+        event = register_dog(name)
+        dog = project_dog(None, [event])
+        self.save(dog, event)
+        return event.originator_id
+
+    def add_trick(self, dog_id: UUID, trick: str) -> None:
+        dog = self.repository.get(dog_id, projector_func=project_dog)
+        event = add_trick(dog, Trick(name=trick))
+        dog = cast(Dog, project_dog(dog, [event]))
+        self.save(dog, event)
+
+
+class TestDogSchool(TestCase):
+    def test_dog_school(self) -> None:
+        # Construct application object.
+        school = SubDogSchool()
+
+        # Check error when snapshotting_projectors not set.
+        with self.assertRaises(ProgrammingError) as cm:
+            school.register_dog("Fido")
+
+        self.assertIn("Cannot take snapshot", cm.exception.args[0])
+
+        # Set snapshotting_projectors.
+        SubDogSchool.snapshotting_projectors = {Dog: project_dog}
+
+        # Check snapshotting when snapshotting_projectors is set.
+        dog_id = school.register_dog("Fido")
+
+        assert school.snapshots is not None
+        self.assertEqual(1, len(list(school.snapshots.get(dog_id))))
+
+        school.add_trick(dog_id, "roll over")
+        self.assertEqual(2, len(list(school.snapshots.get(dog_id))))
+
+        school.add_trick(dog_id, "play dead")
+        self.assertEqual(3, len(list(school.snapshots.get(dog_id))))
+
+        # Query application state.
+        dog = school.get_dog(dog_id)
+        self.assertEqual(dog["name"], "Fido")
+        self.assertEqual(dog["tricks"], ("roll over", "play dead"))

eventsourcing/examples/aggregate7a/application.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, Type
+
+from eventsourcing.application import Application, ProjectorFunction
+from eventsourcing.examples.aggregate7.persistence import (
+    OrjsonTranscoder,
+    PydanticMapper,
+)
+from eventsourcing.examples.aggregate7a.domainmodel import (
+    Dog,
+    Snapshot,
+    add_trick,
+    project_dog,
+    register_dog,
+)
+
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
+    from eventsourcing.domain import MutableOrImmutableAggregate
+    from eventsourcing.persistence import Mapper, Transcoder
+
+
+class DogSchool(Application):
+    is_snapshotting_enabled = True
+    snapshot_class = Snapshot
+    snapshotting_intervals: ClassVar[
+        Dict[Type[MutableOrImmutableAggregate], int] | None
+    ] = {Dog: 5}
+    snapshotting_projectors: ClassVar[
+        Dict[Type[MutableOrImmutableAggregate], ProjectorFunction[Any, Any]] | None
+    ] = {Dog: project_dog}
+
+    def register_dog(self, name: str) -> UUID:
+        dog = register_dog(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=project_dog)
+        dog = add_trick(dog, trick)
+        self.save(dog)
+
+    def get_dog(self, dog_id: UUID) -> Dict[str, Any]:
+        dog = self.repository.get(dog_id, projector_func=project_dog)
+        return {"name": dog.name, "tricks": tuple([t.name for t in dog.tricks])}
+
+    def construct_mapper(self) -> Mapper:
+        return self.factory.mapper(
+            transcoder=self.construct_transcoder(),
+            mapper_class=PydanticMapper,
+        )
+
+    def construct_transcoder(self) -> Transcoder:
+        return OrjsonTranscoder()

eventsourcing/examples/aggregate7a/domainmodel.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import contextlib
+from collections import defaultdict
+from datetime import datetime, timezone
+from functools import singledispatch
+from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, TypeVar
+from uuid import UUID, uuid4
+
+from pydantic import BaseModel
+
+from eventsourcing.utils import get_topic
+
+
+class DomainEvent(BaseModel):
+    originator_id: UUID
+    originator_version: int
+    timestamp: datetime
+
+    class Config:
+        frozen = True
+
+
+def create_timestamp() -> datetime:
+    return datetime.now(tz=timezone.utc)
+
+
+class Aggregate(BaseModel):
+    id: UUID
+    version: int
+    created_on: datetime
+    modified_on: datetime
+
+    class Config:
+        frozen = True
+
+    def hold_event(self, event: DomainEvent) -> None:
+        all_pending_events[id(self)].append(event)
+
+    def collect_events(self) -> List[DomainEvent]:
+        try:
+            return all_pending_events.pop(id(self))
+        except KeyError:  # pragma: no cover
+            return []
+
+    def __del__(self) -> None:
+        with contextlib.suppress(KeyError):
+            all_pending_events.pop(id(self))
+
+
+class Snapshot(DomainEvent):
+    topic: str
+    state: Dict[str, Any]
+
+    @classmethod
+    def take(cls, aggregate: Aggregate) -> Snapshot:
+        return Snapshot(
+            originator_id=aggregate.id,
+            originator_version=aggregate.version,
+            timestamp=create_timestamp(),
+            topic=get_topic(type(aggregate)),
+            state=aggregate.model_dump(),
+        )
+
+
+TAggregate = TypeVar("TAggregate", bound=Aggregate)
+MutatorFunction = Callable[..., Optional[TAggregate]]
+
+
+def aggregate_projector(
+    mutator: MutatorFunction[TAggregate],
+) -> Callable[[TAggregate | None, Iterable[DomainEvent]], TAggregate | None]:
+    def project_aggregate(
+        aggregate: TAggregate | None, events: Iterable[DomainEvent]
+    ) -> TAggregate | None:
+        for event in events:
+            aggregate = mutator(event, aggregate)
+        return aggregate
+
+    return project_aggregate
+
+
+class Trick(BaseModel):
+    name: str
+
+
+all_pending_events: Dict[int, List[DomainEvent]] = defaultdict(list)
+
+
+class Dog(Aggregate):
+    name: str
+    tricks: Tuple[Trick, ...]
+
+
+class DogRegistered(DomainEvent):
+    name: str
+
+
+class TrickAdded(DomainEvent):
+    trick: Trick
+
+
+def register_dog(name: str) -> Dog:
+    event = DogRegistered(
+        originator_id=uuid4(),
+        originator_version=1,
+        timestamp=create_timestamp(),
+        name=name,
+    )
+    dog = mutate_dog(event, None)
+    assert isinstance(dog, Dog)
+    dog.hold_event(event)
+    return dog
+
+
+def add_trick(dog: Dog, trick: str) -> Dog:
+    event = TrickAdded(
+        originator_id=dog.id,
+        originator_version=dog.version + 1,
+        timestamp=create_timestamp(),
+        trick=Trick(name=trick),
+    )
+    dog_ = mutate_dog(event, dog)
+    assert isinstance(dog_, Dog)
+    dog_.hold_event(event)
+    return dog_
+
+
+@singledispatch
+def mutate_dog(_: DomainEvent, __: Dog | None) -> Dog | None:
+    """Mutates aggregate with event."""
+
+
+@mutate_dog.register
+def _(event: DogRegistered, _: 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_dog.register
+def _(event: TrickAdded, dog: Dog) -> Dog:
+    return Dog(
+        id=dog.id,
+        version=event.originator_version,
+        created_on=dog.created_on,
+        modified_on=event.timestamp,
+        name=dog.name,
+        tricks=(*dog.tricks, event.trick),
+    )
+
+
+@mutate_dog.register
+def _(event: Snapshot, _: 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=event.state["tricks"],
+    )
+
+
+project_dog = aggregate_projector(mutate_dog)

eventsourcing/examples/aggregate7a/test_application.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from unittest import TestCase
+
+from eventsourcing.examples.aggregate7a.application import DogSchool
+from eventsourcing.examples.aggregate7a.domainmodel import project_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)
+        self.assertEqual(dog["name"], "Fido")
+        self.assertEqual(dog["tricks"], ("roll over", "play dead"))
+
+        # Select notifications.
+        notifications = school.notification_log.select(start=1, limit=10)
+        assert len(notifications) == 3
+
+        # Take snapshot.
+        assert school.snapshots is not None
+        assert len(list(school.snapshots.get(dog_id))) == 0
+        school.take_snapshot(dog_id, version=3, projector_func=project_dog)
+        assert len(list(school.snapshots.get(dog_id))) == 1
+        dog = school.get_dog(dog_id)
+        self.assertEqual(dog["name"], "Fido")
+        self.assertEqual(dog["tricks"], ("roll over", "play dead"))
+
+        # Continue with snapshotted aggregate.
+        school.add_trick(dog_id, "fetch ball")
+        dog = school.get_dog(dog_id)
+        self.assertEqual(dog["name"], "Fido")
+        self.assertEqual(dog["tricks"], ("roll over", "play dead", "fetch ball"))
+
+        # Auto-snapshotting at version 5.
+        assert len(list(school.snapshots.get(dog_id))) == 1
+        school.add_trick(dog_id, "jump hoop")
+        assert len(list(school.snapshots.get(dog_id))) == 2

eventsourcing/examples/aggregate7a/test_compression_and_encryption.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from unittest import TestCase
+
+from eventsourcing.cipher import AESCipher
+from eventsourcing.examples.aggregate7a.application import DogSchool
+from eventsourcing.examples.aggregate7a.domainmodel import project_dog
+
+
+class TestDogSchool(TestCase):
+    def test_dog_school(self) -> None:
+        # Construct application object.
+        school = DogSchool(
+            env={
+                "COMPRESSOR_TOPIC": "eventsourcing.compressor:ZlibCompressor",
+                "CIPHER_TOPIC": "eventsourcing.cipher:AESCipher",
+                "CIPHER_KEY": AESCipher.create_key(num_bytes=32),
+            }
+        )
+
+        # 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"
+        self.assertEqual(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=project_dog)
+        dog = school.get_dog(dog_id)
+        assert dog["name"] == "Fido"
+        self.assertEqual(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"
+        self.assertEqual(dog["tricks"], ("roll over", "play dead", "fetch ball"))

eventsourcing/examples/aggregate8/application.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict
+
+from eventsourcing.application import Application
+from eventsourcing.examples.aggregate8.domainmodel import Dog, Trick
+from eventsourcing.examples.aggregate8.persistence import (
+    OrjsonTranscoder,
+    PydanticMapper,
+)
+
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
+    from eventsourcing.persistence import Mapper, Transcoder
+
+
+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(name=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([t.name for t in dog.tricks]),
+            "created_on": dog.created_on,
+            "modified_on": dog.modified_on,
+        }
+
+    def construct_mapper(self) -> Mapper:
+        return self.factory.mapper(
+            transcoder=self.construct_transcoder(),
+            mapper_class=PydanticMapper,
+        )
+
+    def construct_transcoder(self) -> Transcoder:
+        return OrjsonTranscoder()

eventsourcing/examples/aggregate8/domainmodel.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from datetime import datetime  # noqa: TCH003
+from typing import List
+from uuid import UUID  # noqa: TCH003
+
+from pydantic import BaseModel, Extra
+
+from eventsourcing.domain import (
+    Aggregate as BaseAggregate,
+    CanInitAggregate,
+    CanMutateAggregate,
+    CanSnapshotAggregate,
+    event,
+)
+
+
+class DomainEvent(BaseModel):
+    originator_id: UUID
+    originator_version: int
+    timestamp: datetime
+
+    class Config:
+        frozen = True
+
+
+class Aggregate(BaseAggregate):
+    class Event(DomainEvent, CanMutateAggregate):
+        pass
+
+    class Created(Event, CanInitAggregate):
+        originator_topic: str
+
+
+class SnapshotState(BaseModel):
+    class Config:
+        extra = Extra.allow
+
+
+class AggregateSnapshot(DomainEvent, CanSnapshotAggregate):
+    topic: str
+    state: SnapshotState
+
+
+class Trick(BaseModel):
+    name: str
+
+
+class DogState(SnapshotState):
+    name: str
+    tricks: List[Trick]
+
+
+class Dog(Aggregate):
+    class Snapshot(AggregateSnapshot):
+        state: DogState
+
+    @event("Registered")
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.tricks: List[Trick] = []
+
+    @event("TrickAdded")
+    def add_trick(self, trick: Trick) -> None:
+        self.tricks.append(trick)

eventsourcing/examples/aggregate8/persistence.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, cast
+
+import orjson
+from pydantic import BaseModel
+
+from eventsourcing.persistence import (
+    Mapper,
+    ProgrammingError,
+    StoredEvent,
+    Transcoder,
+    Transcoding,
+)
+from eventsourcing.utils import get_topic, resolve_topic
+
+if TYPE_CHECKING:  # pragma: nocover
+    from eventsourcing.domain import DomainEventProtocol
+
+
+class PydanticMapper(Mapper):
+    def to_stored_event(self, domain_event: DomainEventProtocol) -> StoredEvent:
+        topic = get_topic(domain_event.__class__)
+        event_state = cast(BaseModel, domain_event).model_dump()
+        stored_state = self.transcoder.encode(event_state)
+        if self.compressor:
+            stored_state = self.compressor.compress(stored_state)
+        if self.cipher:
+            stored_state = self.cipher.encrypt(stored_state)
+        return StoredEvent(
+            originator_id=domain_event.originator_id,
+            originator_version=domain_event.originator_version,
+            topic=topic,
+            state=stored_state,
+        )
+
+    def to_domain_event(self, stored: StoredEvent) -> DomainEventProtocol:
+        stored_state = stored.state
+        if self.cipher:
+            stored_state = self.cipher.decrypt(stored_state)
+        if self.compressor:
+            stored_state = self.compressor.decompress(stored_state)
+        event_state: Dict[str, Any] = self.transcoder.decode(stored_state)
+        cls = resolve_topic(stored.topic)
+        return cls(**event_state)
+
+
+class OrjsonTranscoder(Transcoder):
+    def encode(self, obj: Any) -> bytes:
+        return orjson.dumps(obj)
+
+    def decode(self, data: bytes) -> Any:
+        return orjson.loads(data)
+
+    def register(self, _: Transcoding) -> None:  # pragma: no cover
+        msg = "Please use Pydantic BaseModel"
+        raise ProgrammingError(msg)

eventsourcing/examples/aggregate8/test_application.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from unittest import TestCase
+
+from eventsourcing.examples.aggregate8.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)
+        self.assertEqual(dog["name"], "Fido")
+        self.assertEqual(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)
+        self.assertEqual(dog["name"], "Fido")
+        self.assertEqual(dog["tricks"], ("roll over", "play dead"))
+
+        # Continue with snapshotted aggregate.
+        school.add_trick(dog_id, "fetch ball")
+        dog = school.get_dog(dog_id)
+        self.assertEqual(dog["name"], "Fido")
+        self.assertEqual(dog["tricks"], ("roll over", "play dead", "fetch ball"))