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

db: Convert the DecadeTable 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 15:13:55 -04:00
parent e6a65f8fe3
commit 8365afc0e3
5 changed files with 59 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
db/__init__.py
View File

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

63
db/decade.py
View File

@ -5,61 +5,44 @@
# | decadeid | plstateid | decade |
# +----------+-----------+--------+
from gi.repository import GObject
from .sql import execute
from . import objects
from . import state
from . import playlist
from . import sql
from . import year
class Decade(objects.Row):
def __gt__(self, rhs): return self.decade > rhs.decade
def __lt__(self, rhs): return self.decade < rhs.decade
def __str__(self): return f"{self.decade}s"
def do_get_column(self, column):
return execute(f"SELECT {column} FROM decades "
"WHERE decadeid=?", [ self.rowid ])
def years(self):
cursor = execute(f"SELECT yearid FROM years "
"WHERE decadeid=?", [ self.rowid ])
return [ year.Year(row["yearid"]) for row in cursor.fetchall() ]
class Decade(playlist.ParentPlaylist):
def __init__(self, row):
playlist.ParentPlaylist.__init__(self, row)
self._decade = row["decade"]
@GObject.Property
def decade(self):
return self.get_column("decade")
def decade(self): return self._decade
@GObject.Property
def playlist_state(self):
return state.Table.get(self.get_column("plstateid"))
def name(self): return f"{self._decade}s"
def get_child_table(self): return year.Table
class DecadeTable(objects.Table):
class DecadeTable(playlist.Model):
def __init__(self):
objects.Table.__init__(self, "decades", Decade)
playlist.Model.__init__(self, "decades", "decade")
def do_create(self):
execute("CREATE TABLE IF NOT EXISTS decades "
"(decadeid INTEGER PRIMARY KEY, "
" plstateid INTEGER NOT NULL, "
" decade INTEGER UNIQUE, "
" FOREIGN KEY(plstateid) REFERENCES playlist_states(plstateid))")
sql.execute("CREATE TABLE IF NOT EXISTS decades "
"(decadeid INTEGER PRIMARY KEY, "
" plstateid INTEGER NOT NULL, "
" decade INTEGER UNIQUE, "
" FOREIGN KEY(plstateid) REFERENCES playlist_states(plstateid))")
def do_insert(self, decade):
plstate = state.Table.insert(random=False, loop=False)
return execute("INSERT INTO decades (plstateid,decade) "
"VALUES (?, ?)", [ plstate.rowid, decade ])
def do_factory(self, row):
return Decade(row)
def do_delete(self, decade):
state.Table.delete(decade.playlist_state)
return execute("DELETE FROM decades WHERE decadeid=?", [ int(decade) ])
def do_get(self, rowid):
return execute("SELECT decadeid FROM decades "
"WHERE decadeid=?", [ rowid ])
def do_insert(self, plstate, decade):
return sql.execute("INSERT INTO decades (plstateid,decade) "
"VALUES (?, ?)", [ plstate.rowid, decade ])
def do_lookup(self, decade):
return execute("SELECT decadeid FROM decades "
"WHERE decade=?", [ decade ])
return sql.execute("SELECT * FROM decades WHERE decade=?", [ decade ])
Table = DecadeTable()

70
db/test_decade.py
View File

