eventsourcing 9.3.3__py3-none-any.whl → 9.3.5__py3-none-any.whl

eventsourcing/examples/aggregate8/application.py

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

@@ -1,71 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime
-from typing import Any, List
-from uuid import UUID
-
-from pydantic import BaseModel, ConfigDict, TypeAdapter
-
-from eventsourcing.domain import (
-    Aggregate as BaseAggregate,
-    CanInitAggregate,
-    CanMutateAggregate,
-    CanSnapshotAggregate,
-    event,
-)
-
-
-class DomainEvent(BaseModel):
-    model_config = ConfigDict(frozen=True, extra="forbid")
-
-    originator_id: UUID
-    originator_version: int
-    timestamp: datetime
-
-
-datetime_adapter = TypeAdapter(datetime)
-
-
-class SnapshotState(BaseModel):
-    model_config = ConfigDict(frozen=True, extra="allow")
-
-    def __init__(self, **kwargs: Any) -> None:
-        for key in ["_created_on", "_modified_on"]:
-            kwargs[key] = datetime_adapter.validate_python(kwargs[key])
-        super().__init__(**kwargs)
-
-
-class AggregateSnapshot(DomainEvent, CanSnapshotAggregate):
-    topic: str
-    state: SnapshotState
-
-
-class Aggregate(BaseAggregate):
-    class Event(DomainEvent, CanMutateAggregate):
-        pass
-
-    class Created(Event, CanInitAggregate):
-        originator_topic: str
-
-
-class Trick(BaseModel):
-    name: str
-
-
-class DogSnapshotState(SnapshotState):
-    name: str
-    tricks: List[Trick]
-
-
-class Dog(Aggregate):
-    class Snapshot(AggregateSnapshot):
-        state: DogSnapshotState
-
-    @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

@@ -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/aggregate8/test_application.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime
-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"))
-        self.assertIsInstance(dog["created_on"], datetime)
-        self.assertIsInstance(dog["modified_on"], datetime)
-
-        # 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"))
-        self.assertIsInstance(dog["created_on"], datetime)
-        self.assertIsInstance(dog["modified_on"], datetime)
-
-        # 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"))
-        self.assertIsInstance(dog["created_on"], datetime)
-        self.assertIsInstance(dog["modified_on"], datetime)

eventsourcing/examples/aggregate8/test_compression_and_encryption.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-from unittest import TestCase
-
-from eventsourcing.cipher import AESCipher
-from eventsourcing.examples.aggregate8.application import DogSchool
-
-
-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"
-        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/aggregate8/test_snapshotting_intervals.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, ClassVar, Dict, Type
-from unittest import TestCase
-
-from eventsourcing.examples.aggregate8.application import DogSchool
-from eventsourcing.examples.aggregate8.domainmodel import Dog
-
-if TYPE_CHECKING:  # pragma: nocover
-    from eventsourcing.domain import MutableOrImmutableAggregate
-
-
-class SubDogSchool(DogSchool):
-    snapshotting_intervals: ClassVar[
-        Dict[Type[MutableOrImmutableAggregate], int] | None
-    ] = {Dog: 1}
-
-
-class TestDogSchool(TestCase):
-    def test_dog_school(self) -> None:
-        # Construct application object.
-        school = SubDogSchool()
-
-        # Evolve application state.
-        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/bankaccounts/application.py

