eventsourcing 9.5.0b3__py3-none-any.whl

eventsourcing/cipher.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import os
+from base64 import b64decode, b64encode
+from typing import TYPE_CHECKING
+
+from Crypto.Cipher import AES
+from Crypto.Cipher._mode_gcm import (
+    GcmMode,  # pyright: ignore [reportPrivateImportUsage]
+)
+from Crypto.Cipher.AES import key_size
+
+from eventsourcing.persistence import Cipher
+
+if TYPE_CHECKING:
+    from eventsourcing.utils import Environment
+
+
+class AESCipher(Cipher):
+    """Cipher strategy that uses AES cipher (in GCM mode)
+    from the Python pycryptodome package.
+    """
+
+    CIPHER_KEY = "CIPHER_KEY"
+    KEY_SIZES = key_size
+
+    @staticmethod
+    def create_key(num_bytes: int) -> str:
+        """Creates AES cipher key, with length num_bytes.
+
+        :param num_bytes: An int value, either 16, 24, or 32.
+
+        """
+        AESCipher.check_key_size(num_bytes)
+        return b64encode(AESCipher.random_bytes(num_bytes)).decode("utf8")
+
+    @staticmethod
+    def check_key_size(num_bytes: int) -> None:
+        if num_bytes not in AESCipher.KEY_SIZES:
+            msg = f"Invalid key size: {num_bytes} not in {AESCipher.KEY_SIZES}"
+            raise ValueError(msg)
+
+    @staticmethod
+    def random_bytes(num_bytes: int) -> bytes:
+        return os.urandom(num_bytes)
+
+    def __init__(self, environment: Environment):
+        """Initialises AES cipher with ``cipher_key``.
+
+        :param str cipher_key: 16, 24, or 32 bytes encoded as base64
+        """
+        cipher_key = environment.get(self.CIPHER_KEY)
+        if not cipher_key:
+            msg = f"'{self.CIPHER_KEY}' not in env"
+            raise OSError(msg)
+        key = b64decode(cipher_key.encode("utf8"))
+        AESCipher.check_key_size(len(key))
+        self.key = key
+
+    def encrypt(self, plaintext: bytes) -> bytes:
+        """Return ciphertext for given plaintext."""
+        # Construct AES-GCM cipher, with 96-bit nonce.
+        nonce = AESCipher.random_bytes(12)
+        cipher = self.construct_cipher(nonce)
+
+        # Encrypt and digest.
+        result = cipher.encrypt_and_digest(plaintext)
+        encrypted = result[0]
+        tag = result[1]
+
+        # Return ciphertext.
+        return nonce + tag + encrypted
+        # return nonce + tag + encrypted
+
+    def construct_cipher(self, nonce: bytes) -> GcmMode:
+        cipher = AES.new(
+            self.key,
+            AES.MODE_GCM,
+            nonce,
+        )
+        assert isinstance(cipher, GcmMode)
+        return cipher
+
+    def decrypt(self, ciphertext: bytes) -> bytes:
+        """Return plaintext for given ciphertext."""
+        # Split out the nonce, tag, and encrypted data.
+        nonce = ciphertext[:12]
+        if len(nonce) != 12:
+            msg = "Damaged cipher text: invalid nonce length"
+            raise ValueError(msg)
+
+        tag = ciphertext[12:28]
+        if len(tag) != 16:
+            msg = "Damaged cipher text: invalid tag length"
+            raise ValueError(msg)
+        encrypted = ciphertext[28:]
+
+        # Construct AES cipher, with old nonce.
+        cipher = self.construct_cipher(nonce)
+
+        # Decrypt and verify.
+        try:
+            plaintext = cipher.decrypt_and_verify(encrypted, tag)
+        except ValueError as e:
+            msg = f"Cipher text is damaged: {e}"
+            raise ValueError(msg) from None
+        return plaintext

eventsourcing/compressor.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import zlib
+
+from eventsourcing.persistence import Compressor
+
+
+class ZlibCompressor(Compressor):
+    def compress(self, data: bytes) -> bytes:
+        """Compress bytes using zlib."""
+        return zlib.compress(data)
+
+    def decompress(self, data: bytes) -> bytes:
+        """Decompress bytes using zlib."""
+        return zlib.decompress(data)

