eventsourcing 9.5.0b3__py3-none-any.whl

eventsourcing/tests/postgres_utils.py

@@ -0,0 +1,131 @@
+import os
+
+import psycopg
+from psycopg.sql import SQL, Identifier
+
+from eventsourcing.dcb.postgres_tt import (
+    DB_FUNCTION_NAME_DCB_CONDITIONAL_APPEND_TT,
+    DB_FUNCTION_NAME_DCB_UNCONDITIONAL_APPEND_TT,
+    DB_TYPE_NAME_DCB_EVENT_TT,
+    DB_TYPE_NAME_DCB_QUERY_ITEM_TT,
+)
+from eventsourcing.postgres import PostgresDatastore
+from examples.dcb_enrolment_with_basic_objects.postgres_ts import (
+    PG_FUNCTION_NAME_DCB_CHECK_APPEND_CONDITION_TS,
+    PG_FUNCTION_NAME_DCB_INSERT_EVENTS_TS,
+    PG_FUNCTION_NAME_DCB_SELECT_EVENTS_TS,
+    PG_PROCEDURE_NAME_DCB_APPEND_EVENTS_TS,
+    PG_TYPE_NAME_DCB_EVENT_TS,
+)
+
+
+def pg_close_all_connections(
+    name: str = "eventsourcing",
+    host: str = "127.0.0.1",
+    port: str = "5432",
+    user: str = "postgres",
+    password: str = "postgres",  # noqa: S107
+) -> None:
+    try:
+        # For local development... probably.
+        pg_conn = psycopg.connect(
+            dbname=name,
+            host=host,
+            port=port,
+        )
+    except psycopg.Error:
+        # For GitHub actions.
+        """CREATE ROLE postgres LOGIN SUPERUSER PASSWORD 'postgres';"""
+        pg_conn = psycopg.connect(
+            dbname=name,
+            host=host,
+            port=port,
+            user=user,
+            password=password,
+        )
+    close_all_connections = """
+    SELECT
+        pg_terminate_backend(pid)
+    FROM
+        pg_stat_activity
+    WHERE
+        -- don't kill my own connection!
+        pid <> pg_backend_pid();
+
+    """
+    pg_conn_cursor = pg_conn.cursor()
+    pg_conn_cursor.execute(close_all_connections)
+
+
+def drop_tables() -> None:
+
+    for schema in ["public", "myschema"]:
+        datastore = PostgresDatastore(
+            dbname=os.environ.get("POSTGRES_DBNAME", "eventsourcing"),
+            host=os.environ.get("POSTGRES_HOST", "127.0.0.1"),
+            port=os.environ.get("POSTGRES_PORT", "5432"),
+            user=os.environ.get("POSTGRES_USER", "eventsourcing"),
+            password=os.environ.get("POSTGRES_PASSWORD", "eventsourcing"),
+            schema=schema,
+        )
+        with datastore.transaction(commit=True) as curs:
+            select_table_names = SQL(
+                "SELECT table_name FROM information_schema.tables "
+                "WHERE table_schema = %s"
+            )
+            fetchall = curs.execute(select_table_names, (datastore.schema,)).fetchall()
+            for row in fetchall:
+                table_name = row["table_name"]
+                # print(f"Dropping table '{table_name}' in schema '{schema}'")
+                statement = SQL("DROP TABLE IF EXISTS {0}.{1} CASCADE").format(
+                    Identifier(datastore.schema), Identifier(table_name)
+                )
+                curs.execute(statement, prepare=False)
+                # print(f"Dropped table '{table_name}' in schema '{schema}'")
+
+            # Also drop composite types.
+            composite_types = [
+                "stored_event_uuid",
+                "stored_event_text",
+                PG_TYPE_NAME_DCB_EVENT_TS,
+                DB_TYPE_NAME_DCB_EVENT_TT,
+                DB_TYPE_NAME_DCB_QUERY_ITEM_TT,
+            ]
+            for name in composite_types:
+                statement = SQL("DROP TYPE IF EXISTS {schema}.{name} CASCADE").format(
+                    schema=Identifier(datastore.schema),
+                    name=Identifier(name),
+                )
+                curs.execute(statement, prepare=False)
+
+            # Also drop functions.
+            functions = [
+                "es_insert_events_uuid",
+                "es_insert_events_text",
+                PG_FUNCTION_NAME_DCB_INSERT_EVENTS_TS,
+                PG_FUNCTION_NAME_DCB_SELECT_EVENTS_TS,
+                PG_FUNCTION_NAME_DCB_CHECK_APPEND_CONDITION_TS,
+                DB_FUNCTION_NAME_DCB_UNCONDITIONAL_APPEND_TT,
+                DB_FUNCTION_NAME_DCB_CONDITIONAL_APPEND_TT,
+            ]
+            for name in functions:
+                statement = SQL(
+                    "DROP FUNCTION IF EXISTS {schema}.{name} CASCADE"
+                ).format(
+                    schema=Identifier(datastore.schema),
+                    name=Identifier(name),
+                )
+                curs.execute(statement, prepare=False)
+
+            # Also drop procedures.
+            procedures = [
+                PG_PROCEDURE_NAME_DCB_APPEND_EVENTS_TS,
+            ]
+            for name in procedures:
+                statement = SQL(
+                    "DROP PROCEDURE IF EXISTS {schema}.{name} CASCADE"
+                ).format(
+                    schema=Identifier(datastore.schema),
+                    name=Identifier(name),
+                )
+                curs.execute(statement, prepare=False)

