audio: Pick the next track from the current playlist

Signed-off-by: Anna Schumaker <Anna@NoWheyCreamery.com>

audio/artwork.py

@@ -22,7 +22,7 @@ class Artwork(Gtk.AspectFrame):
         self.on_track_changed(player, None, player.track)
 
     def __set_from_cover_jpg__(self, track):
-        cover = track.filepath().parent / "cover.jpg"
+        cover = track.path.parent / "cover.jpg"
         if cover.exists():
             self.picture.set_filename(str(cover))
             return True

audio/nowplaying.py

@@ -22,7 +22,7 @@ class TrackArtist(Gtk.Label):
         self.add_css_class("subtitle")
 
     def on_track_changed(self, player, old, new):
-        text = f"by {new.artist}" if new else "The Cheesy Music Player"
+        text = f"by {new.artist.name}" if new else "The Cheesy Music Player"
         self.set_markup(f"<big>{GLib.markup_escape_text(text)}</big>")
 
 

audio/player.py

@@ -1,53 +1,52 @@
 # Copyright 2021 (c) Anna Schumaker.
 import db
 import lib
-import tagdb
 from gi.repository import GObject
 from . import bass
 from . import scale
-from . import selector
 
 
 class Player(bass.BassPlayer):
     def __init__(self):
         bass.BassPlayer.__init__(self)
         self.Autopause = scale.AutoPauseScale()
-        self.Selector = selector.TagdbSelector()
         self.playlist = None
         self.track = None
 
         self.set_playlist(db.find_playlist(lib.settings.get_int("audio.plstateid")))
-        self.change_track(tagdb.Tracks[lib.settings.get_int("audio.trackid")])
+        self.change_track(db.track.Table.get(lib.settings.get_int("audio.trackid")))
-        if self.track:
-            self.track.add_to_playlist("Previous")
 
-    def change_track(self, track, reset=False):
+    def change_track(self, track, reset=False, add_prev=True):
         if self.track and self.play_percent > (2 / 3):
             self.track.played()
         if reset:
             self.uri = None
         self.emit("track-changed", self.track, track)
+        if track and add_prev:
+            db.user.Table.find("Previous").add_track(track)
 
     def do_about_to_finish(self):
         if self.Autopause.get_value() != 0:
             self.Autopause.decrement()
-            self.change_track(self.Selector.next())
+            self.change_track(self.playlist.next_track())
 
     def do_eos(self):
         self.Autopause.decrement()
-        self.change_track(self.Selector.next())
+        self.change_track(self.playlist.next_track())
         self.playing = self.Autopause.keep_playing
 
     def play(self): self.playing = True
     def pause(self): self.playing = False
     def playpause(self): self.playing = not self.playing
 
-    def play_track(self, track):
+    def play_track(self, track, add_prev=True):
-        self.change_track(track, reset=True)
+        self.change_track(track, reset=True, add_prev=add_prev)
         self.play()
 
-    def next(self): self.play_track(self.Selector.next())
+    def next(self): self.play_track(self.playlist.next_track())
-    def previous(self): self.play_track(self.Selector.previous())
+    def previous(self):
+        previous = db.user.Table.find("Previous")
+        self.play_track(previous.previous_track(), add_prev=False)
 
     def set_playlist(self, plist):
         if plist is None:
@@ -55,12 +54,12 @@ class Player(bass.BassPlayer):
         if plist != self.playlist:
             self.emit("playlist-changed", self.playlist, plist)
 
-    @GObject.Signal(arg_types=(tagdb.track.Track, tagdb.track.Track))
+    @GObject.Signal(arg_types=(db.track.Track, db.track.Track))
     def track_changed(self, prev, new):
         self.track = new
         if self.track:
-            lib.settings.set("audio.trackid", new.trackid)
+            lib.settings.set("audio.trackid", new.rowid)
-            self.uri = new.filepath().absolute().as_uri()
+            self.uri = new.path.absolute().as_uri()
 
     @GObject.Signal(arg_types=(db.playlist.Playlist, db.playlist.Playlist))
     def playlist_changed(self, prev, new):

audio/test_audio.py

@@ -1,20 +1,20 @@
 # Copyright 2021 (c) Anna Schumaker.
 import audio
+import db
 import pathlib
-import tagdb
 import unittest
 from gi.repository import Gtk
 
 test_album = pathlib.Path("./data/Test Album/")
+test_track = test_album / "01 - Test Track.ogg"
 
 class TestAudio(unittest.TestCase):
     def test_init(self):
         self.assertIsInstance(audio.Player, audio.player.Player)
 
     def test_play_track(self):
-        lib = tagdb.Library.add(test_album)
+        db.reset()
-        lib.scan().join()
+        track = db.make_fake_track(1, 10, "Test Track", test_track, test_album)
-        track = [ t for t in lib.tracks if t.tracknumber == 1 ][0]
 
         self.assertTrue(audio.play_track(track))
         self.assertTrue(audio.Player.playing)

audio/test_nowplaying.py

@@ -1,14 +1,19 @@
 # Copyright 2021 (c) Anna Schumaker.
+import db
 import unittest
 from gi.repository import GObject
 from gi.repository import Gtk
 from . import nowplaying
 
+class FakeArtist(GObject.GObject):
+    def __init__(self):
+        self.name = "Test Artist"
+
 class FakeTrack(GObject.GObject):
     def __init__(self):
         GObject.GObject.__init__(self)
         self.title = "Test Title"
-        self.artist = "Test Artist"
+        self.artist = FakeArtist()
 
 class FakePlayer(GObject.GObject):
     def __init__(self):

audio/test_player.py

@@ -2,14 +2,13 @@
 import db
 import lib
 import pathlib
-import tagdb
+import scanner
 import unittest
 from gi.repository import GLib
 from gi.repository import Gst
 from . import bass
 from . import player
 from . import scale
-from . import selector
 
 main_context = GLib.main_context_default()
 test_album = pathlib.Path("./data/Test Album/")
@@ -17,38 +16,18 @@ test_track = test_album / "01 - Test Track.ogg"
 test_uri = test_track.absolute().as_uri()
 
 
-class FakeSelector(selector.Selector):
-    def __init__(self, library):
-        selector.Selector.__init__(self)
-        t1 = [ t for t in library.tracks if t.tracknumber == 1 ][0]
-        t2 = [ t for t in library.tracks if t.tracknumber == 11 ][0]
-        self.tracks = [ t1, t2 ]
-        self.cur = -1
-
-    def next(self):
-        self.cur += 1
-        return self.tracks[self.cur]
-
-    def previous(self):
-        self.cur -= 1
-        return self.tracks[self.cur]
-
-
-
 class TestPlayer(unittest.TestCase):
     def setUpClass():
-        tagdb.reset()
+        db.reset()
-        lib = tagdb.Library.add(test_album)
+        lib = db.library.Table.find(test_album)
-        lib.scan().join()
+        scanner.Queue.push(scanner.task.DirectoryTask(lib, test_album))
+        while scanner.Queue.run() == GLib.SOURCE_CONTINUE: pass
 
     def setUp(self):
         self.changed = None
         lib.settings.reset()
-        self.library = tagdb.Library.store[test_album]
+        self.library = db.library.Table.lookup(test_album)
-        self.track = [ t for t in self.library.tracks if t.tracknumber == 1 ][0]
+        self.track = db.track.Table.lookup(test_track)
-
-    def tearDownClass():
-        tagdb.reset()
 
     def on_track_changed(self, player, prev, new):
         self.changed = (prev, new)
@@ -56,12 +35,11 @@ class TestPlayer(unittest.TestCase):
     def on_playlist_changed(self, player, prev, new):
         self.changed = (prev, new)
 
-    def test_player_init(self):
+    def test_init(self):
         play = player.Player()
         self.assertIsInstance(play, bass.BassPlayer)
         self.assertIsInstance(play.bus, Gst.Bus)
         self.assertIsInstance(play.Autopause, scale.AutoPauseScale)
-        self.assertIsInstance(play.Selector, selector.Selector)
         self.assertIsNone(play.track)
 
         self.assertEqual(play.playlist, db.user.Table.find("Collection"))
@@ -106,13 +84,13 @@ class TestPlayer(unittest.TestCase):
 
         play.change_track(self.track, reset=True)
         self.assertEqual(play.track, self.track)
-        self.assertEqual(lib.settings.get_int("audio.trackid"), self.track.trackid)
+        self.assertEqual(lib.settings.get_int("audio.trackid"), self.track.rowid)
         self.assertEqual(self.changed, (None, self.track) )
 
-        tagdb.tags.User["Previous"].tracks.clear()
+        db.sql.execute("DELETE FROM temp_playlist_map")
         play2 = player.Player()
         self.assertEqual(play2.track, self.track)
-        self.assertIn(self.track, tagdb.tags.User["Previous"].tracks)
+        self.assertEqual(db.user.Table.find("Previous").get_track(0), self.track)
 
     def test_play_track(self):
         play = player.Player()
@@ -121,7 +99,7 @@ class TestPlayer(unittest.TestCase):
         self.assertTrue(play.playing)
         play.pause()
 
-    def test_player_play_pause(self):
+    def test_play_pause(self):
         play = player.Player()
 
         play.play_track(self.track)
@@ -142,20 +120,23 @@ class TestPlayer(unittest.TestCase):
         play.pause()
         self.assertFalse(play.playing)
 
-    def test_player_next_previous(self):
+    def test_next_previous(self):
-        select = FakeSelector(self.library)
+        collection = db.user.Table.find("Collection")
         play = player.Player()
+        play.set_playlist(collection)
         play.connect("track-changed", self.on_track_changed)
-        play.Selector = select
+
+        track0 = collection.get_track(0)
+        track1 = collection.get_track(1)
 
         play.next()
-        self.assertEqual(play.track.trackid, 1)
+        self.assertEqual(play.track, track0)
-        self.assertEqual(self.changed, (None, tagdb.Tracks[1]) )
+        self.assertEqual(self.changed, (None, track0))
 
         play.next()
-        self.assertEqual(play.track.trackid, 11)
+        self.assertEqual(play.track, track1)
-        self.assertEqual(self.changed, (tagdb.Tracks[1], tagdb.Tracks[11]) )
+        self.assertEqual(self.changed, (track0, track1))
 
         play.previous()
-        self.assertEqual(play.track.trackid, 1)
+        self.assertEqual(play.track, track0)
-        self.assertEqual(self.changed, (tagdb.Tracks[11], tagdb.Tracks[1]) )
+        self.assertEqual(self.changed, (track1, track0))