anna/emmental
anna
/
emmental
1
0
Fork 0
Code Issues 11 Pull Requests Projects 1 Releases 12 Wiki Activity

db: Convert the UserTable to a playlist.Model 

Implements: Issue #11 (Cache database items fields)
Implements: Issue #14 (Convert Tables into Gio.ListModels)
Signed-off-by: Anna Schumaker <Anna@NoWheyCreamery.com>
This commit is contained in:
Anna Schumaker 2021-10-10 13:49:19 -04:00
parent 67238ed385
commit 4235e794bd
5 changed files with 111 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
db/__init__.py
View File

@ -26,11 +26,11 @@ def make_fake_track(trackno, length, title, path, lib="/a/b/c", art="Test Artist
length, title, pathlib.Path(path)) length, title, pathlib.Path(path))
def reset(): def reset():
mods = [ artist, album, disc, genre, decade, year, library, state ] mods = [ state, user, artist, album, disc, genre, decade, year, library ]
for mod in mods: mod.Table.reset() for mod in mods: mod.Table.reset()
mods = [ track, user ] mods = [ track ]
for mod in mods: mod.Table.drop() for mod in mods: mod.Table.drop()
for mod in mods: mod.Table.do_create() for mod in mods: mod.Table.do_create()
@ -38,8 +38,6 @@ def reset():
genre.Map.reset() genre.Map.reset()
user.Map.reset() user.Map.reset()
user.TempMap.reset() user.TempMap.reset()
user.Table.create_default_playlists()
if lib.version.TESTING: reset() if lib.version.TESTING: reset()
user.Table.create_default_playlists()

3
db/playlist.py
View File

@ -50,7 +50,8 @@ class ParentPlaylist(Playlist):
class Model(table.Model): class Model(table.Model):
def insert(self, *args, **kwargs): def insert(self, *args, **kwargs):
return super().insert(state.Table.insert(), *args) loop = kwargs.pop("loop", False)
return super().insert(state.Table.insert(loop=loop), *args)
def delete(self, plist): def delete(self, plist):
state.Table.delete(plist.plist_state) state.Table.delete(plist.plist_state)

2
db/table.py
View File

@ -49,8 +49,8 @@ class Table:
class Model(GObject.GObject, Gio.ListModel, Table): class Model(GObject.GObject, Gio.ListModel, Table):
def __init__(self, table, order): def __init__(self, table, order):
GObject.GObject.__init__(self) GObject.GObject.__init__(self)
Table.__init__(self, table)
self.order = order self.order = order
Table.__init__(self, table)
def do_get_item_type(self): def do_get_item_type(self):
return GObject.TYPE_PYOBJECT return GObject.TYPE_PYOBJECT

109
db/test_user.py
View File