eventsourcing/utils.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+import importlib
+from collections.abc import Callable, Iterator, Mapping
+from functools import wraps
+from inspect import isfunction
+from random import random
+from threading import Lock
+from time import sleep
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, TypeVar, no_type_check, overload
+
+if TYPE_CHECKING:
+    from types import FunctionType, WrapperDescriptorType
+
+
+class TopicError(Exception):
+    """Raised when topic doesn't resolve."""
+
+
+SupportsTopic = type | Callable[..., Any] | ModuleType
+
+_type_cache: dict[SupportsTopic, str] = {}
+_topic_cache: dict[str, SupportsTopic] = {}
+_topic_cache_lock = Lock()
+
+
+def get_topic(obj: SupportsTopic, /) -> str:
+    """Returns a "topic string" that locates the given class
+    in its module. The string is formed by joining the
+    module name and the class qualname separated by the
+    colon character.
+    """
+    try:
+        return _type_cache[obj]
+    except KeyError:
+        topic = construct_topic(obj)
+        register_topic(topic, obj)
+        _type_cache[obj] = topic
+        return topic
+
+
+def construct_topic(obj: SupportsTopic, /) -> str:
+    return getattr(obj, "TOPIC", f"{obj.__module__}:{obj.__qualname__}")
+
+
+def resolve_topic(topic: str) -> Any:
+    """Returns an object located by the given topic.
+
+    This function can be (is) used to locate domain
+    event classes and aggregate classes from the
+    topics in stored events and snapshots. It can
+    also be used to locate compression modules,
+    timezone objects, etc.
+    """
+    try:
+        obj = _topic_cache[topic]
+    except KeyError:
+        module_name, _, attr_name = topic.partition(":")
+
+        attr_name_parts = attr_name.split(".")
+        for i in range(len(attr_name_parts) - 1, 0, -1):
+            part_name = ".".join(attr_name_parts[:i])
+            try:
+                obj = _topic_cache[f"{module_name}:{part_name}"]
+            except KeyError:
+                continue
+            else:
+                attr_name = ".".join(attr_name_parts[i:])
+                break
+
+        else:
+            try:
+                obj = _topic_cache[module_name]
+            except KeyError:
+                module_name_parts = module_name.split(".")
+                for i in range(len(module_name_parts) - 1, 0, -1):
+                    part_name = ".".join(module_name_parts[:i])
+                    try:
+                        obj = _topic_cache[f"{part_name}"]
+                    except KeyError:
+                        continue
+                    else:
+                        module_name = ".".join([obj.__name__, *module_name_parts[i:]])
+                        break
+                try:
+                    obj = importlib.import_module(module_name)
+                except ImportError as e:
+                    msg = f"Failed to resolve topic '{topic}': {e}"
+                    raise TopicError(msg) from e
+        if attr_name:
+            try:
+                for attr_name_part in attr_name.split("."):
+                    obj = getattr(obj, attr_name_part)
+            except AttributeError as e:
+                msg = f"Failed to resolve topic '{topic}': {e}"
+                raise TopicError(msg) from e
+        register_topic(topic, obj)
+    return obj
+
+
+def register_topic(topic: str, obj: SupportsTopic) -> None:
+    """Registers a topic with an object, so the object will be
+    returned whenever the topic is resolved.
+
+    This function can be used to cache the topic of a class, so
+    that the topic can be resolved faster. It can also be used to
+    register old topics for objects that have been renamed or moved,
+    so that old topics will resolve to the renamed or moved object.
+    """
+    with _topic_cache_lock:
+        try:
+            cached_obj = _topic_cache[topic]
+        except KeyError:
+            _topic_cache[topic] = obj
+        else:
+            if cached_obj != obj:
+                msg = (
+                    f"Refusing to cache {obj} (oid {id(obj)}): {cached_obj} (oid "
+                    f"{id(cached_obj)}) is already registered for topic '{topic}'"
+                )
+                raise TopicError(msg)
+
+
+def clear_topic_cache() -> None:
+    _topic_cache.clear()
+
+
+def retry(
+    exc: type[Exception] | tuple[type[Exception], ...] = Exception,
+    max_attempts: int = 1,
+    wait: float = 0,
+    stall: float = 0,
+) -> Callable[[Any], Any]:
+    """Retry decorator.
+
+    :param exc: List of exceptions that will cause the call to be retried if raised.
+    :param max_attempts: Maximum number of attempts to try.
+    :param wait: Amount of time to wait before retrying after an exception.
+    :param stall: Amount of time to wait before the first attempt.
+    :return: Returns the value returned by decorated function.
+    """
+
+    @no_type_check
+    def _retry(func: Callable) -> Callable:
+        @wraps(func)
+        def retry_decorator(*args: Any, **kwargs: Any) -> Any:
+            if stall:
+                sleep(stall)
+            attempts = 0
+            while True:
+                try:
+                    return func(*args, **kwargs)
+                except exc:  # noqa: PERF203
+                    attempts += 1
+                    if max_attempts is None or attempts < max_attempts:
+                        sleep(wait * (1 + 0.1 * (random() - 0.5)))  # noqa: S311
+                    else:
+                        # Max retries exceeded.
+                        raise
+
+        return retry_decorator
+
+    # If using decorator in bare form, the decorated
+    # function is the first arg, so check 'exc'.
+    if isfunction(exc):
+        # Remember the given function.
+        _func = exc
+        # Set 'exc' to a sensible exception class for _retry().
+        exc = Exception
+        # Wrap and return.
+        return _retry(func=_func)
+    # Check decorator args, and return _retry,
+    # to be called with the decorated function.
+    if isinstance(exc, (list, tuple)):
+        for _exc in exc:
+            if not (isinstance(_exc, type) and issubclass(_exc, Exception)):
+                msg = f"not an exception class: {_exc}"
+                raise TypeError(msg)
+    elif not (isinstance(exc, type) and issubclass(exc, Exception)):
+        msg = f"not an exception class: {exc}"
+        raise TypeError(msg)
+    if not isinstance(max_attempts, int):
+        msg = f"'max_attempts' must be an int: {max_attempts}"
+        raise TypeError(msg)
+    if not isinstance(wait, (float, int)):
+        msg = f"'wait' must be a float: {max_attempts}"
+        raise TypeError(msg)
+    if not isinstance(stall, (float, int)):
+        msg = f"'stall' must be a float: {max_attempts}"
+        raise TypeError(msg)
+    return _retry
+
+
+def strtobool(val: str) -> bool:
+    """Convert a string representation of truth to True or False.
+
+    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
+    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
+    'val' is anything else.
+    """
+    if not isinstance(val, str):
+        msg = f"{val} is not a str"
+        raise TypeError(msg)
+    val = val.lower()
+    if val in ("y", "yes", "t", "true", "on", "1"):
+        return True
+    if val in ("n", "no", "f", "false", "off", "0"):
+        return False
+    msg = f"invalid truth value {val!r}"
+    raise ValueError(msg)
+
+
+def reversed_keys(d: dict[Any, Any]) -> Iterator[Any]:
+    return reversed(d.keys())
+
+
+# TODO: Inline this now.
+def get_method_name(
+    method: Callable[..., Any] | FunctionType | WrapperDescriptorType,
+) -> str:
+    return method.__qualname__
+
+
+EnvType = Mapping[str, str]
+T = TypeVar("T")
+
+
+class Environment(dict[str, str]):
+    def __init__(self, name: str = "", env: EnvType | None = None):
+        super().__init__(env or {})
+        self.name = name
+
+    @overload  # type: ignore[override]
+    def get(self, __key: str, /) -> str | None: ...  # pragma: no cover
+
+    @overload
+    def get(self, __key: str, /, __default: str) -> str: ...  # pragma: no cover
+
+    @overload
+    def get(self, __key: str, /, __default: T) -> str | T: ...  # pragma: no cover
+
+    def get(  # pyright: ignore [reportIncompatibleMethodOverride]
+        self, __key: str, /, __default: str | T | None = None
+    ) -> str | T | None:
+        for _key in self.create_keys(__key):
+            value = super().get(_key, None)
+            if value is not None:
+                return value
+        return __default
+
+    def create_keys(self, key: str) -> list[str]:
+        keys = []
+        if self.name:
+            keys.append(self.name.upper() + "_" + key)
+        keys.append(key)
+        return keys

