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

eventsourcing/persistence.py

@@ -12,12 +12,11 @@ from time import time
 from types import ModuleType
 from typing import (
     Any,
-    Deque,
     Dict,
     Generic,
     Iterator,
     List,
-    Optional,
+    Mapping,
     Sequence,
     Type,
     TypeVar,
@@ -109,11 +108,12 @@ class JSONTranscoder(Transcoder):
         try:
             transcoding = self.types[type(o)]
         except KeyError:
-            raise TypeError(
+            msg = (
                 f"Object of type {type(o)} is not "
                 "serializable. Please define and register "
                 "a custom transcoding for this type."
-            ) from None
+            )
+            raise TypeError(msg) from None
         else:
             return {
                 "_type_": transcoding.name,
@@ -134,12 +134,13 @@ class JSONTranscoder(Transcoder):
                 else:
                     try:
                         transcoding = self.names[cast(str, _type_)]
-                    except KeyError:
-                        raise TypeError(
+                    except KeyError as e:
+                        msg = (
                             f"Data serialized with name '{cast(str, _type_)}' is not "
                             "deserializable. Please register a "
                             "custom transcoding for this type."
                         )
+                        raise TypeError(msg) from e
                     else:
                         return transcoding.decode(_data_)
         else:
@@ -266,8 +267,8 @@ class Mapper:
     def __init__(
         self,
         transcoder: Transcoder,
-        compressor: Optional[Compressor] = None,
-        cipher: Optional[Cipher] = None,
+        compressor: Compressor | None = None,
+        cipher: Cipher | None = None,
     ):
         self.transcoder = transcoder
         self.compressor = compressor
@@ -365,7 +366,7 @@ class DataError(DatabaseError):
 
 class OperationalError(DatabaseError):
     """
-    Exception raised for errors that are related to the database’s
+    Exception raised for errors that are related to the database's
     operation and not necessarily under the control of the programmer,
     e.g. an unexpected disconnect occurs, the data source name is not
     found, a transaction could not be processed, a memory allocation
@@ -414,7 +415,7 @@ class AggregateRecorder(ABC):
     @abstractmethod
     def insert_events(
         self, stored_events: List[StoredEvent], **kwargs: Any
-    ) -> Optional[Sequence[int]]:
+    ) -> Sequence[int] | None:
         """
         Writes stored events into database.
         """
@@ -423,10 +424,11 @@ class AggregateRecorder(ABC):
     def select_events(
         self,
         originator_id: UUID,
-        gt: Optional[int] = None,
-        lte: Optional[int] = None,
+        *,
+        gt: int | None = None,
+        lte: int | None = None,
         desc: bool = False,
-        limit: Optional[int] = None,
+        limit: int | None = None,
     ) -> List[StoredEvent]:
         """
         Reads stored events from database.
@@ -458,7 +460,7 @@ class ApplicationRecorder(AggregateRecorder):
         self,
         start: int,
         limit: int,
-        stop: Optional[int] = None,
+        stop: int | None = None,
         topics: Sequence[str] = (),
     ) -> List[Notification]:
         """
@@ -549,10 +551,11 @@ class EventStore:
     def get(
         self,
         originator_id: UUID,
-        gt: Optional[int] = None,
-        lte: Optional[int] = None,
+        *,
+        gt: int | None = None,
+        lte: int | None = None,
         desc: bool = False,
-        limit: Optional[int] = None,
+        limit: int | None = None,
     ) -> Iterator[DomainEventProtocol]:
         """
         Retrieves domain events from aggregate sequence.
@@ -611,37 +614,39 @@ class InfrastructureFactory(ABC):
             or "eventsourcing.popo"
         )
         try:
-            obj: Union[Type[InfrastructureFactory], ModuleType] = resolve_topic(topic)
+            obj: Type[InfrastructureFactory] | ModuleType = resolve_topic(topic)
         except TopicError as e:
-            raise EnvironmentError(
+            msg = (
                 "Failed to resolve persistence module topic: "
                 f"'{topic}' from environment "
                 f"variable '{cls.PERSISTENCE_MODULE}'"
-            ) from e
+            )
+            raise OSError(msg) from e
 
         if isinstance(obj, ModuleType):
             # Find the factory in the module.
-            factory_classes: List[Type[InfrastructureFactory]] = []
-            for member in obj.__dict__.values():
+            factory_classes: List[Type[InfrastructureFactory]] = [
+                member
+                for member in obj.__dict__.values()
                 if (
                     member is not InfrastructureFactory
                     and isinstance(member, type)
                     and issubclass(member, InfrastructureFactory)
-                ):
-                    factory_classes.append(member)
+                )
+            ]
             if len(factory_classes) == 1:
                 factory_cls = factory_classes[0]
             else:
