eventsourcing 9.2.21__py3-none-any.whl → 9.3.0__py3-none-any.whl

eventsourcing/examples/aggregate6/application.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict
+
+from eventsourcing.application import Application
+from eventsourcing.examples.aggregate6.domainmodel import (
+    add_trick,
+    project_dog,
+    register_dog,
+)
+
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
+
+class DogSchool(Application):
+    is_snapshotting_enabled = True
+
+    def register_dog(self, name: str) -> UUID:
+        event = register_dog(name)
+        self.save(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)
+        self.save(add_trick(dog, trick))
+
+    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": dog.tricks}

eventsourcing/examples/aggregate6/domainmodel.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from functools import singledispatch
+from typing import Callable, Iterable, Optional, Tuple, TypeVar
+from uuid import UUID, uuid4
+
+from eventsourcing.domain import Snapshot
+
+
+@dataclass(frozen=True)
+class DomainEvent:
+    originator_id: UUID
+    originator_version: int
+    timestamp: datetime
+
+
+def create_timestamp() -> datetime:
+    return datetime.now(tz=timezone.utc)
+
+
+@dataclass(frozen=True)
+class Aggregate:
+    id: UUID
+    version: int
+    created_on: datetime
+    modified_on: datetime
+
+
+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
+
+
+@dataclass(frozen=True)
+class Dog(Aggregate):
+    name: str
+    tricks: Tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class DogRegistered(DomainEvent):
+    name: str
+
+
+@dataclass(frozen=True)
+class TrickAdded(DomainEvent):
+    trick: str
+
+
+def register_dog(name: str) -> DomainEvent:
+    return DogRegistered(
+        originator_id=uuid4(),
+        originator_version=1,
+        timestamp=create_timestamp(),
+        name=name,
+    )
+
+
+def add_trick(dog: Dog, trick: str) -> DomainEvent:
+    return TrickAdded(
+        originator_id=dog.id,
+        originator_version=dog.version + 1,
+        timestamp=create_timestamp(),
+        trick=trick,
+    )
+
+
+@singledispatch
+def mutate_dog(_: DomainEvent | Snapshot, __: 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=tuple(event.state["tricks"]),  # comes back from JSON as a list
+    )
+
+
+project_dog = aggregate_projector(mutate_dog)

eventsourcing/examples/aggregate6/test_application.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from unittest import TestCase
+
+from eventsourcing.examples.aggregate6.application import DogSchool
+from eventsourcing.examples.aggregate6.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)
+        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=project_dog)
+        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/aggregate6a/application.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, Type
+
+from eventsourcing.application import Application, ProjectorFunction
+from eventsourcing.examples.aggregate6a.domainmodel import (
+    Dog,
+    add_trick,
+    project_dog,
+    register_dog,
+)
+
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
+    from eventsourcing.domain import MutableOrImmutableAggregate
+
+
+class DogSchool(Application):
+    is_snapshotting_enabled = True
+    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": dog.tricks}

eventsourcing/examples/aggregate6a/domainmodel.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import contextlib
+from collections import defaultdict
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from functools import singledispatch
+from typing import Callable, Dict, Iterable, List, Optional, Tuple, TypeVar
+from uuid import UUID, uuid4
+
+from eventsourcing.domain import Snapshot
+
+
+@dataclass(frozen=True)
+class DomainEvent:
+    originator_id: UUID
+    originator_version: int
+    timestamp: datetime
+
+
+def create_timestamp() -> datetime:
+    return datetime.now(tz=timezone.utc)
+
+
+@dataclass(frozen=True)
+class Aggregate:
+    id: UUID
+    version: int
+    created_on: datetime
+    modified_on: datetime
+
+    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))
+
+
+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
+
+
+all_pending_events: Dict[int, List[DomainEvent]] = defaultdict(list)
+
+
+@dataclass(frozen=True)
+class Dog(Aggregate):
+    name: str
+    tricks: Tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class DogRegistered(DomainEvent):
+    name: str
+
+
+@dataclass(frozen=True)
+class TrickAdded(DomainEvent):
+    trick: str
+
+
+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,
+    )
+    dog_ = mutate_dog(event, dog)
+    assert isinstance(dog_, Dog)
+    dog_.hold_event(event)
+    return dog_
+
+
+@singledispatch
+def mutate_dog(_: DomainEvent | Snapshot, __: 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=tuple(event.state["tricks"]),  # comes back from JSON as a list
+    )
+
+
+project_dog = aggregate_projector(mutate_dog)

eventsourcing/examples/aggregate6a/test_application.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from unittest import TestCase
+
+from eventsourcing.examples.aggregate6a.application import DogSchool
+from eventsourcing.examples.aggregate6a.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)
+        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.
+        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)
+        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")
+
+        assert len(list(school.snapshots.get(dog_id))) == 1
+        school.add_trick(dog_id, "jump hoop")  # Version 5, autosnapshot.
+        assert len(list(school.snapshots.get(dog_id))) == 2

eventsourcing/examples/aggregate7/application.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict
+
+from eventsourcing.application import Application
+from eventsourcing.examples.aggregate7.domainmodel import (
+    Snapshot,
+    Trick,
+    add_trick,
+    project_dog,
+    register_dog,
+)
+from eventsourcing.examples.aggregate7.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
+    snapshot_class = Snapshot
+
+    def register_dog(self, name: str) -> UUID:
+        event = register_dog(name)
+        self.save(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)
+        self.save(add_trick(dog, Trick(name=trick)))
+
+    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/aggregate7/domainmodel.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from functools import singledispatch
+from typing import Any, Callable, Dict, Iterable, 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
+
+
+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
+
+
+class Dog(Aggregate):
+    name: str
+    tricks: Tuple[Trick, ...]
+
+
+class DogRegistered(DomainEvent):
+    name: str
+
+
+class TrickAdded(DomainEvent):
+    trick: Trick
+
+
+def register_dog(name: str) -> DomainEvent:
+    return DogRegistered(
+        originator_id=uuid4(),
+        originator_version=1,
+        timestamp=create_timestamp(),
+        name=name,
+    )
+
+
+def add_trick(dog: Dog, trick: Trick) -> DomainEvent:
+    return TrickAdded(
+        originator_id=dog.id,
+        originator_version=dog.version + 1,
+        timestamp=create_timestamp(),
+        trick=trick,
+    )
+
+
+@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/aggregate7/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)