eventsourcing 9.4.0b2__py3-none-any.whl → 9.4.0b4__py3-none-any.whl

eventsourcing/popo.py

@@ -235,7 +235,7 @@ class POPOProcessRecorder(
         self, stored_events: list[StoredEvent], **kwargs: Any
     ) -> None:
         super()._assert_uniqueness(stored_events, **kwargs)
-        t: Tracking | None = kwargs.get("tracking", None)
+        t: Tracking | None = kwargs.get("tracking")
         if t:
             self._assert_tracking_uniqueness(t)
 
@@ -243,7 +243,7 @@ class POPOProcessRecorder(
         self, stored_events: list[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         notification_ids = super()._update_table(stored_events, **kwargs)
-        t: Tracking | None = kwargs.get("tracking", None)
+        t: Tracking | None = kwargs.get("tracking")
         if t:
             self._insert_tracking(t)
         return notification_ids

eventsourcing/postgres.py

@@ -75,7 +75,7 @@ class ConnectionPool(psycopg_pool.ConnectionPool[Any]):
 
 
 class PostgresDatastore:
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         dbname: str,
         host: str,
@@ -440,11 +440,9 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
         *,
         inclusive_of_start: bool = True,
     ) -> list[Notification]:
-        """
-        Returns a list of event notifications
+        """Returns a list of event notifications
         from 'start', limited by 'limit'.
         """
-
         params: list[int | str | Sequence[str]] = []
         statement = SQL("SELECT * FROM {0}.{1}").format(
             Identifier(self.datastore.schema),
@@ -501,9 +499,7 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
     def max_notification_id(self) -> int | None:
-        """
-        Returns the maximum notification ID.
-        """
+        """Returns the maximum notification ID."""
         with self.datastore.get_connection() as conn, conn.cursor() as curs:
             curs.execute(self.max_notification_id_statement)
             fetchone = curs.fetchone()
@@ -553,7 +549,7 @@ class PostgresApplicationRecorder(PostgresAggregateRecorder, ApplicationRecorder
                     notification_ids.append(row["notification_id"])
             if len(notification_ids) != len(stored_events):
                 msg = "Couldn't get all notification IDs "
-                msg += f"(got {len(notification_ids)}, expected {len(stored_events)}"
+                msg += f"(got {len(notification_ids)}, expected {len(stored_events)})"
                 raise ProgrammingError(msg)
         return notification_ids
 
@@ -730,7 +726,7 @@ class PostgresProcessRecorder(
         stored_events: list[StoredEvent],
         **kwargs: Any,
     ) -> None:
-        tracking: Tracking | None = kwargs.get("tracking", None)
+        tracking: Tracking | None = kwargs.get("tracking")
         if tracking is not None:
             self._insert_tracking(curs, tracking=tracking)
         super()._insert_events(curs, stored_events, **kwargs)
@@ -974,7 +970,8 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
                 tracking_recorder_class = resolve_topic(tracking_recorder_topic)
             else:
                 tracking_recorder_class = cast(
-                    type[TPostgresTrackingRecorder], type(self).tracking_recorder_class
+                    "type[TPostgresTrackingRecorder]",
+                    type(self).tracking_recorder_class,
                 )
         assert tracking_recorder_class is not None
         assert issubclass(tracking_recorder_class, PostgresTrackingRecorder)

eventsourcing/projection.py

@@ -29,8 +29,7 @@ if TYPE_CHECKING:
 
 
 class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
-    """
-    An iterator that yields all domain events recorded in an application
+    """An iterator that yields all domain events recorded in an application
     sequence that have notification IDs greater than a given value. The iterator
     will block when all recorded domain events have been yielded, and then
     continue when new events are recorded. Domain events are returned along
@@ -52,30 +51,23 @@ class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
         self.subscription = self.recorder.subscribe(gt=gt, topics=topics)
 
     def stop(self) -> None:
-        """
-        Stops the stored event subscription.
-        """
+        """Stops the stored event subscription."""
         self.subscription.stop()
 
     def __enter__(self) -> Self:
-        """
-        Calls __enter__ on the stored event subscription.
-        """
+        """Calls __enter__ on the stored event subscription."""
         self.subscription.__enter__()
         return self
 
     def __exit__(self, *args: object, **kwargs: Any) -> None:
-        """
-        Calls __exit__ on the stored event subscription.
-        """
+        """Calls __exit__ on the stored event subscription."""
         self.subscription.__exit__(*args, **kwargs)
 
     def __iter__(self) -> Self:
         return self
 
     def __next__(self) -> tuple[DomainEventProtocol, Tracking]:
-        """
-        Returns the next stored event from the stored event subscription.
+        """Returns the next stored event from the stored event subscription.
         Constructs a tracking object that identifies the position of
         the event in the application sequence, and reconstructs a domain
         event object from the stored event object.
@@ -86,10 +78,9 @@ class ApplicationSubscription(Iterator[tuple[DomainEventProtocol, Tracking]]):
         return domain_event, tracking
 
     def __del__(self) -> None:
-        """
-        Stops the stored event subscription.
-        """
-        self.stop()
+        """Stops the stored event subscription."""
+        with contextlib.suppress(AttributeError):
+            self.stop()
 
 
 class Projection(ABC, Generic[TTrackingRecorder]):
@@ -120,9 +111,7 @@ class Projection(ABC, Generic[TTrackingRecorder]):
     def process_event(
         self, domain_event: DomainEventProtocol, tracking: Tracking
     ) -> None:
-        """
-        Process a domain event and track it.
-        """
+        """Process a domain event and track it."""
 
 
 TApplication = TypeVar("TApplication", bound=Application)
@@ -137,8 +126,7 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         view_class: type[TTrackingRecorder],
         env: EnvType | None = None,
     ):
-        """
-        Constructs application from given application class with given environment.
+        """Constructs application from given application class with given environment.
         Also constructs a materialised view from given class using an infrastructure
         factory constructed with an environment named after the projection. Also
         constructs a projection with the constructed materialised view object.
@@ -194,9 +182,7 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         return self._is_interrupted
 
     def _construct_env(self, name: str, env: EnvType | None = None) -> Environment:
-        """
-        Constructs environment from which projection will be configured.
-        """
+        """Constructs environment from which projection will be configured."""
         _env: dict[str, str] = {}
         _env.update(os.environ)
         if env is not None:
@@ -204,9 +190,7 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         return Environment(name, _env)
 
     def stop(self) -> None:
-        """
-        Sets the "interrupted" event.
-        """
+        """Sets the "interrupted" event."""
         self._has_called_stop = True
         self._is_interrupted.set()
 
@@ -215,8 +199,8 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         subscription: ApplicationSubscription,
         is_stopping: Event,
     ) -> None:
-        """
-        Stops the application subscription, which will stop the event-processing thread.
+        """Stops the application subscription, which
+        will stop the event-processing thread.
         """
         try:
             is_stopping.wait()
@@ -238,7 +222,7 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         except BaseException as e:
             _runner = runner()  # get reference from weakref
             if _runner is not None:
-                _runner._thread_error = e
+                _runner._thread_error = e  # noqa: SLF001
             else:
                 msg = "ProjectionRunner was deleted before error could be assigned:\n"
                 msg += format_exc()
@@ -251,8 +235,7 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
             is_stopping.set()
 
     def run_forever(self, timeout: float | None = None) -> None:
-        """
-        Blocks until timeout, or until the runner is stopped or errors. Re-raises
+        """Blocks until timeout, or until the runner is stopped or errors. Re-raises
         any error otherwise exits normally
         """
         if (
@@ -264,8 +247,7 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
             raise error
 
     def wait(self, notification_id: int | None, timeout: float = 1.0) -> None:
-        """
-        Blocks until timeout, or until the materialised view has recorded a tracking
+        """Blocks until timeout, or until the materialised view has recorded a tracking
         object that is greater than or equal to the given notification ID.
         """
         try:
@@ -293,9 +275,7 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> None:
-        """
-        Calls stop() and waits for the event-processing thread to exit.
-        """
+        """Calls stop() and waits for the event-processing thread to exit."""
         self.stop()
         self._stop_thread.join()
         self._processing_thread.join()
@@ -305,8 +285,6 @@ class ProjectionRunner(Generic[TApplication, TTrackingRecorder]):
             raise error
 
     def __del__(self) -> None:
-        """
-        Calls stop().
-        """
+        """Calls stop()."""
         with contextlib.suppress(AttributeError):
             self.stop()

eventsourcing/sqlite.py

@@ -412,8 +412,7 @@ class SQLiteApplicationRecorder(
         *,
         inclusive_of_start: bool = True,
     ) -> list[Notification]:
-        """
-        Returns a list of event notifications
+        """Returns a list of event notifications
         from 'start', limited by 'limit'.
         """
         params: list[int | str] = []
@@ -443,7 +442,7 @@ class SQLiteApplicationRecorder(
             else:
                 statement += "AND "
             params += list(topics)
-            statement += "topic IN (%s) " % ",".join("?" * len(topics))
+            statement += f"topic IN ({','.join('?' * len(topics))}) "
 
         params.append(limit)
         statement += "ORDER BY rowid LIMIT ?"
@@ -462,9 +461,7 @@ class SQLiteApplicationRecorder(
             ]
 
     def max_notification_id(self) -> int:
-        """
-        Returns the maximum notification ID.
-        """
+        """Returns the maximum notification ID."""
         with self.datastore.transaction(commit=False) as c:
             return self._max_notification_id(c)
 
@@ -561,7 +558,7 @@ class SQLiteProcessRecorder(
         **kwargs: Any,
     ) -> Sequence[int] | None:
         returning = super()._insert_events(c, stored_events, **kwargs)
-        tracking: Tracking | None = kwargs.get("tracking", None)
+        tracking: Tracking | None = kwargs.get("tracking")
         if tracking is not None:
             self._insert_tracking(c, tracking)
         return returning