@ -4,73 +4,80 @@ import sqlite3
import unittest import unittest
from gi.repository import GObject from gi.repository import GObject
expected = [ (1, 1, "Collection", "collection", 0, 1), class TestCollection(unittest.TestCase):
(2, 2, "Favorites", "favorites", 0, 0), def test_init(self):
(3, 3, "New Tracks", "new tracks", 0, 0), collection = db.user.Table.find("Collection")
(4, 4, "Previous", "previous", 0, 0), self.assertIsInstance(collection, db.user.UserPlaylist)
(5, 5, "Queued Tracks", "queued tracks", 0, 0) ]
class TestFavorites(unittest.TestCase):
def test_init(self):
favorites = db.user.Table.find("Favorites")
self.assertIsInstance(favorites, db.user.UserPlaylist)
class TestNewTracks(unittest.TestCase):
def test_init(self):
new = db.user.Table.find("New Tracks")
self.assertIsInstance(new, db.user.UserPlaylist)
class TestPrevious(unittest.TestCase):
def test_init(self):
previous = db.user.Table.find("Previous")
self.assertIsInstance(previous, db.user.UserPlaylist)
class TestQueuedTracks(unittest.TestCase):
def test_init(self):
queued = db.user.Table.find("Queued Tracks")
self.assertIsInstance(queued, db.user.UserPlaylist)
class TestUserPlaylist(unittest.TestCase):
def test_init(self):
plist = db.user.Table.find("Test Playlist")
self.assertIsInstance(plist, db.playlist.Playlist)
self.assertEqual(plist._name, "Test Playlist")
self.assertEqual(plist.get_property("name"), "Test Playlist")
class TestUserTable(unittest.TestCase): class TestUserTable(unittest.TestCase):
def setUp(self): def setUp(self):
db.reset() db.reset()
def test_playlist_table_init(self): def test_init(self):
self.assertIsInstance(db.user.Table, db.user.PlaylistTable) table = db.user.UserTable()
self.assertEqual(db.user.Default, [ "Collection", "Favorites", "New Tracks", self.assertIsInstance(table, db.playlist.Model)
"Previous", "Queued Tracks" ]) self.assertEqual(table.table, "playlists")
self.assertEqual(table.order, "sort")
cur = db.sql.execute("SELECT playlistid, " self.assertIsInstance(db.user.Table, db.user.UserTable)
"playlists.plstateid, " db.sql.execute("SELECT playlistid,plstateid,name,sort FROM playlists")
"name, "
"playlists.sort, "
"random,loop "
"FROM playlists "
"JOIN playlist_states "
"ON playlists.plstateid = playlist_states.plstateid")
rows = cur.fetchall()
self.assertEqual(tuple(rows[0]), expected[0])
self.assertEqual(tuple(rows[1]), expected[1])
self.assertEqual(tuple(rows[2]), expected[2])
self.assertEqual(tuple(rows[3]), expected[3])
self.assertEqual(tuple(rows[4]), expected[4])
def test_playlist_table_insert(self): def test_insert(self):
playlist = db.user.Table.insert("Test Playlist") table = db.user.UserTable()
self.assertIsInstance(playlist, db.user.Playlist) playlist = table.find("Test Playlist")
self.assertIsInstance(playlist, db.objects.Tag)
self.assertEqual(playlist.name, "Test Playlist") self.assertIsInstance(playlist, db.user.UserPlaylist)
self.assertEqual(playlist.sort, "test playlist") self.assertEqual(playlist._name, "Test Playlist")
self.assertIsInstance(playlist.playlist_state, db.state.PlaylistState)
with self.assertRaises(sqlite3.IntegrityError): with self.assertRaises(sqlite3.IntegrityError):
db.user.Table.insert("Test Playlist") db.user.Table.insert("Test Playlist")
def test_playlist_table_delete(self): def test_lookup(self):
playlist = db.user.Table.find("Test Playlist")
track = db.make_fake_track(1, 1.234, "Test Title", "/a/b.cde")
db.user.Map.insert(playlist, track)
db.user.TempMap.insert(playlist, track)
db.user.Table.delete(playlist)
self.assertIsNone(db.user.Table.lookup("Test Playlist"))
self.assertEqual(db.user.Map.lookup_playlists(track), [ ])
self.assertEqual(db.user.TempMap.lookup_playlists(track), [ ])
def test_playlist_table_get(self):
playlist = db.user.Playlist(1)
self.assertEqual(db.user.Table.get(1), playlist)
self.assertIsNone(db.user.Table.get(6))
def test_playlist_table_lookup(self):
playlist = db.user.Table.insert("Test Playlist") playlist = db.user.Table.insert("Test Playlist")
self.assertEqual(db.user.Table.lookup("Test Playlist"), playlist) self.assertEqual(db.user.Table.lookup("Test Playlist"), playlist)
self.assertIsNone(db.user.Table.lookup("none")) self.assertIsNone(db.user.Table.lookup("none"))
def test_playlist_create_default_playlists(self): def test_default_playlists(self):
db.user.Table.create_default_playlists() table = db.user.UserTable()
self.assertEqual(table.get_n_items(), 5)
self.assertEqual(table.get_item(0).name, "Collection")
self.assertEqual(table.get_item(1).name, "Favorites")
self.assertEqual(table.get_item(2).name, "New Tracks")
self.assertEqual(table.get_item(3).name, "Previous")
self.assertEqual(table.get_item(4).name, "Queued Tracks")
class TestPlaylistMap(unittest.TestCase): class TestPlaylistMap(unittest.TestCase):
@ -81,7 +88,7 @@ class TestPlaylistMap(unittest.TestCase):
self.assertIsInstance(db.user.Map, db.user.PlaylistMap) self.assertIsInstance(db.user.Map, db.user.PlaylistMap)
self.assertIsInstance(db.user.TempMap, db.user.PlaylistMap) self.assertIsInstance(db.user.TempMap, db.user.PlaylistMap)
self.assertEqual(db.user.Map.map_lhs, db.user.Playlist) self.assertEqual(db.user.Map.map_lhs, db.user.Table.get)
self.assertEqual(db.user.Map.map_rhs, db.track.Track) self.assertEqual(db.user.Map.map_rhs, db.track.Track)
self.assertFalse(db.user.Map.temporary) self.assertFalse(db.user.Map.temporary)

