app/helpers.py

@@ -97,8 +97,8 @@ def get_tags(path: str) -> Dict[str, Union[str, int]]:
     )
 
 
-def get_relative_date(past_date: datetime,
+def get_relative_date(past_date: datetime, reference_date: datetime = None) \
-                      reference_date: Optional[datetime] = None) -> str:
+        -> str:
     """
     Return how long before reference_date past_date is as string.
 

app/models.py

@@ -93,6 +93,35 @@ class NoteColours(Base):
             f"colour={self.colour}>"
         )
 
+        #     def __init__(
+        #             self, session: Session, substring: str, colour: str,
+        #             enabled: bool = True, is_regex: bool = False,
+        #             is_casesensitive: bool = False, order: int = 0) -> None:
+        #         self.substring = substring
+        #         self.colour = colour
+        #         self.enabled = enabled
+        #         self.is_regex = is_regex
+        #         self.is_casesensitive = is_casesensitive
+        #         self.order = order
+        #
+        #         session.add(self)
+        #         session.flush()
+        #
+        #     @classmethod
+        #     def get_all(cls, session: Session) ->
+        #             Optional[List["NoteColours"]]:
+        #         """Return all records"""
+        #
+        #         return session.query(cls).all()
+        #
+        #     @classmethod
+        #     def get_by_id(cls, session: Session, note_id: int) -> \
+        #             Optional["NoteColours"]:
+        #         """Return record identified by id, or None if not found"""
+        #
+        #         return session.query(NoteColours).filter(
+        #             NoteColours.id == note_id).first()
+
     @staticmethod
     def get_colour(session: Session, text: str) -> Optional[str]:
         """
@@ -177,6 +206,16 @@ class Playdates(Base):
             .all()
         )
 
+        #     @staticmethod
+        #     def remove_track(session: Session, track_id: int) -> None:
+        #         """
+        #         Remove all records of track_id
+        #         """
+        #
+        #         session.query(Playdates).filter(
+        #             Playdates.track_id == track_id).delete()
+        #         session.flush()
+
 
 class Playlists(Base):
     """
@@ -211,14 +250,27 @@ class Playlists(Base):
         session.add(self)
         session.commit()
 
+        #     def add_track(
+        #             self, session: Session, track_id: int,
+        #             row: Optional[int] = None) -> None:
+        #         """
+        #         Add track to playlist at given row.
+        #         If row=None, add to end of playlist
+        #         """
+        #
+        #         if row is None:
+        #             row = self.next_free_row(session, self.id)
+        #
+        #         xPlaylistTracks(session, self.id, track_id, row)
+
     def close(self, session: Session) -> None:
         """Mark playlist as unloaded"""
 
+        # Closing this tab will mean all higher-number tabs have moved
+        # down by one
         closed_idx = self.tab
         self.tab = None
 
