Move SQLAlchemy statements to models.py

Moved into datastructures.py

app/datastructures.py

@@ -0,0 +1,20 @@
+from PyQt6.QtCore import pyqtSignal, QObject
+
+from helpers import singleton
+
+
+@singleton
+class MusicMusterSignals(QObject):
+    """
+    Class for all MusicMuster signals. See:
+     - https://zetcode.com/gui/pyqt5/eventssignals/
+     - https://stackoverflow.com/questions/62654525/
+        emit-a-signal-from-another-class-to-main-class
+    and Singleton class at
+    https://refactoring.guru/design-patterns/singleton/python/example#example-0
+    """
+
+    enable_escape_signal = pyqtSignal(bool)
+    set_next_track_signal = pyqtSignal(int, int)
+    span_cells_signal = pyqtSignal(int, int, int, int)
+    add_track_to_playlist_signal = pyqtSignal(int, int, int, str)

app/helpers.py

@@ -1,3 +1,4 @@
+import functools
 import os
 import psutil
 import shutil
@@ -154,23 +155,21 @@ def get_file_metadata(filepath: str) -> dict:
     # Get title, artist, bitrate, duration, path
     metadata: Dict[str, str | int | float] = get_tags(filepath)
 
-    metadata['mtime'] = os.path.getmtime(filepath)
+    metadata["mtime"] = os.path.getmtime(filepath)
 
     # Set start_gap, fade_at and silence_at
     audio = get_audio_segment(filepath)
     if not audio:
-        audio_values = dict(
+        audio_values = dict(start_gap=0, fade_at=0, silence_at=0)
-            start_gap=0,
-            fade_at=0,
-            silence_at=0
-        )
     else:
         audio_values = dict(
             start_gap=leading_silence(audio),
-            fade_at=int(round(fade_point(audio) / 1000, Config.MILLISECOND_SIGFIGS) * 1000),
+            fade_at=int(
+                round(fade_point(audio) / 1000, Config.MILLISECOND_SIGFIGS) * 1000
+            ),
             silence_at=int(
                 round(trailing_silence(audio) / 1000, Config.MILLISECOND_SIGFIGS) * 1000
-            )
+            ),
         )
     metadata |= audio_values
 
@@ -381,6 +380,22 @@ def show_warning(parent: QMainWindow, title: str, msg: str) -> None:
     QMessageBox.warning(parent, title, msg, buttons=QMessageBox.StandardButton.Cancel)
 
 
