eventsourcing 9.3.0__py3-none-any.whl → 9.3.0a1__py3-none-any.whl

eventsourcing/examples/searchabletimestamps/test_searchabletimestamps.py

@@ -76,19 +76,16 @@ class WithPostgreSQL(SearchableTimestampsTestCase):
         super().tearDown()
 
     def drop_tables(self) -> None:
-        with PostgresDatastore(
+        db = PostgresDatastore(
             os.environ["POSTGRES_DBNAME"],
             os.environ["POSTGRES_HOST"],
             os.environ["POSTGRES_PORT"],
             os.environ["POSTGRES_USER"],
             os.environ["POSTGRES_PASSWORD"],
-        ) as datastore:
-            drop_postgres_table(
-                datastore, "public.searchabletimestampsapplication_events"
-            )
-            drop_postgres_table(
-                datastore, "public.searchabletimestampsapplication_timestamps"
-            )
+        )
+        drop_postgres_table(db, "public.searchabletimestampsapplication_events")
+        drop_postgres_table(db, "public.searchabletimestampsapplication_timestamps")
+        db.close()
 
 
 del SearchableTimestampsTestCase

eventsourcing/postgres.py

@@ -2,14 +2,13 @@ from __future__ import annotations
 
 import logging
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, Callable, Iterator, List, Sequence
+from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Sequence
 
 import psycopg
 import psycopg.errors
 import psycopg_pool
 from psycopg import Connection, Cursor
 from psycopg.rows import DictRow, dict_row