-        # Closing this tab will mean all higher-number tabs have moved
-        # down by one
         session.execute(
             update(Playlists)
             .where(Playlists.tab > closed_idx)

app/music.py

@@ -1,6 +1,6 @@
 # import os
 import threading
-import vlc                          # type: ignore
+import vlc
 #
 from config import Config
 from datetime import datetime
@@ -114,6 +114,7 @@ class Music:
             self.player = self.VLC.media_player_new(path)
         if self.player:
             self.player.audio_set_volume(self.max_volume)
+            self.current_track_start_time = datetime.now()
             status = self.player.play()
             if position:
                 self.player.set_position(position)

app/musicmuster.py

@@ -9,7 +9,7 @@ import threading
 
 from datetime import datetime, timedelta
 from time import sleep
-from typing import Callable, List, Optional
+from typing import List, Optional
 
 from PyQt5.QtCore import pyqtSignal, QDate, QEvent, Qt, QSize, QTime, QTimer
 from PyQt5.QtGui import QColor, QFont, QPalette, QResizeEvent
@@ -111,72 +111,17 @@ class CartButton(QPushButton):
         self.pgb.setGeometry(0, 0, self.width(), 10)
 
 
-class PlaylistTrack:
+class TrackData:
-    """
+    def __init__(self, track):
-    Used to provide a single reference point for specific playlist tracks,
+        self.id = track.id
-    typicall the previous, current and next track.
+        self.title = track.title
-    """
-
-    def __init__(self) -> None:
-        """
-        Only initialises data structure. Call set_plr to populate.
-        """
-
-        self.artist = None
-        self.duration = None
-        self.end_time = None
-        self.fade_at = None
-        self.fade_length = None
-        self.path = None
-        self.playlist_id = None
-        self.playlist_tab = None
-        self.plr_id = None
-        self.row_number = None
-        self.silence_at = None
-        self.start_gap = None
-        self.start_time = None
-        self.title = None
-        self.track_id = None
-
-    def __repr__(self) -> str:
-        return (
-            f"<PlaylistTrack(title={self.title}, artist={self.artist}, "
-            f"row_number={self.row_number} playlist_id={self.playlist_id}>"
-        )
-
-    def set_plr(self, session: Session, plr: PlaylistRows,
-                tab: PlaylistTab) -> None:
-        """
-        Update with new plr information
-        """
-
-        self.playlist_tab = tab
-
-        session.add(plr)
-        track = plr.track
-
         self.artist = track.artist
         self.duration = track.duration
-        self.end_time = None
-        self.fade_at = track.fade_at
-        self.fade_length = track.silence_at - track.fade_at
-        self.path = track.path
-        self.playlist_id = plr.playlist_id
-        self.plr_id = plr.id
-        self.row_number = plr.row_number
-        self.silence_at = track.silence_at
         self.start_gap = track.start_gap
-        self.start_time = None
+        self.fade_at = track.fade_at
-        self.title = track.title
+        self.silence_at = track.silence_at
-        self.track_id = track.id
+        self.path = track.path
-
+        self.mtime = track.mtime
-    def start(self) -> None:
-        """
-        Called when track starts playing
-        """
-
-        self.start_time = datetime.now()
-        self.end_time = self.start_time + timedelta(milliseconds=self.duration)
 
 
 class Window(QMainWindow, Ui_MainWindow):
@@ -186,14 +131,15 @@ class Window(QMainWindow, Ui_MainWindow):
 
         self.timer: QTimer = QTimer()
         self.even_tick: bool = True
-
-        self.music: music.Music = music.Music()
         self.playing: bool = False
 
-        self.current_track = PlaylistTrack()
+        self.music: music.Music = music.Music()
-        self.next_track = PlaylistTrack()
+        self.current_track: Optional[TrackData] = None
-        self.previous_track = PlaylistTrack()
+        self.current_track_playlist_tab: Optional[PlaylistTab] = None
-
+        self.current_track_end_time = None
+        self.next_track: Optional[TrackData] = None
+        self.next_track_playlist_tab: Optional[PlaylistTab] = None
+        self.previous_track: Optional[TrackData] = None
         self.previous_track_position: Optional[int] = None
         self.selected_plrs = None
 
@@ -359,7 +305,7 @@ class Window(QMainWindow, Ui_MainWindow):
         """Handle attempt to close main window"""
 
         # Don't allow window to close when a track is playing
-        if self.playing:
+        if self.music.player and self.music.player.is_playing():
             event.ignore()
             helpers.show_warning(
                 "Track playing",
@@ -424,7 +370,7 @@ class Window(QMainWindow, Ui_MainWindow):
             return
 
         # Don't close next track playlist
-        if self.tabPlaylist.widget(tab_index) == self.next_track.playlist_tab:
+        if self.tabPlaylist.widget(tab_index) == self.next_track_playlist_tab:
             self.statusbar.showMessage(
                 "Can't close next track playlist", 5000)
             return
@@ -464,7 +410,6 @@ class Window(QMainWindow, Ui_MainWindow):
         self.actionOpenPlaylist.triggered.connect(self.open_playlist)
         self.actionPaste.triggered.connect(self.paste_rows)
         self.actionPlay_next.triggered.connect(self.play_next)
-        self.actionResume.triggered.connect(self.resume)
         self.actionSave_as_template.triggered.connect(self.save_as_template)
         self.actionSearch.triggered.connect(self.search_playlist)
         self.actionSelect_next_track.triggered.connect(self.select_next_row)
@@ -610,14 +555,16 @@ class Window(QMainWindow, Ui_MainWindow):
         # doesn't see player=None and kick off end-of-track actions
         self.playing = False
 
-        # Repaint playlist to remove currently playing track colour
+        # Reset current track
-        with Session() as session:
+        if self.current_track:
-            self.current_track.playlist_tab.update_display(session)
-
-        # Reset PlaylistTrack objects
-        if self.current_track.track_id:
             self.previous_track = self.current_track
-            self.current_track = PlaylistTrack()
+            self.current_track = None
+
+        # Tell playlist_tab track has finished and
+        # reset current playlist_tab
+        if self.current_track_playlist_tab:
+            self.current_track_playlist_tab.play_stopped()
+            self.current_track_playlist_tab = None
 
         # Reset clocks
         self.frame_fade.setStyleSheet("")
@@ -629,7 +576,7 @@ class Window(QMainWindow, Ui_MainWindow):
         self.label_start_time.setText("00:00:00")
         self.label_end_time.setText("00:00:00")
 
-        if self.next_track.track_id:
+        if self.next_track:
             self.label_track_length.setText(
                 helpers.ms_to_mmss(self.next_track.duration)
             )
@@ -639,6 +586,9 @@ class Window(QMainWindow, Ui_MainWindow):
             self.label_track_length.setText("0:00")
             self.label_fade_length.setText("0:00")
 
+        # Reset end time
+        self.current_track_end_time = None
+
         # Update headers
         self.update_headers()
 
@@ -839,29 +789,23 @@ class Window(QMainWindow, Ui_MainWindow):
         Move passed playlist rows to another playlist
 
         Actions required:
-        - exclude current/next tracks from being moved
         - identify destination playlist
         - update playlist for the rows in the database
         - remove them from the display
         - update destination playlist display if loaded
         """
 
-        # Remove current/next rows from list
+        if not playlistrows:
-        plrs_to_move = [plr for plr in playlistrows if
+            log.debug(f"musicmuster.move_playlist_rows({playlistrows=}")
-                        plr.id not in
-                            [self.current_track.plr_id,
-                             self.next_track.plr_id]
-                        ]
-
-        rows_to_delete = [plr.row_number for plr in plrs_to_move]
 
         # Identify destination playlist
-        playlists = []
         visible_tab = self.visible_playlist_tab()
-        source_playlist_id = visible_tab.playlist_id
+        source_playlist = visible_tab.playlist_id
 
+        # Get destination playlist id
+        playlists = []
         for playlist in Playlists.get_all(session):
-            if playlist.id == source_playlist_id:
+            if playlist.id == source_playlist:
                 continue
             else:
                 playlists.append(playlist)
@@ -872,6 +816,10 @@ class Window(QMainWindow, Ui_MainWindow):
             return
         destination_playlist_id = dlg.playlist.id
 
+        # Remove moved rows from display and save
+        visible_tab.remove_rows([plr.row_number for plr in playlistrows])
+        visible_tab.save_playlist(session)
+
         # Update destination playlist in the database
         last_row = PlaylistRows.get_last_used_row(session,
                                                   destination_playlist_id)
@@ -880,17 +828,11 @@ class Window(QMainWindow, Ui_MainWindow):
         else:
             next_row = 0
 
-        for plr in plrs_to_move:
+        for plr in playlistrows:
             plr.row_number = next_row
-            next_row += 1
             plr.playlist_id = destination_playlist_id
             # Reset played as it's not been played on this playlist
             plr.played = False
-        session.commit()
-
-        # Remove moved rows from display and save visible playlist
-        visible_tab.remove_rows(rows_to_delete)
-        visible_tab.save_playlist(session)
 
         # Update destination playlist_tab if visible (if not visible, it
         # will be re-populated when it is opened)
@@ -926,13 +868,13 @@ class Window(QMainWindow, Ui_MainWindow):
 
         playlist_id = self.visible_playlist_tab().playlist_id
         with Session() as session:
-            unplayed_plrs = PlaylistRows.get_unplayed_rows(
+            unplayed_playlist_rows = PlaylistRows.get_unplayed_rows(
                 session, playlist_id)
             if helpers.ask_yes_no("Move tracks",
                                   f"Move {len(unplayed_playlist_rows)} tracks:"
                                   " Are you sure?"
                                   ):
-                self.move_playlist_rows(session, unplayed_plrs)
+                self.move_playlist_rows(session, unplayed_playlist_rows)
 
     def new_from_template(self) -> None:
         """Create new playlist from template"""
@@ -1027,9 +969,9 @@ class Window(QMainWindow, Ui_MainWindow):
         # Reset so rows can't be repasted
         self.selected_plrs = None
 
-    def play_next(self, position: Optional[float] = None) -> None:
+    def play_next(self) -> None:
         """
-        Play next track, optionally from passed position.
+        Play next track.
 
         Actions required:
         - If there is no next track set, return.
@@ -1047,7 +989,7 @@ class Window(QMainWindow, Ui_MainWindow):
         """
 
         # If there is no next track set, return.
-        if not self.next_track.track_id:
+        if not self.next_track:
             log.debug("musicmuster.play_next(): no next track selected")
             return
 
@@ -1055,21 +997,21 @@ class Window(QMainWindow, Ui_MainWindow):
             # If there's currently a track playing, fade it.
             self.stop_playing(fade=True)
 
-            # Ensure playlist tabs are the correct colour
-            # If next track is on a different playlist_tab to the
-            # current track, reset the current track playlist_tab colour
-            if self.current_track.playlist_tab != self.next_track.playlist_tab:
-                self.set_tab_colour(self.current_track.playlist_tab,
-                                    QColor(Config.COLOUR_NORMAL_TAB))
-
             # Move next track to current track.
-            # stop_playing() above has called end_of_track_actions()
-            # which will have populated self.previous_track
             self.current_track = self.next_track
-            self.next_track = PlaylistTrack()
+            self.next_track = None
 
+            # Ensure playlist tabs are the correct colour
+            # If current track on different playlist_tab to last, reset
+            # last track playlist_tab colour
+            if self.current_track_playlist_tab != self.next_track_playlist_tab:
+                self.set_tab_colour(self.current_track_playlist_tab,
+                                    QColor(Config.COLOUR_NORMAL_TAB))
+            # # Update record of current track playlist_tab
+            self.current_track_playlist_tab = self.next_track_playlist_tab
+            self.next_track_playlist_tab = None
             # Set current track playlist_tab colour
-            self.set_tab_colour(self.current_track.playlist_tab,
+            self.set_tab_colour(self.current_track_playlist_tab,
                                 QColor(Config.COLOUR_CURRENT_TAB))
 
             # Restore volume if -3dB active
@@ -1077,14 +1019,14 @@ class Window(QMainWindow, Ui_MainWindow):
                 self.btnDrop3db.setChecked(False)
 
             # Play (new) current track
-            self.current_track.start()
+            start_at = datetime.now()
-            self.music.play(self.current_track.path, position)
+            self.music.play(self.current_track.path)
 
             # Tell database to record it as played
-            Playdates(session, self.current_track.track_id)
+            Playdates(session, self.current_track.id)
 
             # Tell playlist track is now playing
-            self.current_track.playlist_tab.play_started(session)
+            self.current_track_playlist_tab.play_started(session)
 
             # Note that track is now playing
             self.playing = True
@@ -1099,51 +1041,16 @@ class Window(QMainWindow, Ui_MainWindow):
             self.label_track_length.setText(
                 helpers.ms_to_mmss(self.current_track.duration)
             )
+            fade_at = self.current_track.fade_at
+            silence_at = self.current_track.silence_at
             self.label_fade_length.setText(
-                helpers.ms_to_mmss(self.current_track.fade_length))
+                helpers.ms_to_mmss(silence_at - fade_at))
             self.label_start_time.setText(
-                self.current_track.start_time.strftime(
+                start_at.strftime(Config.TRACK_TIME_FORMAT))
-                    Config.TRACK_TIME_FORMAT))
+            self.current_track_end_time = start_at + timedelta(
+                milliseconds=self.current_track.duration)
             self.label_end_time.setText(
-                self.current_track.end_time.strftime(Config.TRACK_TIME_FORMAT))
+                self.current_track_end_time.strftime(Config.TRACK_TIME_FORMAT))
-
-    def resume(self) -> None:
-        """
-        Resume playing stopped track
-
-        Actions required:
-        - Return if no saved position
-        - Store saved position
-        - Store next track
-        - Set previous track to be next track
-        - Call play_next() from saved position
-        - Reset next track
-        """
-
-        # Return if no saved position
-        if not self.previous_track_position:
-            return
-
-        # Note resume point
-        resume_from = self.previous_track_position
-
-        # Remember what was to have been the next track
-        original_next_plr_id = self.next_track.plr_id
-        original_next_plr_playlist_tab = self.next_track.playlist_tab
-
-        with Session() as session:
-            # Set next track to be the last one played
-            self.next_track = self.previous_track
-            self.previous_track = PlaylistTrack()
-
-            # Resume last track
-            self.play_next(resume_from)
-
-            # Reset next track if there was one
-            if original_next_plr_id:
-                next_plr = session.get(PlaylistRows, original_next_plr_id)
-                self.this_is_the_next_playlist_row(
-                    session, next_plr, original_next_plr_playlist_tab)
 
     def save_as_template(self) -> None:
         """Save current playlist as template"""
@@ -1241,15 +1148,17 @@ class Window(QMainWindow, Ui_MainWindow):
     def show_current(self) -> None:
         """Scroll to show current track"""
 
-        if self.current_track.playlist_tab != self.visible_playlist_tab():
+        log.debug(f"KAE: musicmuster.show_current()")
-            self.tabPlaylist.setCurrentWidget(self.current_track.playlist_tab)
+        if self.current_track_playlist_tab != self.visible_playlist_tab():
+            self.tabPlaylist.setCurrentWidget(self.current_track_playlist_tab)
         self.tabPlaylist.currentWidget().scroll_current_to_top()
 
     def show_next(self) -> None:
         """Scroll to show next track"""
 
-        if self.next_track.playlist_tab != self.visible_playlist_tab():
+        log.debug(f"KAE: musicmuster.show_next()")
-            self.tabPlaylist.setCurrentWidget(self.next_track.playlist_tab)
+        if self.next_track_playlist_tab != self.visible_playlist_tab():
+            self.tabPlaylist.setCurrentWidget(self.next_track_playlist_tab)
         self.tabPlaylist.currentWidget().scroll_next_to_top()
 
     def solicit_playlist_name(self) -> Optional[str]:
@@ -1293,11 +1202,11 @@ class Window(QMainWindow, Ui_MainWindow):
             self.music.stop()
 
         # Reset playlist_tab colour
-        if self.current_track.playlist_tab == self.next_track.playlist_tab:
+        if self.current_track_playlist_tab == self.next_track_playlist_tab:
-            self.set_tab_colour(self.current_track.playlist_tab,
+            self.set_tab_colour(self.current_track_playlist_tab,
                                 QColor(Config.COLOUR_NEXT_TAB))
         else:
-            self.set_tab_colour(self.current_track.playlist_tab,
+            self.set_tab_colour(self.current_track_playlist_tab,
                                 QColor(Config.COLOUR_NORMAL_TAB))
 
         # Run end-of-track actions
@@ -1312,12 +1221,12 @@ class Window(QMainWindow, Ui_MainWindow):
             # May also be called when last tab is closed
             pass
 
-    def this_is_the_next_playlist_row(self, session: Session,
+    def this_is_the_next_track(self, session: Session,
-                                      plr: PlaylistRows,
+                               playlist_tab: PlaylistTab,
-                                      playlist_tab: PlaylistTab) -> None:
+                               track: Tracks) -> None:
         """
         This is notification from a playlist tab that it holds the next
-        playlist row to be played.
+        track to be played.
 
         Actions required:
          - Clear next track if on other tab
@@ -1330,51 +1239,48 @@ class Window(QMainWindow, Ui_MainWindow):
 
         """
 
-        if plr.track_id is None:
+        # Clear next track if on another tab
-            return
+        if self.next_track_playlist_tab != playlist_tab:
+            # We need to reset the ex-next-track playlist
+            if self.next_track_playlist_tab:
+                self.next_track_playlist_tab.clear_next(session)
 
-        # Clean up if we are replacing an existing "next track"
+                # Reset tab colour if on other tab
-        original_next_track_playlist_tab = None
+                if (self.next_track_playlist_tab !=
-        if (
+                        self.current_track_playlist_tab):
-            # If we already have a next tab lined up and it's neither
+                    self.set_tab_colour(
-            # the "new" next tab nor the current track tab then we need
+                        self.next_track_playlist_tab,
-            # to reset the tab colour.
-            self.next_track.playlist_tab and
-            self.next_track.playlist_tab != playlist_tab and
-            self.next_track.playlist_tab != self.current_track.playlist_tab
-        ):
-            original_next_track_playlist_tab = self.next_track.playlist_tab
-            self.set_tab_colour(self.next_track.playlist_tab,
                         QColor(Config.COLOUR_NORMAL_TAB))
 
-            # Discard now-incorrect next_track PlaylistTrack
+            # Note next playlist tab
-            self.next_track = PlaylistTrack()
+            self.next_track_playlist_tab = playlist_tab
 
-        self.next_track.set_plr(session, plr, playlist_tab)
+        # Set next playlist_tab tab colour if it isn't the
-        self.next_track.playlist_tab.update_display(session)
+        # currently-playing tab
-        if self.current_track.playlist_tab != self.next_track.playlist_tab:
+        if (self.next_track_playlist_tab !=
-            self.set_tab_colour(self.next_track.playlist_tab,
+                self.current_track_playlist_tab):
+            self.set_tab_colour(
+                self.next_track_playlist_tab,
                 QColor(Config.COLOUR_NEXT_TAB))
 
-        # If we've changed playlist tabs for next track, refresh old one
+        # Note next track
-        # to remove highligting of next track
+        self.next_track = TrackData(track)
-        if original_next_track_playlist_tab:
-            original_next_track_playlist_tab.update_display(session)
 
         # Populate footer if we're not currently playing
-        if not self.playing and self.next_track.track_id:
+
+        if not self.playing and self.next_track:
             self.label_track_length.setText(
                 helpers.ms_to_mmss(self.next_track.duration)
             )
             self.label_fade_length.setText(helpers.ms_to_mmss(
-                self.next_track.fade_length))
+                self.next_track.silence_at - self.next_track.fade_at))
 
         # Update headers
         self.update_headers()
 
         # Populate 'info' tabs with Wikipedia info, but queue it because
         # it isn't quick
-        track_title = self.next_track.title
+        track_title = track.title
         QTimer.singleShot(
             1, lambda: self.tabInfolist.open_in_wikipedia(track_title)
         )
@@ -1459,28 +1365,40 @@ class Window(QMainWindow, Ui_MainWindow):
             if self.playing:
                 self.stop_playing()
 
+    def update_current_track(self, track):
+        """Update current track with passed details"""
+
+        self.current_track = TrackData(track)
+        self.update_headers()
+
+    def update_next_track(self, track):
+        """Update next track with passed details"""
+
+        self.next_track = TrackData(track)
+        self.update_headers()
+
     def update_headers(self) -> None:
         """
         Update last / current / next track headers
         """
 
-        if self.previous_track.title:
+        try:
             self.hdrPreviousTrack.setText(
                 f"{self.previous_track.title} - {self.previous_track.artist}")
-        else:
+        except AttributeError:
             self.hdrPreviousTrack.setText("")
 
-        if self.current_track.title:
+        try:
             self.hdrCurrentTrack.setText(
                 f"{self.current_track.title} - {self.current_track.artist}")
-        else:
+        except AttributeError:
             self.hdrCurrentTrack.setText("")
 
-        if self.next_track.title:
+        try:
             self.hdrNextTrack.setText(
                 f"{self.next_track.title} - {self.next_track.artist}"
             )
-        else:
+        except AttributeError:
             self.hdrNextTrack.setText("")
 
 

app/playlists.py

@@ -62,6 +62,13 @@ start_time_re = re.compile(r"@\d\d:\d\d:\d\d")
 HEADER_NOTES_COLUMN = 2
 MINIMUM_ROW_HEIGHT = 30
 
+
+class RowMeta:
+    UNREADABLE = 2
+    NEXT = 3
+    CURRENT = 4
+
+
 # Columns
 Column = namedtuple("Column", ['idx', 'heading'])
 columns = {}
@@ -133,6 +140,7 @@ class PlaylistTab(QTableWidget):
         self.playlist_id = playlist_id
 
         self.menu: Optional[QMenu] = None
+        self.current_track_start_time: Optional[datetime] = None
 
         # Don't select text on edit
         self.setItemDelegate(NoSelectDelegate(self))
@@ -261,10 +269,8 @@ class PlaylistTab(QTableWidget):
                 track_row = track_id > 0
                 header_row = not track_row
                 if track_row:
-                    current = (
+                    current = row_number == self._get_current_track_row()
-                        row_number == self._get_current_track_row_number()
+                    next_row = row_number == self._get_next_track_row()
-                    )
-                    next_row = row_number == self._get_next_track_row_number()
                 else:
                     current = next_row = False
 
@@ -413,16 +419,12 @@ class PlaylistTab(QTableWidget):
 
         # Determin cell type changed
         with Session() as session:
+            if self.edit_cell_type == ROW_NOTES:
                 # Get playlistrow object
                 plr_id = self._get_playlistrow_id(row)
                 plr_item = session.get(PlaylistRows, plr_id)
-
-            # Note any updates needed to PlaylistTrack objects
-            update_current = self.musicmuster.current_track.plr_id == plr_id
-            update_next = self.musicmuster.next_track.plr_id == plr_id
-
-            if self.edit_cell_type == ROW_NOTES:
                 plr_item.note = new_text
+
                 # Set/clear row start time accordingly
                 start_time = self._get_note_text_time(new_text)
                 if start_time:
@@ -434,22 +436,22 @@ class PlaylistTab(QTableWidget):
                 if track_id:
                     track = session.get(Tracks, track_id)
                     if track:
+                        update_current = row == self._get_current_track_row()
+                        update_next = row == self._get_next_track_row()
                         if self.edit_cell_type == TITLE:
                             log.debug(f"KAE: _cell_changed:440, {new_text=}")
                             track.title = new_text
-                            if update_current:
-                                self.musicmuster.current_track.title = new_text
-                            if update_next:
-                                self.musicmuster.next_track.title = new_text
                         elif self.edit_cell_type == ARTIST:
                             track.artist = new_text
                         if update_current:
-                                self.musicmuster.current_track.artist = \
+                            self.musicmuster.update_current_track(track)
-                                    new_text
+                        elif update_next:
-                            if update_next:
+                            self.musicmuster.update_next_track(track)
-                                self.musicmuster.next_track.artist = new_text
 
-                        if update_next or update_current:
+                        # Headers will be incorrect if the edited track is
+                        # previous / current / next TODO: this will require
+                        # the stored data in musicmuster to be updated,
+                        # which currently it isn't).
                         self.musicmuster.update_headers()
 
     def closeEditor(self,
@@ -530,6 +532,12 @@ class PlaylistTab(QTableWidget):
 
 #     # ########## Externally called functions ##########
 
+    def clear_next(self, session) -> None:
+        """Clear next track marker"""
+
+        self._meta_clear_next()
+        self.update_display(session)
+
     def clear_selection(self) -> None:
         """Unselect all tracks and reset drag mode"""
 
@@ -641,6 +649,10 @@ class PlaylistTab(QTableWidget):
             last_played_item = QTableWidgetItem(last_played_str)
             self.setItem(row, LASTPLAYED, last_played_item)
 
+            # Mark track if file is unreadable
+            if not file_is_readable(plr.track.path):
+                self._set_unreadable_row(row)
+
         else:
             # This is a section header so it must have note text
             if plr.note is None:
@@ -666,7 +678,7 @@ class PlaylistTab(QTableWidget):
             userdata_item.setData(self.ROW_TRACK_ID, 0)
 
         if repaint:
-            self.update_display(session)
+            self.update_display(session, clear_selection=False)
 
     def insert_track(self, session: Session, track: Tracks,
                      note: str = None, repaint: bool = True) -> None:
@@ -718,14 +730,40 @@ class PlaylistTab(QTableWidget):
         - Update display
         """
 
-        search_from = self._get_current_track_row_number() + 1
+        # Note start time
+        self.current_track_start_time = datetime.now()
+
+        # Mark next-track row as current
+        current_row = self._get_next_track_row()
+        if current_row is None:
+            return
+        self._set_current_track_row(current_row)
+
+        # Mark current row as played
+        self._set_played_row(session, current_row)
+
+        # Set next track
+        search_from = current_row + 1
         next_row = self._find_next_track_row(session, search_from)
         if next_row:
             self._set_next(session, next_row)
+            self._scroll_to_top(next_row)
 
         # Update display
         self.update_display(session)
 
+    def play_stopped(self) -> None:
+        """
+        Notification from musicmuster that track has ended.
+
+        Actions required:
+        - Remove current track marker
+        - Reset current track start time
+        """
+
+        self._clear_current_track_row()
+        self.current_track_start_time = None
+
     def populate_display(self, session: Session, playlist_id: int,
                          scroll_to_top: bool = True) -> None:
         """
@@ -814,13 +852,13 @@ class PlaylistTab(QTableWidget):
     def scroll_current_to_top(self) -> None:
         """Scroll currently-playing row to top"""
 
-        current_row = self._get_current_track_row_number()
+        current_row = self._get_current_track_row()
         self._scroll_to_top(current_row)
 
     def scroll_next_to_top(self) -> None:
         """Scroll nextly-playing row to top"""
 
-        next_row = self._get_next_track_row_number()
+        next_row = self._get_next_track_row()
         self._scroll_to_top(next_row)
 
     def set_search(self, text: str) -> None:
@@ -938,22 +976,25 @@ class PlaylistTab(QTableWidget):
         # Set row heights
         self.resizeRowsToContents()
         self.setColumnWidth(len(columns) - 1, 0)
-        with Session() as session:
-            self.update_display(session)
 
-    def update_display(self, session: Session) -> None:
+    def update_display(self, session, clear_selection: bool = True) -> None:
         """
         Set row colours, fonts, etc
 
         Actions required:
+        - Clear selection if required
         - Render notes in correct colour
         - Render current, next and unplayable tracks in correct colour
         - Set start and end times
         - Show unplayed tracks in bold
         """
 
-        current_row: Optional[int] = self._get_current_track_row_number()
+        # Clear selection if required
-        next_row: Optional[int] = self._get_next_track_row_number()
+        if clear_selection:
+            self.clear_selection()
+
+        current_row: Optional[int] = self._get_current_track_row()
+        next_row: Optional[int] = self._get_next_track_row()
         played = [
             p.row_number for p in PlaylistRows.get_played_rows(
                 session, self.playlist_id)
@@ -1034,13 +1075,14 @@ class PlaylistTab(QTableWidget):
 
                 # Render playing track
                 if row == current_row:
+                    # Set start time
+                    self._set_row_start_time(
+                        row, self.current_track_start_time)
                     # Set last played time to "Today"
                     self.item(row, LASTPLAYED).setText("Today")
                     # Calculate next_start_time
                     next_start_time = self._calculate_end_time(
-                        self.musicmuster.current_track.start_time,
+                        self.current_track_start_time, track.duration)
-                        track.duration
-                    )
                     # Set end time
                     self._set_row_end_time(row, next_start_time)
                     # Set colour
@@ -1056,7 +1098,7 @@ class PlaylistTab(QTableWidget):
                     # if there's a track playing, set start time from
                     # that. It may be on a different tab, so we get
                     # start time from musicmuster.
-                    start_time = self.musicmuster.current_track.end_time
+                    start_time = self.musicmuster.current_track_end_time
                     if start_time is None:
                         # No current track to base from, but don't change
                         # time if it's already set
@@ -1180,6 +1222,20 @@ class PlaylistTab(QTableWidget):
 
         return start + timedelta(milliseconds=duration)
 
+    def _clear_current_track_row(self) -> None:
+        """
+        Clear current row if there is one.
+        """
+
+        current_row = self._get_current_track_row()
+
+        if current_row is None:
+            return
+
+        self._meta_clear_attribute(current_row, RowMeta.CURRENT)
+        # Reset colour
+        self._set_row_colour(current_row, None)
+
     def _column_resize(self, idx: int, old: int, new: int) -> None:
         """
         Called when column widths are changed.
@@ -1286,37 +1342,28 @@ class PlaylistTab(QTableWidget):
                 session, self.playlist_id)
         ]
         for row in range(starting_row, self.rowCount()):
