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

db: Convert the GenreTable into 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-09 16:50:56 -04:00
parent 90c6593921
commit f7907e4142
4 changed files with 67 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
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))
def reset():
mods = [ decade, year, library, state ]
mods = [ genre, decade, year, library, state ]
for mod in mods: mod.Table.reset()
mods = [ artist, album, disc, genre, track, user ]
mods = [ artist, album, disc, track, user ]
for mod in mods: mod.Table.drop()
for mod in mods: mod.Table.do_create()

85
db/genre.py
View File

@ -15,82 +15,75 @@
# | genreid | trackid |
# +---------+---------+
from gi.repository import GObject
from .sql import execute
from . import objects
from . import state
from . import playlist
from . import track
from . import sql
class Genre(objects.Tag):
def do_get_column(self, column):
return execute(f"SELECT {column} FROM genres "
"WHERE genreid=?", [ self.rowid ])
class Genre(playlist.Playlist):
def __init__(self, row):
playlist.Playlist.__init__(self, row)
self._name = row["name"]
@GObject.Property
def playlist_state(self):
return state.Table.get(self.get_column("plstateid"))
def name(self): return self._name
class GenreTable(objects.Table):
class GenreTable(playlist.Model):
def __init__(self):
objects.Table.__init__(self, "genres", Genre)
playlist.Model.__init__(self, "genres", "sort")
def do_create(self):
execute("CREATE TABLE IF NOT EXISTS genres "
"(genreid INTEGER PRIMARY KEY, "
" plstateid INTEGER NOT NULL, "
" name TEXT UNIQUE, "
" sort TEXT)")
execute("CREATE INDEX IF NOT EXISTS genre_index "
"ON genres(name)")
sql.execute("CREATE TABLE IF NOT EXISTS genres "
"(genreid INTEGER PRIMARY KEY, "
" plstateid INTEGER NOT NULL, "
" name TEXT UNIQUE, "
" sort TEXT, "
" FOREIGN KEY(plstateid) REFERENCES playlist_states(plstateid))")
sql.execute("CREATE INDEX IF NOT EXISTS genre_index "
"ON genres(name)")
def do_insert(self, name):
plstate = state.Table.insert(random=False, loop=False)
return execute("INSERT INTO genres (plstateid, name, sort) "
"VALUES (?, ?, ?)",
[ plstate.rowid, name, name.casefold() ])
def do_factory(self, row):
return Genre(row)
def do_delete(self, genre):
state.Table.delete(genre.playlist_state)
return execute("DELETE FROM genres WHERE genreid=?", [ int(genre) ])
def do_get(self, rowid):
return execute("SELECT genreid FROM genres "
"WHERE genreid=?", [ rowid ])
def do_insert(self, plstate, name):
return sql.execute("INSERT INTO genres (plstateid, name, sort) "
"VALUES (?, ?, ?)",
[ plstate.rowid, name, name.casefold() ])
def do_lookup(self, name):
return execute("SELECT genreid FROM genres "
"WHERE name=?", [ name ])
return sql.execute("SELECT * FROM genres WHERE name=?", [ name ])
class GenreMap(objects.Map):
def __init__(self):
objects.Map.__init__(self, "genre_map", Genre, track.Track)
objects.Map.__init__(self, "genre_map", Table.get, track.Track)
self.lookup_tracks = self.lookup_rhs
self.lookup_genres = self.lookup_lhs
def do_create(self):
execute("CREATE TABLE IF NOT EXISTS genre_map "
"(genreid INTEGER, "
" trackid INTEGER, "
" FOREIGN KEY(genreid) REFERENCES genres(genreid), "
" FOREIGN KEY(trackid) REFERENCES tracks(trackid), "
" UNIQUE(genreid, trackid))")
sql.execute("CREATE TABLE IF NOT EXISTS genre_map "
"(genreid INTEGER, "
" trackid INTEGER, "
" FOREIGN KEY(genreid) REFERENCES genres(genreid), "
" FOREIGN KEY(trackid) REFERENCES tracks(trackid), "
" UNIQUE(genreid, trackid))")
def do_insert(self, genre, track):
execute("INSERT INTO genre_map (genreid, trackid) "
"VALUES (?, ?)", [ int(genre), int(track) ])
sql.execute("INSERT INTO genre_map (genreid, trackid) "
"VALUES (?, ?)", [ genre.rowid, int(track) ])
def do_delete(self, genre, track):
return execute("DELETE FROM genre_map WHERE genreid=? AND trackid=?",
[ int(genre), int(track) ])
return sql.execute("DELETE FROM genre_map WHERE genreid=? AND trackid=?",
[ genre.rowid, int(track) ])
def do_lookup_rhs(self, genre):
return execute("SELECT trackid FROM genre_map "
"WHERE genreid=?", [ int(genre) ])
return sql.execute("SELECT trackid FROM genre_map "
"WHERE genreid=?", [ genre.rowid ])
def do_lookup_lhs(self, track):
return execute("SELECT genreid FROM genre_map "
"WHERE trackid=?", [ int(track) ])
return sql.execute("SELECT genreid FROM genre_map "
"WHERE trackid=?", [ int(track) ])
def delete_track(self, track):
for genre in self.lookup_genres(track):