-from typing_extensions import Self
 
 from eventsourcing.persistence import (
     AggregateRecorder,
@@ -63,11 +62,11 @@ class PostgresDatastore:
         user: str,
         password: str,
         *,
-        connect_timeout: int = 30,
+        connect_timeout: int = 5,
         idle_in_transaction_session_timeout: int = 0,
         pool_size: int = 2,
         max_overflow: int = 2,
-        max_waiting: int = 0,
+        pool_timeout: float = 5.0,
         conn_max_age: float = 60 * 60.0,
         pre_ping: bool = False,
         lock_timeout: int = 0,
@@ -80,6 +79,7 @@ class PostgresDatastore:
         self.pool_open_timeout = pool_open_timeout
 
         check = ConnectionPool.check_connection if pre_ping else None
+        kwargs: Dict[str, Any] = {"check": check}
         self.pool = ConnectionPool(
             get_password_func=get_password_func,
             connection_class=Connection[DictRow],
@@ -96,9 +96,9 @@ class PostgresDatastore:
             open=False,
             configure=self.after_connect,
             timeout=connect_timeout,
-            max_waiting=max_waiting,
+            max_waiting=round(pool_timeout),
             max_lifetime=conn_max_age,
-            check=check,
+            **kwargs,  # use the 'check' argument when no longer supporting Python 3.7
         )
         self.lock_timeout = lock_timeout
         self.schema = schema.strip()
@@ -156,12 +156,6 @@ class PostgresDatastore:
     def __del__(self) -> None:
         self.close()
 
-    def __enter__(self) -> Self:
-        return self
-
-    def __exit__(self, *args: object, **kwargs: Any) -> None:
-        self.close()
-
 
 class PostgresAggregateRecorder(AggregateRecorder):
     def __init__(
@@ -564,10 +558,10 @@ class Factory(InfrastructureFactory):
     POSTGRES_CONNECT_TIMEOUT = "POSTGRES_CONNECT_TIMEOUT"
     POSTGRES_CONN_MAX_AGE = "POSTGRES_CONN_MAX_AGE"
     POSTGRES_PRE_PING = "POSTGRES_PRE_PING"
-    POSTGRES_MAX_WAITING = "POSTGRES_MAX_WAITING"
+    POSTGRES_POOL_TIMEOUT = "POSTGRES_POOL_TIMEOUT"
     POSTGRES_LOCK_TIMEOUT = "POSTGRES_LOCK_TIMEOUT"
     POSTGRES_POOL_SIZE = "POSTGRES_POOL_SIZE"
-    POSTGRES_MAX_OVERFLOW = "POSTGRES_MAX_OVERFLOW"
+    POSTGRES_POOL_MAX_OVERFLOW = "POSTGRES_POOL_MAX_OVERFLOW"
     POSTGRES_IDLE_IN_TRANSACTION_SESSION_TIMEOUT = (
         "POSTGRES_IDLE_IN_TRANSACTION_SESSION_TIMEOUT"
     )
@@ -624,7 +618,7 @@ class Factory(InfrastructureFactory):
             get_password_func = resolve_topic(get_password_topic)
             password = ""
 
-        connect_timeout = 30
+        connect_timeout = 5
         connect_timeout_str = self.env.get(self.POSTGRES_CONNECT_TIMEOUT)
         if connect_timeout_str:
             try:
@@ -670,30 +664,30 @@ class Factory(InfrastructureFactory):
                 raise OSError(msg) from None
 
         pool_max_overflow = 10
-        pool_max_overflow_str = self.env.get(self.POSTGRES_MAX_OVERFLOW)
+        pool_max_overflow_str = self.env.get(self.POSTGRES_POOL_MAX_OVERFLOW)
         if pool_max_overflow_str:
             try:
                 pool_max_overflow = int(pool_max_overflow_str)
             except ValueError:
                 msg = (
                     "Postgres environment value for key "
-                    f"'{self.POSTGRES_MAX_OVERFLOW}' is invalid. "
+                    f"'{self.POSTGRES_POOL_MAX_OVERFLOW}' is invalid. "
                     "If set, an integer or empty string is expected: "
                     f"'{pool_max_overflow_str}'"
                 )
                 raise OSError(msg) from None
 
-        max_waiting = 0
-        max_waiting_str = self.env.get(self.POSTGRES_MAX_WAITING)
-        if max_waiting_str:
+        pool_timeout = 30.0
+        pool_timeout_str = self.env.get(self.POSTGRES_POOL_TIMEOUT)
+        if pool_timeout_str:
             try:
-                max_waiting = int(max_waiting_str)
+                pool_timeout = float(pool_timeout_str)
             except ValueError:
                 msg = (
                     "Postgres environment value for key "
-                    f"'{self.POSTGRES_MAX_WAITING}' is invalid. "
-                    "If set, an integer or empty string is expected: "
-                    f"'{max_waiting_str}'"
+                    f"'{self.POSTGRES_POOL_TIMEOUT}' is invalid. "
+                    "If set, a float or empty string is expected: "
+                    f"'{pool_timeout_str}'"
                 )
                 raise OSError(msg) from None
 
@@ -739,16 +733,13 @@ class Factory(InfrastructureFactory):
             idle_in_transaction_session_timeout=idle_in_transaction_session_timeout,
             pool_size=pool_size,
             max_overflow=pool_max_overflow,
-            max_waiting=max_waiting,
+            pool_timeout=pool_timeout,
             conn_max_age=conn_max_age,
             pre_ping=pre_ping,
             lock_timeout=lock_timeout,
             schema=schema,
         )
 
-    def env_create_table(self) -> bool:
-        return strtobool(self.env.get(self.CREATE_TABLE) or "yes")
-
     def aggregate_recorder(self, purpose: str = "events") -> AggregateRecorder:
         prefix = self.env.name.lower() or "stored"
         events_table_name = prefix + "_" + purpose
@@ -792,6 +783,9 @@ class Factory(InfrastructureFactory):
             recorder.create_table()
         return recorder
 
+    def env_create_table(self) -> bool:
+        return strtobool(self.env.get(self.CREATE_TABLE) or "yes")
+
     def close(self) -> None:
         if hasattr(self, "datastore"):
             self.datastore.close()

eventsourcing/system.py

@@ -8,7 +8,6 @@ from queue import Full, Queue
 from threading import Event, Lock, RLock, Thread
 from types import FrameType, ModuleType
 from typing import (
-    Any,
     ClassVar,
     Dict,
     Iterable,
@@ -22,8 +21,6 @@ from typing import (
     cast,
 )
 
-from typing_extensions import Self
-
 from eventsourcing.application import (
     Application,
     NotificationLog,
@@ -528,13 +525,6 @@ class SingleThreadedRunner(Runner, RecordingEventReceiver):
         assert isinstance(app, cls)
         return app
 
-    def __enter__(self) -> Self:
-        self.start()
-        return self
-
-    def __exit__(self, *args: object, **kwargs: Any) -> None:
-        self.stop()
-
 
 class NewSingleThreadedRunner(Runner, RecordingEventReceiver):
     """

eventsourcing/tests/docs_tests/test_docs.py

@@ -20,32 +20,32 @@ class TestDocs(TestCase):
         super().setUp()
         self.uris = tmpfile_uris()
 
-        with PostgresDatastore(
+        db = PostgresDatastore(
             "eventsourcing",
             "127.0.0.1",
             "5432",
             "eventsourcing",
             "eventsourcing",
-        ) as datastore:
-            drop_postgres_table(datastore, "dogschool_events")
-            drop_postgres_table(datastore, "counters_events")
-            drop_postgres_table(datastore, "counters_tracking")
+        )
+        drop_postgres_table(db, "dogschool_events")
+        drop_postgres_table(db, "counters_events")
+        drop_postgres_table(db, "counters_tracking")
 
     def tearDown(self) -> None:
         self.clean_env()
 
     def clean_env(self):
         clear_topic_cache()
-        with PostgresDatastore(
+        db = PostgresDatastore(
             "eventsourcing",
             "127.0.0.1",
             "5432",
             "eventsourcing",
             "eventsourcing",
-        ) as datastore:
-            drop_postgres_table(datastore, "dogschool_events")
-            drop_postgres_table(datastore, "counters_events")
-            drop_postgres_table(datastore, "counters_tracking")
+        )
+        drop_postgres_table(db, "dogschool_events")
+        drop_postgres_table(db, "counters_events")
+        drop_postgres_table(db, "counters_tracking")
 
         keys = [
             "PERSISTENCE_MODULE",

eventsourcing/tests/domain_tests/test_aggregate.py

@@ -5,7 +5,6 @@ from decimal import Decimal
 from unittest.case import TestCase
 from uuid import NAMESPACE_URL, UUID, uuid4, uuid5
 
-from eventsourcing.application import AggregateNotFound, AggregateNotFoundError
 from eventsourcing.domain import (
     Aggregate,
     AggregateCreated,
@@ -731,7 +730,6 @@ class TestAggregateCreation(TestCase):
         order = Order("name")
         pending = order.collect_events()
         self.assertEqual(type(pending[0]).__name__, "Started")
-        self.assertTrue(isinstance(pending[0], Order.Created))
 
     def test_raises_when_given_created_event_name_conflicts_with_created_event_class(
         self,
@@ -1100,19 +1098,6 @@ class TestAggregateEventsAreSubclassed(TestCase):
             MySubclass.Ended.__qualname__,
         )
 
-        self.assertTrue(
-            MySubclass._created_event_class.__qualname__.endswith("MySubclass.Opened")
-        )
-
-        class MySubSubClass(MySubclass):
-            pass
-
-        self.assertTrue(
-            MySubSubClass._created_event_class.__qualname__.endswith(
-                "MySubSubClass.Opened"
-            )
-        )
-
 
 class TestBankAccount(TestCase):
     def test_subclass_bank_account(self):
@@ -1172,9 +1157,3 @@ class TestBankAccount(TestCase):
         # Collect pending events.
         pending = account.collect_events()
         self.assertEqual(len(pending), 7)
-
-
-class TestAggregateNotFound(TestCase):
-    def test(self):
-        e = AggregateNotFound()
-        self.assertIsInstance(e, AggregateNotFoundError)

eventsourcing/tests/persistence.py

@@ -839,9 +839,6 @@ class InfrastructureFactoryTestCase(ABC, TestCase):
         self.transcoder.register(DecimalAsStr())
         self.transcoder.register(DatetimeAsISO())
 
-    def tearDown(self):
-        self.factory.close()
-
     def test_createmapper(self):
         # Want to construct:
         #  - application recorder