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

eventsourcing/examples/aggregate7/domainmodel.py

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

@@ -1,57 +0,0 @@
-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/aggregate7/test_application.py

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

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

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

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

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

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

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