-            plr = self._get_playlistrow_object(session, row)
+            if row not in track_rows or row in played_rows:
-            if (
-                    row not in track_rows or
-                    row in played_rows or
-                    not file_is_readable(plr.track.path)
-            ):
                 continue
             else:
                 return row
 
         return None
 
-    def _get_current_track_row_number(self) -> Optional[int]:
+    def _get_current_track_row(self) -> Optional[int]:
-        """Return current track row or None"""
+        """Return row marked as current, or None"""
 
-        current_track = self.musicmuster.current_track
+        row = self._meta_search(RowMeta.CURRENT)
-        if not current_track.track_id:
+        if len(row) > 0:
-            return None
+            return row[0]
-        if current_track.playlist_tab == self:
-            return current_track.row_number
         else:
             return None
 
-    def _get_next_track_row_number(self) -> Optional[int]:
+    def _get_next_track_row(self) -> Optional[int]:
-        """Return next track row or None"""
+        """Return row marked as next, or None"""
 
-        next_track = self.musicmuster.next_track
+        row = self._meta_search(RowMeta.NEXT)
-        if not next_track.track_id:
+        if len(row) > 0:
-            return None
+            return row[0]
-        if next_track.playlist_tab == self:
-            return next_track.row_number
         else:
             return None
 
