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

eventsourcing/examples/aggregate5/domainmodel.py

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

@@ -1,38 +0,0 @@
-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")

eventsourcing/examples/aggregate6/application.py

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

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

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

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

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

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

@@ -1,48 +0,0 @@
-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()