105
db/user.py
View File

@ -10,62 +10,53 @@
# | name -> playlistid | # | name -> playlistid |
# +--------------------+ # +--------------------+
from gi.repository import GObject from gi.repository import GObject
from .sql import execute
from . import objects from . import objects
from . import state from . import playlist
from . import sql
from . import track from . import track
Default = [ "Collection", "Favorites", "New Tracks", class UserPlaylist(playlist.Playlist):
"Previous", "Queued Tracks" ] def __init__(self, row):
playlist.Playlist.__init__(self, row)
self._name = row["name"]
class Playlist(objects.Tag):
def do_get_column(self, column):
return execute(f"SELECT {column} FROM playlists "
"WHERE playlistid=?", [ self.rowid ])
@GObject.Property @GObject.Property
def playlist_state(self): def name(self): return self._name
return state.Table.get(self.get_column("plstateid"))
class PlaylistTable(objects.Table): class UserTable(playlist.Model):
def __init__(self): def __init__(self):
objects.Table.__init__(self, "playlists", Playlist) playlist.Model.__init__(self, "playlists", "sort")
def do_create(self): def do_create(self):
execute("CREATE TABLE IF NOT EXISTS playlists " sql.execute("CREATE TABLE IF NOT EXISTS playlists "
"(playlistid INTEGER PRIMARY KEY, " "(playlistid INTEGER PRIMARY KEY, "
" plstateid INTEGER NOT NULL, " " plstateid INTEGER NOT NULL, "
" name TEXT UNIQUE, " " name TEXT UNIQUE, "
" sort TEXT, " " sort TEXT, "
" FOREIGN KEY (plstateid) REFERENCES playlist_states(plstateid))") " FOREIGN KEY (plstateid) REFERENCES playlist_states(plstateid))")
execute("CREATE INDEX IF NOT EXISTS playlist_index " sql.execute("CREATE INDEX IF NOT EXISTS playlist_index ON playlists(name)")
"ON playlists(name)")
def do_insert(self, name, loop=False): self.find("Collection", loop=True)
plstate = state.Table.insert(random=False, loop=loop) self.find("Favorites")
return execute("INSERT INTO playlists (plstateid, name, sort) " self.find("New Tracks")
"VALUES (?, ?, ?)", (plstate.rowid, name, name.casefold())) self.find("Previous")
self.find("Queued Tracks")
def do_delete(self, playlist): def do_factory(self, row):
Map.delete_playlist(playlist) return UserPlaylist(row)
TempMap.delete_playlist(playlist)
return execute("DELETE FROM playlists WHERE playlistid=?", [ int(playlist) ])
def do_get(self, rowid): def do_insert(self, plstate, name):
return execute("SELECT playlistid FROM playlists " return sql.execute("INSERT INTO playlists (plstateid, name, sort) "
"WHERE playlistid=?", [ rowid ]) "VALUES (?, ?, ?)", [ plstate.rowid, name, name.casefold() ])
def do_lookup(self, name): def do_lookup(self, name):
return execute("SELECT playlistid FROM playlists " return sql.execute("SELECT * FROM playlists WHERE name=?", [ name ])
"WHERE name=?", [ name ])
def create_default_playlists(self): def find(self, name, loop=False):
for name in Default: if (res := self.lookup(name)) == None:
if (plist := self.lookup(name)) != None: res = self.insert(name, loop=loop)
continue return res
self.do_insert(name, name == "Collection")
class PlaylistMap(objects.Map): class PlaylistMap(objects.Map):
@ -73,35 +64,35 @@ class PlaylistMap(objects.Map):
name = "playlist_map" if temp==False else "temp_playlist_map" name = "playlist_map" if temp==False else "temp_playlist_map"
self.temporary = temp self.temporary = temp
objects.Map.__init__(self, name, Playlist, track.Track) objects.Map.__init__(self, name, Table.get, track.Track)
self.lookup_tracks = self.lookup_rhs self.lookup_tracks = self.lookup_rhs
self.lookup_playlists = self.lookup_lhs self.lookup_playlists = self.lookup_lhs
def do_create(self): def do_create(self):
temp = "" if self.temporary == False else "TEMPORARY" temp = "" if self.temporary == False else "TEMPORARY"
execute(f"CREATE {temp} TABLE IF NOT EXISTS {self.map_name} " sql.execute(f"CREATE {temp} TABLE IF NOT EXISTS {self.map_name} "
"(playlistid INTEGER, " "(playlistid INTEGER, "
" trackid INTEGER, " " trackid INTEGER, "
" FOREIGN KEY(playlistid) REFERENCES playlists(playlistid), " " FOREIGN KEY(playlistid) REFERENCES playlists(playlistid), "
" FOREIGN KEY(trackid) REFERENCES tracks(trackid), " " FOREIGN KEY(trackid) REFERENCES tracks(trackid), "
" UNIQUE(playlistid, trackid))") " UNIQUE(playlistid, trackid))")
def do_insert(self, playlist, track): def do_insert(self, playlist, track):
execute(f"INSERT INTO {self.map_name} (playlistid, trackid) " sql.execute(f"INSERT INTO {self.map_name} (playlistid, trackid) "
"VALUES (?, ?)", [ int(playlist), int(track) ]) "VALUES (?, ?)", [ playlist.rowid, int(track) ])
def do_delete(self, playlist, track): def do_delete(self, playlist, track):
return execute(f"DELETE FROM {self.map_name} " return sql.execute(f"DELETE FROM {self.map_name} "
"WHERE playlistid=? AND trackid=?", "WHERE playlistid=? AND trackid=?",
[ int(playlist), int(track) ]) [ playlist.rowid, int(track) ])
def do_lookup_rhs(self, playlist): def do_lookup_rhs(self, playlist):
return execute(f"SELECT trackid FROM {self.map_name} " return sql.execute(f"SELECT trackid FROM {self.map_name} "
"WHERE playlistid=?", [ int(playlist) ]) "WHERE playlistid=?", [ playlist.rowid ])
def do_lookup_lhs(self, track): def do_lookup_lhs(self, track):
return execute(f"SELECT playlistid FROM {self.map_name} " return sql.execute(f"SELECT playlistid FROM {self.map_name} "
"WHERE trackid=?", [ int(track) ]) "WHERE trackid=?", [ int(track) ])
def delete_track(self, track): def delete_track(self, track):
for playlist in self.lookup_playlists(track): for playlist in self.lookup_playlists(track):
@ -112,6 +103,6 @@ class PlaylistMap(objects.Map):
self.delete(playlist, track) self.delete(playlist, track)
Table = PlaylistTable() Table = UserTable()
Map = PlaylistMap(temp=False) Map = PlaylistMap(temp=False)
TempMap = PlaylistMap(temp=True) TempMap = PlaylistMap(temp=True)