@@ -1344,12 +1391,6 @@ class PlaylistTab(QTableWidget):
 
         return playlistrow_id
 
-    def _get_playlistrow_object(self, session: Session, row: int) -> int:
-        """Return the playlistrow object associated with this row"""
-
-        playlistrow_id = (self.item(row, USERDATA).data(self.PLAYLISTROW_ID))
-        return session.get(PlaylistRows, playlistrow_id)
-
     def _get_row_artist(self, row: int) -> Optional[str]:
         """Return artist on this row or None if none"""
 
@@ -1482,6 +1523,15 @@ class PlaylistTab(QTableWidget):
         new_metadata: int = self._meta_get(row) & ~(1 << attribute)
         self.item(row, USERDATA).setData(self.ROW_FLAGS, new_metadata)
 
+    def _meta_clear_next(self) -> None:
+        """
+            Clear next row if there is one.
+            """
+
+        next_row: Optional[int] = self._get_next_track_row()
+        if next_row is not None:
+            self._meta_clear_attribute(next_row, RowMeta.NEXT)
+
     def _meta_get(self, row: int) -> int:
         """Return row metadata"""
 
@@ -1515,6 +1565,19 @@ class PlaylistTab(QTableWidget):
             )
             raise AttributeError(f"Multiple '{metadata}' metadata {matches}")
 