eventsourcing/cryptography.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import os
+from base64 import b64decode, b64encode
+from typing import TYPE_CHECKING
+
+from cryptography.exceptions import InvalidTag
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+from eventsourcing.persistence import Cipher
+
+if TYPE_CHECKING:
+    from eventsourcing.utils import Environment
+
+
+class AESCipher(Cipher):
+    """Cipher strategy that uses AES cipher (in GCM mode)
+    from the Python cryptography package.
+    """
+
+    CIPHER_KEY = "CIPHER_KEY"
+    KEY_SIZES = (16, 24, 32)
+
+    @staticmethod
+    def create_key(num_bytes: int) -> str:
+        """Creates AES cipher key, with length num_bytes.
+
+        :param num_bytes: An int value, either 16, 24, or 32.
+
+        """
+        AESCipher.check_key_size(num_bytes)
+        key = AESGCM.generate_key(num_bytes * 8)
+        return b64encode(key).decode("utf8")
+
+    @staticmethod
+    def check_key_size(num_bytes: int) -> None:
+        if num_bytes not in AESCipher.KEY_SIZES:
+            msg = f"Invalid key size: {num_bytes} not in {AESCipher.KEY_SIZES}"
+            raise ValueError(msg)
+
+    @staticmethod
+    def random_bytes(num_bytes: int) -> bytes:
+        return os.urandom(num_bytes)
+
+    def __init__(self, environment: Environment):
+        """Initialises AES cipher with ``cipher_key``.
+
+        :param str cipher_key: 16, 24, or 32 bytes encoded as base64
+        """
+        cipher_key = environment.get(self.CIPHER_KEY)
+        if not cipher_key:
+            msg = f"'{self.CIPHER_KEY}' not in env"
+            raise OSError(msg)
+        key = b64decode(cipher_key.encode("utf8"))
+        AESCipher.check_key_size(len(key))
+        self.key = key
+
+    def encrypt(self, plaintext: bytes) -> bytes:
+        """Return ciphertext for given plaintext."""
+        # Construct AES-GCM cipher, with 96-bit nonce.
+        aesgcm = AESGCM(self.key)
+        nonce = AESCipher.random_bytes(12)
+        res = aesgcm.encrypt(nonce, plaintext, None)
+        # Put tag at the front for compatibility with eventsourcing.crypto.AESCipher.
+        tag = res[-16:]
+        encrypted = res[:-16]
+        return nonce + tag + encrypted
+
+    def decrypt(self, ciphertext: bytes) -> bytes:
+        """Return plaintext for given ciphertext."""
+        # Split out the nonce, tag, and encrypted data.
+        nonce = ciphertext[:12]
+        if len(nonce) != 12:
+            msg = "Damaged cipher text: invalid nonce length"
+            raise ValueError(msg)
+
+        # Expect tag at the front.
+        tag = ciphertext[12:28]
+        if len(tag) != 16:
+            msg = "Damaged cipher text: invalid tag length"
+            raise ValueError(msg)
+        encrypted = ciphertext[28:]
+
+        aesgcm = AESGCM(self.key)
+        try:
+            plaintext = aesgcm.decrypt(nonce, encrypted + tag, None)
+        except InvalidTag as e:
+            msg = "Invalid cipher tag"
+            raise ValueError(msg) from e
+        # Decrypt and verify.
+        return plaintext