@@ -1,70 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from eventsourcing.application import AggregateNotFoundError, Application
-from eventsourcing.examples.bankaccounts.domainmodel import BankAccount
-
-if TYPE_CHECKING:  # pragma: nocover
-    from decimal import Decimal
-    from uuid import UUID
-
-
-class BankAccounts(Application):
-    def open_account(self, full_name: str, email_address: str) -> UUID:
-        account = BankAccount(
-            full_name=full_name,
-            email_address=email_address,
-        )
-        self.save(account)
-        return account.id
-
-    def get_account(self, account_id: UUID) -> BankAccount:
-        try:
-            return self.repository.get(account_id)
-        except AggregateNotFoundError:
-            raise AccountNotFoundError(account_id) from None
-
-    def get_balance(self, account_id: UUID) -> Decimal:
-        account = self.get_account(account_id)
-        return account.balance
-
-    def deposit_funds(self, credit_account_id: UUID, amount: Decimal) -> None:
-        account = self.get_account(credit_account_id)
-        account.credit(amount)
-        self.save(account)
-
-    def withdraw_funds(self, debit_account_id: UUID, amount: Decimal) -> None:
-        account = self.get_account(debit_account_id)
-        account.debit(amount)
-        self.save(account)
-
-    def transfer_funds(
-        self,
-        debit_account_id: UUID,
-        credit_account_id: UUID,
-        amount: Decimal,
-    ) -> None:
-        debit_account = self.get_account(debit_account_id)
-        credit_account = self.get_account(credit_account_id)
-        debit_account.debit(amount)
-        credit_account.credit(amount)
-        self.save(debit_account, credit_account)
-
-    def set_overdraft_limit(self, account_id: UUID, overdraft_limit: Decimal) -> None:
-        account = self.get_account(account_id)
-        account.set_overdraft_limit(overdraft_limit)
-        self.save(account)
-
-    def get_overdraft_limit(self, account_id: UUID) -> Decimal:
-        account = self.get_account(account_id)
-        return account.overdraft_limit
-
-    def close_account(self, account_id: UUID) -> None:
-        account = self.get_account(account_id)
-        account.close()
-        self.save(account)
-
-
-class AccountNotFoundError(Exception):
-    pass

eventsourcing/examples/bankaccounts/domainmodel.py

@@ -1,56 +0,0 @@
-from __future__ import annotations
-
-from decimal import Decimal
-
-from eventsourcing.domain import Aggregate, event
-
-
-class BankAccount(Aggregate):
-    @event("Opened")
-    def __init__(self, full_name: str, email_address: str):
-        self.full_name = full_name
-        self.email_address = email_address
-        self.balance = Decimal("0.00")
-        self.overdraft_limit = Decimal("0.00")
-        self.is_closed = False
-
-    @event("Credited")
-    def credit(self, amount: Decimal) -> None:
-        self.check_account_is_not_closed()
-        self.balance += amount
-
-    @event("Debited")
-    def debit(self, amount: Decimal) -> None:
-        self.check_account_is_not_closed()
-        self.check_has_sufficient_funds(amount)
-        self.balance -= amount
-
-    @event("OverdraftLimitSet")
-    def set_overdraft_limit(self, overdraft_limit: Decimal) -> None:
-        assert overdraft_limit > Decimal("0.00")
-        self.check_account_is_not_closed()
-        self.overdraft_limit = overdraft_limit
-
-    @event("Closed")
-    def close(self) -> None:
-        self.is_closed = True
-
-    def check_account_is_not_closed(self) -> None:
-        if self.is_closed:
-            raise AccountClosedError({"account_id": self.id})
-
-    def check_has_sufficient_funds(self, amount: Decimal) -> None:
-        if self.balance - amount < -self.overdraft_limit:
-            raise InsufficientFundsError({"account_id": self.id})
-
-
-class TransactionError(Exception):
-    pass
-
-
-class AccountClosedError(TransactionError):
-    pass
-
-
-class InsufficientFundsError(TransactionError):
-    pass

eventsourcing/examples/bankaccounts/test.py