+    def _meta_set_attribute(self, row: int, attribute: int) -> None:
+        """Set row metadata"""
+
+        if row is None:
+            raise ValueError(f"_meta_set_attribute({row=}, {attribute=})")
+
+        current_metadata: int = self._meta_get(row)
+        if not current_metadata:
+            new_metadata: int = (1 << attribute)
+        else:
+            new_metadata = self._meta_get(row) | (1 << attribute)
+        self.item(row, USERDATA).setData(self.ROW_FLAGS, new_metadata)
+
     def _move_row(self, session: Session, plr: PlaylistRows,
                   new_row_number: int) -> None:
         """Move playlist row to new_row_number using parent copy/paste"""
@@ -1742,15 +1805,22 @@ class PlaylistTab(QTableWidget):
             else:
                 self.setColumnWidth(idx, Config.DEFAULT_COLUMN_WIDTH)
 
+    def _set_current_track_row(self, row: int) -> None:
+        """Mark this row as current track"""
+
+        self._clear_current_track_row()
+        self._meta_set_attribute(row, RowMeta.CURRENT)
+
     def _set_next(self, session: Session, row_number: int) -> None:
         """
-        Set passed row as next playlist row to play.
+        Set passed row as next track to play.
 
         Actions required:
         - Check row has a track
         - Check track is readable
-        - Notify musicmuster
+        - Mark as next track
         - Update display
+        - Notify musicmuster
         """
 
         track_id = self._get_row_track_id(row_number)