eventsourcing/dcb/api.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
+
+from eventsourcing.persistence import ProgrammingError
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from typing_extensions import Self
+
+
+@dataclass
+class DCBQueryItem:
+    types: list[str] = field(default_factory=list)
+    tags: list[str] = field(default_factory=list)
+
+
+@dataclass
+class DCBQuery:
+    items: list[DCBQueryItem] = field(default_factory=list)
+
+
+@dataclass
+class DCBAppendCondition:
+    fail_if_events_match: DCBQuery = field(default_factory=DCBQuery)
+    after: int | None = None
+
+
+@dataclass
+class DCBEvent:
+    type: str
+    data: bytes
+    tags: list[str] = field(default_factory=list)
+
+
+@dataclass
+class DCBSequencedEvent:
+    event: DCBEvent
+    position: int
+
+
+class DCBReadResponse(Iterator[DCBSequencedEvent], ABC):
+    @property
+    @abstractmethod
+    def head(self) -> int | None:
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def __next__(self) -> DCBSequencedEvent:
+        pass  # pragma: no cover
+
+    # @abstractmethod
+    # def next_batch(self) -> list[DCBSequencedEvent]:
+    #     """
+    #     Returns a batch of events as a list.
+    #     Updates the head position similar to __next__.
+    #     """
+
+
+class DCBRecorder(ABC):
+    @abstractmethod
+    def read(
+        self,
+        query: DCBQuery | None = None,
+        *,
+        after: int | None = None,
+        limit: int | None = None,
+    ) -> DCBReadResponse:
+        """
+        Returns all events, unless 'after' is given then only those with position
+        greater than 'after', and unless any query items are given, then only those
+        that match at least one query item. An event matches a query item if its type
+        is in the item types or there are no item types, and if all the item tags are
+        in the event tags.
+        """
+
+    @abstractmethod
+    def append(
+        self, events: Sequence[DCBEvent], condition: DCBAppendCondition | None = None
+    ) -> int:
+        """
+        Appends given events to the event store, unless the condition fails.
+        """
+
+    @abstractmethod
+    def subscribe(
+        self,
+        query: DCBQuery | None = None,
+        *,
+        after: int | None = None,
+    ) -> DCBSubscription[Self]:
+        """
+        Returns all events, unless 'after' is given then only those with position
+        greater than 'after', and unless any query items are given, then only those
+        that match at least one query item. An event matches a query item if its type
+        is in the item types or there are no item types, and if all the item tags are
+        in the event tags. The subscription will block when the last recorded event
+        is received, and then continue when new events are recorded.
+        """
+
+
+TDCBRecorder_co = TypeVar("TDCBRecorder_co", bound=DCBRecorder, covariant=True)
+
+
+class DCBSubscription(Iterator[DCBSequencedEvent], Generic[TDCBRecorder_co]):
+    def __init__(
+        self,
+        recorder: TDCBRecorder_co,
+        query: DCBQuery | None = None,
+        after: int | None = None,
+    ) -> None:
+        self._recorder = recorder
+        self._query = query
+        self._has_been_entered = False
+        self._has_been_stopped = False
+        self._last_position: int = after or 0
+
+    def __enter__(self) -> Self:
+        if self._has_been_entered:
+            msg = "Already entered subscription context manager"
+            raise ProgrammingError(msg)
+        self._has_been_entered = True
+        return self
+
+    def __exit__(self, *args: object, **kwargs: Any) -> None:
+        if not self._has_been_entered:
+            msg = "Not already entered subscription context manager"
+            raise ProgrammingError(msg)
+        self.stop()
+
+    def stop(self) -> None:
+        """Stops the subscription."""
+        self._has_been_stopped = True
+
+    def __iter__(self) -> Self:
+        return self
+
+    @abstractmethod
+    def __next__(self) -> DCBSequencedEvent:
+        """Returns the next DCBEvent in the sequence."""

