first commit

swingmusic/db/sqlite/__init__.py

@@ -0,0 +1,3 @@
+"""
+This module contains the functions to interact with the SQLite database.
+"""

swingmusic/db/sqlite/migrations.py

@@ -0,0 +1,31 @@
+"""
+Reads and saves the latest database migrations version.
+"""
+
+from swingmusic.db.sqlite.utils import SQLiteManager
+
+
+class MigrationManager:
+    @staticmethod
+    def get_index() -> int:
+        """
+        Returns the latest databases migrations index.
+        """
+        sql = "SELECT * FROM dbmigrations"
+        with SQLiteManager() as cur:
+            cur.execute(sql)
+            ver = int(cur.fetchone()[1])
+            cur.close()
+
+            return ver
+
+    # 👇 Setters 👇
+    @staticmethod
+    def set_index(version: int):
+        """
+        Updates the databases migrations index.
+        """
+        sql = "UPDATE dbmigrations SET version = ? WHERE id = 1"
+        with SQLiteManager() as cur:
+            cur.execute(sql, (version,))
+            cur.close()

swingmusic/db/sqlite/utils.py

@@ -0,0 +1,118 @@
+"""
+Helper functions for use with the SQLite database.
+"""
+
+import sqlite3
+import time
+from sqlite3 import Connection, Cursor
+
+from swingmusic import settings
+from swingmusic.models import Album, Playlist, Track
+
+
+def tuple_to_track(track: tuple):
+    """
+    Takes a tuple and returns a Track object
+    """
+    return Track(*track[1:])  # rowid is removed from the tuple
+
+
+def tuples_to_tracks(tracks: list[tuple]):
+    """
+    Takes a list of tuples and returns a generator that yields a Track object for each tuple
+    """
+    for track in tracks:
+        yield tuple_to_track(track)
+
+
+def tuple_to_album(album: tuple):
+    """
+    Takes a tuple and returns an Album object
+    """
+    return Album(*album[1:])  # rowid is removed from the tuple
+
+
+def tuples_to_albums(albums: list[tuple]):
+    """
+    Takes a list of tuples and returns a generator that yields an album object for each tuple
+    """
+    for album in albums:
+        yield tuple_to_album(album)
+
+
+def tuple_to_playlist(playlist: tuple):
+    """
+    Takes a tuple and returns a Playlist object
+    """
+    return Playlist(*playlist)
+
+
+def tuples_to_playlists(playlists: list[tuple]):
+    """
+    Takes a list of tuples and returns a list of Playlist objects
+    """
+    for playlist in playlists:
+        yield tuple_to_playlist(playlist)
+
+
+class SQLiteManager:
+    """
+    This is a context manager that handles the connection and cursor
+    for you. It also commits and closes the connection when you're done.
+    """
+
+    def __init__(
+        self,
+        conn: Connection | None = None,
+        userdata_db=False,
+        test_db_path: str = None,
+    ) -> None:
+        """
+        When a connection is passed in, don't close the connection, because it's
+        a connection to the search database [in memory db].
+        """
+        self.conn = conn
+        self.CLOSE_CONN = True
+        self.userdata_db = userdata_db
+        self.test_db_path = test_db_path
+
+        if conn:
+            self.conn = conn
+            self.CLOSE_CONN = False
+
+    def __enter__(self) -> Cursor:
+        if self.conn is not None:
+            cur = self.conn.cursor()
+            cur.execute("PRAGMA foreign_keys = ON")
+            return cur
+
+        db_path = self.test_db_path or settings.Paths().app_db_path
+
+        if self.userdata_db:
+            db_path = settings.Paths().userdata_db_path
+
+        self.conn = sqlite3.connect(
+            db_path,
+            timeout=15,
+        )
+
+        cur = self.conn.cursor()
+        cur.execute("PRAGMA foreign_keys = ON")
+        return cur
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        trial_count = 0
+
+        while trial_count < 10:
+            try:
+                self.conn.commit()
+
+                if self.CLOSE_CONN:
+                    self.conn.close()
+
+                return
+            except sqlite3.OperationalError:
+                trial_count += 1
+                time.sleep(3)
+
+        self.conn.close()