@@ -1767,16 +1837,24 @@ class PlaylistTab(QTableWidget):
 
         # Check track is readable
         if not file_is_readable(track.path):
+            self._set_unreadable_row(row_number)
             return None
 
-        # Notify musicmuster
+        # Mark as next track
-        plr = session.get(PlaylistRows, self._get_playlistrow_id(row_number))
+        self._set_next_track_row(row_number)
-        self.musicmuster.this_is_the_next_playlist_row(session, plr, self)
 
         # Update display
-        self.clear_selection()
         self.update_display(session)
 
+        # Notify musicmuster
+        self.musicmuster.this_is_the_next_track(session, self, track)
+
+    def _set_next_track_row(self, row: int) -> None:
+        """Mark this row as next track"""
+
+        self._meta_clear_next()
+        self._meta_set_attribute(row, RowMeta.NEXT)
+
     def _set_played_row(self, session: Session, row: int) -> None:
         """Mark this row as played"""
 
@@ -1849,6 +1927,11 @@ class PlaylistTab(QTableWidget):
         item = QTableWidgetItem(time_str)
         self.setItem(row, START_TIME, item)
 
+    def _set_unreadable_row(self, row: int) -> None:
+        """Mark this row as unreadable"""
+
+        self._meta_set_attribute(row, RowMeta.UNREADABLE)
+
     def _get_section_timing_string(self, ms: int,
                                    no_end: bool = False) -> None:
         """Return string describing section duration"""