@ -4,58 +4,48 @@ import sqlite3
import unittest
from gi.repository import GObject
class TestDecade(unittest.TestCase):
def setUp(self):
db.reset()
def test_init(self):
decade = db.decade.Table.insert(2020)
self.assertIsInstance(decade, db.playlist.ParentPlaylist)
self.assertEqual(decade.get_property("name"), "2020s")
self.assertEqual(decade.get_child_table(), db.year.Table)
def test_decade(self):
decade = db.decade.Table.insert(2020)
self.assertEqual(decade._decade, 2020)
self.assertEqual(decade.get_property("decade"), 2020)
class TestDecadeTable(unittest.TestCase):
def setUp(self):
db.reset()
def test_decade_table_init(self):
def test_init(self):
table = db.decade.DecadeTable()
self.assertIsInstance(table, db.playlist.Model)
self.assertEqual(table.table, "decades")
self.assertEqual(table.order, "decade")
self.assertIsInstance(db.decade.Table, db.decade.DecadeTable)
db.sql.execute("SELECT decadeid,plstateid,decade FROM decades")
def test_decade_table_insert(self):
decade = db.decade.Table.insert(2020)
def test_insert(self):
table = db.decade.DecadeTable()
decade = table.insert(2020)
self.assertIsInstance(decade, db.decade.Decade)
self.assertIsInstance(decade, db.objects.Row)
self.assertEqual(decade.decade, 2020)
self.assertEqual(str(decade), "2020s")
self.assertIsInstance(decade.playlist_state, db.state.PlaylistState)
self.assertEqual(decade._decade, 2020)
with self.assertRaises(sqlite3.IntegrityError):
db.decade.Table.insert(2020)
def test_decade_table_delete(self):
decade = db.decade.Table.find(2020)
state = decade.playlist_state
def test_lookup(self):
table = db.decade.DecadeTable()
decade = table.insert(2020)
db.decade.Table.delete(decade)
self.assertIsNone(db.decade.Table.lookup(2020))
self.assertIsNone(db.state.Table.get(state.rowid))
def test_decade_table_get(self):
decade = db.decade.Table.insert(2020)
self.assertEqual(db.decade.Table.get(1), decade)
self.assertIsNone(db.decade.Table.get(2))
def test_decade_table_lookup(self):
decade = db.decade.Table.insert(2020)
self.assertEqual(db.decade.Table.lookup(2020), decade)
self.assertIsNone(db.decade.Table.lookup(2021))
def test_decade_compare(self):
d2010 = db.decade.Table.insert(2010)
d2020 = db.decade.Table.insert(2020)
self.assertTrue(d2010 < d2020)
self.assertTrue(d2020 > d2010)
self.assertFalse(d2010 > d2020)
self.assertFalse(d2020 < d2010)
def test_decade_years(self):
decade = db.decade.Table.insert(2020)
y2020 = db.year.Table.insert(2020)
y2021 = db.year.Table.insert(2021)
self.assertEqual(decade.years(), [ y2020, y2021 ])
self.assertEqual(table.lookup(2020), decade)
self.assertIsNone(table.lookup(2021))

4
db/track.py
View File

@ -47,7 +47,7 @@ class Track(objects.Row):
@GObject.Property
def decade(self):
return decade.Decade(self.get_column("decadeid"))
return decade.Table.get(self.get_column("decadeid"))
@GObject.Property
def year(self):
@ -125,7 +125,7 @@ class TrackTable(objects.Table):
"decadeid, yearid, number, length, title, path) "
"VALUES (?,?,?,?,?,?,?,?,?,?)",
[ library.rowid, int(artist), int(album), int(disc),
int(year.decade), int(year), number, length, title, str(path) ])
year.decade.rowid, int(year), number, length, title, str(path) ])
def do_delete(self, track):
from . import genre

4
db/year.py
View File

@ -21,7 +21,7 @@ class Year(objects.Row):
@GObject.Property
def decade(self):
return decade.Decade(self.get_column("decadeid"))
return decade.Table.get(self.get_column("decadeid"))
@GObject.Property
def playlist_state(self):
@ -50,7 +50,7 @@ class YearTable(objects.Table):
plstate = state.Table.insert(random=False, loop=False)
return execute("INSERT INTO years (decadeid, plstateid, year) "
"VALUES (?, ?, ?)",
[ int(dec), plstate.rowid, year ])
[ dec.rowid, plstate.rowid, year ])
def do_delete(self, year):
state.Table.delete(year.playlist_state)