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

db: Convert the YearTable into a playlist.ChildModel 

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:20:24 -04:00
parent 8365afc0e3
commit 4141ca211c
8 changed files with 72 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
db/__init__.py
View File

@ -20,16 +20,18 @@ def make_fake_track(trackno, length, title, path, lib="/a/b/c", art="Test Artist
art = artist.Table.find(art, art)
alb = album.Table.find(art, alb)
disk = disc.Table.find(alb, disk, subtitle)
yeer = year.Table.find(yeer)
return track.Table.insert(lib, art, alb, disk, yeer,trackno,
dec = decade.Table.find((yeer // 10) * 10)
if (yeer := year.Table.lookup(yeer)) == None:
yeer = year.Table.insert(dec, yeer)
return track.Table.insert(lib, art, alb, disk, dec, yeer, trackno,
length, title, pathlib.Path(path))
def reset():
mods = [ decade, library, state ]
mods = [ decade, year, library, state ]
for mod in mods: mod.Table.reset()
mods = [ artist, album, disc, genre, year, track, user ]
mods = [ artist, album, disc, genre, track, user ]
for mod in mods: mod.Table.drop()
for mod in mods: mod.Table.do_create()

4
db/table.py
View File

@ -26,9 +26,7 @@ class Table:
return self.cache.setdefault(row[0], self.do_factory(row))
def find(self, *args):
if (ret := self.lookup(*args)):
return ret
return self.insert(*args)
return ret if (ret := self.lookup(*args)) else self.insert(*args)
def get(self, rowid):
if (row := self.cache.get(rowid)):

9
db/test_track.py
View File

@ -21,8 +21,9 @@ class TestTrackTable(unittest.TestCase):
artist = db.artist.Table.find("Test Artist", "test artist")
album = db.album.Table.find(artist, "Test Album")
disc = db.disc.Table.find(album, 1, None)
year = db.year.Table.find(2021)
track = db.track.Table.insert(library, artist, album, disc, year,
decade = db.decade.Table.find(2020)
year = db.year.Table.insert(decade, 2021)
track = db.track.Table.insert(library, artist, album, disc, decade, year,
1, 1.234, "Test Title", pathlib.Path("/a/b/c/d.efg"))
self.assertIsInstance(track, db.track.Track)
@ -32,7 +33,7 @@ class TestTrackTable(unittest.TestCase):
self.assertEqual(track.artist, artist)
self.assertEqual(track.album, album)
self.assertEqual(track.disc, disc)
self.assertEqual(track.decade, year.decade)
self.assertEqual(track.decade, decade)
self.assertEqual(track.year, year)
self.assertEqual(track.number, 1)
@ -43,7 +44,7 @@ class TestTrackTable(unittest.TestCase):
self.assertEqual(track.path, pathlib.Path("/a/b/c/d.efg"))
with self.assertRaises(sqlite3.IntegrityError):
db.track.Table.insert(library, artist, album, disc, year,
db.track.Table.insert(library, artist, album, disc, decade, year,
1, 1.234, "Test Title", pathlib.Path("/a/b/c/d.efg"))
def test_track_table_delete(self):

58
db/test_year.py
View File

@ -4,53 +4,43 @@ import sqlite3
import unittest
from gi.repository import GObject
class TestYear(unittest.TestCase):
def setUp(self):
db.reset()
def test_init(self):
decade = db.decade.Table.find(2020)
year = db.year.Table.insert(decade, 2021)
self.assertIsInstance(year, db.playlist.Playlist)
self.assertEqual(year.get_property("name"), "2021")
self.assertEqual(year.get_property("year"), 2021)
class TestYearTable(unittest.TestCase):
def setUp(self):
db.reset()
def test_year_table_init(self):
def test_init(self):
table = db.year.YearTable()
self.assertIsInstance(table, db.playlist.ChildModel)
self.assertEqual(table.table, "years")
self.assertEqual(table.order, "year")
self.assertIsInstance(db.year.Table, db.year.YearTable)
db.sql.execute("SELECT yearid,decadeid,plstateid,year FROM years")
def test_year_table_insert(self):
def test_insert(self):
decade = db.decade.Table.insert(2020)
year = db.year.Table.insert(2021)
year = db.year.Table.insert(decade, 2021)
self.assertIsInstance(year, db.year.Year)
self.assertIsInstance(year, db.objects.Row)
self.assertEqual(year.year, 2021)
self.assertEqual(str(year), "2021")
self.assertEqual(year.get_property("decade"), decade)
self.assertIsInstance(year.playlist_state, db.state.PlaylistState)
self.assertEqual(year._year, 2021)
with self.assertRaises(sqlite3.IntegrityError):
db.year.Table.insert(2021)
db.year.Table.insert(decade, 2021)
def test_year_table_delete(self):
year = db.year.Table.find(2021)
state = year.playlist_state
db.year.Table.delete(year)
self.assertIsNone(db.year.Table.lookup(2021))
self.assertIsNone(db.state.Table.get(state.rowid))
def test_year_table_get(self):
year = db.year.Table.insert(2021)
self.assertEqual(db.year.Table.get(1), year)
self.assertIsNone(db.year.Table.get(2))
def test_year_table_lookup(self):
year = db.year.Table.insert(2021)
def test_lookup(self):
decade = db.decade.Table.find(2020)
year = db.year.Table.insert(decade, 2021)
self.assertEqual(db.year.Table.lookup(2021), year)
self.assertIsNone(db.year.Table.lookup(2022))
def test_year_compare(self):
y2021 = db.year.Table.insert(2021)
y2022 = db.year.Table.insert(2022)
self.assertTrue(y2021 < y2022)
self.assertTrue(y2022 > y2021)
self.assertFalse(y2021 > y2022)
self.assertFalse(y2022 < y2021)

6
db/track.py
View File

@ -51,7 +51,7 @@ class Track(objects.Row):
@GObject.Property
def year(self):
return year.Year(self.get_column("yearid"))
return year.Table.get(self.get_column("yearid"))
@GObject.Property
def number(self):
@ -120,12 +120,12 @@ class TrackTable(objects.Table):
" FOREIGN KEY(yearid) REFERENCES years(yearid))")
execute("CREATE INDEX IF NOT EXISTS track_index ON tracks(path)")
def do_insert(self, library, artist, album, disc, year, number, length, title, path):
def do_insert(self, library, artist, album, disc, decade, year, number, length, title, path):
return execute("INSERT INTO tracks (libraryid, artistid, albumid, discid, "
"decadeid, yearid, number, length, title, path) "
"VALUES (?,?,?,?,?,?,?,?,?,?)",
[ library.rowid, int(artist), int(album), int(disc),
year.decade.rowid, int(year), number, length, title, str(path) ])
decade.rowid, year.rowid, number, length, title, str(path) ])
def do_delete(self, track):
from . import genre

67
db/year.py
View File

@ -5,64 +5,43 @@
# | yearid | decadeid | plstateid | year |
# +--------+----------+-----------+------+
from gi.repository import GObject
from .sql import execute
from . import decade
from . import objects
from . import state
from . import playlist
from . import sql
class Year(objects.Row):
def __gt__(self, rhs): return self.year > rhs.year
def __lt__(self, rhs): return self.year < rhs.year
def __str__(self): return str(self.year)
def do_get_column(self, column):
return execute(f"SELECT {column} FROM years "
"WHERE yearid=?", [ self.rowid ])
class Year(playlist.Playlist):
def __init__(self, row):
playlist.Playlist.__init__(self, row)
self._year = row["year"]
@GObject.Property
def decade(self):
return decade.Table.get(self.get_column("decadeid"))
def name(self): return str(self._year)
@GObject.Property
def playlist_state(self):
return state.Table.get(self.get_column("plstateid"))
@GObject.Property
def year(self):
return self.get_column("year")
def year(self): return self._year
class YearTable(objects.Table):
class YearTable(playlist.ChildModel):
def __init__(self):
objects.Table.__init__(self, "years", Year)
playlist.ChildModel.__init__(self, "years", "decadeid", "year")
def do_create(self):
execute("CREATE TABLE IF NOT EXISTS years "
"(yearid INTEGER PRIMARY KEY, "
" decadeid INTEGER, "
" plstateid INTEGER NOT NULL, "
" year INTEGER UNIQUE, "
" FOREIGN KEY(decadeid) REFERENCES decades(decadeid), "
" FOREIGN KEY(plstateid) REFERENCES playlist_states(plstateid))")
sql.execute("CREATE TABLE IF NOT EXISTS years "
"(yearid INTEGER PRIMARY KEY, "
" decadeid INTEGER, "
" plstateid INTEGER NOT NULL, "
" year INTEGER UNIQUE, "
" FOREIGN KEY(decadeid) REFERENCES decades(decadeid), "
" FOREIGN KEY(plstateid) REFERENCES playlist_states(plstateid))")
def do_insert(self, year):
dec = decade.Table.find( (year // 10) * 10)
plstate = state.Table.insert(random=False, loop=False)
return execute("INSERT INTO years (decadeid, plstateid, year) "
"VALUES (?, ?, ?)",
[ dec.rowid, plstate.rowid, year ])
def do_insert(self, plstate, dec, year):
return sql.execute("INSERT INTO years (decadeid, plstateid, year) "
"VALUES (?, ?, ?)", [ dec.rowid, plstate.rowid, year ])
def do_delete(self, year):
state.Table.delete(year.playlist_state)
return execute("DELETE FROM years WHERE yearid=?", [ int(year) ])
def do_get(self, rowid):
return execute("SELECT yearid FROM years "
"WHERE yearid=?", [ rowid ])
def do_factory(self, row):
return Year(row)
def do_lookup(self, year):
return execute("SELECT yearid FROM years "
"WHERE year=?", [ year ])
return sql.execute("SELECT * FROM years WHERE year=?", [ year ])
Table = YearTable()

11
scanner/task.py
View File

@ -25,10 +25,13 @@ class FileTask(Task):
artist = db.artist.Table.find(meta.artist(), meta.artistsort())
album = db.album.Table.find(artist, meta.album())
disc = db.disc.Table.find(album, meta.discnumber(), meta.discsubtitle())
year = db.year.Table.find(meta.year())
track = db.track.Table.insert(self.library, artist, album, disc, year,
meta.tracknumber(), meta.length(),
meta.title(), self.filepath)
decade = db.decade.Table.find(meta.decade())
if (year := db.year.Table.lookup(meta.year())) == None:
year = db.year.Table.insert(decade, meta.year())
track = db.track.Table.insert(self.library, artist, album, disc,
decade, year, meta.tracknumber(),
meta.length(), meta.title(),
self.filepath)
for genre in meta.genres():
db.genre.Map.insert(db.genre.Table.find(genre), track)
db.user.TempMap.insert(db.user.Table.find("New Tracks"), track)

3
scanner/test_task.py
View File

@ -46,6 +46,9 @@ class TestScannerFileTask(unittest.TestCase):
self.assertIsNotNone(album)
self.assertIsNotNone(db.disc.Table.lookup(album, 1))
decade = db.decade.Table.lookup(2010)
self.assertIsNotNone(decade)
self.assertIsNotNone(db.year.Table.lookup(2019))
track = db.track.Table.lookup(test_track01)