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 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 savePlaylistAJAX(self):
playlistname = request.params['name']
trackids = simplejson.loads(request.params['trackids'])
trackids = map(lambda x: x.replace('track_',''), trackids)
results = Session.query(Track, MBRecording).join(MBRecording).filter(Track.id.in_(trackids)).all()
results.sort(lambda a,b: cmp(trackids.index(a[0].id), trackids.index(b[0].id)))
recordings = map(itemgetter(1), results)
Session.begin()
user_name = request.environ['repoze.what.credentials']['repoze.what.userid']
user_id = Session.query(User).filter(User.user_name==user_name).one().user_id
playlist = Session.query(Playlist) \
.filter(Playlist.owner_id==user_id) \
.filter(Playlist.name==playlistname) \
.first()
if not trackids:
if playlist is None:
return '{}'
else:
Session.delete(playlist)
else:
if playlist is None:
playlist = Playlist(user_id, playlistname)
Session.add(playlist)
else:
playlist.modified = datetime.now()
playlist.tracks = recordings
Session.commit()
return '{}'
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 getLyricsAJAX(self):
trackid = request.params['trackid'].split('_')[1]
track = Session.query(Track).filter_by(id=trackid).one()
ip = request.environ['REMOTE_ADDR']
user_name = request.environ['repoze.what.credentials']['repoze.what.userid']
user = Session.query(User).filter(User.user_name==user_name).one()
Session.begin()
play = TrackPlay(track.mbid, user, ip)
Session.add(play)
Session.commit()
lyrics = lyricsservice.get_lyrics(Session, track)
if lyrics:
return simplejson.dumps({'lyrics' : lyrics})
else:
return '{}'
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 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 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 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 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 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 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 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 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 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 _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 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 currentMembersForTrackArtist(self):
trackid = request.params["trackid"]
track = Session.query(Track).filter_by(id=trackid).one()
# search for triples with subject matching current artist
db_uri = u""
for triple in Session.query(RDFTriple).filter_by(artistid=track.artistid):
if triple.subject == ":artist":
if triple.predicate == "hasdbpedia":
db_uri = triple.obj
if db_uri == "":
art_mbid = track.artist.mbid
db_uri = sDB.dbpedia_from_MBID(art_mbid)
db_unicode = unicode(db_uri.__str__())
artist = track.artist
triple = RDFTriple(
subject=u":artist", predicate=u"hasdbpedia", obj=db_unicode, artist=artist, track=None, album=None
)
Session.save(triple)
Session.commit()
g = Graph()
g.parse(db_uri)
pmem_re = re.compile("pastmember", re.I)
cmem_re = re.compile("currentmember", re.I)
out = {}
past_members = []
current_members = []
for s, p, o in g.triples((None, None, None)):
if re.search(pmem_re, p):
past_members.append(getURILabel(o))
if re.search(cmem_re, p):
current_members.append(getURILabel(o))
out["past_members"] = past_members
out["current_members"] = current_members
return sjson.dumps(out)
def create(self):
usr = request.params['login']
if Session.query(User).filter_by(user_name=usr).count() > 0:
return simplejson.dumps({'success':False,'msg':'That username is already taken, sorry.'})
pwd = request.params['pass']
if len(usr) < 3 or len(pwd) < 3:
return simplejson.dumps({'success':False,'msg':'Your username and password must each be at least 3 characters.'})
code = request.params['code']
invite = Session.query(Invite).filter_by(code=code).first()
if invite is None:
return simplejson.dumps({'success':False,'msg':'Your registration code appears to be invalid.'})
user = User()
user.who = invite.who
user.user_name = usr
user.password = pwd
user.registered = datetime.now()
Session.begin()
user.groups = [Session.query(Group).filter_by(group_name='users').one()]
Session.delete(invite)
Session.add(user)
Session.commit()
return simplejson.dumps({'success':True})
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()])
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)