app/ui/main_window.ui

@@ -854,7 +854,6 @@ padding-left: 8px;</string>
     <addaction name="actionPlay_next"/>
     <addaction name="actionFade"/>
     <addaction name="actionStop"/>
-    <addaction name="actionResume"/>
     <addaction name="separator"/>
     <addaction name="actionSkipToNext"/>
     <addaction name="separator"/>
@@ -1198,14 +1197,6 @@ padding-left: 8px;</string>
     <string>Ctrl+V</string>
    </property>
   </action>
-  <action name="actionResume">
-   <property name="text">
-    <string>Resume</string>
-   </property>
-   <property name="shortcut">
-    <string>Ctrl+R</string>
-   </property>
-  </action>
  </widget>
  <customwidgets>
   <customwidget>

app/ui/main_window_ui.py

@@ -503,8 +503,6 @@ class Ui_MainWindow(object):
         self.actionMark_for_moving.setObjectName("actionMark_for_moving")
         self.actionPaste = QtWidgets.QAction(MainWindow)
         self.actionPaste.setObjectName("actionPaste")
-        self.actionResume = QtWidgets.QAction(MainWindow)
-        self.actionResume.setObjectName("actionResume")
         self.menuFile.addAction(self.actionNewPlaylist)
         self.menuFile.addAction(self.actionOpenPlaylist)
         self.menuFile.addAction(self.actionClosePlaylist)