-                raise AssertionError(
+                msg = (
                     f"Found {len(factory_classes)} infrastructure factory classes in"
                     f" '{topic}', expected 1."
                 )
+                raise AssertionError(msg)
         elif isinstance(obj, type) and issubclass(obj, InfrastructureFactory):
             factory_cls = obj
         else:
-            raise AssertionError(
-                f"Not an infrastructure factory class or module: {topic}"
-            )
+            msg = f"Not an infrastructure factory class or module: {topic}"
+            raise AssertionError(msg)
         return cast(TInfrastructureFactory, factory_cls(env=env))
 
     def __init__(self, env: Environment):
@@ -656,7 +661,7 @@ class InfrastructureFactory(ABC):
         """
         Constructs a transcoder.
         """
-        # Todo: Implement support for TRANSCODER_TOPIC.
+        # TODO: Implement support for TRANSCODER_TOPIC.
         return JSONTranscoder()
 
     def mapper(
@@ -665,21 +670,21 @@ class InfrastructureFactory(ABC):
         """
         Constructs a mapper.
         """
-        # Todo: Implement support for MAPPER_TOPIC.
+        # TODO: Implement support for MAPPER_TOPIC.
         return mapper_class(
             transcoder=transcoder,
             cipher=self.cipher(),
             compressor=self.compressor(),
         )
 
-    def cipher(self) -> Optional[Cipher]:
+    def cipher(self) -> Cipher | None:
         """
         Reads environment variables 'CIPHER_TOPIC'
         and 'CIPHER_KEY' to decide whether or not
         to construct a cipher.
         """
         cipher_topic = self.env.get(self.CIPHER_TOPIC)
-        cipher: Optional[Cipher] = None
+        cipher: Cipher | None = None
         default_cipher_topic = "eventsourcing.cipher:AESCipher"
         if self.env.get("CIPHER_KEY") and not cipher_topic:
             cipher_topic = default_cipher_topic
@@ -690,15 +695,15 @@ class InfrastructureFactory(ABC):
 
         return cipher
 
-    def compressor(self) -> Optional[Compressor]:
+    def compressor(self) -> Compressor | None:
         """
         Reads environment variable 'COMPRESSOR_TOPIC' to
         decide whether or not to construct a compressor.
         """
-        compressor: Optional[Compressor] = None
+        compressor: Compressor | None = None
         compressor_topic = self.env.get(self.COMPRESSOR_TOPIC)
         if compressor_topic:
-            compressor_cls: Union[Type[Compressor], Compressor] = resolve_topic(
+            compressor_cls: Type[Compressor] | Compressor = resolve_topic(
                 compressor_topic
             )
             if isinstance(compressor_cls, type):
@@ -757,9 +762,12 @@ class Tracking:
     notification_id: int
 
 
+Params = Union[Sequence[Any], Mapping[str, Any]]
+
+
 class Cursor(ABC):
     @abstractmethod
-    def execute(self, statement: Union[str, bytes], params: Any = None) -> None:
+    def execute(self, statement: str | bytes, params: Params | None = None) -> None:
         """Executes given statement."""
 
     @abstractmethod
@@ -775,14 +783,14 @@ TCursor = TypeVar("TCursor", bound=Cursor)
 
 
 class Connection(ABC, Generic[TCursor]):
-    def __init__(self, max_age: Optional[float] = None) -> None:
+    def __init__(self, max_age: float | None = None) -> None:
         self._closed = False
         self._closing = Event()
         self._close_lock = Lock()
         self.in_use = Lock()
         self.in_use.acquire()
         if max_age is not None:
-            self._max_age_timer: Optional[Timer] = Timer(
+            self._max_age_timer: Timer | None = Timer(
                 interval=max_age,
                 function=self._close_when_not_in_use,
             )
@@ -790,7 +798,7 @@ class Connection(ABC, Generic[TCursor]):
             self._max_age_timer.start()
         else:
             self._max_age_timer = None
-        self.is_writer: Optional[bool] = None
+        self.is_writer: bool | None = None
 
     @property
     def closed(self) -> bool:
@@ -832,19 +840,19 @@ class Connection(ABC, Generic[TCursor]):
 TConnection = TypeVar("TConnection", bound=Connection[Any])
 
 
-class ConnectionPoolClosed(EventSourcingError):
+class ConnectionPoolClosedError(EventSourcingError):
     """
     Raised when using a connection pool that is already closed.
     """
 
 
-class ConnectionNotFromPool(EventSourcingError):
+class ConnectionNotFromPoolError(EventSourcingError):
     """
     Raised when putting a connection in the wrong pool.
     """
 
 
-class ConnectionUnavailable(OperationalError, TimeoutError):
+class ConnectionUnavailableError(OperationalError, TimeoutError):
     """
     Raised when a request to get a connection from a
     connection pool times out.
@@ -854,10 +862,11 @@ class ConnectionUnavailable(OperationalError, TimeoutError):
 class ConnectionPool(ABC, Generic[TConnection]):
     def __init__(
         self,
+        *,
         pool_size: int = 5,
         max_overflow: int = 10,
         pool_timeout: float = 30.0,
-        max_age: Optional[float] = None,
+        max_age: float | None = None,
         pre_ping: bool = False,
         mutually_exclusive_read_write: bool = False,
     ) -> None:
@@ -896,8 +905,8 @@ class ConnectionPool(ABC, Generic[TConnection]):
         self.pool_timeout = pool_timeout
         self.max_age = max_age
         self.pre_ping = pre_ping
-        self._pool: Deque[TConnection] = deque()
-        self._in_use: Dict[int, TConnection] = dict()
+        self._pool: deque[TConnection] = deque()
+        self._in_use: Dict[int, TConnection] = {}
         self._get_semaphore = Semaphore()
         self._put_condition = Condition()
         self._no_readers = Condition()
@@ -907,6 +916,10 @@ class ConnectionPool(ABC, Generic[TConnection]):
         self._mutually_exclusive_read_write = mutually_exclusive_read_write
         self._closed = False
 
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
     @property
     def num_in_use(self) -> int:
         """
@@ -940,7 +953,7 @@ class ConnectionPool(ABC, Generic[TConnection]):
         return self._num_in_use >= self.pool_size + self.max_overflow
 
     def get_connection(
-        self, timeout: Optional[float] = None, is_writer: Optional[bool] = None
+        self, timeout: float | None = None, is_writer: bool | None = None
     ) -> TConnection:
         """
         Issues connections, or raises ConnectionPoolExhausted error.
@@ -968,7 +981,7 @@ class ConnectionPool(ABC, Generic[TConnection]):
         """
         # Make sure we aren't dealing with a closed pool.
         if self._closed:
-            raise ConnectionPoolClosed
+            raise ConnectionPoolClosedError
 
         # Decide the timeout for getting a connection.
         timeout = self.pool_timeout if timeout is None else timeout
@@ -984,20 +997,16 @@ class ConnectionPool(ABC, Generic[TConnection]):
                     if not self._writer_lock.acquire(
                         timeout=self._time_remaining(timeout, started)
                     ):
-                        raise ConnectionUnavailable(
-                            "Timed out waiting for return of writer"
-                        )
+                        msg = "Timed out waiting for return of writer"
+                        raise ConnectionUnavailableError(msg)
                     if self._mutually_exclusive_read_write:
                         with self._no_readers:
-                            if self._num_readers > 0:
-                                # print("writer waiting")
-                                if not self._no_readers.wait(
-                                    timeout=self._time_remaining(timeout, started)
-                                ):
-                                    self._writer_lock.release()
-                                    raise ConnectionUnavailable(
-                                        "Timed out waiting for return of reader"
-                                    )
+                            if self._num_readers > 0 and not self._no_readers.wait(
+                                timeout=self._time_remaining(timeout, started)
+                            ):
+                                self._writer_lock.release()
+                                msg = "Timed out waiting for return of reader"
+                                raise ConnectionUnavailableError(msg)
                     self._num_writers += 1
 
                 # If connection is for reading, and writing excludes reading,
@@ -1007,9 +1016,8 @@ class ConnectionPool(ABC, Generic[TConnection]):
                         if not self._writer_lock.acquire(
                             timeout=self._time_remaining(timeout, started)
                         ):
-                            raise ConnectionUnavailable(
-                                "Timed out waiting for return of writer"
-                            )
+                            msg = "Timed out waiting for return of writer"
+                            raise ConnectionUnavailableError(msg)
                         self._writer_lock.release()
                     with self._no_readers:
                         self._num_readers += 1
@@ -1028,9 +1036,8 @@ class ConnectionPool(ABC, Generic[TConnection]):
                 self._get_semaphore.release()
         else:
             # Timed out waiting for semaphore.
-            raise ConnectionUnavailable(
-                "Timed out waiting for connection pool semaphore"
-            )
+            msg = "Timed out waiting for connection pool semaphore"
+            raise ConnectionUnavailableError(msg)
 
     def _get_connection(self, timeout: float = 0.0) -> TConnection:
         """
@@ -1060,18 +1067,15 @@ class ConnectionPool(ABC, Generic[TConnection]):
                         return self._get_connection(
                             timeout=self._time_remaining(timeout, started)
                         )
-                    else:
-                        # Timed out waiting for a connection to be returned.
-                        raise ConnectionUnavailable(
-                            "Timed out waiting for return of connection"
-                        ) from None
-                else:
-                    # Not fully used, so create a new connection.
-                    conn = self._create_connection()
-                    # print("created another connection")
+                    # Timed out waiting for a connection to be returned.
+                    msg = "Timed out waiting for return of connection"
+                    raise ConnectionUnavailableError(msg) from None
+                # Not fully used, so create a new connection.
+                conn = self._create_connection()
+                # print("created another connection")
 
-                    # Connection should be pre-locked for use (avoids timer race).
-                    assert conn.in_use.locked()
+                # Connection should be pre-locked for use (avoids timer race).
+                assert conn.in_use.locked()
 
             else:
                 # Got unused connection from pool, so lock for use.
@@ -1122,15 +1126,15 @@ class ConnectionPool(ABC, Generic[TConnection]):
         with self._put_condition:
             # Make sure we aren't dealing with a closed pool
             if self._closed:
-                raise ConnectionPoolClosed("Pool is closed")
+                msg = "Pool is closed"
+                raise ConnectionPoolClosedError(msg)
 
             # Make sure we are dealing with a connection from this pool.
             try:
                 del self._in_use[id(conn)]
             except KeyError:
-                raise ConnectionNotFromPool(
-                    "Connection not in use in this pool"
-                ) from None
+                msg = "Connection not in use in this pool"
+                raise ConnectionNotFromPoolError(msg) from None
 
             if not conn.closed:
                 # Put open connection in pool if not full.
@@ -1181,7 +1185,7 @@ class ConnectionPool(ABC, Generic[TConnection]):
             while True:
                 try:
                     conn = self._pool.popleft()
-                except IndexError:
+                except IndexError:  # noqa: PERF203
                     break
                 else:
                     conn.close()

eventsourcing/popo.py

@@ -2,8 +2,7 @@ from __future__ import annotations
 
 from collections import defaultdict
 from threading import Lock
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Set
-from uuid import UUID
+from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Sequence
 
 from eventsourcing.persistence import (
     AggregateRecorder,
@@ -17,6 +16,9 @@ from eventsourcing.persistence import (
 )
 from eventsourcing.utils import reversed_keys
 
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
 
 class POPOAggregateRecorder(AggregateRecorder):
     def __init__(self) -> None:
@@ -26,33 +28,33 @@ class POPOAggregateRecorder(AggregateRecorder):
 
     def insert_events(
         self, stored_events: List[StoredEvent], **kwargs: Any
-    ) -> Optional[Sequence[int]]:
+    ) -> Sequence[int] | None:
         self._insert_events(stored_events, **kwargs)
         return None
 
     def _insert_events(
         self, stored_events: List[StoredEvent], **kwargs: Any
-    ) -> Optional[Sequence[int]]:
+    ) -> Sequence[int] | None:
         with self._database_lock:
             self._assert_uniqueness(stored_events, **kwargs)
             return self._update_table(stored_events, **kwargs)
 
-    def _assert_uniqueness(
-        self, stored_events: List[StoredEvent], **kwargs: Any
-    ) -> None:
+    def _assert_uniqueness(self, stored_events: List[StoredEvent], **_: Any) -> None:
         new = set()
         for s in stored_events:
             # Check events don't already exist.
             if s.originator_version in self._stored_events_index[s.originator_id]:
-                raise IntegrityError(f"Stored event already recorded: {s}")
+                msg = f"Stored event already recorded: {s}"
+                raise IntegrityError(msg)
             new.add((s.originator_id, s.originator_version))
         # Check new events are unique.
         if len(new) < len(stored_events):
-            raise IntegrityError(f"Stored events are not unique: {stored_events}")
+            msg = f"Stored events are not unique: {stored_events}"
+            raise IntegrityError(msg)
 
     def _update_table(
-        self, stored_events: List[StoredEvent], **kwargs: Any
-    ) -> Optional[Sequence[int]]:
+        self, stored_events: List[StoredEvent], **_: Any
+    ) -> Sequence[int] | None:
         notification_ids = []
         for s in stored_events:
             self._stored_events.append(s)
@@ -65,27 +67,23 @@ class POPOAggregateRecorder(AggregateRecorder):
     def select_events(
         self,
         originator_id: UUID,
-        gt: Optional[int] = None,
-        lte: Optional[int] = None,
+        *,
+        gt: int | None = None,
+        lte: int | None = None,
         desc: bool = False,
-        limit: Optional[int] = None,
+        limit: int | None = None,
     ) -> List[StoredEvent]:
         with self._database_lock:
             results = []
 
             index = self._stored_events_index[originator_id]
             positions: Iterable[int]
-            if desc:
-                positions = reversed_keys(index)
-            else:
-                positions = index.keys()
+            positions = reversed_keys(index) if desc else index.keys()
             for p in positions:
-                if gt is not None:
-                    if not p > gt:
-                        continue
-                if lte is not None:
-                    if not p <= lte:
-                        continue
+                if gt is not None and not p > gt:
+                    continue
+                if lte is not None and not p <= lte:
+                    continue
                 s = self._stored_events[index[p]]
                 results.append(s)
                 if len(results) == limit:
@@ -96,14 +94,14 @@ class POPOAggregateRecorder(AggregateRecorder):
 class POPOApplicationRecorder(ApplicationRecorder, POPOAggregateRecorder):
     def insert_events(
         self, stored_events: List[StoredEvent], **kwargs: Any
-    ) -> Optional[Sequence[int]]:
+    ) -> Sequence[int] | None:
         return self._insert_events(stored_events, **kwargs)
 
     def select_notifications(
         self,
         start: int,
         limit: int,
-        stop: Optional[int] = None,
+        stop: int | None = None,
         topics: Sequence[str] = (),
     ) -> List[Notification]:
         with self._database_lock:
@@ -140,25 +138,26 @@ class POPOApplicationRecorder(ApplicationRecorder, POPOAggregateRecorder):
 class POPOProcessRecorder(ProcessRecorder, POPOApplicationRecorder):
     def __init__(self) -> None:
         super().__init__()
-        self._tracking_table: Dict[str, Set[int]] = defaultdict(set)
+        self._tracking_table: Dict[str, set[int]] = defaultdict(set)
         self._max_tracking_ids: Dict[str, int] = defaultdict(lambda: 0)
 
     def _assert_uniqueness(
         self, stored_events: List[StoredEvent], **kwargs: Any
     ) -> None:
         super()._assert_uniqueness(stored_events, **kwargs)
-        t: Optional[Tracking] = kwargs.get("tracking", None)
+        t: Tracking | None = kwargs.get("tracking", None)
         if t and t.notification_id in self._tracking_table[t.application_name]:
-            raise IntegrityError(
+            msg = (
                 f"Already recorded notification ID {t.notification_id} "
                 f"for application {t.application_name}"
             )
+            raise IntegrityError(msg)
 
     def _update_table(
         self, stored_events: List[StoredEvent], **kwargs: Any
-    ) -> Optional[Sequence[int]]:
+    ) -> Sequence[int] | None:
         notification_ids = super()._update_table(stored_events, **kwargs)
-        t: Optional[Tracking] = kwargs.get("tracking", None)
+        t: Tracking | None = kwargs.get("tracking", None)
         if t:
             self._tracking_table[t.application_name].add(t.notification_id)
             if self._max_tracking_ids[t.application_name] < t.notification_id: