def tracksByTag(self, parent, parentvalue, child = None, childval = None):
if parent not in SUPPORTEDTAGS:
return
if child is None:
s = """SELECT path, filename, bitrate,
samplerate, length, title, tracknumber, year, genre,
comment, size, lastModified, layer, mimetype,
version, mode, lyrics_id, synced_lyrics_id, notes,rating,
medium, artist, album FROM tracks WHERE """ + \
PROKYONTAGS[parent] + " = BINARY %s"
self.cursor.execute(s, (parentvalue.encode('utf8'),))
tracks = self.cursor.fetchall()
else:
if childval is None:
children = self.children(parent, parentvalue, child)
tracks = [self.tracksByTag(parent, parentvalue, child, cval)
for cval in children]
return tracks
else:
s = """SELECT path, filename, bitrate,
samplerate, length, title, tracknumber, year, genre,
comment, size, lastModified, layer, mimetype,
version, mode, lyrics_id, synced_lyrics_id, notes,rating,
medium, artist, album FROM tracks WHERE """ + \
PROKYONTAGS[parent] + " = BINARY %s AND " + \
PROKYONTAGS[child] + " = BINARY %s"
self.cursor.execute(s, (parentvalue.encode('utf8'), childval.encode('utf8')))
tracks = self.cursor.fetchall()
return [musiclib.Tag(self, self.convertTrack(track)) for track in tracks]
def getTracks(self, artist, albums = None):
ret = []
artist = self.utflatin(artist)
if albums is None:
albums = self.getAlbums(artist)
for album in albums:
try:
album = self.utflatin(album)
except Exception, e:
print 'artist:',artist, 'album',album
raise e
if not album:
self.cursor.execute(u"""SELECT path, filename, bitrate,
samplerate, length, title, tracknumber, year, genre,
comment, size, lastModified, layer, mimetype,
version, mode, lyrics_id, synced_lyrics_id, notes,rating,
medium FROM tracks WHERE artist = BINARY %s
AND (album = '' or album is NULL)""", (artist,))
else:
self.cursor.execute(u"""SELECT path, filename, bitrate,
samplerate, length, title, tracknumber, year, genre,
comment, size, lastModified, layer, mimetype,
version, mode, lyrics_id, synced_lyrics_id, notes,rating,
medium FROM tracks WHERE artist = BINARY %s
AND album = BINARY %s""", (artist, album))
tracks = self.cursor.fetchall()
ret.extend([musiclib.Tag(self, self.convertTrack(track, artist, album)) for track in tracks])
def search(self, term):
self.cursor.execute(
u'''SELECT tags.url, tags.dir, tags.createdate,
tags.modifydate, composer.name as composer,
genre.name as genre, tags.title, year.name as year, tags.comment,
tags.track, tags.discnumber, tags.bitrate, tags.length,
tags.samplerate, tags.filesize, tags.filetype, tags.sampler,
tags.bpm, tags.deviceid,
artist.name AS artist, album.name as album
FROM tags, artist, album, genre, composer, year WHERE
(tags.artist = artist.id AND tags.album = album.id
AND tags.genre = genre.id AND tags.composer = composer.id AND
tags.year = year.id)
AND
(UCASE(tags.url) REGEXP UCASE(%s) OR UCASE(artist.name) REGEXP UCASE(%s)
OR UCASE(album.name) REGEXP UCASE(%s) OR UCASE(tags.title) REGEXP
UCASE(%s) OR UCASE(tags.composer) REGEXP UCASE(%s) OR
UCASE(genre.name) REGEXP UCASE(%s) OR UCASE(year.name)
REGEXP UCASE(%s)) limit 1000''', (term, ) * 7)
return [
musiclib.Tag(self, self.convertTrack(z, convert=False))
for z in self.cursor.fetchall()
]
def getTracks(self, artist, albums=None):
ret = []
if albums is None:
albums = self.albums[artist].keys()
if artist in self.albums:
stored = self.albums[artist]
for album in albums:
if album in stored:
ret.extend(self.tracks[stored[album]])
return [musiclib.Tag(self, z) for z in ret]
def search(self, term):
self.cursor.execute(u"""SELECT path, filename, bitrate,
samplerate, length, title, tracknumber, year, genre,
comment, size, lastModified, layer, mimetype,
version, mode, lyrics_id, notes,rating,
medium, artist, album FROM tracks WHERE
UCASE(artist) REGEXP(%s) or UCASE(filename) REGEXP(%s) or
UCASE(title) REGEXP(%s) or UCASE(path) REGEXP(%s) or
UCASE(album) REGEXP(%s) or UCASE(genre) REGEXP(%s) or
UCASE(comment) REGEXP(%s) or UCASE(notes) REGEXP(%s) or
UCASE(year) REGEXP(%s)
""", (term,) * 9)
return [musiclib.Tag(self, self.convertTrack(track)) for track in self.cursor.fetchall()]
def tracksByTag(self, parent, parentvalue, child=None, childval=None):
if parent not in SUPPORTEDTAGS:
return
if parent == 'artist' and child == 'album':
return self.getTracks(parentvalue, childval)
if (childval is None) or (child is None):
files = []
for album in self.tracks:
for f in album:
if f[parent] == parentvalue:
files.append(f)
elif childval and child:
files = []
for album in self.tracks:
for f in album:
if f[parent] == parentvalue and f[child] == childval:
files.append(f)
return [musiclib.Tag(self, z) for z in files]
def search(self, term):
term = term.upper()
ret = []
artists = set([z for z in self.albums if term in z.upper()])
[ret.extend(self.getTracks(z)) for z in artists]
others = set(self.albums).difference(artists)
for artist in others:
albums = self.albums[artist]
for album in albums:
if term in album.upper():
ret.extend(self.getTracks(artist, [album]))
else:
index = self.albums[artist][album]
tracks = self.tracks[index]
for track in tracks:
for value in track.values():
if term in value.upper():
ret.append(track)
break
return [musiclib.Tag(self, z) for z in ret]
def getTracks(self, artist, albums):
ret = []
if not albums:
albums = self.getAlbums(artist)
if self.cursor.execute(
u"SELECT DISTINCT BINARY id FROM artist WHERE name = BINARY %s",
(self.utflatin(artist), )):
artistid = self.cursor.fetchall()[0][0]
if not self.cursor.execute(
u"""SELECT DISTINCT BINARY album FROM tags WHERE artist = BINARY %s""",
(artistid, )):
return []
albumids = {}
for albumid in [z[0] for z in self.cursor.fetchall()]:
self.cursor.execute(
u"""SELECT DISTINCT BINARY name FROM album WHERE id = BINARY %s""",
(albumid, ))
albumids[self.cursor.fetchall()[0][0]] = albumid
for album in albums:
albumid = albumids[album]
self.cursor.execute(
u"""SELECT url, dir, createdate, modifydate,
composer, genre, title, year, comment,
track, discnumber, bitrate, length, samplerate,
filesize, filetype, sampler, bpm, deviceid
FROM tags WHERE artist = BINARY %s
AND album = BINARY %s""", (artistid, albumid))
tracks = self.cursor.fetchall()
ret.extend([
musiclib.Tag(self, self.convertTrack(track, artist, album))
for track in tracks
])
return ret
