Row timings improved but next row not always correct

app/playlistmodel.py

@@ -101,7 +101,9 @@ class PlaylistModel(QAbstractTableModel):
         self.signals.signal_set_next_row.connect(self.set_next_row)
         self.signals.signal_track_started.connect(self.track_started)
         self.signals.signal_track_ended.connect(self.previous_track_ended)
-        self.signals.signal_next_track_changed.connect(self.signal_next_track_changed_handler)
+        self.signals.signal_next_track_changed.connect(
+            self.signal_next_track_changed_handler
+        )
 
         # Populate self.playlist_rows
         for dto in ds.playlistrows_by_playlist(self.playlist_id):
@@ -697,9 +699,7 @@ class PlaylistModel(QAbstractTableModel):
                     move_existing = True
 
         if move_existing and existing_plr:
-            self.move_track_add_note(
+            self.move_track_add_note(new_row_number, existing_plr, note="")
-                new_row_number, existing_plr, note=""
-            )
         else:
             super().beginInsertRows(QModelIndex(), new_row_number, new_row_number)
 
@@ -1500,6 +1500,25 @@ class PlaylistModel(QAbstractTableModel):
 
         return end_time
 
+    def update_start_end_times(
+        self, plr: PlaylistRow, start_time: dt.datetime, end_time: dt.datetime
+    ) -> bool:
+        """
+        Set the the start time of the passed PlaylistRow. If we changed
+        it, return True else return False.
+        """
+
+        changed = False
+
+        if start_time != plr.forecast_start_time:
+            plr.forecast_start_time = start_time
+            changed = True
+        if end_time != plr.forecast_end_time:
+            plr.forecast_end_time = end_time
+            changed = True
+
+        return changed
+
     # @log_call
     def update_track_times(self) -> None:
         """
@@ -1525,15 +1544,14 @@ class PlaylistModel(QAbstractTableModel):
             new_start_time = self.track_sequence.current.start_time
             if not new_start_time:
                 raise ApplicationError(
-                    f"Can't get start time for current track ({self.track_sequence.current=})")
+                    f"Can't get start time for current track ({self.track_sequence.current=})"
+                )
 
-            if new_start_time != plr.forecast_start_time:
+            next_start_time = self.get_end_time(
-                plr.forecast_start_time = new_start_time
+                current_track_row_number, new_start_time
-                update_rows.append(current_track_row_number)
+            )
 
-            next_start_time = self.get_end_time(current_track_row_number, new_start_time)
+            if self.update_start_end_times(plr, new_start_time, next_start_time):
-            if next_start_time != plr.forecast_end_time:
-                plr.forecast_end_time = next_start_time
                 update_rows.append(current_track_row_number)
 
         # If we have a next track, note row number
@@ -1565,24 +1583,27 @@ class PlaylistModel(QAbstractTableModel):
                 continue
 
             # Set start time for next row if we have a current track
-            if (current_track_row_number and row_number == next_track_row):
+            if current_track_row_number and row_number == next_track_row:
                 plr = self.playlist_rows[row_number]
-                next_start_time = self.playlist_rows[current_track_row_number].forecast_end_time
+                this_start_time = self.playlist_rows[
-                if next_start_time != plr.forecast_start_time:
+                    current_track_row_number
-                    plr.forecast_start_time = next_start_time
+                ].forecast_end_time
-                    update_rows.append(row_number)
+                if this_start_time:
-
+                    next_start_time = self.get_end_time(
-                # Get next start time, which is end time for this track
+                        current_track_row_number, this_start_time
-                if next_start_time:
+                    )
-                    next_start_time = self.get_end_time(current_track_row_number, next_start_time)
+                    if self.update_start_end_times(
-                    if next_start_time != plr.forecast_end_time:
+                        plr, this_start_time, next_start_time
-                        plr.forecast_end_time = next_start_time
+                    ):
-                        update_rows.append(current_track_row_number)
+                        update_rows.append(row_number)
-                continue
 
             # If we're between the current and next row, zero out
             # times
-            if (current_track_row_number or row_count) < row_number < (next_track_row or 0):
+            if (
+                (current_track_row_number or row_count)
+                < row_number
+                < (next_track_row or 0)
+            ):
                 plr.forecast_start_time = plr.forecast_end_time = None
                 update_rows.append(row_number)
                 continue
@@ -1591,14 +1612,9 @@ class PlaylistModel(QAbstractTableModel):
             if not next_start_time:
                 continue
             plr = self.playlist_rows[row_number]
-            if next_start_time != plr.forecast_start_time:
+            start_time = next_start_time
-                plr.forecast_start_time = next_start_time
-                update_rows.append(row_number)
-
-            # Get next start time, which is end time for this track
             next_start_time = self.get_end_time(row_number, next_start_time)
-            if next_start_time != plr.forecast_end_time:
+            if self.update_start_end_times(plr, start_time, next_start_time):
-                plr.forecast_end_time = next_start_time
                 update_rows.append(row_number)
             continue