eventsourcing-9.5.0b3.dist-info/METADATA

@@ -0,0 +1,253 @@
+Metadata-Version: 2.4
+Name: eventsourcing
+Version: 9.5.0b3
+Summary: Event sourcing in Python
+License-Expression: BSD-3-Clause
+License-File: AUTHORS
+License-File: LICENSE
+Keywords: event sourcing,event store,domain driven design,domain-driven design,ddd,cqrs,cqs
+Author: John Bywater
+Author-email: john.bywater@appropriatesoftware.net
+Requires-Python: >=3.10.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Provides-Extra: crypto
+Provides-Extra: cryptography
+Provides-Extra: postgres
+Requires-Dist: cryptography (>=44.0) ; extra == "cryptography"
+Requires-Dist: psycopg[pool] (>=3.2) ; extra == "postgres"
+Requires-Dist: pycryptodome (>=3.22) ; extra == "crypto"
+Requires-Dist: typing_extensions
+Project-URL: Documentation, https://eventsourcing.readthedocs.io/
+Project-URL: Homepage, https://github.com/pyeventsourcing/eventsourcing
+Project-URL: Repository, https://github.com/pyeventsourcing/eventsourcing
+Description-Content-Type: text/markdown
+
+[![Build Status](https://github.com/pyeventsourcing/eventsourcing/actions/workflows/runtests.yaml/badge.svg?branch=9.5)](https://github.com/pyeventsourcing/eventsourcing)
+[![Coverage Status](https://coveralls.io/repos/github/pyeventsourcing/eventsourcing/badge.svg?branch=main)](https://coveralls.io/github/pyeventsourcing/eventsourcing?branch=main)
+[![Documentation Status](https://readthedocs.org/projects/eventsourcing/badge/?version=stable)](https://eventsourcing.readthedocs.io/en/stable/)
+[![Latest Release](https://badge.fury.io/py/eventsourcing.svg)](https://pypi.org/project/eventsourcing/)
+[![Downloads](https://static.pepy.tech/personalized-badge/eventsourcing?period=total&units=international_system&left_color=grey&right_color=brightgreen&left_text=downloads)](https://pypistats.org/packages/eventsourcing)
+[![Code Style: Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+
+# Event Sourcing in Python
+
+This project is a comprehensive Python library for implementing event sourcing, a design pattern where all
+changes to application state are stored as a sequence of events. This library provides a solid foundation
+for building event-sourced applications in Python, with a focus on reliability, performance, and developer
+experience. Please [read the docs](https://eventsourcing.readthedocs.io/). See also [extension projects](https://github.com/pyeventsourcing).
+
+*"totally amazing and a pleasure to use"*
+
+*"very clean and intuitive"*
+
+*"a huge help and time saver"*
+
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/pyeventsourcing/eventsourcing)
+
+
+## Installation
+
+Use pip to install the [stable distribution](https://pypi.org/project/eventsourcing/)
+from the Python Package Index.
+
+    $ pip install eventsourcing
+
+Please note, it is recommended to install Python
+packages into a Python virtual environment.
+
+
+## Synopsis
+
+Define aggregates with the `Aggregate` class and the `@event` decorator.
+
+```python
+from eventsourcing.domain import Aggregate, event
+
+class Dog(Aggregate):
+    @event('Registered')
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.tricks: list[str] = []
+
+    @event('TrickAdded')
+    def add_trick(self, trick: str) -> None:
+        self.tricks.append(trick)
+```
+
+Define application objects with the `Application` class.
+
+```python
+from typing import Any
+from uuid import UUID
+
+from eventsourcing.application import Application
+
+
+class DogSchool(Application[UUID]):
+    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)
+        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(dog.tricks)}
+```
+
+Write a test.
+
+```python
+def test_dog_school() -> 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)
+    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
+```
+
+Run the test with the default persistence module. Events are stored
+in memory using Python objects.
+
+```python
+test_dog_school()
+```
+
+Configure the application to run with an SQLite database. Other persistence modules are available.
+
+```python
+import os
+
+os.environ["PERSISTENCE_MODULE"] = 'eventsourcing.sqlite'
+os.environ["SQLITE_DBNAME"] = ':memory:'
+```
+
+Run the test with SQLite.
+
+```python
+test_dog_school()
+```
+
+See the [documentation](https://eventsourcing.readthedocs.io/) for more information.
+
+
+## Features
+
+**Flexible event store** — flexible persistence of domain events. Combines
+an event mapper and an event recorder in ways that can be easily extended.
+Mapper uses a transcoder that can be easily substituted or extended to support
+custom model object types. Recorders supporting different databases can be easily
+substituted and configured with environment variables.
+
+**Domain models and applications** — base classes for event-sourced domain models
+and applications. Suggests how to structure an event-sourced application. This
+library supports event-sourced aggregates and dynamic consistency boundaries.
+
+**Application-level encryption and compression** — encrypts and decrypts events inside the
+application. This means data will be encrypted in transit across a network ("on the wire")
+and at disk level including backups ("at rest"), which is a legal requirement in some
+jurisdictions when dealing with personally identifiable information (PII) for example
+the EU's GDPR. Compression reduces the size of stored domain events and snapshots, usually
+by around 25% to 50% of the original size. Compression reduces the size of data
+in the database and decreases transit time across a network.
+
+**Snapshotting** — reduces access-time for aggregates with many domain events.
+
+**Versioning** - allows domain model changes to be introduced after an application
+has been deployed. Both domain events and aggregate classes can be versioned.
+The recorded state of an older version can be upcast to be compatible with a new
+version. Stored events and snapshots are upcast from older versions
+to new versions before the event or aggregate object is reconstructed.
+
+**Optimistic concurrency control** — ensures a distributed or horizontally scaled
+application doesn't become inconsistent due to concurrent method execution. Leverages
+optimistic concurrency controls in adapted database management systems.
+
+**Notifications and projections** — reliable propagation of application
+events with pull-based notifications allows the application state to be
+projected accurately into replicas, indexes, view models, and other applications.
+Supports materialised views and CQRS.
+
+**Event-driven systems** — reliable event processing. Event-driven systems
+can be defined independently of particular persistence infrastructure and mode of
+running.
+
+**Detailed documentation** — documentation provides general overview, introduction
+of concepts, explanation of usage, and detailed descriptions of library classes.
+All code is annotated with type hints.
+
+**Worked examples** — includes examples showing how to develop aggregates, applications
+and systems.
+
+
+
+## Extensions
+
+The GitHub organisation
+[Event Sourcing in Python](https://github.com/pyeventsourcing)
+hosts extension projects for the Python eventsourcing library.
+There are projects that adapt popular ORMs such as
+[Django](https://github.com/pyeventsourcing/eventsourcing-django#readme)
+and [SQLAlchemy](https://github.com/pyeventsourcing/eventsourcing-sqlalchemy#readme).
+There are projects that adapt specialist event stores such as
+[Axon Server](https://github.com/pyeventsourcing/eventsourcing-axonserver#readme) and
+[KurrentDB](https://github.com/pyeventsourcing/eventsourcing-kurrentdb#readme).
+There are projects that support popular NoSQL databases such as
+[DynamoDB](https://github.com/pyeventsourcing/eventsourcing-dynamodb#readme).
+There are also projects that provide examples of using the
+library with web frameworks such as
+[FastAPI](https://github.com/pyeventsourcing/example-fastapi#readme)
+and [Flask](https://github.com/pyeventsourcing/example-flask#readme),
+and for serving applications and running systems with efficient
+inter-process communication technologies like [gRPC](https://github.com/pyeventsourcing/eventsourcing-grpc#readme).
+And there are examples of event-sourced applications and systems
+of event-sourced applications, such as the
+[Paxos system](https://github.com/pyeventsourcing/example-paxos#readme),
+which is used as the basis for a
+[replicated state machine](https://github.com/pyeventsourcing/example-paxos/tree/master/replicatedstatemachine),
+which is used as the basis for a
+[distributed key-value store](https://github.com/pyeventsourcing/example-paxos/tree/master/keyvaluestore).
+
+## Project
+
+This project is [hosted on GitHub](https://github.com/pyeventsourcing/eventsourcing).
+
+Please register questions, requests and
+[issues on GitHub](https://github.com/pyeventsourcing/eventsourcing/issues),
+or post in the project's Slack channel.
+
+There is a [Slack channel](https://join.slack.com/t/eventsourcinginpython/shared_invite/zt-3hogb36o-LCvKd4Rz8JMALoLSl_pQ8g)
+for this project, which you are [welcome to join](https://join.slack.com/t/eventsourcinginpython/shared_invite/zt-3hogb36o-LCvKd4Rz8JMALoLSl_pQ8g).
+
+Please refer to the [documentation](https://eventsourcing.readthedocs.io/) for installation and usage guides.
+
+

eventsourcing-9.5.0b3.dist-info/RECORD

@@ -0,0 +1,35 @@
+eventsourcing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/application.py,sha256=OjzmDs0SbNRRUVs4Um2qmfiD6jD0QA-jZx66c7tixu4,37321
+eventsourcing/cipher.py,sha256=ulTBtX5K9ejRAkdUaUbdIaj4H7anYwDOi7JxOolj2uo,3295
+eventsourcing/compressor.py,sha256=qEYWvsUXFLyhKgfuv-HGNJ6VF4sRw4z0IxbNW9ukOfc,385
+eventsourcing/cryptography.py,sha256=aFZLlJxxSb5seVbh94-T8FA_RIGOe-VFu5SJrbOnwUU,2969
+eventsourcing/dcb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/dcb/api.py,sha256=2h9KzUi1NWZjq7y2DHz_wRYUIv7NzibyJdsd2iTk5P8,4153
+eventsourcing/dcb/application.py,sha256=-2CG1ph1nHRGbwrlXnNikz4898YVCmkXS8gi5yqIn4Y,5089
+eventsourcing/dcb/domain.py,sha256=YrXAnDfQSrtraq8Je0QNM5rtnb8teon3iJFZJCJmZgA,12250
+eventsourcing/dcb/msgpack.py,sha256=a6AZgou_TvlSSzUqIS5bYCSFxPyOrP24FJhevrib4C0,1097
+eventsourcing/dcb/persistence.py,sha256=EScPVFi0xPtbxwykyeXOx1NA0KgUYOmel-z0BHhCvEg,6116
+eventsourcing/dcb/popo.py,sha256=4mXl2m2gbs6uLjgLRGmBh0YzAP_FwDmZ11-NkLhXSjE,5678
+eventsourcing/dcb/postgres_tt.py,sha256=pmAQKLydTFQTi6QIc_Frqko9SjoTCgZvs68WufKHB-Y,23036
+eventsourcing/dcb/tests.py,sha256=QGBwWHWpzeeUHZHjzpBXZrJ0EBRX4ldRJ8oe7Llt_pc,24698
+eventsourcing/dispatch.py,sha256=A36Oj0zs28lk2E08p2M2QMEkj4PUECAs60OeEQziTf4,2828
+eventsourcing/domain.py,sha256=WuGpjXhDYH1l2yuJgZYQ1lmzrz7LAeraGW3VkkVy2iw,75999
+eventsourcing/interface.py,sha256=K7tAJjriOJa_XB9-wptJR9VTb5sHlBpqrz3BGUXxI4A,5387
+eventsourcing/persistence.py,sha256=PKLBVnXASLgOcRd5vKMsiOpnkmeHDmXHwPNSSLRQCcI,50057
+eventsourcing/popo.py,sha256=fBPLn6_49kDbfqtFvVPozYfPQfeSl4VhBP38klCUL_A,9203
+eventsourcing/postgres.py,sha256=7NjIrrP5g46zfbeP-zB4vyxFqcWgQ6pHaNPix8cUB74,56277
+eventsourcing/projection.py,sha256=SFek7kw2op0Zg3bchZV9xSRQT-OnssT2TFN8TgmRSSU,18718
+eventsourcing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/sqlite.py,sha256=xvgu9euGYalgMoKurCuzBWySEMi3Ga4rGzXmm0XGep8,27949
+eventsourcing/system.py,sha256=_jAYtB7gkDx3Kdm0we2AJJHQR5JLPYtA7loOrS7mDHY,45907
+eventsourcing/tests/__init__.py,sha256=FtOyuj-L-oSisYeByTIrnUw-XzsctSbq76XmjPy5fMc,102
+eventsourcing/tests/application.py,sha256=pE2tYfuykbV4Q6WW1U-gi_YgyW2485NGLXkemaH46Do,18072
+eventsourcing/tests/domain.py,sha256=yN-F6gMRumeX6nIXIcZGxAR3RrUslzmEMM8JksnkI8Q,3227
+eventsourcing/tests/persistence.py,sha256=jsS2JUo5U8gG5POdWGfuTDiQzhd8OoroWpt8QzpID1o,62942
+eventsourcing/tests/postgres_utils.py,sha256=hKW7xd3yzOHl7W5Q4-1YAecoLRS7QaYr8zBOrUFWfVA,4690
+eventsourcing/utils.py,sha256=tR4qVXHvgq0fJuS_1x_ULahdePrQPvg8wSEtmEVaRy0,8586
+eventsourcing-9.5.0b3.dist-info/METADATA,sha256=AhS14onZ5jHiWf-l7DtdLdKNj0NnOlDXMvYQ4tnLbGM,10564
+eventsourcing-9.5.0b3.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+eventsourcing-9.5.0b3.dist-info/licenses/AUTHORS,sha256=8aHOM4UbNZcKlD-cHpFRcM6RWyCqtwtxRev6DeUgVRs,137
+eventsourcing-9.5.0b3.dist-info/licenses/LICENSE,sha256=CQEQzcZO8AWXL5i3hIo4yVKrYjh2FBz6hCM7kpXWpw4,1512
+eventsourcing-9.5.0b3.dist-info/RECORD,,

eventsourcing-9.5.0b3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any