def getAlbumInfoAJAX(self):
trackid = request.params['trackid'].split('_')[1]
track = Session.query(Track).filter_by(id=trackid).one()
json = {}
albumMbid = track.album.mbid
# get wikipedia from the release group
wikipedia = Session.query(MBURL.url) \
.join(MBLReleaseGroupURL) \
.join(MBLink) \
.join(MBLinkType) \
.filter(MBLinkType.name=='wikipedia') \
.join(MBReleaseGroup) \
.filter(MBReleaseGroup.gid==albumMbid) \
.all()
wikipedia = filter(self._filterForEnglishWiki, map(lambda x: x[0], wikipedia))
if wikipedia:
wurl = wikipedia[0]
json['wikipedia'] = wurl
json['summary'] = albumsummary.get_album_summary(Session, albumMbid, wurl)
# get amazon from any of the releases
amazon = Session.query(MBURL) \
.join(MBLReleaseURL) \
.join(MBLink) \
.join(MBLinkType) \
.filter(MBLinkType.name=='amazon asin') \
.join(MBRelease) \
.join(MBReleaseGroup) \
.filter(MBReleaseGroup.gid==albumMbid) \
.first()
if amazon:
json['amazon'] = amazon.url
json['musicbrainz'] = 'http://musicbrainz.org/release-group/' + albumMbid
return simplejson.dumps(json)
def getLyricsAJAX(self):
trackid = request.params['trackid'].split('_')[1]
track = Session.query(Track).filter_by(id=trackid).one()
if not track.lyrics and \
(track.lastHitLyricWiki is None or \
datetime.now() > track.lastHitLyricWiki + timedelta(days=10)):
track.lastHitLyricWiki = datetime.now()
title = track.id3title
artist = track.id3artist
params = {
'artist' : artist,
'song' : title,
'fmt' : 'json',
}
url = 'http://lyrics.wikia.com/api.php?%s' % urllib.urlencode(params)
html = urllib.urlopen(url).read()
if not "'lyrics':'Not found'" in html:
search = re.search("'url':'(?P<url>.*?)'",html)
lyricurl = urllib.unquote(search.group('url'))
lyrichtml = urllib.urlopen(lyricurl).read()
lyrics = re.search("<div class='lyricbox'>.*?</div>(?P<lyrics>.*?)<!-- \n", lyrichtml).group('lyrics')
lyrics = unescape(lyrics)
track.lyrics = lyrics
Session.begin()
Session.commit()
json = {}
if track.lyrics:
json['lyrics'] = track.lyrics
return simplejson.dumps(json)
def trackArtistAlbumsLOCAL(self):
trackid = request.params['trackid']
#note that we can do this because there is
#only a single foreign key matched between
#tracks and albums.
artistid=Session.query(Track).filter_by(id=trackid)[0].artistid
joined=Session.query(Track).filter_by(artistid=artistid)
aids = []
out = []
for t in joined:
aid = t.albumid
if not aid in aids:
aids.append(aid)
year_re = re.compile('[0-9]{4}')
early_year = (re.search(year_re,t.id3date)).group()
json = {
'aid':aid,
'mbid':t.album.mbid,
'name':t.album.name,
'year':early_year
}
out.append(json)
return sjson.dumps(out)
def clearAlbumArt(self):
id = request.params['id']
Session.begin()
album = Session.query(Album).filter_by(id=id).one()
album.albumArtFilename = None
album.lastHitAlbumArtExchange = None
Session.commit()
return 'Cleared album art for ' + album.artist.name + ' - ' + album.name
def saveLyricsFramesAJAX(self):
trackid = request.params['trackid']
recordedFrames = simplejson.loads(request.params['frames']) # list of (time, lyrics line index) pairs
recordedFrames.sort(key = itemgetter(0)) # (sort by time)
Session.begin()
track = Session.query(Track).filter_by(id=trackid).one()
track.lyricsFrames = recordedFrames
Session.commit()
def setAlbumArt(self):
id = request.params['id']
url = request.params['url']
Session.begin()
album = Session.query(Album).filter_by(id=id).one()
album.albumArtFilename = albumart._fetchAlbumArt(album.artist.name, album.name, url)
Session.commit()
return 'Set album art for ' + album.artist.name + ' - ' + album.name + ' to ' + url + ', saved to ' + album.albumArtFilename
def pp2(self):
artists = Session.query(Artist)
tracks = Session.query(Track)
paths = []
for r in tracks:
paths.append( os.path.join('.media', r.filepath ))
return render('/hello2.html')
def similarTrackAJAX(self):
id = request.params['id'].split('_')[1]
track = Session.query(Track).filter_by(id=id).one()
lastfmArtist = self.lastfmNetwork.get_artist(track.artist.name)
similarArtists = lastfmArtist.get_similar()
similarMbids = filter(lambda x: x is not None, map(lambda x: x.mbid, similarArtists))
randomSimilarArtist = Session.query(Artist).filter(Artist.mbid.in_(similarMbids)).order_by(random()).first()
return simplejson.dumps([rand.choice(randomSimilarArtist.tracks).toPlaylistJSON()]) \
if randomSimilarArtist \
else self.randomTrackAJAX()
def randomRooAlbumAJAX(self):
album = Session.query(Album) \
.join(Album.artists) \
.filter(Artist.mbid.in_(Bonnaroo.artist_mbids)) \
.order_by(random()) \
.first()
tracks = Session.query(Track) \
.filter_by(albumid=album.mbid)
json = map(lambda x: x.toPlaylistJSON(), tracks)
return simplejson.dumps(json)
def _getTracksForPlaylist(self, id):
playlist = Session.query(Playlist).filter(Playlist.playlist_id==id).one()
recordings = playlist.tracks
recording_mbids = map(lambda x: x.gid, recordings)
tracks = Session.query(Track).filter(Track.mbid.in_(recording_mbids)).all()
tracks.sort(lambda a,b: cmp(recording_mbids.index(a.mbid), recording_mbids.index(b.mbid)))
filtertracks = [tracks[0]]
for track in tracks[1:]:
if track.mbid != filtertracks[-1].mbid:
filtertracks.append(track)
return filtertracks
def searchShopAlbumAJAX(self):
mbid = request.params['mbid']
(album, albumname, artistname) = Session.query(MBReleaseGroup, MBReleaseName, MBArtistName) \
.join(MBReleaseName) \
.join(MBReleaseGroup.artistcredit, MBArtistCredit.name) \
.filter(MBReleaseGroup.gid==mbid) \
.one()
user_name = request.environ['repoze.what.credentials']['repoze.what.userid']
user_id = Session.query(User).filter(User.user_name==user_name).one().user_id
infohash = shopservice.download(Session, mbid, user_id)
if infohash:
return simplejson.dumps({'success' : True})
else:
return simplejson.dumps({'success' : False})
def searchAJAX(self):
search = request.params['search']
maxResults = 50
artists = Session.query(Artist). \
filter(Artist.name.like('%'+search+'%')). \
join(Album) \
[0:maxResults]
albums = Session.query(Album). \
filter(Album.name.like('%'+search+'%')) \
[0:maxResults]
tracks = Session.query(Track). \
filter(Track.id3title.like('%'+search+'%')) \
[0:maxResults]
if len(artists) == maxResults or len(tracks) == maxResults or len(albums) == maxResults:
truncated = True
else:
truncated = False
artistIdToJSON = {}
albumsIdToJSON = {}
for artist in artists:
if artist.id not in artistIdToJSON:
artistJSON = artist.toTreeJSON()
artistIdToJSON[artist.id] = artistJSON
for album in albums:
if album.artist and album.artist.id not in artistIdToJSON:
artistJSON = album.artist.toTreeJSON(children=[])
artistIdToJSON[album.artist.id] = artistJSON
albumJSON = album.toTreeJSON()
artistJSON['children'].append(albumJSON)
else:
continue
for track in tracks:
if track.album and \
track.album.artist and \
track.album.artist.id not in artistIdToJSON:
artistJSON = track.album.artist.toTreeJSON(children=[])
artistIdToJSON[track.album.artist.id] = artistJSON
else:
continue
if track.album and track.album.id not in albumsIdToJSON:
albumJSON = track.album.toTreeJSON(children=[])
artistJSON['children'].append(albumJSON)
albumsIdToJSON[track.album.id] = albumJSON
else:
continue
albumJSON['children'].append(track.toTreeJSON())
json = artistIdToJSON.values()
json.sort(self._compareTreeFloatVA)
return simplejson.dumps(json)
def alltracks(self):
tracks = Session.query(Track)
count = 0
namefun = lambda x: x.id3title
out = []
this_artist_count = 0
last_artist = ''
max_per_artist = 5
for t in tracks:
name = namefun(t)
type = t.__class__.__name__
this_artist = t.artistid
if this_artist == last_artist:
this_artist_count = this_artist_count + 1
else:
this_artist_count = 0
last_artist = this_artist
if this_artist_count < max_per_artist:
json = {
'type':type,
'name':name,
'url':self.track_URL_from_id(t.id),
'id':t.id,
'albumid':t.albumid,
'artistid':t.artistid
}
out.append(json)
count = count + 1
if count > 50: break
return sjson.dumps(out)
def randomRooTrackAJAX(self):
track = Session.query(Track) \
.join(Album, Album.artists) \
.filter(Artist.mbid.in_(Bonnaroo.artist_mbids)) \
.order_by(random()) \
.first()
return simplejson.dumps([track.toPlaylistJSON()])
def index(self):
# Return a rendered template
#return render('/ben_kvp.mako')
# or, return a string
return 'Hello World - how you doing today {0}'.format(Session.query(User).first())
def alltracks(self):
trk_total_limit = 200;
trk_artist_limit = 10;
tracks = Session.query(Track)
count = 0
namefun = lambda x: x.id3title
out = []
this_artist_count = 0
last_artist = ''
for t in tracks:
name = namefun(t)
this_artist = t.artistid
if this_artist == last_artist:
this_artist_count = this_artist_count + 1
else:
this_artist_count = 0
last_artist = this_artist
if this_artist_count < trk_artist_limit:
json = {
'track_name':name,
'url':self.track_URL_from_id(t.id),
'track_id':t.id,
'albumid':t.albumid,
'artistid':t.artistid,
'datatype':'track',
'tostring':name
}
out.append(json)
count = count + 1
if count > trk_total_limit: break
return sjson.dumps(out)
def printPaths(self):
tracks = Session.query(Track)
paths = []
for r in tracks:
paths.append( os.path.join('.media', r.filepath ))
return paths
def getArtistInfoAJAX(self):
json = {}
# Get the artist credit for the given artist or track
if 'trackid' in request.params:
trackid = request.params['trackid'].split('_')[1]
artistCreditNames = self._getArtistCreditNames(trackid)
credit = []
for artistcredit in artistCreditNames:
credit.append({
'text' : artistcredit.name.name,
'mbid' : artistcredit.artist.gid
})
if artistcredit.joinphrase:
credit.append({
'text' : artistcredit.joinphrase
})
artistMbid = artistCreditNames[0].artist.gid
elif 'mbid' in request.params:
artistMbid = request.params['mbid']
artist = Session.query(MBArtist).filter(MBArtist.gid==artistMbid).one()
credit = [{
'text' : artist.name.name
}]
else:
raise Exception('need trackid or artist mbid')
json['credit'] = credit
# Get artist bio, and url relationships
urls = Session.query(MBURL.url, MBLinkType.name) \
.join(MBLArtistURL) \
.join(MBLink) \
.join(MBLinkType) \
.join(MBArtist) \
.filter(MBArtist.gid==artistMbid) \
.all()
urls = self._mapify(urls)
if 'wikipedia' in urls:
wurls = filter(self._filterForEnglishWiki, urls['wikipedia'])
if wurls:
wurl = wurls[0]
json['wikipedia'] = wurl
json['bio'] = artistbio.get_artist_bio(Session, artistMbid, wurl)
if 'youtube' in urls:
json['youtube'] = urls['youtube'][0]
if 'official homepage' in urls:
json['official'] = urls['official homepage'][0]
json['musicbrainz'] = 'http://musicbrainz.org/artist/' + artistMbid
return simplejson.dumps(json)
def getAlbumArtAJAX(self):
trackid = request.params['trackid'].split('_')[1]
track = Session.query(Track).filter_by(id=trackid).one()
albumartfilename = albumart.get_art(Session, track.album)
json = {}
if albumartfilename is not None:
json['albumArtURL'] = albumartfilename
return simplejson.dumps(json)
def getAlbumArtAJAX(self):
trackid = request.params['trackid'].split('_')[1]
track = Session.query(Track).filter_by(id=trackid).one()
albumartfilename = albumart.get_art(Session, track.album)
if albumartfilename:
return simplejson.dumps({'albumArtURL' : albumartfilename})
else:
return '{}'
def getAlbumArtAJAX(self):
trackid = request.params['trackid'].split('_')[1]
track = Session.query(Track).filter_by(id=trackid).one()
if not track.album.albumArtFilename and ( \
track.album.lastHitAlbumArtExchange is None \
or datetime.now() > track.album.lastHitAlbumArtExchange + timedelta(days=10)):
track.album.lastHitAlbumArtExchange = datetime.now()
album = track.album.name
artist = track.album.artist.name
if artist == 'Various Artists':
q = album
else:
q = (artist + ' ' + album)
q = q.replace("'","")
site = 'http://www.albumartexchange.com'
params = {
'grid' : '2x7',
'sort' : 7,
'q' : q,
}
url = site + '/covers.php?%s' % urllib.urlencode(params)
html = urllib.urlopen(url).read()
search = re.search('src="/phputil/scale_image.php\?size=150&src=(?P<src>.*?)"',html)
if search:
image = site + urllib.unquote(search.group('src'))
extension = image.rsplit('.', 1)[1]
delchars = ''.join(c for c in map(chr, range(256)) if not c.isalnum())
delchars = delchars.translate(None," ()'&!-+_.")
filename = (artist + ' - ' + album).encode('utf-8').translate(None, delchars) + '.' + extension
urllib.urlretrieve(image, 'scatterbrainz/public/art/' + filename)
albumArt = '/art/' + filename
track.album.albumArtFilename = albumArt
Session.begin()
Session.commit()
json = {}
if track.album.albumArtFilename:
json['albumArtURL'] = track.album.albumArtFilename
return simplejson.dumps(json)
def getArtistInfoAJAX(self):
trackid = request.params['trackid'].split('_')[1]
track = Session.query(Track).filter_by(id=trackid).one()
artist = self.lastfmNetwork.get_artist(track.artist.name)
return simplejson.dumps({
'bio' : artist.get_bio_content(),
'images' : map(lambda i:[i.sizes.largesquare, i.sizes.original], artist.get_images(limit=20))
})
def clearimport(download):
with importlock:
assert not download.isdone, 'download is already done'
assert download.failedimport, 'import isnt failed'
mbid = download.release_group_mbid
dirpath = mbid[:2] + '/' + mbid
cmd = 'rm -rf ' + Config.MUSIC_PATH + dirpath
log.info('running ' + cmd)
os.system(cmd)
if Config.SCP_SHOP_DOWNLOADS:
cmd = 'rm -rf ' + Config.SCP_FOLDER + '/' + download.infohash
log.info('running ' + cmd)
os.system(cmd)
Session.begin()
download.failedimport = False
download.importtrace = None
Session.commit()
def getTrackInfoAJAX(self):
trackid = request.params['trackid'].split('_')[1]
track = Session.query(Track).filter_by(id=trackid).one()
(artistName, albumName, trackName) = (track.id3artist, track.id3album, track.id3title)
log.info(request.remote_addr + ' playing ' + artistName + ' - ' + trackName)
if (not track.artist.mbid or not track.album.mbid or not track.album.asin) and \
(track.album.lastHitMusicbrainz is None \
or datetime.now() > track.album.lastHitMusicbrainz + timedelta(days=10)):
track.album.lastHitMusicbrainz = datetime.now()
album = track.album
artist = album.artist
release = None
if album.mbid:
release = getRelease(album.mbid)
else:
if artist.name == 'Various Artists':
release = searchRelease(None, album.name)
else:
if artist.name.startswith('The') or artist.name.startswith('the') or artist.name.startswith('THE'):
artistSearch = artist.name[4:]
else:
artistSearch = artist.name
release = searchRelease(artistSearch, album.name)
if release and not album.mbid:
album.mbid = release.id.split('/')[-1]
if release and not artist.mbid:
artist.mbid = release.artist.id.split('/')[-1]
if release:
albumName = release.title
asin = release.getAsin()
if asin:
track.album.asin = asin
if release.artist:
artistName = release.artist.name
Session.begin()
Session.commit()
json = {}
json['artist'] = artistName
json['album'] = albumName
json['track'] = trackName
if track.album.asin:
json['asin'] = track.album.asin
return simplejson.dumps(json)
def _tracksForArtistPlaylistJSON(self, mbid):
albums = Session.query(Artist).filter_by(mbid=mbid).one().albums
albums.sort(lambda a,b: cmp(a.getReleaseDate(), b.getReleaseDate()))
tracks = []
for album in albums:
albumtracks = album.tracks
albumtracks.sort(self._compareTracks)
tracks.extend(albumtracks)
return self._playlistJSON(tracks)
def getSimilarArtistsAJAX(self):
mbid = request.params['mbid']
artist = Session.query(MBArtist).filter(MBArtist.gid==mbid).one()
try:
similarartistmbids = similarartist.get_similar_artists(Session, self.lastfmNetwork, artist)
except (BadStatusLine, SocketTimeout) as e:
log.error('[lastfm] down? ' + e.__repr__())
return '{}'
similarartists = Session.query(MBArtist, MBArtistName).join(MBArtist.name).filter(MBArtist.gid.in_(similarartistmbids)).all()
similarmap = {}
for artist in similarartists:
similarmap[artist[0].gid] = {'mbid' : artist[0].gid, 'name' : artist[1].name, 'local' : False}
localsimilarartists = Session.query(Artist).filter(Artist.mbid.in_(similarartistmbids)).all()
for artist in localsimilarartists:
similarmap[artist.mbid]['local'] = True
similarjson = []
for mbid in similarartistmbids:
similarjson.append(similarmap[mbid])
return simplejson.dumps({'similar' : similarjson})
def run(self):
# Only let one worker run via pg advisory lock
acquired = Session.execute(select([func.pg_try_advisory_lock(importlockid)])).fetchone()[0]
threadid = 'PID ' + str(os.getpid()) + ' thread ' + str(threading.current_thread())
if acquired:
log.info('[shop worker] %s acquired lock, starting..' % threadid)
else:
return
pendingdownloads = False
while True:
try:
downloads = Session.query(ShopDownload) \
.filter(ShopDownload.isdone==False) \
.filter(ShopDownload.failedimport==False) \
.all()
pendingdownloads = len(downloads) != 0
if pendingdownloads:
rtorrent = xmlrpclib.ServerProxy(Config.SHOP_RPC_URL)
for download in downloads:
try:
infohash = download.infohash
iscomplete = rtorrent.d.get_complete(infohash) == 1
if iscomplete:
shopservice.importDownload(download)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
importtrace = repr(traceback.format_exception(exc_type, exc_value, exc_traceback))
log.error('[shop worker] caught exception in loop ' + importtrace)
Session.rollback()
Session.begin()
download.failedimport = True
download.importtrace = importtrace
Session.commit()
except Exception as e:
log.error('[shop worker] caught exception out of loop ' + repr(e))
Session.rollback()
if pendingdownloads:
time.sleep(10)
else:
time.sleep(30)
def allalbums(self):
if request.params.has_key('mbid') :
mbid = request.params['mbid']
artist = Session.query(Artist).filter_by(mbid=mbid)[0].id;
albums = Session.query(Album).filter_by(artistid=artist);
else:
albums = Session.query(Album)
out = []
for a in albums:
name = a.name
mbid = a.mbid
out.append({'tostring':name,
'album_name':name,
'album_mbid':mbid,
'datatype':'album'})
return sjson.dumps(out)
def allartists(self):
artists = Session.query(Artist)
out = []
for a in artists:
name = a.name
mbid = a.mbid
out.append({'tostring':name,
'artist_name':name,
'artist_mbid':mbid,
'datatype':'artist'})
return sjson.dumps(out)
def similarTrackAJAX(self):
trackid = request.params['id'].split('_')[1]
artists = Session.query(MBArtist).join(MBArtistCreditName, MBArtistCredit, MBRecording, AudioFile, AudioFile.track).filter(Track.id==trackid).all()
similarMbids = set([])
try:
for artist in artists:
similarMbids.update(similarartist.get_similar_artists(Session, self.lastfmNetwork, artist))
except (BadStatusLine, SocketTimeout) as e:
log.error('[lastfm] down? ' + e.__repr__())
return ''
artistMbidsWithAlbums = Session.query(Artist.mbid) \
.join(artist_albums) \
.filter(Artist.mbid.in_(similarMbids)) \
.distinct() \
.subquery()
randomSimilarArtist = Session.query(Artist) \
.filter(Artist.mbid.in_(artistMbidsWithAlbums)) \
.order_by(random()) \
.first()
randomAlbum = rand.choice(randomSimilarArtist.albums)
randomTrack = rand.choice(randomAlbum.tracks)
return simplejson.dumps([randomTrack.toPlaylistJSON()])
