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

eventsourcing/sqlite.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import sqlite3
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal, cast
 from uuid import UUID
 
 from eventsourcing.persistence import (
@@ -213,6 +213,7 @@ class SQLiteDatastore:
         max_age: float | None = None,
         pre_ping: bool = False,
         single_row_tracking: bool = True,
+        originator_id_type: Literal["uuid", "text"] = "uuid",
     ):
         self.pool = SQLiteConnectionPool(
             db_name=db_name,
@@ -224,6 +225,7 @@ class SQLiteDatastore:
             pre_ping=pre_ping,
         )
         self.single_row_tracking = single_row_tracking
+        self.originator_id_type = originator_id_type
 
     @contextmanager
     def transaction(self, *, commit: bool) -> Iterator[SQLiteCursor]:
@@ -268,6 +270,13 @@ class SQLiteRecorder(Recorder):
         for statement in self.create_table_statements:
             c.execute(statement)
 
+    def convert_originator_id(self, originator_id: str) -> UUID | str:
+        return (
+            UUID(originator_id)
+            if self.datastore.originator_id_type == "uuid"
+            else originator_id
+        )
+
 
 class SQLiteAggregateRecorder(SQLiteRecorder, AggregateRecorder):
     def __init__(
@@ -358,7 +367,7 @@ class SQLiteAggregateRecorder(SQLiteRecorder, AggregateRecorder):
             c.execute(statement, params)
             return [
                 StoredEvent(
-                    originator_id=row["originator_id"],
+                    originator_id=self.convert_originator_id(row["originator_id"]),
                     originator_version=row["originator_version"],
                     topic=row["topic"],
                     state=row["state"],
@@ -467,7 +476,7 @@ class SQLiteApplicationRecorder(
             return [
                 Notification(
                     id=row["rowid"],
-                    originator_id=row["originator_id"],
+                    originator_id=self.convert_originator_id(row["originator_id"]),
                     originator_version=row["originator_version"],
                     topic=row["topic"],
                     state=row["state"],
@@ -674,6 +683,7 @@ class SQLiteFactory(InfrastructureFactory[SQLiteTrackingRecorder]):
     SQLITE_DBNAME = "SQLITE_DBNAME"
     SQLITE_LOCK_TIMEOUT = "SQLITE_LOCK_TIMEOUT"
     SQLITE_SINGLE_ROW_TRACKING = "SINGLE_ROW_TRACKING"
+    ORIGINATOR_ID_TYPE = "ORIGINATOR_ID_TYPE"
     CREATE_TABLE = "CREATE_TABLE"
 
     aggregate_recorder_class = SQLiteAggregateRecorder
@@ -713,10 +723,22 @@ class SQLiteFactory(InfrastructureFactory[SQLiteTrackingRecorder]):
             self.env.get(self.SQLITE_SINGLE_ROW_TRACKING, "t")
         )
 
+        originator_id_type = cast(
+            Literal["uuid", "text"],
+            self.env.get(self.ORIGINATOR_ID_TYPE, "uuid"),
+        )
+        if originator_id_type.lower() not in ("uuid", "text"):
+            msg = (
+                f"Invalid {self.ORIGINATOR_ID_TYPE} '{originator_id_type}', "
+                f"must be 'uuid' or 'text'"
+            )
+            raise OSError(msg)
+
         self.datastore = SQLiteDatastore(
             db_name=db_name,
             lock_timeout=lock_timeout,
             single_row_tracking=single_row_tracking,
+            originator_id_type=originator_id_type,
         )
 
     def aggregate_recorder(self, purpose: str = "events") -> AggregateRecorder:

eventsourcing/tests/application.py

@@ -165,6 +165,10 @@ class ApplicationTestCase(TestCase):
 
         self.assertEqual(MyApplication2.name, "MyBoundedContext")
 
+    def test_as_context_manager(self) -> None:
+        with Application[UUID]():
+            pass
+
     def test_resolve_persistence_topics(self) -> None:
         # None specified.
         app = Application[UUID]()
@@ -475,5 +479,5 @@ class ApplicationTestCase(TestCase):
         self.assertEqual(1, len(w))
         self.assertIs(w[-1].category, DeprecationWarning)
         self.assertIn(
-            "'log' is deprecated, use 'notifications' instead", str(w[-1].message)
+            "'log' is deprecated, use 'notification_log' instead", str(w[-1].message)
         )

eventsourcing/tests/persistence.py

@@ -45,9 +45,14 @@ if TYPE_CHECKING:
     from typing_extensions import Never
 
 
-class AggregateRecorderTestCase(TestCase, ABC):
+class RecorderTestCase(TestCase, ABC):
     INITIAL_VERSION = 1
 
+    def new_originator_id(self) -> UUID | str:
+        return uuid4()
+
+
+class AggregateRecorderTestCase(RecorderTestCase, ABC):
     @abstractmethod
     def create_recorder(self) -> AggregateRecorder:
         """"""
@@ -61,7 +66,7 @@ class AggregateRecorderTestCase(TestCase, ABC):
         self.assertEqual(notification_ids, None)
 
         # Select stored events, expect empty list.
-        originator_id1 = uuid4()
+        originator_id1 = self.new_originator_id()
         self.assertEqual(
             recorder.select_events(originator_id1, desc=True, limit=1),
             [],
@@ -79,7 +84,6 @@ class AggregateRecorderTestCase(TestCase, ABC):
 
         # Select stored events, expect list of one.
         stored_events = recorder.select_events(originator_id1)
-        stored_events = convert_stored_event_originator_ids(stored_events)
         self.assertEqual(len(stored_events), 1)
         self.assertEqual(stored_events[0].originator_id, originator_id1)
         self.assertEqual(stored_events[0].originator_version, self.INITIAL_VERSION)
@@ -106,7 +110,6 @@ class AggregateRecorderTestCase(TestCase, ABC):
 
         # Check still only have one record.
         stored_events = recorder.select_events(originator_id1)
-        stored_events = convert_stored_event_originator_ids(stored_events)
         self.assertEqual(len(stored_events), 1)
         self.assertEqual(stored_events[0].originator_id, stored_event1.originator_id)
         self.assertEqual(
@@ -126,7 +129,6 @@ class AggregateRecorderTestCase(TestCase, ABC):
 
         # Check we got what was written.
         stored_events = recorder.select_events(originator_id1)
-        stored_events = convert_stored_event_originator_ids(stored_events)
         self.assertEqual(len(stored_events), 3)
         self.assertEqual(stored_events[0].originator_id, originator_id1)
         self.assertEqual(stored_events[0].originator_version, self.INITIAL_VERSION)
@@ -143,7 +145,6 @@ class AggregateRecorderTestCase(TestCase, ABC):
 
         # Check we can get the last one recorded (used to get last snapshot).
         stored_events = recorder.select_events(originator_id1, desc=True, limit=1)
-        stored_events = convert_stored_event_originator_ids(stored_events)
         self.assertEqual(len(stored_events), 1)
         self.assertEqual(
             stored_events[0],
@@ -154,7 +155,6 @@ class AggregateRecorderTestCase(TestCase, ABC):
         stored_events = recorder.select_events(
             originator_id1, lte=self.INITIAL_VERSION + 1, desc=True, limit=1
         )
-        stored_events = convert_stored_event_originator_ids(stored_events)
         self.assertEqual(len(stored_events), 1)
         self.assertEqual(
             stored_events[0],
@@ -165,7 +165,6 @@ class AggregateRecorderTestCase(TestCase, ABC):
         stored_events = recorder.select_events(
             originator_id1, gt=self.INITIAL_VERSION, lte=self.INITIAL_VERSION + 1
         )
-        stored_events = convert_stored_event_originator_ids(stored_events)
         self.assertEqual(len(stored_events), 1)
         self.assertEqual(
             stored_events[0],
@@ -173,7 +172,7 @@ class AggregateRecorderTestCase(TestCase, ABC):
         )
 
         # Check aggregate sequences are distinguished.
-        originator_id2 = uuid4()
+        originator_id2 = self.new_originator_id()
         self.assertEqual(
             recorder.select_events(originator_id2),
             [],
@@ -188,7 +187,6 @@ class AggregateRecorderTestCase(TestCase, ABC):
         )
         recorder.insert_events([stored_event4])
         stored_events = recorder.select_events(originator_id2)
-        stored_events = convert_stored_event_originator_ids(stored_events)
         self.assertEqual(
             stored_events,
             [stored_event4],
@@ -199,7 +197,7 @@ class AggregateRecorderTestCase(TestCase, ABC):
         recorder = self.create_recorder()
 
         def insert() -> None:
-            originator_id = uuid4()
+            originator_id = self.new_originator_id()
 
             stored_event = StoredEvent(
                 originator_id=originator_id,
@@ -227,41 +225,9 @@ _TApplicationRecorder = TypeVar(
 )
 
 
-def convert_notification_originator_ids(
-    notifications: Sequence[Notification],
-) -> Sequence[Notification]:
-    return [
-        Notification(
-            originator_id=convert_originator_id(n.originator_id),
-            originator_version=n.originator_version,
-            topic=n.topic,
-            state=n.state,
-            id=n.id,
-        )
-        for n in notifications
-    ]
-
-
-def convert_stored_event_originator_ids(
-    stored_events: Sequence[StoredEvent],
-) -> Sequence[StoredEvent]:
-    return [
-        StoredEvent(
-            originator_id=convert_originator_id(s.originator_id),
-            originator_version=s.originator_version,
-            topic=s.topic,
-            state=s.state,
-        )
-        for s in stored_events
-    ]
-
-
-def convert_originator_id(originator_id: UUID | str) -> UUID:
-    return originator_id if isinstance(originator_id, UUID) else UUID(originator_id)
-
-
-class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder]):
-    INITIAL_VERSION = 1
+class ApplicationRecorderTestCase(
+    RecorderTestCase, ABC, Generic[_TApplicationRecorder]
+):
     EXPECT_CONTIGUOUS_NOTIFICATION_IDS = True
 
     @abstractmethod
@@ -282,8 +248,8 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         self.assertIsNone(recorder.max_notification_id())
 
         # Write two stored events.
-        originator_id1 = uuid4()
-        originator_id2 = uuid4()
+        originator_id1 = self.new_originator_id()
+        originator_id2 = self.new_originator_id()
 
         stored_event1 = StoredEvent(
             originator_id=originator_id1,
@@ -324,7 +290,6 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
 
         # sleep(1)  # Added to make eventsourcing-axon tests work.
         notifications = recorder.select_notifications(start=None, limit=10)
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 3)
         self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -340,7 +305,6 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         self.assertEqual(notifications[2].state, b"state3")
 
         notifications = recorder.select_notifications(start=1, limit=10)
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 3)
         self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -356,7 +320,6 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         self.assertEqual(notifications[2].state, b"state3")
 
         notifications = recorder.select_notifications(start=None, stop=2, limit=10)
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 2)
         self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -370,7 +333,6 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         notifications = recorder.select_notifications(
             start=1, limit=10, inclusive_of_start=False
         )
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 2)
         self.assertEqual(notifications[0].id, 2)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -384,7 +346,6 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         notifications = recorder.select_notifications(
             start=2, limit=10, inclusive_of_start=False
         )
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 3)
         self.assertEqual(notifications[0].originator_id, originator_id2)
@@ -394,7 +355,6 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         notifications = recorder.select_notifications(
             start=None, limit=10, topics=["topic1", "topic2", "topic3"]
         )
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 3)
         self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -410,7 +370,6 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         self.assertEqual(notifications[2].state, b"state3")
 
         notifications = recorder.select_notifications(1, 10, topics=["topic1"])
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -418,7 +377,6 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         self.assertEqual(notifications[0].state, b"state1")
 
         notifications = recorder.select_notifications(1, 3, topics=["topic2"])
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 2)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -426,7 +384,6 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         self.assertEqual(notifications[0].state, b"state2")
 
         notifications = recorder.select_notifications(1, 3, topics=["topic3"])
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 3)
         self.assertEqual(notifications[0].originator_id, originator_id2)
@@ -434,7 +391,6 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         self.assertEqual(notifications[0].state, b"state3")
 
         notifications = recorder.select_notifications(1, 3, topics=["topic1", "topic3"])
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 2)
         self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[0].originator_id, originator_id1)
