eventsourcing 9.4.5__py3-none-any.whl → 9.5.0a0__py3-none-any.whl

eventsourcing/dcb/persistence.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Literal, TypeVar, overload
+
+from eventsourcing.dcb.api import (
+    DCBAppendCondition,
+    DCBEvent,
+    DCBQuery,
+    DCBQueryItem,
+    DCBRecorder,
+)
+from eventsourcing.dcb.domain import (
+    CanMutateEnduringObject,
+    Group,
+    Selector,
+)
+from eventsourcing.persistence import InfrastructureFactory, TTrackingRecorder
+from eventsourcing.utils import get_topic
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+TGroup = TypeVar("TGroup", bound=Group)
+
+
+class DCBMapper(ABC):
+    @abstractmethod
+    def to_dcb_event(self, event: CanMutateEnduringObject) -> DCBEvent:
+        raise NotImplementedError  # pragma: no cover
+
+    @abstractmethod
+    def to_domain_event(self, event: DCBEvent) -> CanMutateEnduringObject:
+        raise NotImplementedError  # pragma: no cover
+
+
+class DCBEventStore:
+    def __init__(self, mapper: DCBMapper, recorder: DCBRecorder):
+        self.mapper = mapper
+        self.recorder = recorder
+
+    def put(
+        self,
+        *events: CanMutateEnduringObject,
+        cb: Selector | Sequence[Selector] | None = None,
+        after: int | None = None,
+    ) -> int:
+        if not cb and not after:
+            condition = None
+        else:
+            query = self._cb_to_dcb_query(cb)
+            condition = DCBAppendCondition(
+                fail_if_events_match=query,
+                after=after,
+            )
+        return self.recorder.append(
+            events=[self.mapper.to_dcb_event(e) for e in events],
+            condition=condition,
+        )
+
+    @overload
+    def get(
+        self,
+        cb: Selector | Sequence[Selector] | None = None,
+        *,
+        after: int | None = None,
+    ) -> Sequence[CanMutateEnduringObject]:
+        pass  # pragma: no cover
+
+    @overload
+    def get(
+        self,
+        cb: Selector | Sequence[Selector] | None = None,
+        *,
+        with_last_position: Literal[True],
+        after: int | None = None,
+    ) -> tuple[Sequence[CanMutateEnduringObject], int | None]:
+        pass  # pragma: no cover
+
+    @overload
+    def get(
+        self,
+        cb: Selector | Sequence[Selector] | None = None,
+        *,
+        with_positions: Literal[True],
+        after: int | None = None,
+    ) -> Sequence[tuple[CanMutateEnduringObject, int]]:
+        pass  # pragma: no cover
+
+    def get(
+        self,
+        cb: Selector | Sequence[Selector] | None = None,
+        *,
+        after: int | None = None,
+        with_positions: bool = False,
+        with_last_position: bool = False,
+    ) -> (
+        Sequence[tuple[CanMutateEnduringObject, int]]
+        | tuple[Sequence[CanMutateEnduringObject], int | None]
+        | Sequence[CanMutateEnduringObject]
+    ):
+        query = self._cb_to_dcb_query(cb)
+        dcb_sequenced_events, head = self.recorder.read(
+            query=query,
+            after=after,
+        )
+        if not (with_positions or with_last_position):
+            return tuple(
+                self.mapper.to_domain_event(s.event) for s in dcb_sequenced_events
+            )
+        if with_last_position:
+            return (
+                tuple(
+                    [self.mapper.to_domain_event(s.event) for s in dcb_sequenced_events]
+                ),
+                head,
+            )
+        return tuple(
+            (self.mapper.to_domain_event(s.event), s.position)
+            for s in dcb_sequenced_events
+        )
+
+    @staticmethod
+    def _cb_to_dcb_query(
+        cb: Selector | Sequence[Selector] | None = None,
+    ) -> DCBQuery:
+        cb = [cb] if isinstance(cb, Selector) else cb or []
+        return DCBQuery(
+            items=[
+                DCBQueryItem(
+                    types=[get_topic(t) for t in s.types],
+                    tags=list(s.tags),
+                )
+                for s in cb
+            ]
+        )
+
+
+class NotFoundError(Exception):
+    pass
+
+
+class DCBInfrastructureFactory(InfrastructureFactory[TTrackingRecorder], ABC):
+    @abstractmethod
+    def dcb_event_store(self) -> DCBRecorder:
+        pass  # pragma: no cover

eventsourcing/dcb/popo.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import TYPE_CHECKING
+
+from eventsourcing.dcb.api import (
+    DCBAppendCondition,
+    DCBEvent,
+    DCBQuery,
+    DCBRecorder,
+    DCBSequencedEvent,
+)
+from eventsourcing.dcb.persistence import DCBInfrastructureFactory
+from eventsourcing.persistence import IntegrityError, ProgrammingError
+from eventsourcing.popo import POPOFactory, POPORecorder, POPOTrackingRecorder
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
+
+
+class InMemoryDCBRecorder(DCBRecorder, POPORecorder):
+    def __init__(self) -> None:
+        super().__init__()
+        self.events: list[DCBSequencedEvent] = []
+        self.position_sequence = self._position_sequence_generator()
+
+    def read(
+        self,
+        query: DCBQuery | None = None,
+        *,
+        after: int | None = None,
+        limit: int | None = None,
+    ) -> tuple[Sequence[DCBSequencedEvent], int | None]:
+        query = query or DCBQuery()
+        with self._database_lock:
+            events_generator = (
+                event
+                for event in self.events
+                if (after is None or event.position > after)
+                and (
+                    not query.items
+                    or any(
+                        (not item.types or event.event.type in item.types)
+                        and (set(event.event.tags) >= set(item.tags))
+                        for item in query.items
+                    )
+                )
+            )
+
+            events = []
+            for i, event in enumerate(events_generator):
+                if limit is not None and i >= limit:
+                    break
+                events.append(deepcopy(event))
+            if limit is None:
+                head = self.events[-1].position if self.events else None
+            else:
+                head = events[-1].position if events else None
+            return events, head
+
+    def append(
+        self, events: Sequence[DCBEvent], condition: DCBAppendCondition | None = None
+    ) -> int:
+        if len(events) == 0:
+            msg = "Should be at least one event. Avoid this elsewhere"
+            raise ProgrammingError(msg)
+        with self._database_lock:
+            if condition is not None:
+                matched, head = self.read(
+                    query=condition.fail_if_events_match,
+                    after=condition.after,
+                    limit=1,
+                )
+                if matched:
+                    raise IntegrityError(condition)
+            self.events.extend(
+                DCBSequencedEvent(
+                    position=next(self.position_sequence),
+                    event=deepcopy(event),
+                )
+                for event in events
+            )
+            return self.events[-1].position
+
+    def _position_sequence_generator(self) -> Iterator[int]:
+        position = 1
+        while True:
+            yield position
+            position += 1
+
+
+class InMemoryDCBFactory(POPOFactory, DCBInfrastructureFactory[POPOTrackingRecorder]):
+
+    def dcb_event_store(self) -> DCBRecorder:
+        return InMemoryDCBRecorder()