@@ -524,7 +522,6 @@ class Ui_MainWindow(object):
         self.menuPlaylist.addAction(self.actionPlay_next)
         self.menuPlaylist.addAction(self.actionFade)
         self.menuPlaylist.addAction(self.actionStop)
-        self.menuPlaylist.addAction(self.actionResume)
         self.menuPlaylist.addSeparator()
         self.menuPlaylist.addAction(self.actionSkipToNext)
         self.menuPlaylist.addSeparator()
@@ -649,7 +646,5 @@ class Ui_MainWindow(object):
         self.actionMark_for_moving.setShortcut(_translate("MainWindow", "Ctrl+C"))
         self.actionPaste.setText(_translate("MainWindow", "Paste"))
         self.actionPaste.setShortcut(_translate("MainWindow", "Ctrl+V"))
-        self.actionResume.setText(_translate("MainWindow", "Resume"))
-        self.actionResume.setShortcut(_translate("MainWindow", "Ctrl+R"))
 from infotabs import InfoTabs
 import icons_rc

pyproject.toml

@@ -24,24 +24,17 @@ python-Levenshtein = "^0.12.2"
 pyfzf = "^0.3.1"
 pydymenu = "^0.5.2"
 stackprinter = "^0.2.10"
-sqlalchemy-stubs = "^0.4"
-sqlalchemy2-stubs = "^0.0.2-alpha.31"
 
 [tool.poetry.dev-dependencies]
 ipdb = "^0.13.9"
 sqlalchemy-stubs = "^0.4"
 PyQt5-stubs = "^5.15.2"
+mypy = "^0.931"
 pytest = "^7.0.1"
 pytest-qt = "^4.0.2"
 pydub-stubs = "^0.25.1"
 line-profiler = "^4.0.2"
-flakehell = "^0.9.0"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"
-
-[tool.mypy]
-mypy_path = "/home/kae/.cache/pypoetry/virtualenvs/musicmuster-oWgGw1IG-py3.9:/home/kae/git/musicmuster/app"
-plugins = "sqlalchemy.ext.mypy.plugin"
-