@@ -448,42 +404,34 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
 
         # Check limit is working
         notifications = recorder.select_notifications(None, 1)
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 1)
 
         notifications = recorder.select_notifications(2, 1)
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 2)
 
         notifications = recorder.select_notifications(1, 1, inclusive_of_start=False)
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 2)
 
         notifications = recorder.select_notifications(2, 2)
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 2)
         self.assertEqual(notifications[0].id, 2)
         self.assertEqual(notifications[1].id, 3)
 
         notifications = recorder.select_notifications(3, 1)
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 3)
 
         notifications = recorder.select_notifications(3, 1, inclusive_of_start=False)
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 0)
 
         notifications = recorder.select_notifications(start=2, limit=10, stop=2)
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1)
         self.assertEqual(notifications[0].id, 2)
 
         notifications = recorder.select_notifications(start=1, limit=10, stop=2)
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 2, len(notifications))
         self.assertEqual(notifications[0].id, 1)
         self.assertEqual(notifications[1].id, 2)
@@ -491,10 +439,36 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         notifications = recorder.select_notifications(
             start=1, limit=10, stop=2, inclusive_of_start=False
         )
-        notifications = convert_notification_originator_ids(notifications)
         self.assertEqual(len(notifications), 1, len(notifications))
         self.assertEqual(notifications[0].id, 2)
 
