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

eventsourcing/sqlite.py

@@ -1,16 +1,16 @@
+from __future__ import annotations
+
 import sqlite3
 from contextlib import contextmanager
-from sqlite3 import Connection, Cursor
-from types import TracebackType
-from typing import Any, Iterator, List, Optional, Sequence, Type, Union
+from typing import TYPE_CHECKING, Any, Iterator, List, Sequence, Type
 from uuid import UUID
 
 from eventsourcing.persistence import (
     AggregateRecorder,
     ApplicationRecorder,
-    Connection as BaseConnection,
+    Connection,
     ConnectionPool,
-    Cursor as BaseCursor,
+    Cursor,
     DatabaseError,
     DataError,
     InfrastructureFactory,
@@ -28,17 +28,20 @@ from eventsourcing.persistence import (
 )
 from eventsourcing.utils import Environment, strtobool
 
+if TYPE_CHECKING:  # pragma: nocover
+    from types import TracebackType
+
 SQLITE3_DEFAULT_LOCK_TIMEOUT = 5
 
 
-class SQLiteCursor(BaseCursor):
-    def __init__(self, sqlite_cursor: Cursor):
+class SQLiteCursor(Cursor):
+    def __init__(self, sqlite_cursor: sqlite3.Cursor):
         self.sqlite_cursor = sqlite_cursor
 
-    def __enter__(self, *args: Any, **kwargs: Any) -> Cursor:
+    def __enter__(self) -> sqlite3.Cursor:
         return self.sqlite_cursor
 
-    def __exit__(self, *args: Any, **kwargs: Any) -> None:
+    def __exit__(self, *args: object, **kwargs: Any) -> None:
         self.sqlite_cursor.close()
 
     def execute(self, *args: Any, **kwargs: Any) -> None:
@@ -58,18 +61,16 @@ class SQLiteCursor(BaseCursor):
         return self.sqlite_cursor.lastrowid
 
 
-class SQLiteConnection(BaseConnection[SQLiteCursor]):
-    def __init__(self, sqlite_conn: Connection, max_age: Optional[float]):
+class SQLiteConnection(Connection[SQLiteCursor]):
+    def __init__(self, sqlite_conn: sqlite3.Connection, max_age: float | None):
         super().__init__(max_age=max_age)
         self._sqlite_conn = sqlite_conn
 
     @contextmanager
-    def transaction(self, commit: bool) -> Iterator[SQLiteCursor]:
-        # Context managed transaction.
-        with SQLiteTransaction(self, commit) as curs:
-            # Context managed cursor.
-            with curs:
-                yield curs
+    def transaction(self, *, commit: bool) -> Iterator[SQLiteCursor]:
+        # Context managed cursor, and context managed transaction.
+        with SQLiteTransaction(self, commit=commit) as curs, curs:
+            yield curs
 
     def cursor(self) -> SQLiteCursor:
         return SQLiteCursor(self._sqlite_conn.cursor())
@@ -86,7 +87,7 @@ class SQLiteConnection(BaseConnection[SQLiteCursor]):
 
 
 class SQLiteTransaction:
-    def __init__(self, connection: SQLiteConnection, commit: bool = False):
+    def __init__(self, connection: SQLiteConnection, *, commit: bool = False):
         self.connection = connection
         self.commit = commit
 
@@ -99,9 +100,9 @@ class SQLiteTransaction:
 
     def __exit__(
         self,
-        exc_type: Type[BaseException],
-        exc_val: BaseException,
-        exc_tb: TracebackType,
+        exc_type: Type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         try:
             if exc_val:
@@ -109,7 +110,7 @@ class SQLiteTransaction:
                 # if an exception occurs.
                 self.connection.rollback()
                 raise exc_val
-            elif not self.commit:
+            if not self.commit:
                 self.connection.rollback()
             else:
                 self.connection.commit()
@@ -136,12 +137,13 @@ class SQLiteTransaction:
 class SQLiteConnectionPool(ConnectionPool[SQLiteConnection]):
     def __init__(
         self,
+        *,
         db_name: str,
-        lock_timeout: Optional[int] = None,
+        lock_timeout: int | None = None,
         pool_size: int = 5,
         max_overflow: int = 10,
         pool_timeout: float = 5.0,
-        max_age: Optional[float] = None,
+        max_age: float | None = None,
         pre_ping: bool = False,
     ):
         self.db_name = db_name
@@ -174,20 +176,19 @@ class SQLiteConnectionPool(ConnectionPool[SQLiteConnection]):
                 timeout=self.lock_timeout or SQLITE3_DEFAULT_LOCK_TIMEOUT,
             )
         except (sqlite3.Error, TypeError) as e:
-            raise InterfaceError(e)
+            raise InterfaceError(e) from e
 
         # Use WAL (write-ahead log) mode if file-based database.
-        if not self.is_sqlite_memory_mode:
-            if not self.is_journal_mode_wal:
-                cursor = c.cursor()
-                cursor.execute("PRAGMA journal_mode;")
-                mode = cursor.fetchone()[0]
-                if mode.lower() == "wal":
-                    self.is_journal_mode_wal = True
-                else:
-                    cursor.execute("PRAGMA journal_mode=WAL;")
-                    self.is_journal_mode_wal = True
-                    self.journal_mode_was_changed_to_wal = True
+        if not self.is_sqlite_memory_mode and not self.is_journal_mode_wal:
+            cursor = c.cursor()
+            cursor.execute("PRAGMA journal_mode;")
+            mode = cursor.fetchone()[0]
+            if mode.lower() == "wal":
+                self.is_journal_mode_wal = True
+            else:
+                cursor.execute("PRAGMA journal_mode=WAL;")
+                self.is_journal_mode_wal = True
+                self.journal_mode_was_changed_to_wal = True
 
         # Set the row factory.
         c.row_factory = sqlite3.Row
@@ -200,11 +201,12 @@ class SQLiteDatastore:
     def __init__(
         self,
         db_name: str,
-        lock_timeout: Optional[int] = None,
+        *,
+        lock_timeout: int | None = None,
         pool_size: int = 5,
         max_overflow: int = 10,
         pool_timeout: float = 5.0,
-        max_age: Optional[float] = None,
+        max_age: float | None = None,
         pre_ping: bool = False,
     ):
         self.pool = SQLiteConnectionPool(
@@ -218,13 +220,13 @@ class SQLiteDatastore:
         )
 
     @contextmanager
-    def transaction(self, commit: bool) -> Iterator[SQLiteCursor]:
-        with self.get_connection(commit=commit) as conn:
-            with conn.transaction(commit) as curs:
-                yield curs
+    def transaction(self, *, commit: bool) -> Iterator[SQLiteCursor]:
+        connection = self.get_connection(commit=commit)
+        with connection as conn, conn.transaction(commit=commit) as curs:
+            yield curs
 
     @contextmanager
-    def get_connection(self, commit: bool) -> Iterator[SQLiteConnection]:
+    def get_connection(self, *, commit: bool) -> Iterator[SQLiteConnection]:
         # Using reader-writer interlocking is necessary for in-memory databases,
         # but also speeds up (and provides "fairness") to file-based databases.
         conn = self.pool.get_connection(is_writer=commit)
@@ -254,7 +256,7 @@ class SQLiteAggregateRecorder(AggregateRecorder):
             f"INSERT INTO {self.events_table_name} VALUES (?,?,?,?)"
         )
         self.select_events_statement = (
-            "SELECT * " f"FROM {self.events_table_name} " "WHERE originator_id=? "
+            f"SELECT * FROM {self.events_table_name} WHERE originator_id=? "
         )
 
     def construct_create_table_statements(self) -> List[str]:
@@ -275,11 +277,10 @@ class SQLiteAggregateRecorder(AggregateRecorder):
         with self.datastore.transaction(commit=True) as c:
             for statement in self.create_table_statements:
                 c.execute(statement)
-            pass  # for Coverage 5.5 bug with CPython 3.10.0rc1
 
     def insert_events(
         self, stored_events: List[StoredEvent], **kwargs: Any
-    ) -> Optional[Sequence[int]]:
+    ) -> Sequence[int] | None:
         with self.datastore.transaction(commit=True) as c:
             return self._insert_events(c, stored_events, **kwargs)
 
@@ -287,28 +288,28 @@ class SQLiteAggregateRecorder(AggregateRecorder):
         self,
         c: SQLiteCursor,
         stored_events: List[StoredEvent],
-        **kwargs: Any,
-    ) -> Optional[Sequence[int]]:
-        params = []
-        for stored_event in stored_events:
-            params.append(
-                (
-                    stored_event.originator_id.hex,
-                    stored_event.originator_version,
-                    stored_event.topic,
-                    stored_event.state,
-                )
+        **_: Any,
+    ) -> Sequence[int] | None:
+        params = [
+            (
+                s.originator_id.hex,
+                s.originator_version,
+                s.topic,
+                s.state,
             )
+            for s in stored_events
+        ]
         c.executemany(self.insert_events_statement, params)
         return None
 
     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]:
         statement = self.select_events_statement
         params: List[Any] = [originator_id.hex]