eventsourcing/dcb/application.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Any, Generic, cast
+
+from eventsourcing.dcb.domain import (
+    EnduringObject,
+    InitialDecision,
+    Perspective,
+    Selector,
+    TDecision,
+    TGroup,
+    TPerspective,
+    TSlice,
+)
+from eventsourcing.dcb.persistence import (
+    DCBEventStore,
+    DCBInfrastructureFactory,
+    DCBMapper,
+    NotFoundError,
+)
+from eventsourcing.utils import Environment, EnvType, resolve_topic
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+    from types import TracebackType
+
+    from typing_extensions import Self
+
+
+class DCBApplication:
+    name = "DCBApplication"
+    env: Mapping[str, str] = {"PERSISTENCE_MODULE": "eventsourcing.dcb.popo"}
+
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        if "name" not in cls.__dict__:
+            cls.name = cls.__name__
+
+    def __init__(self, env: EnvType | None = None):
+        self.env = self.construct_env(self.name, env)
+        self.factory = DCBInfrastructureFactory.construct(self.env)
+        self.recorder = self.factory.dcb_recorder()
+        if "MAPPER_TOPIC" in self.env:
+            # Only need a mapper, event store, and repository
+            # if we are using the higher-level abstractions.
+            self.mapper = cast(
+                DCBMapper[Any], resolve_topic(self.env["MAPPER_TOPIC"])()
+            )
+            assert isinstance(self.mapper, DCBMapper)
+            self.events = DCBEventStore(self.mapper, self.recorder)
+            self.repository = DCBRepository(self.events)
+
+    def construct_env(self, name: str, env: EnvType | None = None) -> Environment:
+        """Constructs environment from which application will be configured."""
+        _env = dict(type(self).env)
+        _env.update(os.environ)
+        if env is not None:
+            _env.update(env)
+        return Environment(name, _env)
+
+    def do(self, s: TSlice) -> TSlice:
+        """
+        Advances and executes a slice, then saves new decisions.
+        """
+        if type(s).do_projection:
+            s = self.repository.advance(s)
+        s.execute()
+        if s.new_decisions:
+            self.repository.save(s)
+        return s
+
+    def close(self) -> None:
+        self.factory.close()
+
+    def __enter__(self) -> Self:
+        self.factory.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self.close()
+        self.factory.__exit__(exc_type, exc_val, exc_tb)
+
+
+class DCBRepository(Generic[TDecision]):
+    def __init__(self, eventstore: DCBEventStore[TDecision]):
+        self.eventstore = eventstore
+
+    def save(self, p: Perspective[TDecision]) -> int:
+        return self.eventstore.append(
+            events=p.collect_events(),
+            cb=p.consistency_boundary(),
+            after=p.last_known_position,
+        )
+
+    def get(
+        self,
+        enduring_object_id: str,
+    ) -> EnduringObject[TDecision]:
+        cb = [Selector(tags=[enduring_object_id])]
+        events = self.eventstore.read(*cb)
+        obj: EnduringObject[TDecision] | None = None
+        for event in events:
+            obj = event.decision.mutate(obj)
+        if obj is None:
+            raise NotFoundError
+        obj.last_known_position = events.head
+        return obj
+
+    def get_many(
+        self,
+        *enduring_object_ids: str,
+    ) -> list[EnduringObject[TDecision] | None]:
+        cb = [
+            Selector(tags=[enduring_object_id])
+            for enduring_object_id in enduring_object_ids
+        ]
+        tagged_decisions = self.eventstore.read(cb)
+        objs: dict[str, EnduringObject[TDecision] | None] = dict.fromkeys(
+            enduring_object_ids
+        )
+        for tagged in tagged_decisions:
+            for tag in tagged.tags:
+                obj = objs.get(tag)
+                if not isinstance(tagged.decision, InitialDecision) and not obj:
+                    continue
+                obj = tagged.decision.mutate(obj)
+                objs[tag] = obj
+        for obj in objs.values():
+            if obj is not None:
+                obj.last_known_position = tagged_decisions.head
+        return list(objs.values())
+
+    def get_group(self, cls: type[TGroup], *enduring_object_ids: str) -> TGroup:
+        enduring_objects = self.get_many(*enduring_object_ids)
+        perspective = cls(*enduring_objects)
+        last_known_positions = [
+            o.last_known_position
+            for o in enduring_objects
+            if o and o.last_known_position
+        ]
+        perspective.last_known_position = (
+            max(last_known_positions) if last_known_positions else None
+        )
+        return perspective
+
+    def advance(self, p: TPerspective) -> TPerspective:
+        events = self.eventstore.read(
+            cb=p.consistency_boundary(),
+            after=p.last_known_position,
+        )
+        for event in events:
+            event.decision.mutate(p)
+        p.last_known_position = events.head
+        return p