+    def test_performance(self) -> None:
+        # Construct the recorder.
+        recorder = self.create_recorder()
+
+        def insert() -> None:
+            originator_id = self.new_originator_id()
+
+            stored_event = StoredEvent(
+                originator_id=originator_id,
+                originator_version=self.INITIAL_VERSION,
+                topic="topic1",
+                state=b"state1",
+            )
+            recorder.insert_events([stored_event])
+
+        # Warm up.
+        number = 10
+        timeit(insert, number=number)
+
+        number = 100
+        duration = timeit(insert, number=number)
+        print(
+            self,
+            f"\n{1000000 * duration / number:.1f} μs per insert, "
+            f"{number / duration:.0f} inserts per second",
+        )
+
     def test_concurrent_no_conflicts(self) -> None:
         print(self)
 
@@ -525,7 +499,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
             # thread_num = threads[thread_id]
             # count = counts[thread_id]
 
-            originator_id = uuid4()
+            originator_id = self.new_originator_id()
             stored_events = [
                 StoredEvent(
                     originator_id=originator_id,
@@ -612,7 +586,7 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         num_workers = 4
 
         def insert_events() -> None:
-            originator_id = uuid4()
+            originator_id = self.new_originator_id()
             stored_events = [
                 StoredEvent(
                     originator_id=originator_id,
@@ -663,8 +637,8 @@ class ApplicationRecorderTestCase(TestCase, ABC, Generic[_TApplicationRecorder])
         max_notification_id1 = recorder.max_notification_id()
 
         # Write two stored events.
-        originator_id1 = uuid4()
-        originator_id2 = uuid4()
+        originator_id1 = self.new_originator_id()
+        originator_id2 = self.new_originator_id()
 
         stored_event1 = StoredEvent(
             originator_id=originator_id1,
@@ -893,7 +867,7 @@ class TrackingRecorderTestCase(TestCase, ABC):
             tracking_recorder.wait("upstream1", 22, interrupt=interrupt)
 
 
-class ProcessRecorderTestCase(TestCase, ABC):
+class ProcessRecorderTestCase(RecorderTestCase, ABC):
     @abstractmethod
     def create_recorder(self) -> ProcessRecorder:
         """"""
@@ -906,8 +880,8 @@ class ProcessRecorderTestCase(TestCase, ABC):
         self.assertIsNone(recorder.max_tracking_id("upstream_app"))
 
         # Write two stored events.
-        originator_id1 = uuid4()
-        originator_id2 = uuid4()
+        originator_id1 = self.new_originator_id()
+        originator_id2 = self.new_originator_id()
 
         stored_event1 = StoredEvent(
             originator_id=originator_id1,
@@ -1086,7 +1060,7 @@ class ProcessRecorderTestCase(TestCase, ABC):
         notification_ids = iter(range(1, number + 1))
 
         def insert_events() -> None:
-            originator_id = uuid4()
+            originator_id = self.new_originator_id()
 
             stored_event = StoredEvent(
                 originator_id=originator_id,
@@ -1114,7 +1088,7 @@ class ProcessRecorderTestCase(TestCase, ABC):
         )
 
 
-class NonInterleavingNotificationIDsBaseCase(ABC, TestCase):
+class NonInterleavingNotificationIDsBaseCase(RecorderTestCase, ABC):
     insert_num = 1000
 
     def test(self) -> None:
@@ -1124,8 +1098,8 @@ class NonInterleavingNotificationIDsBaseCase(ABC, TestCase):
 
         race_started = Event()
 
-        originator1_id = uuid4()
-        originator2_id = uuid4()
+        originator1_id = self.new_originator_id()
+        originator2_id = self.new_originator_id()
 
         stack1 = self.create_stack(originator1_id)
         stack2 = self.create_stack(originator2_id)
@@ -1159,7 +1133,6 @@ class NonInterleavingNotificationIDsBaseCase(ABC, TestCase):
             limit=2 * self.insert_num,
             inclusive_of_start=False,
         )
-        notifications = convert_notification_originator_ids(notifications)
         ids_for_sequence1 = [
             e.id for e in notifications if e.originator_id == originator1_id
         ]
@@ -1179,7 +1152,7 @@ class NonInterleavingNotificationIDsBaseCase(ABC, TestCase):
         else:
             self.assertGreater(min_id_for_sequence2, max_id_for_sequence1)
 
-    def create_stack(self, originator_id: UUID) -> Sequence[StoredEvent]:
+    def create_stack(self, originator_id: UUID | str) -> Sequence[StoredEvent]:
         return [
             StoredEvent(
                 originator_id=originator_id,

eventsourcing/tests/postgres_utils.py

@@ -3,7 +3,19 @@ import os
 import psycopg
 from psycopg.sql import SQL, Identifier
 
+from eventsourcing.dcb.postgres_tt import (
+    DB_FUNCTION_NAME_DCB_CONDITIONAL_APPEND_TT,
+    DB_TYPE_NAME_DCB_EVENT_TT,
+    DB_TYPE_NAME_DCB_QUERY_ITEM_TT,
+)
 from eventsourcing.postgres import PostgresDatastore
+from examples.coursebookingdcb.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(
@@ -64,8 +76,54 @@ def drop_tables() -> None:
             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}").format(
+                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_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

@@ -35,12 +35,16 @@ def get_topic(obj: SupportsTopic, /) -> str:
     try:
         return _type_cache[obj]
     except KeyError:
-        topic = getattr(obj, "TOPIC", f"{obj.__module__}:{obj.__qualname__}")
+        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.
 
@@ -113,8 +117,8 @@ def register_topic(topic: str, obj: SupportsTopic) -> None:
         else:
             if cached_obj != obj:
                 msg = (
-                    f"Object {cached_obj} is already registered "
-                    f"for topic '{topic}', so refusing to cache obj {obj}"
+                    f"Refusing to cache {obj} (oid {id(obj)}): {cached_obj} (oid "
+                    f"{id(cached_obj)}) is already registered for topic '{topic}'"
                 )
                 raise TopicError(msg)
 

{eventsourcing-9.4.5.dist-info → eventsourcing-9.5.0a0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.3
 Name: eventsourcing
-Version: 9.4.5
+Version: 9.5.0a0
 Summary: Event sourcing in Python
 License: BSD-3-Clause
 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.9.2
-Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research

eventsourcing-9.5.0a0.dist-info/RECORD

@@ -0,0 +1,33 @@
+eventsourcing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/application.py,sha256=MT24nfoakzRhpHJsV0knNz3Z3Dammh9m3MYipzo1gr8,37122
+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=daCNfhFdAj9DE0CJDHMLWo2fwAhDlDA5jJ2Jx2Tz0EQ,1628
+eventsourcing/dcb/application.py,sha256=OlC6H09tGG43Fk9RkeP9rxEiyz_1bSQZbZCXw5cQC6w,3845
+eventsourcing/dcb/domain.py,sha256=vZ3kv_lTTlzVY1kPWAr7OPGGGHntfZtU0vFJLKqp8Ks,14523
+eventsourcing/dcb/persistence.py,sha256=PuBC1LvYH-AWc233qaTTATFMyWFMeTB-CV1GxiEhb1M,4126
+eventsourcing/dcb/popo.py,sha256=0X_9mcC6II1zqYI1gRAqYdQ5hvAcUTtoPPgJ3K8akjk,3145
+eventsourcing/dcb/postgres_tt.py,sha256=Wn4EPnHojmjGRALPSZfz7_1Qgs0mmBquCKcibYkuruQ,19674
+eventsourcing/dispatch.py,sha256=-yI-0EpyXnpMBkciTHNPlxSHJebUe7Ko9rT-gdOjoIo,2797
+eventsourcing/domain.py,sha256=YmI1_Szmefceh1IBfghzQd-A-vkHGDU5yeJj5nHaXns,76301
+eventsourcing/interface.py,sha256=K7tAJjriOJa_XB9-wptJR9VTb5sHlBpqrz3BGUXxI4A,5387
+eventsourcing/persistence.py,sha256=WcOpFo7710MU5xeOrlqYxJWJ1bTaDSrkbhw1gGHAzmY,49509
+eventsourcing/popo.py,sha256=fBPLn6_49kDbfqtFvVPozYfPQfeSl4VhBP38klCUL_A,9203
+eventsourcing/postgres.py,sha256=xj5xMvBG5WW8SKqj26rVTqq7CREfQqrGmS0_GlDx0Aw,53980
+eventsourcing/projection.py,sha256=iSNSRMEJO3W6NspNDZRk68ABkOXkmiNolkA41QYVNXk,14962
+eventsourcing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventsourcing/sqlite.py,sha256=xvgu9euGYalgMoKurCuzBWySEMi3Ga4rGzXmm0XGep8,27949
+eventsourcing/system.py,sha256=JG9JudGCbnSSF9N9UHBYCQT-zUgL2XXw0As3TGsGLDo,45933
+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=Rux3Wq30moBGioUvpa091Mego3o4zCTvpU1DwJi9zg0,62340
+eventsourcing/tests/postgres_utils.py,sha256=Wl7SnPhCctT7bgQesWAlmeyvAeQlm5Vb9MARwhuka74,4562
+eventsourcing/utils.py,sha256=9ZcCyttDqEFu3EMiKq0t04tSY4_PHTsZcuctaBNC9ms,8691
+eventsourcing-9.5.0a0.dist-info/AUTHORS,sha256=8aHOM4UbNZcKlD-cHpFRcM6RWyCqtwtxRev6DeUgVRs,137
+eventsourcing-9.5.0a0.dist-info/LICENSE,sha256=CQEQzcZO8AWXL5i3hIo4yVKrYjh2FBz6hCM7kpXWpw4,1512
+eventsourcing-9.5.0a0.dist-info/METADATA,sha256=psiUPn_VCBGOoDGHWs5ABO-G4eAcYbJvBt9okp2ZMSA,10255
+eventsourcing-9.5.0a0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+eventsourcing-9.5.0a0.dist-info/RECORD,,