python-event-sourcery 0.4.0a17__tar.gz → 0.4.0a19__tar.gz

{python_event_sourcery-0.4.0a17 → python_event_sourcery-0.4.0a19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: python-event-sourcery
-Version: 0.4.0a17
+Version: 0.4.0a19
 Summary: 
 License: MIT
 Author: Your Name

{python_event_sourcery-0.4.0a17 → python_event_sourcery-0.4.0a19}/event_sourcery/event_store/__init__.py

@@ -2,7 +2,6 @@ __all__ = [
     "DEFAULT_TENANT",
     "NO_VERSIONING",
     "Backend",
-    "BackendFactory",
     "Context",
     "Dispatcher",
     "Entry",
@@ -10,7 +9,7 @@ __all__ = [
     "EventRegistry",
     "EventStore",
     "ExplicitVersioning",
-    "InMemoryBackendFactory",
+    "InMemoryBackend",
     "Listener",
     "Position",
     "RawEvent",
@@ -22,13 +21,14 @@ __all__ = [
     "TransactionalBackend",
     "Versioning",
     "WrappedEvent",
+    "backend",
     "exceptions",
-    "factory",
     "interfaces",
     "subscription",
 ]
 
-from event_sourcery.event_store import exceptions, factory, interfaces, subscription
+from event_sourcery.event_store import backend, exceptions, interfaces, subscription
+from event_sourcery.event_store.backend import Backend, TransactionalBackend
 from event_sourcery.event_store.dispatcher import Dispatcher, Listener
 from event_sourcery.event_store.event import (
     Context,
@@ -42,12 +42,7 @@ from event_sourcery.event_store.event import (
     WrappedEvent,
 )
 from event_sourcery.event_store.event_store import EventStore
-from event_sourcery.event_store.factory import (
-    Backend,
-    BackendFactory,
-    TransactionalBackend,
-)
-from event_sourcery.event_store.in_memory import InMemoryBackendFactory
+from event_sourcery.event_store.in_memory import InMemoryBackend
 from event_sourcery.event_store.stream_id import StreamId, StreamUUID
 from event_sourcery.event_store.tenant_id import DEFAULT_TENANT, TenantId
 from event_sourcery.event_store.versioning import (

python_event_sourcery-0.4.0a19/event_sourcery/event_store/backend.py

@@ -0,0 +1,174 @@
+import abc
+from collections import UserDict
+from collections.abc import Iterator
+from contextlib import AbstractContextManager
+from functools import wraps
+from typing import NoReturn, Protocol, TypeVar, cast
+
+from typing_extensions import Self
+
+from event_sourcery.event_store import subscription
+from event_sourcery.event_store.dispatcher import Dispatcher, Listeners
+from event_sourcery.event_store.event import (
+    Encryption,
+    EventRegistry,
+    NoEncryptionStrategy,
+    NoKeyStorageStrategy,
+    RawEvent,
+    RecordedRaw,
+    Serde,
+)
+from event_sourcery.event_store.event_store import EventStore
+from event_sourcery.event_store.interfaces import (
+    EncryptionKeyStorageStrategy,
+    EncryptionStrategy,
+    OutboxFiltererStrategy,
+    OutboxStorageStrategy,
+    StorageStrategy,
+    SubscriptionStrategy,
+)
+from event_sourcery.event_store.outbox import Outbox
+from event_sourcery.event_store.tenant_id import DEFAULT_TENANT, TenantId
+
+
+class NoProviderConfigured(Exception):
+    pass
+
+
+def no_filter(entry: RawEvent) -> bool:
+    return True
+
+
+class NoOutboxStorageStrategy(OutboxStorageStrategy):
+    def outbox_entries(
+        self, limit: int
+    ) -> Iterator[AbstractContextManager[RecordedRaw]]:
+        return iter([])
+
+
+T_co = TypeVar("T_co", covariant=True)
+T = TypeVar("T")
+
+
+class _Provider(Protocol[T_co]):
+    def __call__(self, container: "_Container") -> T_co: ...
+
+
+def singleton(provider: _Provider[T]) -> _Provider[T]:
+    result: T | None = None
+
+    @wraps(provider)
+    def _wrapper(container: "_Container") -> T:
+        nonlocal result
+        if result is not None:
+            return result
+        result = provider(container)
+        return result
+
+    return _wrapper
+
+
+def not_configured(error_message: str) -> _Provider[T]:
+    def _raise(container: "_Container") -> NoReturn:
+        raise NoProviderConfigured(error_message)  # pragma: no cover
+
+    return _raise
+
+
+class _Container(UserDict[type[T], _Provider[T] | T]):
+    def __getitem__(self, _type: type[T]) -> T:
+        provider = cast(_Provider[T], self.data[_type])
+        return provider(self)
+
+    def __setitem__(self, _type: type[T], value: T | _Provider[T]) -> None:
+        self.data[_type] = (
+            cast(_Provider[T], lambda _: value) if isinstance(value, _type) else value
+        )
+
+    def copy(self) -> Self:
+        new: Self = self.__class__()
+        new.data.update(self.data.copy())
+        return new
+
+
+class Backend(_Container):
+    tenant_id: TenantId
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.tenant_id = DEFAULT_TENANT
+        self[EventRegistry] = lambda _: EventRegistry()
+        self[EncryptionStrategy] = lambda _: NoEncryptionStrategy()
+        self[EncryptionKeyStorageStrategy] = (
+            lambda c: NoKeyStorageStrategy().scoped_for_tenant(c.tenant_id)
+        )
+        self[Encryption] = lambda c: Encryption(
+            registry=c[EventRegistry],
+            strategy=c[EncryptionStrategy],
+            key_storage=c[EncryptionKeyStorageStrategy],
+        )
+        self[Serde] = lambda c: Serde(
+            registry=c[EventRegistry],
+            encryption=c[Encryption],
+        )
+        self[StorageStrategy] = not_configured(
+            "Use one of pyES backends: SQLAlchemy, Django or KurrentDB",
+        )
+        self[EventStore] = lambda c: EventStore(
+            storage_strategy=c[StorageStrategy],
+            serde=c[Serde],
+        )
+        self[Outbox] = lambda c: Outbox(
+            strategy=c[OutboxStorageStrategy],
+            serde=c[Serde],
+        )
+        self[OutboxStorageStrategy] = lambda _: NoOutboxStorageStrategy()
+        self[SubscriptionStrategy] = not_configured(
+            "Use one of pyES backends: SQLAlchemy, Django or KurrentDB",
+        )
+        self[subscription.PositionPhase] = lambda c: subscription.SubscriptionBuilder(
+            c[Serde],
+            c[SubscriptionStrategy],
+        )
+
+    @property
+    def event_store(self) -> EventStore:
+        return cast(EventStore, self[EventStore])
+
+    @property
+    def outbox(self) -> Outbox:
+        return cast(Outbox, self[Outbox])
+
+    @property
+    def subscriber(self) -> subscription.PositionPhase:
+        return cast(subscription.PositionPhase, self[subscription.PositionPhase])
+
+    def in_tenant_mode(self, tenant_id: TenantId) -> Self:
+        in_tenant_mode = self.copy()
+        in_tenant_mode.tenant_id = tenant_id
+        return in_tenant_mode
+
+    @abc.abstractmethod
+    def with_outbox(self, filterer: OutboxFiltererStrategy = no_filter) -> Self: ...
+
+    def with_encryption(
+        self,
+        strategy: EncryptionStrategy,
+        key_storage: EncryptionKeyStorageStrategy,
+    ) -> Self:
+        self[EncryptionStrategy] = strategy
+        self[EncryptionKeyStorageStrategy] = lambda c: key_storage.scoped_for_tenant(
+            c.tenant_id
+        )
+        return self
+
+
+class TransactionalBackend(Backend, abc.ABC):
+    def __init__(self) -> None:
+        super().__init__()
+        self[Listeners] = singleton(lambda _: Listeners())
+        self[Dispatcher] = lambda c: Dispatcher(c[Serde], c[Listeners])
+
+    @property
+    def in_transaction(self) -> Listeners:
+        return cast(Listeners, self[Listeners])

python_event_sourcery-0.4.0a19/event_sourcery/event_store/dispatcher.py

@@ -0,0 +1,64 @@
+from collections.abc import Iterator
+from itertools import chain
+from typing import Protocol
+
+from event_sourcery.event_store.event import (
+    Event,
+    Position,
+    RecordedRaw,
+    Serde,
+    WrappedEvent,
+)
+from event_sourcery.event_store.stream_id import StreamId
+from event_sourcery.event_store.tenant_id import TenantId
+
+
+class Listener(Protocol):
+    def __call__(
+        self,
+        wrapped_event: WrappedEvent,
+        stream_id: StreamId,
+        tenant_id: TenantId,
+        position: Position,
+    ) -> None: ...
+
+
+class Listeners:
+    def __init__(self) -> None:
+        self._listeners: dict[type[Event], set[Listener]] = {}
+
+    def __getitem__(self, event_type: type[Event]) -> Iterator[Listener]:
+        return chain(
+            *(
+                listeners
+                for registered_to, listeners in self._listeners.items()
+                if issubclass(event_type, registered_to)
+            )
+        )
+
+    def register(self, listener: Listener, to: type[Event]) -> None:
+        if to not in self._listeners:
+            self._listeners[to] = set()
+        self._listeners[to].add(listener)
+
+    def remove(self, listener: Listener, to: type[Event]) -> None:
+        if to in self._listeners and listener in self._listeners[to]:
+            self._listeners[to].remove(listener)
+
+
+class Dispatcher:
+    def __init__(self, serde: Serde, listeners: Listeners) -> None:
+        self._serde = serde
+        self._listeners = listeners
+
+    def dispatch(self, *raws: RecordedRaw) -> None:
+        for raw in raws:
+            record = self._serde.deserialize_record(raw)
+            event_type = record.wrapped_event.event.__class__
+            for listener in self._listeners[event_type]:
+                listener(
+                    record.wrapped_event,
+                    record.stream_id,
+                    record.tenant_id,
+                    record.position,
+                )

{python_event_sourcery-0.4.0a17 → python_event_sourcery-0.4.0a19}/event_sourcery/event_store/event/__init__.py

@@ -6,6 +6,8 @@ __all__ = [
     "Entry",
     "Event",
     "EventRegistry",
+    "NoEncryptionStrategy",
+    "NoKeyStorageStrategy",
     "Position",
     "RawEvent",
     "Recorded",
@@ -27,6 +29,10 @@ from event_sourcery.event_store.event._dto import (
     RecordedRaw,
     WrappedEvent,
 )
-from event_sourcery.event_store.event._encryption import Encryption
+from event_sourcery.event_store.event._encryption import (
+    Encryption,
+    NoEncryptionStrategy,
+    NoKeyStorageStrategy,
+)
 from event_sourcery.event_store.event._registry import EventRegistry
 from event_sourcery.event_store.event._serde import Serde

{python_event_sourcery-0.4.0a17 → python_event_sourcery-0.4.0a19}/event_sourcery/event_store/event/_encryption.py

@@ -1,6 +1,6 @@
 import json
 from collections import UserDict
-from dataclasses import dataclass, field, replace
+from dataclasses import dataclass
 from typing import Any
 
 from pydantic import BaseModel
@@ -68,11 +68,9 @@ class Encryption:
       - Processing event encryption/decryption with field annotations
     """
 
-    registry: EventRegistry = field(default_factory=EventRegistry)
-    strategy: EncryptionStrategy = field(default_factory=NoEncryptionStrategy)
-    key_storage: EncryptionKeyStorageStrategy = field(
-        default_factory=NoKeyStorageStrategy
-    )
+    registry: EventRegistry
+    strategy: EncryptionStrategy
+    key_storage: EncryptionKeyStorageStrategy
 
     def encrypt(self, event: BaseModel, stream_id: StreamId) -> dict[str, Any]:
         event_type = type(event)
@@ -111,7 +109,6 @@ class Encryption:
         if key is None:
             return mask_value
         decrypted = self.strategy.decrypt(value, key)
-
         try:
             return json.loads(decrypted)
         except (json.JSONDecodeError, TypeError):
@@ -130,6 +127,3 @@ class Encryption:
 
     def shred(self, subject_id: str) -> None:
         self.key_storage.delete(subject_id)
-
-    def scoped_for_tenant(self, tenant_id: TenantId) -> Self:
-        return replace(self, key_storage=self.key_storage.scoped_for_tenant(tenant_id))

{python_event_sourcery-0.4.0a17 → python_event_sourcery-0.4.0a19}/event_sourcery/event_store/event/_serde.py

@@ -12,20 +12,16 @@ from event_sourcery.event_store.event._dto import (
 from event_sourcery.event_store.event._encryption import Encryption
 from event_sourcery.event_store.event._registry import EventRegistry
 from event_sourcery.event_store.stream_id import StreamId
-from event_sourcery.event_store.tenant_id import TenantId
 
 
 class Serde:
-    registry: EventRegistry
-    encryption: Encryption
-
     def __init__(
         self,
         registry: EventRegistry,
-        encryption: Encryption | None = None,
+        encryption: Encryption,
     ) -> None:
         self.registry = registry
-        self.encryption = encryption or Encryption(registry)
+        self.encryption = encryption
 
     def deserialize(self, event: RawEvent) -> WrappedEvent:
         event_as_dict = dataclasses.asdict(event)
@@ -77,6 +73,3 @@ class Serde:
         self, events: Sequence[WrappedEvent], stream_id: StreamId
     ) -> list[RawEvent]:
         return [self.serialize(event, stream_id) for event in events]
-
-    def scoped_for_tenant(self, tenant_id: TenantId) -> "Serde":
-        return Serde(self.registry, self.encryption.scoped_for_tenant(tenant_id))

{python_event_sourcery-0.4.0a17 → python_event_sourcery-0.4.0a19}/event_sourcery/event_store/event_store.py

@@ -10,7 +10,6 @@ from event_sourcery.event_store.event import (
 )
 from event_sourcery.event_store.interfaces import StorageStrategy
 from event_sourcery.event_store.stream_id import StreamId
-from event_sourcery.event_store.tenant_id import DEFAULT_TENANT, TenantId
 from event_sourcery.event_store.versioning import (
     NO_VERSIONING,
     ExplicitVersioning,
@@ -190,21 +189,3 @@ class EventStore:
 
         """
         return self._storage_strategy.current_position
-
-    def scoped_for_tenant(self, tenant_id: TenantId = DEFAULT_TENANT) -> "EventStore":
-        """Factory method to create a new event store instance scoped to a tenant.
-
-        Examples:
-            >>> event_store.scoped_for_tenant("tenant_1")
-            <EventStore ...>
-
-        Args:
-            tenant_id: The tenant identifier to work with.
-
-        Returns:
-            An event store instance scoped to the tenant.
-        """
-        return EventStore(
-            storage_strategy=self._storage_strategy.scoped_for_tenant(tenant_id),
-            serde=self._serde.scoped_for_tenant(tenant_id),
-        )

{python_event_sourcery-0.4.0a17 → python_event_sourcery-0.4.0a19}/event_sourcery/event_store/in_memory.py

@@ -2,42 +2,33 @@ import time
 from collections.abc import Generator, Iterator
 from contextlib import AbstractContextManager, contextmanager
 from copy import copy
-from dataclasses import dataclass, field, replace
+from dataclasses import dataclass, field
 from datetime import timedelta
 from operator import getitem
 
 from pydantic import BaseModel, ConfigDict, PositiveInt
 from typing_extensions import Self
 
-from event_sourcery.event_store import (
-    Dispatcher,
-    EventRegistry,
-    EventStore,
-    subscription,
+from event_sourcery.event_store import Dispatcher
+from event_sourcery.event_store.backend import (
+    TransactionalBackend,
+    no_filter,
+    not_configured,
+    singleton,
 )
 from event_sourcery.event_store.event import (
-    Encryption,
     Position,
     RawEvent,
     RecordedRaw,
-    Serde,
 )
 from event_sourcery.event_store.exceptions import ConcurrentStreamWriteError
-from event_sourcery.event_store.factory import (
-    BackendFactory,
-    NoOutboxStorageStrategy,
-    TransactionalBackend,
-    no_filter,
-)
 from event_sourcery.event_store.interfaces import (
     EncryptionKeyStorageStrategy,
-    EncryptionStrategy,
     OutboxFiltererStrategy,
     OutboxStorageStrategy,
     StorageStrategy,
     SubscriptionStrategy,
 )
-from event_sourcery.event_store.outbox import Outbox
 from event_sourcery.event_store.stream_id import StreamId
 from event_sourcery.event_store.tenant_id import DEFAULT_TENANT, TenantId
 from event_sourcery.event_store.versioning import NO_VERSIONING, Versioning
@@ -228,13 +219,12 @@ class InMemoryStorageStrategy(StorageStrategy):
         storage: Storage,
         dispatcher: Dispatcher,
         outbox_strategy: InMemoryOutboxStorageStrategy | None,
-        tenant_id: TenantId = DEFAULT_TENANT,
     ) -> None:
         self._names: dict[str | None, str] = {}
         self._storage = storage
         self._dispatcher = dispatcher
         self._outbox = outbox_strategy
-        self._tenant_id = tenant_id
+        self._tenant_id = DEFAULT_TENANT
 
     def fetch_events(
         self,
@@ -300,85 +290,42 @@ class InMemoryStorageStrategy(StorageStrategy):
         return current_position and Position(current_position)
 
     def scoped_for_tenant(self, tenant_id: TenantId) -> Self:
-        return type(self)(
-            storage=self._storage,
-            dispatcher=self._dispatcher,
-            outbox_strategy=self._outbox,
-            tenant_id=tenant_id,
-        )
+        self._tenant_id = tenant_id
+        return self
 
 
 class Config(BaseModel):
     model_config = ConfigDict(extra="forbid", frozen=True)
-
     outbox_attempts: PositiveInt = 3
 
 
-@dataclass(repr=False)
-class InMemoryBackendFactory(BackendFactory):
+class InMemoryBackend(TransactionalBackend):
     """Lightweight in-memory backend factory for testing and development."""
 
-    serde = Serde(EventRegistry())
-
-    _config: Config = field(default_factory=Config)
-    _storage: Storage = field(default_factory=Storage)
-    _outbox_strategy: InMemoryOutboxStorageStrategy | None = None
-    _subscription_strategy: InMemorySubscriptionStrategy = field(init=False)
-
-    def __post_init__(self) -> None:
-        self._subscription_strategy = InMemorySubscriptionStrategy(self._storage)
-
-    def build(self) -> TransactionalBackend:
-        backend = TransactionalBackend()
-        backend.serde = self.serde
-        backend.in_transaction = Dispatcher(backend.serde)
-        backend.event_store = EventStore(
-            InMemoryStorageStrategy(
-                self._storage,
-                backend.in_transaction,
-                self._outbox_strategy,
-            ),
-            backend.serde,
-        )
-        backend.outbox = Outbox(
-            self._outbox_strategy or NoOutboxStorageStrategy(),
-            backend.serde,
-        )
-        backend.subscriber = subscription.SubscriptionBuilder(
-            _serde=backend.serde,
-            _strategy=self._subscription_strategy,
-        )
-        return backend
-
-    def with_event_registry(self, event_registry: EventRegistry) -> Self:
-        self.serde = Serde(event_registry)
+    def __init__(self) -> None:
+        super().__init__()
+        self[Config] = not_configured("Configure backend with `.configure(config)`")
+        self[Storage] = Storage()
+        self[StorageStrategy] = lambda c: InMemoryStorageStrategy(
+            c[Storage],
+            c[Dispatcher],
+            outbox_strategy=c.get(InMemoryOutboxStorageStrategy),
+        ).scoped_for_tenant(c.tenant_id)
+        self[SubscriptionStrategy] = lambda c: InMemorySubscriptionStrategy(c[Storage])
+
+    def configure(self, config: Config | None = None) -> Self:
+        self[Config] = config or Config()
         return self
 
     def with_outbox(self, filterer: OutboxFiltererStrategy = no_filter) -> Self:
-        self._outbox_strategy = InMemoryOutboxStorageStrategy(
-            filterer,
-            self._config.outbox_attempts,
-        )
-        return self
-
-    def without_outbox(self, filterer: OutboxFiltererStrategy = no_filter) -> Self:
-        self._outbox_strategy = None
-        return self
-
-    def with_encryption(
-        self,
-        strategy: EncryptionStrategy,
-        key_storage: EncryptionKeyStorageStrategy,
-    ) -> Self:
-        registry = self.serde.registry
-        self.serde = Serde(
-            registry,
-            encryption=Encryption(
-                registry=registry,
-                strategy=strategy,
-                key_storage=key_storage,
-            ),
+        self[OutboxFiltererStrategy] = filterer
+        self[InMemoryOutboxStorageStrategy] = singleton(
+            lambda c: InMemoryOutboxStorageStrategy(
+                c[OutboxFiltererStrategy],
+                c[Config].outbox_attempts,
+            )
         )
+        self[OutboxStorageStrategy] = lambda c: c[InMemoryOutboxStorageStrategy]
         return self
 
 
@@ -396,5 +343,5 @@ class InMemoryKeyStorage(EncryptionKeyStorageStrategy):
     def delete(self, subject_id: str) -> None:
         self._keys.pop((self._tenant_id, subject_id), None)
 
-    def scoped_for_tenant(self, tenant_id: TenantId) -> Self:
-        return replace(self, _tenant_id=tenant_id)
+    def scoped_for_tenant(self, tenant_id: TenantId) -> "InMemoryKeyStorage":
+        return InMemoryKeyStorage(self._keys, tenant_id)

{python_event_sourcery-0.4.0a17 → python_event_sourcery-0.4.0a19}/event_sourcery/event_store/interfaces.py

@@ -2,7 +2,7 @@ import abc
 from collections.abc import Iterator
 from contextlib import AbstractContextManager
 from datetime import timedelta
-from typing import Any, Protocol
+from typing import Any, Protocol, runtime_checkable
 
 from typing_extensions import Self
 
@@ -12,6 +12,7 @@ from event_sourcery.event_store.tenant_id import TenantId
 from event_sourcery.event_store.versioning import Versioning
 
 
+@runtime_checkable
 class OutboxFiltererStrategy(Protocol):
     def __call__(self, entry: RawEvent) -> bool: ...
 

python_event_sourcery-0.4.0a19/event_sourcery_django/__init__.py

@@ -0,0 +1,61 @@
+__all__ = [
+    "Config",
+    "DjangoBackend",
+]
+
+from datetime import timedelta
+
+from pydantic import BaseModel, ConfigDict, PositiveInt
+from typing_extensions import Self
+
+from event_sourcery.event_store import Dispatcher
+from event_sourcery.event_store.backend import (
+    TransactionalBackend,
+    no_filter,
+    not_configured,
+)
+from event_sourcery.event_store.interfaces import (
+    OutboxFiltererStrategy,
+    OutboxStorageStrategy,
+    StorageStrategy,
+    SubscriptionStrategy,
+)
+
+
+class Config(BaseModel):
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    outbox_attempts: PositiveInt = 3
+    gap_retry_interval: timedelta = timedelta(seconds=0.5)
+
+
+class DjangoBackend(TransactionalBackend):
+    def __init__(self) -> None:
+        from event_sourcery_django.event_store import DjangoStorageStrategy
+        from event_sourcery_django.outbox import DjangoOutboxStorageStrategy
+        from event_sourcery_django.subscription import DjangoSubscriptionStrategy
+
+        super().__init__()
+        self[Config] = not_configured("Configure backend with `.configure(config)`")
+        self[StorageStrategy] = lambda c: DjangoStorageStrategy(
+            c[Dispatcher],
+            c.get(DjangoOutboxStorageStrategy, None),
+        ).scoped_for_tenant(c.tenant_id)
+        self[SubscriptionStrategy] = lambda c: DjangoSubscriptionStrategy(
+            gap_retry_interval=c[Config].gap_retry_interval
+        )
+
+    def configure(self, config: Config | None = None) -> Self:
+        self[Config] = config or Config()
+        return self
+
+    def with_outbox(self, filterer: OutboxFiltererStrategy = no_filter) -> Self:
+        from event_sourcery_django.outbox import DjangoOutboxStorageStrategy
+
+        self[OutboxFiltererStrategy] = filterer
+        self[DjangoOutboxStorageStrategy] = lambda c: DjangoOutboxStorageStrategy(
+            c[OutboxFiltererStrategy],
+            c[Config].outbox_attempts,
+        )
+        self[OutboxStorageStrategy] = lambda c: c[DjangoOutboxStorageStrategy]
+        return self