4
db/objects.py
View File

@ -118,8 +118,8 @@ class Map(GObject.GObject):
execute(f"DROP TABLE {self.map_name}")
self.do_create()
@GObject.Signal(arg_types=(Row,Row))
@GObject.Signal(arg_types=(GObject.GObject,Row))
def row_inserted(self, lhs, rhs): pass
@GObject.Signal(arg_types=(Row,Row))
@GObject.Signal(arg_types=(GObject.GObject,Row))
def row_deleted(self, lhs, rhs): pass

52
db/test_genre.py
View File

@ -5,45 +5,41 @@ import unittest
from gi.repository import GObject
class TestGenreTable(unittest.TestCase):
def on_row_inserted(self, table, row):
self.row_inserted = row
class TestGenre(unittest.TestCase):
def setUp(self):
db.reset()
def test_genre_table_init(self):
def test_init(self):
genre = db.genre.Table.find("Test Genre")
self.assertIsInstance(genre, db.playlist.Playlist)
self.assertEqual(genre._name, "Test Genre")
self.assertEqual(genre.get_property("name"), "Test Genre")
class TestGenreTable(unittest.TestCase):
def setUp(self):
db.reset()
def test_init(self):
table = db.genre.GenreTable()
self.assertIsInstance(table, db.playlist.Model)
self.assertEqual(table.table, "genres")
self.assertEqual(table.order, "sort")
self.assertIsInstance(db.genre.Table, db.genre.GenreTable)
db.sql.execute("SELECT genreid,plstateid,name,sort FROM genres")
def test_genre_table_insert(self):
db.genre.Table.connect("row-inserted", self.on_row_inserted)
def test_insert(self):
table = db.genre.GenreTable()
genre = table.insert("Test Genre")
genre = db.genre.Table.insert("Test Genre")
self.assertIsInstance(genre, db.genre.Genre)
self.assertIsInstance(genre, db.objects.Tag)
self.assertEqual(self.row_inserted, genre)
self.assertEqual(genre.name, "Test Genre")
self.assertEqual(genre.sort, "test genre")
self.assertIsInstance(genre.playlist_state, db.state.PlaylistState)
self.assertEqual(genre._name, "Test Genre")
with self.assertRaises(sqlite3.IntegrityError):
db.genre.Table.insert("Test Genre")
def test_genre_table_delete(self):
genre = db.genre.Table.find("Test Genre")
state = genre.playlist_state
db.genre.Table.delete(genre)
self.assertIsNone(db.genre.Table.lookup("Test Genre"))
self.assertIsNone(db.state.Table.get(state.rowid))
def test_genre_table_get(self):
genre = db.genre.Table.insert("Test Genre")
self.assertEqual(db.genre.Table.get(1), genre)
self.assertIsNone(db.genre.Table.get(2))
def test_genre_table_lookup(self):
def test_lookup(self):
genre = db.genre.Table.insert("Test Genre")
self.assertEqual(db.genre.Table.lookup("Test Genre"), genre)
self.assertIsNone(db.genre.Table.lookup("none"))
@ -55,7 +51,7 @@ class TestGenreMap(unittest.TestCase):
def test_genre_map_init(self):
self.assertIsInstance(db.genre.Map, db.genre.GenreMap)
self.assertEqual(db.genre.Map.map_lhs, db.genre.Genre)
self.assertEqual(db.genre.Map.map_lhs, db.genre.Table.get)
self.assertEqual(db.genre.Map.map_rhs, db.track.Track)
db.sql.execute("SELECT genreid,trackid FROM genre_map")