+def singleton(cls):
+    """
+    Make a class a Singleton class (see
+    https://realpython.com/primer-on-python-decorators/#creating-singletons)
+    """
+
+    @functools.wraps(cls)
+    def wrapper_singleton(*args, **kwargs):
+        if not wrapper_singleton.instance:
+            wrapper_singleton.instance = cls(*args, **kwargs)
+        return wrapper_singleton.instance
+
+    wrapper_singleton.instance = None
+    return wrapper_singleton
+
+
 def trailing_silence(
     audio_segment: AudioSegment,
     silence_threshold: int = -50,

app/models.py

@@ -11,6 +11,7 @@ from typing import List, Optional, Sequence
 from sqlalchemy.ext.associationproxy import association_proxy
 
 from sqlalchemy import (
+    bindparam,
     Boolean,
     DateTime,
     delete,
@@ -49,9 +50,9 @@ class Carts(Base):
     id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
     cart_number: Mapped[int] = mapped_column(unique=True)
     name: Mapped[str] = mapped_column(String(256), index=True)
-    duration: Mapped[int] = mapped_column(index=True)
+    duration: Mapped[Optional[int]] = mapped_column(index=True)
-    path: Mapped[str] = mapped_column(String(2048), index=False)
+    path: Mapped[Optional[str]] = mapped_column(String(2048), index=False)
-    enabled: Mapped[bool] = mapped_column(default=False)
+    enabled: Mapped[Optional[bool]] = mapped_column(default=False)
 
     def __repr__(self) -> str:
         return (
@@ -63,7 +64,7 @@ class Carts(Base):
         self,
         session: scoped_session,
         cart_number: int,
-        name: Optional[str] = None,
+        name: str,
         duration: Optional[int] = None,
         path: Optional[str] = None,
         enabled: bool = True,
@@ -134,14 +135,11 @@ class NoteColours(Base):
         if not text:
             return None
 
-        for rec in (
+        for rec in session.scalars(
-            session.scalars(
             select(NoteColours)
             .filter(NoteColours.enabled.is_(True))
             .order_by(NoteColours.order)
-            )
+        ).all():
-            .all()
-        ):
             if rec.is_regex:
                 flags = re.UNICODE
                 if not rec.is_casesensitive:
@@ -202,14 +200,11 @@ class Playdates(Base):
     def played_after(session: scoped_session, since: datetime) -> Sequence["Playdates"]:
         """Return a list of Playdates objects since passed time"""
 
-        return (
+        return session.scalars(
-            session.scalars(
             select(Playdates)
             .where(Playdates.lastplayed >= since)
             .order_by(Playdates.lastplayed)
-            )
+        ).all()
-            .all()
-        )
 
 
 class Playlists(Base):
@@ -285,32 +280,25 @@ class Playlists(Base):
     def get_all(cls, session: scoped_session) -> Sequence["Playlists"]:
         """Returns a list of all playlists ordered by last use"""
 
-        return (
+        return session.scalars(
-            session.scalars(
             select(cls)
             .filter(cls.is_template.is_(False))
             .order_by(cls.tab.desc(), cls.last_used.desc())
-            )
+        ).all()
-            .all()
-        )
 
     @classmethod
     def get_all_templates(cls, session: scoped_session) -> Sequence["Playlists"]:
         """Returns a list of all templates ordered by name"""
 
-        return (
+        return session.scalars(
-            session.scalars(
             select(cls).filter(cls.is_template.is_(True)).order_by(cls.name)
-            )
+        ).all()
-            .all()
-        )
 
     @classmethod
     def get_closed(cls, session: scoped_session) -> Sequence["Playlists"]:
         """Returns a list of all closed playlists ordered by last use"""
 
-        return (
+        return session.scalars(
-            session.scalars(
             select(cls)
             .filter(
                 cls.tab.is_(None),
@@ -318,9 +306,7 @@ class Playlists(Base):
                 cls.deleted.is_(False),
             )
             .order_by(cls.last_used.desc())
-            )
+        ).all()
-            .all()
-        )
 
     @classmethod
     def get_open(cls, session: scoped_session) -> Sequence[Optional["Playlists"]]:
@@ -328,10 +314,9 @@ class Playlists(Base):
         Return a list of loaded playlists ordered by tab order.
         """
 
-        return (
+        return session.scalars(
-            session.scalars(select(cls).where(cls.tab.is_not(None)).order_by(cls.tab))
+            select(cls).where(cls.tab.is_not(None)).order_by(cls.tab)
-            .all()
+        ).all()
-        )
 
     def mark_open(self, session: scoped_session, tab_index: int) -> None:
         """Mark playlist as loaded and used now"""
@@ -433,12 +418,9 @@ class PlaylistRows(Base):
     def copy_playlist(session: scoped_session, src_id: int, dst_id: int) -> None:
         """Copy playlist entries"""
 
-        src_rows = (
+        src_rows = session.scalars(
-            session.scalars(
             select(PlaylistRows).filter(PlaylistRows.playlist_id == src_id)
-            )
+        ).all()
-            .all()
-        )
 
         for plr in src_rows:
             PlaylistRows(
@@ -512,14 +494,11 @@ class PlaylistRows(Base):
         Ensure the row numbers for passed playlist have no gaps
         """
 
-        plrs = (
+        plrs = session.scalars(
-            session.scalars(
             select(PlaylistRows)
             .where(PlaylistRows.playlist_id == playlist_id)
             .order_by(PlaylistRows.plr_rownum)
-            )
+        ).all()
-            .all()
-        )
 
         for i, plr in enumerate(plrs):
             plr.plr_rownum = i
@@ -536,14 +515,11 @@ class PlaylistRows(Base):
         PlaylistRows objects
         """
 
-        plrs = (
+        plrs = session.scalars(
-            session.scalars(
             select(cls)
             .where(cls.playlist_id == playlist_id, cls.id.in_(plr_ids))
             .order_by(cls.plr_rownum)
-            )
+        ).all()
-            .all()
-        )
 
         return plrs
 
@@ -581,14 +557,11 @@ class PlaylistRows(Base):
         have been played.
         """
 
-        plrs = (
+        plrs = session.scalars(
-            session.scalars(
             select(cls)
             .where(cls.playlist_id == playlist_id, cls.played.is_(True))
             .order_by(cls.plr_rownum)
-            )
+        ).all()
-            .all()
-        )
 
         return plrs
 
@@ -626,8 +599,7 @@ class PlaylistRows(Base):
         have not been played.
         """
 
-        plrs = (
+        plrs = session.scalars(
-            session.scalars(
             select(cls)
             .where(
                 cls.playlist_id == playlist_id,
@@ -635,12 +607,17 @@ class PlaylistRows(Base):
                 cls.played.is_(False),
             )
             .order_by(cls.plr_rownum)
-            )
+        ).all()
-            .all()
-        )
 
         return plrs
 
+    @classmethod
+    def insert_row(
+        cls, session: scoped_session, playlist_id: int, new_row_number: int
+    ) -> "PlaylistRows":
+        cls.move_rows_down(session, playlist_id, new_row_number, 1)
+        return cls(session, playlist_id, new_row_number)
+
     @staticmethod
     def move_rows_down(
         session: scoped_session, playlist_id: int, starting_row: int, move_by: int
@@ -659,6 +636,26 @@ class PlaylistRows(Base):
             .values(plr_rownum=PlaylistRows.plr_rownum + move_by)
         )
 
+    @staticmethod
+    def update_plr_rownumbers(
+        session: scoped_session, playlist_id: int, sqla_map: List[dict[str, int]]
+    ) -> None:
+        """
+        Take a {plrid: plr_rownum} dictionary and update the row numbers accordingly
+        """
+
+        # Update database. Ref:
+        # https://docs.sqlalchemy.org/en/20/tutorial/data_update.html#the-update-sql-expression-construct
+        stmt = (
+            update(PlaylistRows)
+            .where(
+                PlaylistRows.playlist_id == playlist_id,
+                PlaylistRows.id == bindparam("plrid"),
+            )
+            .values(plr_rownum=bindparam("plr_rownum"))
+        )
+        session.connection().execute(stmt, sqla_map)
+
 
 class Settings(Base):
     """Manage settings"""

app/musicmuster.py

@@ -15,7 +15,6 @@ from datetime import datetime, timedelta
 from pygame import mixer
 from time import sleep
 from typing import (
-    Callable,
     cast,
     List,
     Optional,
@@ -69,6 +68,7 @@ import icons_rc  # noqa F401
 import music
 from models import Base, Carts, Playdates, PlaylistRows, Playlists, Settings, Tracks
 from config import Config
+from datastructures import MusicMusterSignals
 from playlists import PlaylistTab
 from ui.dlg_cart_ui import Ui_DialogCartEdit  # type: ignore
 from ui.dlg_TrackSelect_ui import Ui_Dialog  # type: ignore
@@ -238,20 +238,6 @@ class ImportTrack(QObject):
             self.finished.emit(self.playlist)
 
 
-class MusicMusterSignals(QObject):
-    """
-    Class for all MusicMuster signals. See:
-     - https://zetcode.com/gui/pyqt5/eventssignals/
-     - https://stackoverflow.com/questions/62654525/
-        emit-a-signal-from-another-class-to-main-class
-    """
-
-    enable_escape_signal = pyqtSignal(bool)
-    set_next_track_signal = pyqtSignal(int, int)
-    span_cells_signal = pyqtSignal(int, int, int, int)
-    add_track_to_playlist_signal = pyqtSignal(int, int, str)
-
-
 class PlaylistTrack:
     """
     Used to provide a single reference point for specific playlist tracks,
@@ -349,8 +335,6 @@ class Window(QMainWindow, Ui_MainWindow):
         self.previous_track_position: Optional[float] = None
         self.selected_plrs: Optional[List[PlaylistRows]] = None
 
-        self.signals = MusicMusterSignals()
-
         self.set_main_window_size()
         self.lblSumPlaytime = QLabel("")
         self.statusbar.addPermanentWidget(self.lblSumPlaytime)
@@ -379,6 +363,7 @@ class Window(QMainWindow, Ui_MainWindow):
         self.timer10.start(10)
         self.timer500.start(500)
         self.timer1000.start(1000)
+        self.signals = MusicMusterSignals()
         self.connect_signals_slots()
 
     def about(self) -> None:
@@ -731,7 +716,6 @@ class Window(QMainWindow, Ui_MainWindow):
         playlist_tab = PlaylistTab(
             musicmuster=self,
             playlist_id=playlist.id,
-            signals=self.signals,
         )
         idx = self.tabPlaylist.addTab(playlist_tab, playlist.name)
         self.tabPlaylist.setCurrentIndex(idx)
@@ -1065,7 +1049,7 @@ class Window(QMainWindow, Ui_MainWindow):
         with Session() as session:
             dlg = TrackSelectDialog(
                 session=session,
-                signals=self.signals,
+                new_row_number=self.active_tab().get_selected_row_number(),
                 playlist_id=self.active_tab().playlist_id,
             )
             dlg.exec()
@@ -1923,7 +1907,7 @@ class TrackSelectDialog(QDialog):
     def __init__(
         self,
         session: scoped_session,
-        signals: MusicMusterSignals,
+        new_row_number: int,
         playlist_id: int,
         *args,
         **kwargs,
@@ -1934,7 +1918,7 @@ class TrackSelectDialog(QDialog):
 
         super().__init__(*args, **kwargs)
         self.session = session
-        self.signals = signals
+        self.new_row_number = new_row_number
         self.playlist_id = playlist_id
         self.ui = Ui_Dialog()
         self.ui.setupUi(self)
@@ -1946,6 +1930,7 @@ class TrackSelectDialog(QDialog):
         self.ui.radioTitle.toggled.connect(self.title_artist_toggle)
         self.ui.searchString.textEdited.connect(self.chars_typed)
         self.track: Optional[Tracks] = None
+        self.signals = MusicMusterSignals()
 
         record = Settings.get_int_settings(self.session, "dbdialog_width")
         width = record.f_int or 800
@@ -1974,7 +1959,9 @@ class TrackSelectDialog(QDialog):
         track_id = None
         if track:
             track_id = track.id
-        self.signals.add_track_to_playlist_signal.emit(self.playlist_id, track_id, note)
+        self.signals.add_track_to_playlist_signal.emit(
+            self.playlist_id, self.new_row_number, track_id, note
+        )
 
     def add_selected_and_close(self) -> None:
         """Handle Add and Close button"""

app/playlistmodel.py

@@ -3,15 +3,12 @@ from enum import auto, Enum
 from sqlalchemy import bindparam, update
 from typing import List, Optional, TYPE_CHECKING
 
-from dbconfig import scoped_session, Session
-
 from PyQt6.QtCore import (
     QAbstractTableModel,
     QModelIndex,
     Qt,
     QVariant,
 )
-
 from PyQt6.QtGui import (
     QBrush,
     QColor,
@@ -19,14 +16,15 @@ from PyQt6.QtGui import (
 )
 
 from config import Config
-from playlists import PlaylistTab
+from datastructures import MusicMusterSignals
+from dbconfig import scoped_session, Session
 from helpers import (
     file_is_unreadable,
 )
 from models import PlaylistRows, Tracks
 
-if TYPE_CHECKING:
+
-    from musicmuster import MusicMusterSignals
+HEADER_NOTES_COLUMN = 1
 
 
 class Col(Enum):
@@ -41,9 +39,6 @@ class Col(Enum):
     NOTE = auto()
 
 
-HEADER_NOTES_COLUMN = 1
-
-
 class PlaylistRowData:
     def __init__(self, plr: PlaylistRows) -> None:
         """
@@ -98,18 +93,15 @@ class PlaylistModel(QAbstractTableModel):
 
     def __init__(
         self,
-        playlist: PlaylistTab,
         playlist_id: int,
-        signals: "MusicMusterSignals",
         *args,
         **kwargs,
     ):
-        self.playlist = playlist
         self.playlist_id = playlist_id
-        self.signals = signals
         super().__init__(*args, **kwargs)
 
         self.playlist_rows: dict[int, PlaylistRowData] = {}
+        self.signals = MusicMusterSignals()
 
         self.signals.add_track_to_playlist_signal.connect(self.add_track)
 
@@ -122,7 +114,11 @@ class PlaylistModel(QAbstractTableModel):
         )
 
     def add_track(
-        self, playlist_id: int, track: Optional[Tracks], note: Optional[str]
+        self,
+        playlist_id: int,
+        new_row_number: int,
+        track_id: Optional[int],
+        note: Optional[str],
     ) -> None:
         """
         Add track if it's for our playlist
@@ -132,14 +128,12 @@ class PlaylistModel(QAbstractTableModel):
         if playlist_id != self.playlist_id:
             return
 
-        row_number = self.playlist.get_selected_row_number()
-
         # Insert track if we have one
-        if track:
+        if track_id:
-            self.insert_track_row(row_number, track, note)
+            self.insert_track_row(new_row_number, track_id, note)
         # If we only have a note, add as a header row
         elif note:
-            self.insert_header_row(row_number, note)
+            self.insert_header_row(new_row_number, note)
         else:
             # No track, no note, no point
             return
@@ -366,16 +360,8 @@ class PlaylistModel(QAbstractTableModel):
         else:
             new_row_number = row_number
 
-        # Move rows below new row down
-        stmt = (
-            update(PlaylistRows)
-            .where(PlaylistRows.plr_rownum >= new_row_number)
-            .values({PlaylistRows.plr_rownum: PlaylistRows.plr_rownum + 1})
-        )
-        session.execute(stmt)
-
         # Insert the new row and return it
-        return PlaylistRows(session, self.playlist_id, new_row_number)
+        return PlaylistRows.insert_row(session, self.playlist_id, new_row_number)
 
     def insert_track_row(
         self, row_number: Optional[int], track_id: int, text: Optional[str]
@@ -452,20 +438,8 @@ class PlaylistModel(QAbstractTableModel):
             plrid = self.playlist_rows[oldrow].plrid
             sqla_map.append({"plrid": plrid, "plr_rownum": newrow})
 
-        # Update database. Ref:
-        # https://docs.sqlalchemy.org/en/20/tutorial/data_update.html#the-update-sql-expression-construct
-        stmt = (
-            update(PlaylistRows)
-            .where(
-                PlaylistRows.playlist_id == self.playlist_id,
-                PlaylistRows.id == bindparam("plrid"),
-            )
-            .values(plr_rownum=bindparam("plr_rownum"))
-        )
-
         with Session() as session:
-            session.connection().execute(stmt, sqla_map)
+            PlaylistRows.update_plr_rownumbers(session, self.playlist_id, sqla_map)
-
             # Update playlist_rows
             self.refresh_data(session)
 

app/playlists.py

@@ -6,7 +6,6 @@ import threading
 
 import obsws_python as obs  # type: ignore
 
-# from collections import namedtuple
 from datetime import datetime, timedelta
 from typing import Any, cast, List, Optional, Tuple, TYPE_CHECKING
 
@@ -36,8 +35,9 @@ from PyQt6.QtWidgets import (
     QStyleOption,
 )
 
-from config import Config
+from datastructures import MusicMusterSignals
 from dbconfig import Session, scoped_session
+from config import Config
 from helpers import (
     ask_yes_no,
     file_is_unreadable,
@@ -48,10 +48,8 @@ from helpers import (
     set_track_metadata,
 )
 from log import log
-
 from models import Playlists, PlaylistRows, Settings, Tracks, NoteColours
-
+from playlistmodel import PlaylistModel
-import playlistmodel
 
 if TYPE_CHECKING:
     from musicmuster import Window, MusicMusterSignals
@@ -66,9 +64,9 @@ class EscapeDelegate(QStyledItemDelegate):
     - checks with user before abandoning edit on Escape
     """
 
-    def __init__(self, parent, signals: "MusicMusterSignals") -> None:
+    def __init__(self, parent) -> None:
         super().__init__(parent)
-        self.signals = signals
+        self.signals = MusicMusterSignals()
 
     def createEditor(
         self,
@@ -80,7 +78,7 @@ class EscapeDelegate(QStyledItemDelegate):
         Intercept createEditor call and make row just a little bit taller
         """
 
-        self.signals.enable_escape_signal.emit(False)
+        signals.enable_escape_signal.emit(False)
         if isinstance(self.parent(), PlaylistTab):
             p = cast(PlaylistTab, self.parent())
         if isinstance(index.data(), str):
@@ -156,17 +154,15 @@ class PlaylistTab(QTableView):
         self,
         musicmuster: "Window",
         playlist_id: int,
-        signals: "MusicMusterSignals",
     ) -> None:
         super().__init__()
 
         # Save passed settings
         self.musicmuster = musicmuster
         self.playlist_id = playlist_id
-        self.signals = signals
 
         # Set up widget
-        self.setItemDelegate(EscapeDelegate(self, self.signals))
+        self.setItemDelegate(EscapeDelegate(self))
         self.setAlternatingRowColors(True)
         self.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
         self.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
@@ -194,6 +190,7 @@ class PlaylistTab(QTableView):
             h_header.setStretchLastSection(True)
         # self.itemSelectionChanged.connect(self._select_event)
         # self.signals.set_next_track_signal.connect(self._reset_next)
+        self.signals = MusicMusterSignals()
         self.signals.span_cells_signal.connect(self._span_cells)
 
         # Call self.eventFilter() for events
@@ -205,7 +202,7 @@ class PlaylistTab(QTableView):
         # self.edit_cell_type: Optional[int]
 
         # Load playlist rows
-        self.setModel(playlistmodel.PlaylistModel(self, playlist_id, signals))
+        self.setModel(PlaylistModel(playlist_id))
         self._set_column_widths()
 
     # kae def __repr__(self) -> str:

test_playlistmodel.py

@@ -4,13 +4,12 @@ from app.models import (
 from app import playlistmodel
 from dbconfig import scoped_session
 
-
 def create_model_with_playlist_rows(
     session: scoped_session, rows: int
 ) -> "playlistmodel.PlaylistModel":
     playlist = Playlists(session, "test playlist")
     # Create a model
-    model = playlistmodel.PlaylistModel(playlist.id, None)
+    model = playlistmodel.PlaylistModel(playlist.id)
     for row in range(rows):
         plr = model._insert_row(session, row)
         newrow = plr.plr_rownum