WIP V3: move ImportTrack back to musicmuster.py

app/musicmuster.py

@@ -8,6 +8,8 @@ from typing import (
     Optional,
     Sequence,
 )
+from os.path import basename
+
 import argparse
 import os
 import subprocess
@@ -144,6 +146,51 @@ class CartButton(QPushButton):
         self.pgb.setGeometry(0, 0, self.width(), 10)
 
 
+class ImportTrack(QObject):
+    import_finished = pyqtSignal()
+
+    def __init__(
+        self, filenames: List[str], playlist_id: int, row_number: Optional[int]
+    ) -> None:
+        super().__init__()
+        self.filenames = filenames
+        self.playlist_id = playlist_id
+        self.next_row_number = row_number
+        self.signals = MusicMusterSignals()
+
+    def run(self):
+        """
+        Create track objects from passed files and add to visible playlist
+        """
+
+        with Session() as session:
+            for fname in self.filenames:
+                self.signals.status_message_signal.emit(
+                    f"Importing {basename(fname)}", 5000
+                )
+                metadata = helpers.get_file_metadata(fname)
+                try:
+                    track = Tracks(session, **metadata)
+                except Exception as e:
+                    self.signals.show_warning_signal.emit("Error importing track", e)
+                    return
+                helpers.normalise_track(track.path)
+                # We're importing potentially multiple tracks in a loop.
+                # If there's an error adding the track to the Tracks
+                # table, the session will rollback, thus losing any
+                # previous additions in this loop. So, commit now to
+                # lock in what we've just done.
+                session.commit()
+                self.signals.add_track_to_playlist_signal.emit(
+                    self.playlist_id, self.next_row_number, track.id, ""
+                )
+                self.next_row_number += 1
+            self.signals.status_message_signal.emit(
+                f"{len(self.filenames)} tracks imported", 10000
+            )
+            self.import_finished.emit()
+
+
 class Window(QMainWindow, Ui_MainWindow):
     def __init__(self, parent=None, *args, **kwargs) -> None:
         super().__init__(parent)
@@ -788,10 +835,19 @@ class Window(QMainWindow, Ui_MainWindow):
                         continue
                 new_tracks.append(fname)
 
-        # Pass to model to manage the import
+        # Import in separate thread
-        self.active_model().import_tracks(
+        self.import_thread = QThread()
-            new_tracks, self.active_tab().get_selected_row_number()
+        self.worker = ImportTrack(
+            new_tracks,
+            self.active_tab().playlist_id,
+            self.active_tab().get_selected_row_number(),
         )
+        self.worker.moveToThread(self.import_thread)
+        self.import_thread.started.connect(self.worker.run)
+        self.worker.import_finished.connect(self.import_thread.quit)
+        self.worker.import_finished.connect(self.worker.deleteLater)
+        self.import_thread.finished.connect(self.import_thread.deleteLater)
+        self.import_thread.start()
 
     def insert_header(self) -> None:
         """Show dialog box to enter header text and add to playlist"""

app/playlistmodel.py

@@ -2,16 +2,12 @@ from dataclasses import dataclass
 from datetime import datetime, timedelta
 from enum import auto, Enum
 from operator import attrgetter
-from os.path import basename
 from typing import List, Optional
 
 from PyQt6.QtCore import (
-    pyqtSignal,
     QAbstractTableModel,
     QModelIndex,
-    QObject,
     Qt,
-    QThread,
     QVariant,
 )
 from PyQt6.QtGui import (
@@ -642,28 +638,6 @@ class PlaylistModel(QAbstractTableModel):
 
         return prd.note
 
-    def import_tracks(
-        self, new_tracks: List[str], proposed_row_number: Optional[int]
-    ) -> None:
-        """
-        Import the file paths listed in new_tracks. The files have already been sanitised
-        so no further checks needed. Import in a separate thread as this is slow.
-        """
-
-        # Import in separate thread
-        self.import_thread = QThread()
-        self.worker = ImportTrack(
-            self,
-            new_tracks,
-            proposed_row_number,
-        )
-        self.worker.moveToThread(self.import_thread)
-        self.import_thread.started.connect(self.worker.run)
-        self.worker.import_finished.connect(self.import_thread.quit)
-        self.worker.import_finished.connect(self.worker.deleteLater)
-        self.import_thread.finished.connect(self.import_thread.deleteLater)
-        self.import_thread.start()
-
     def is_header_row(self, row_number: int) -> bool:
         """
         Return True if row is a header row, else False
@@ -864,7 +838,6 @@ class PlaylistModel(QAbstractTableModel):
                 self.refresh_row(session, row_number)
         self.invalidate_row(row_number)
 
-
     def rescan_track(self, row_number: int) -> None:
         """
         Rescan track at passed row number
@@ -941,7 +914,9 @@ class PlaylistModel(QAbstractTableModel):
                     return
                 track_sequence.next.set_plr(session, plr)
                 self.signals.next_track_changed_signal.emit()
-                self.signals.search_wikipedia_signal.emit(self.playlist_rows[row_number].title)
+                self.signals.search_wikipedia_signal.emit(
+                    self.playlist_rows[row_number].title
+                )
                 self.invalidate_row(row_number)
         self.update_track_times()
 
@@ -1116,46 +1091,3 @@ class PlaylistModel(QAbstractTableModel):
                 self.index(updated_row, Col.START_TIME.value),
                 self.index(updated_row, Col.END_TIME.value),
             )
-
-
-class ImportTrack(QObject):
-    import_finished = pyqtSignal()
-
-    def __init__(self, model: PlaylistModel, filenames: List[str], row_number) -> None:
-        super().__init__()
-        self.model = model
-        self.filenames = filenames
-        self.row_number = row_number
-        self.signals = MusicMusterSignals()
-
-    def run(self):
-        """
-        Create track objects from passed files and add to visible playlist
-        """
-
-        target_row = self.row_number
-        with Session() as session:
-            for fname in self.filenames:
-                self.signals.status_message_signal.emit(
-                    f"Importing {basename(fname)}", 5000
-                )
-                metadata = get_file_metadata(fname)
-                try:
-                    track = Tracks(session, **metadata)
-                except Exception as e:
-                    self.signals.show_warning_signal.emit("Error importing track", e)
-                    return
-                normalise_track(track.path)
-                self.model.insert_row(self.row_number, track.id)
-                # Insert next row under this one
-                target_row += 1
-                # We're importing potentially multiple tracks in a loop.
-                # If there's an error adding the track to the Tracks
-                # table, the session will rollback, thus losing any
-                # previous additions in this loop. So, commit now to
-                # lock in what we've just done.
-                session.commit()
-            self.signals.status_message_signal.emit(
-                f"{len(self.filenames)} tracks imported", 10000
-            )
-            self.import_finished.emit()