@@ -326,20 +327,17 @@ class SQLiteAggregateRecorder(AggregateRecorder):
         if limit is not None:
             statement += "LIMIT ? "
             params.append(limit)
-        stored_events = []
         with self.datastore.transaction(commit=False) as c:
             c.execute(statement, params)
-            for row in c.fetchall():
-                stored_events.append(
-                    StoredEvent(
-                        originator_id=UUID(row["originator_id"]),
-                        originator_version=row["originator_version"],
-                        topic=row["topic"],
-                        state=row["state"],
-                    )
+            return [
+                StoredEvent(
+                    originator_id=UUID(row["originator_id"]),
+                    originator_version=row["originator_version"],
+                    topic=row["topic"],
+                    state=row["state"],
                 )
-            pass  # for Coverage 5.5 bug with CPython 3.10.0rc1
-        return stored_events
+                for row in c.fetchall()
+            ]
 
 
 class SQLiteApplicationRecorder(
@@ -373,8 +371,8 @@ class SQLiteApplicationRecorder(
         self,
         c: SQLiteCursor,
         stored_events: List[StoredEvent],
-        **kwargs: Any,
-    ) -> Optional[Sequence[int]]:
+        **_: Any,
+    ) -> Sequence[int] | None:
         returning = []
         for stored_event in stored_events:
             c.execute(
@@ -393,17 +391,15 @@ class SQLiteApplicationRecorder(
         self,
         start: int,
         limit: int,
-        stop: Optional[int] = None,
+        stop: int | None = None,
         topics: Sequence[str] = (),
     ) -> List[Notification]:
         """
         Returns a list of event notifications
         from 'start', limited by 'limit'.
         """
-        notifications = []
-
-        params: List[Union[int, str]] = [start]
-        statement = f"SELECT rowid, * FROM {self.events_table_name} " "WHERE rowid>=? "
+        params: List[int | str] = [start]
+        statement = f"SELECT rowid, * FROM {self.events_table_name} WHERE rowid>=? "
 
         if stop is not None:
             params.append(stop)
@@ -418,19 +414,16 @@ class SQLiteApplicationRecorder(
 
         with self.datastore.transaction(commit=False) as c:
             c.execute(statement, params)
-
-            for row in c.fetchall():
-                notifications.append(
-                    Notification(
-                        id=row["rowid"],
-                        originator_id=UUID(row["originator_id"]),
-                        originator_version=row["originator_version"],
-                        topic=row["topic"],
-                        state=row["state"],
-                    )
+            return [
+                Notification(
+                    id=row["rowid"],
+                    originator_id=UUID(row["originator_id"]),
+                    originator_version=row["originator_version"],
+                    topic=row["topic"],
+                    state=row["state"],
                 )
-            pass  # for Coverage 5.5 bug with CPython 3.10.0rc1
-        return notifications
+                for row in c.fetchall()
+            ]
 
     def max_notification_id(self) -> int:
         """
@@ -479,8 +472,7 @@ class SQLiteProcessRecorder(
         params = [application_name]
         with self.datastore.transaction(commit=False) as c:
             c.execute(self.select_max_tracking_id_statement, params)
-            max_id = c.fetchone()[0] or 0
-        return max_id
+            return c.fetchone()[0] or 0
 
     def has_tracking_id(self, application_name: str, notification_id: int) -> bool:
         params = [application_name, notification_id]
@@ -493,9 +485,9 @@ class SQLiteProcessRecorder(
         c: SQLiteCursor,
         stored_events: List[StoredEvent],
         **kwargs: Any,
-    ) -> Optional[Sequence[int]]:
+    ) -> Sequence[int] | None:
         returning = super()._insert_events(c, stored_events, **kwargs)
-        tracking: Optional[Tracking] = kwargs.get("tracking", None)
+        tracking: Tracking | None = kwargs.get("tracking", None)
         if tracking is not None:
             c.execute(
                 self.insert_tracking_statement,
@@ -512,37 +504,43 @@ class Factory(InfrastructureFactory):
     SQLITE_LOCK_TIMEOUT = "SQLITE_LOCK_TIMEOUT"
     CREATE_TABLE = "CREATE_TABLE"
 
+    aggregate_recorder_class = SQLiteAggregateRecorder
+    application_recorder_class = SQLiteApplicationRecorder
+    process_recorder_class = SQLiteProcessRecorder
+
     def __init__(self, env: Environment):
         super().__init__(env)
         db_name = self.env.get(self.SQLITE_DBNAME)
         if not db_name:
-            raise EnvironmentError(
+            msg = (
                 "SQLite database name not found "
                 "in environment with keys: "
                 f"{', '.join(self.env.create_keys(self.SQLITE_DBNAME))}"
             )
+            raise OSError(msg)
 
         lock_timeout_str = (
             self.env.get(self.SQLITE_LOCK_TIMEOUT) or ""
         ).strip() or None
 
-        lock_timeout: Optional[int] = None
+        lock_timeout: int | None = None
         if lock_timeout_str is not None:
             try:
                 lock_timeout = int(lock_timeout_str)
             except ValueError:
-                raise EnvironmentError(
-                    f"SQLite environment value for key "
+                msg = (
+                    "SQLite environment value for key "
                     f"'{self.SQLITE_LOCK_TIMEOUT}' is invalid. "
-                    f"If set, an int or empty string is expected: "
+                    "If set, an int or empty string is expected: "
                     f"'{lock_timeout_str}'"
                 )
+                raise OSError(msg) from None
 
         self.datastore = SQLiteDatastore(db_name=db_name, lock_timeout=lock_timeout)
 
     def aggregate_recorder(self, purpose: str = "events") -> AggregateRecorder:
         events_table_name = "stored_" + purpose
-        recorder = SQLiteAggregateRecorder(
+        recorder = self.aggregate_recorder_class(
             datastore=self.datastore,
             events_table_name=events_table_name,
         )
@@ -551,13 +549,13 @@ class Factory(InfrastructureFactory):
         return recorder
 
     def application_recorder(self) -> ApplicationRecorder:
-        recorder = SQLiteApplicationRecorder(datastore=self.datastore)
+        recorder = self.application_recorder_class(datastore=self.datastore)
         if self.env_create_table():
             recorder.create_table()
         return recorder
 
     def process_recorder(self) -> ProcessRecorder:
-        recorder = SQLiteProcessRecorder(datastore=self.datastore)
+        recorder = self.process_recorder_class(datastore=self.datastore)
         if self.env_create_table():
             recorder.create_table()
         return recorder