@@ -1,173 +0,0 @@
-from __future__ import annotations
-
-import unittest
-from decimal import Decimal
-from uuid import uuid4
-
-from eventsourcing.examples.bankaccounts.application import (
-    AccountNotFoundError,
-    BankAccounts,
-)
-from eventsourcing.examples.bankaccounts.domainmodel import (
-    AccountClosedError,
-    InsufficientFundsError,
-)
-
-
-class TestBankAccounts(unittest.TestCase):
-    def test(self) -> None:
-        app = BankAccounts()
-
-        # Check account not found error.
-        with self.assertRaises(AccountNotFoundError):
-            app.get_balance(uuid4())
-
-        # Create account #1.
-        account_id1 = app.open_account(
-            full_name="Alice",
-            email_address="alice@example.com",
-        )
-
-        # Check balance of account #1.
-        self.assertEqual(app.get_balance(account_id1), Decimal("0.00"))
-
-        # Deposit funds in account #1.
-        app.deposit_funds(
-            credit_account_id=account_id1,
-            amount=Decimal("200.00"),
-        )
-
-        # Check balance of account #1.
-        self.assertEqual(app.get_balance(account_id1), Decimal("200.00"))
-
-        # Withdraw funds from account #1.
-        app.withdraw_funds(
-            debit_account_id=account_id1,
-            amount=Decimal("50.00"),
-        )
-
-        # Check balance of account #1.
-        self.assertEqual(app.get_balance(account_id1), Decimal("150.00"))
-
-        # Fail to withdraw funds from account #1- insufficient funds.
-        with self.assertRaises(InsufficientFundsError):
-            app.withdraw_funds(
-                debit_account_id=account_id1,
-                amount=Decimal("151.00"),
-            )
-
-        # Check balance of account #1 - should be unchanged.
-        self.assertEqual(app.get_balance(account_id1), Decimal("150.00"))
-
-        # Create account #2.
-        account_id2 = app.open_account(
-            full_name="Bob",
-            email_address="bob@example.com",
-        )
-
-        # Transfer funds from account #1 to account #2.
-        app.transfer_funds(
-            debit_account_id=account_id1,
-            credit_account_id=account_id2,
-            amount=Decimal("100.00"),
-        )
-
-        # Check balances.
-        self.assertEqual(app.get_balance(account_id1), Decimal("50.00"))
-        self.assertEqual(app.get_balance(account_id2), Decimal("100.00"))
-
-        # Fail to transfer funds - insufficient funds.
-        with self.assertRaises(InsufficientFundsError):
-            app.transfer_funds(
-                debit_account_id=account_id1,
-                credit_account_id=account_id2,
-                amount=Decimal("1000.00"),
-            )
-
-        # Check balances - should be unchanged.
-        self.assertEqual(app.get_balance(account_id1), Decimal("50.00"))
-        self.assertEqual(app.get_balance(account_id2), Decimal("100.00"))
-
-        # Close account #1.
-        app.close_account(account_id1)
-
-        # Fail to transfer funds - account #1 is closed.
-        with self.assertRaises(AccountClosedError):
-            app.transfer_funds(
-                debit_account_id=account_id1,
-                credit_account_id=account_id2,
-                amount=Decimal("50.00"),
-            )
-
-        # Fail to withdraw funds - account #1 is closed.
-        with self.assertRaises(AccountClosedError):
-            app.withdraw_funds(
-                debit_account_id=account_id1,
-                amount=Decimal("1.00"),
-            )
-
-        # Fail to deposit funds - account #1 is closed.
-        with self.assertRaises(AccountClosedError):
-            app.deposit_funds(
-                credit_account_id=account_id1,
-                amount=Decimal("1000.00"),
-            )
-
-        # Fail to set overdraft limit on account #1 - account is closed.
-        with self.assertRaises(AccountClosedError):
-            app.set_overdraft_limit(
-                account_id=account_id1,
-                overdraft_limit=Decimal("500.00"),
-            )
-
-        # Check balances - should be unchanged.
-        self.assertEqual(app.get_balance(account_id1), Decimal("50.00"))
-        self.assertEqual(app.get_balance(account_id2), Decimal("100.00"))
-
-        # Check overdraft limits - should be unchanged.
-        self.assertEqual(
-            app.get_overdraft_limit(account_id1),
-            Decimal("0.00"),
-        )
-        self.assertEqual(
-            app.get_overdraft_limit(account_id2),
-            Decimal("0.00"),
-        )
-
-        # Set overdraft limit on account #2.
-        app.set_overdraft_limit(
-            account_id=account_id2,
-            overdraft_limit=Decimal("500.00"),
-        )
-
-        # Can't set negative overdraft limit.
-        with self.assertRaises(AssertionError):
-            app.set_overdraft_limit(
-                account_id=account_id2,
-                overdraft_limit=Decimal("-500.00"),
-            )
-
-        # Check overdraft limit of account #2.
-        self.assertEqual(
-            app.get_overdraft_limit(account_id2),
-            Decimal("500.00"),
-        )
-
-        # Withdraw funds from account #2.
-        app.withdraw_funds(
-            debit_account_id=account_id2,
-            amount=Decimal("500.00"),
-        )
-
-        # Check balance of account #2 - should be overdrawn.
-        self.assertEqual(
-            app.get_balance(account_id2),
-            Decimal("-400.00"),
-        )
-
-        # Fail to withdraw funds from account #2 - insufficient funds.
-        with self.assertRaises(InsufficientFundsError):
-            app.withdraw_funds(
-                debit_account_id=account_id2,
-                amount=Decimal("101.00"),
-            )