def start(self, session=None): cache_key = LibraryUpload.CACHE_KEY % (cherrypy.request.user.id, session) all_tracks = [] cache.set(cache_key, all_tracks) return b''
def _fetch_tag(self, tag_name): key = Remotes.TAG_KEY_FORMAT % tag_name tag = { 'lastfm': lastfm.get_tag(tag_name, 1000), } cache.set(key, tag) ws.emit_all('remotes.tag.fetched', tag_name)
def transcoding_done(self, track): if hasattr(cherrypy.request, 'queue_current_id') and cherrypy.request.queue_current_id is not None: queue_current_id = cherrypy.request.queue_current_id queue_dao.update_queue(queue_current_id, played=True) cherrypy.request.queues_done = True ws_user = ws.get_ws_user() cache.set('queue.current_track_%d' % ws_user.id, None) cache.set('queue.current_progress_%d' % ws_user.id, None)
def transcoding_progress(self, progress, transcoder, track): ws_user = ws.get_ws_user() if ws_user is not None: cache.set('queue.current_progress_%d' % ws_user.id, progress) if 'User-Agent' in cherrypy.request.headers: user_agent = cherrypy.request.headers['User-Agent'] else: user_agent = None format = transcoder.__class__.outputs() ws.emit('queue.progress', progress, self.serialize_track(track), user_agent, format) cherrypy.request.queue_progress = progress
def _fetch_user(self, id, lastfm_user, lastfm_session_key): key = Remotes.USER_KEY_FORMAT % id if lastfm_user is None or lastfm_session_key is None: return user_lastfm = lastfm.get_user(lastfm_user, lastfm_session_key) if user_lastfm is None: return cache.set(key, { 'lastfm': user_lastfm }) ws.emit_all('remotes.user.fetched', id)
def _add_listened_tracks(self, user_id, lastfm_user, lastfm_session_key): key = Remotes.USER_TRACKS_KEY_FORMAT % user_id if lastfm_user is None or lastfm_session_key is None: return count = library_dao.get_listened_tracks_count(user_id) max_timestamp = library_dao.get_listened_track_max_timestamp(user_id) index = 0 for track in lastfm.get_user_tracks(lastfm_user, lastfm_session_key): # if we have less than 90% of what lastfm reports that the total # should be we assume something went wrong before and we redo # the whole thing from the start. # # this could occur if the user shuts down opmuse before this finishes # or if lastfm goes down or rate limits the hell out of us. # # the reason we only do it when it's less than 90% is because there's # a bug in the lastfm api where if the user has submitted non utf8 data # or otherwise "corrupt" data the api call will fail with an empty # response and we'll miss out on some tracks and there's nothing we # can do about that. http://www.last.fm/group/Last.fm+Web+Services/forum/21604/_/626352 # # this could obviously also 'cause some unnecessary re-fetching of all # tracks on every run in some cases, but i'm not gonna fix that until # someone reports it as an actual issue... if index == 0 and count > 0 and count / track['total'] < .90: max_timestamp = None count = 0 library_dao.delete_listened_tracks(user_id) if max_timestamp is not None and track['timestamp'] is not None and max_timestamp >= track['timestamp']: break library_dao.add_listened_track(user_id, track['name'], track['artist'], track['album'], track['timestamp']) index += 1 cache.set(key, True)
def transcoding_start(self, transcoder, track): if hasattr(cherrypy.request, 'queue_current_id') and cherrypy.request.queue_current_id is not None: queue_current_id = cherrypy.request.queue_current_id queue_dao.update_queue(queue_current_id, current_seconds=None, playing=True) track = self.serialize_track(track) if 'User-Agent' in cherrypy.request.headers: user_agent = cherrypy.request.headers['User-Agent'] else: user_agent = None format = transcoder.__class__.outputs() ws_user = ws.get_ws_user() if ws_user is not None: cache.set('queue.current_track_%d' % ws_user.id, track) ws.emit('queue.start', track, user_agent, format)
def _fetch_artist(self, id): key = Remotes.ARTIST_KEY_FORMAT % id try: artist_entity = get_database().query(Artist).filter(Artist.id == id).one() except NoResultFound: # artist removed, just ignore return artist = { 'wikipedia': wikipedia.get_artist(artist_entity.name), 'lastfm': lastfm.get_artist(artist_entity.name), 'google': google.get_artist_search(artist_entity), 'musicbrainz': musicbrainz.get_artist(artist_entity) } cache.set(key, artist) ws.emit_all('remotes.artist.fetched', id, [album.id for album in artist_entity.albums], [track.id for track in artist_entity.tracks])
def _fetch_track(self, id): key = Remotes.TRACK_KEY_FORMAT % id try: track_entity = get_database().query(Track).filter(Track.id == id).one() except NoResultFound: # track was probably removed, edited and therefor recreated. either # way we just ignore it return album_name = track_entity.album.name if track_entity.album is not None else None artist_name = track_entity.artist.name if track_entity.artist is not None else None track = { 'wikipedia': wikipedia.get_track(artist_name, album_name, track_entity.name), 'lastfm': lastfm.get_track(artist_name, track_entity.name) } cache.set(key, track) ws.emit_all('remotes.track.fetched', id)
def _fetch_album(self, id): key = Remotes.ALBUM_KEY_FORMAT % id try: album_entity = get_database().query(Album).filter(Album.id == id).one() except NoResultFound: # album removed, just ignore return if len(album_entity.artists) > 0: artist_name = album_entity.artists[0].name else: artist_name = None album = { 'wikipedia': wikipedia.get_album(artist_name, album_entity.name), 'lastfm': lastfm.get_album(artist_name, album_entity.name), 'musicbrainz': musicbrainz.get_album(album_entity) } cache.set(key, album) ws.emit_all('remotes.album.fetched', id, [track.id for track in album_entity.tracks])
def default(self): user = cherrypy.request.user auth_url = new_auth = None need_config = False cache_key = 'settings_lastfm_session_key_%d' % cherrypy.request.user.id if user.lastfm_session_key is None: session_key = cache.get(cache_key) if session_key is not None: auth_url = session_key.get_auth_url() key = session_key.get_session_key() if key is not None: cache.set(cache_key, None) user.lastfm_session_key = key user.lastfm_user = lastfm.get_authenticated_user_name(key) auth_url = None new_auth = True else: try: session_key = SessionKey() auth_url = session_key.get_auth_url() cache.set(cache_key, session_key) except LastfmError: need_config = True remotes.update_user(user) return { "user": user, 'need_config': need_config, 'auth_url': auth_url, 'new_auth': new_auth }
def _reset_current(self): ws_user = ws.get_ws_user() cache.set('queue.current_track_%d' % ws_user.id, None) cache.set('queue.current_progress_%d' % ws_user.id, None) ws.emit('queue.reset')
def default(self, query=None, type=None): artists = [] albums = [] tracks = [] track_ids = [] hierarchy = None album_track_ids = set() recent_searches = [] if query is not None: albums = None tracks = None # only search for artists if type == 'artist': artists = search.query_artist(query, exact=True) albums = [] tracks = [] else: artists = search.query_artist(query) if albums is None: albums = search.query_album(query) if tracks is None: tracks = search.query_track(query) for artist in artists: remotes.update_artist(artist) for album in albums: remotes.update_album(album) for track in tracks: track_ids.append(track.id) remotes.update_track(track) entities = artists + albums + tracks if len(entities) == 1: for artist in artists: raise HTTPRedirect('/%s' % artist.slug) for album in albums: raise HTTPRedirect('/%s/%s' % (album.artists[0].slug, album.slug)) for track in tracks: raise HTTPRedirect('/library/track/%s' % track.slug) if cache.has(Search.CACHE_RECENT_KEY): recent_searches = cache.get(Search.CACHE_RECENT_KEY) else: cache.set(Search.CACHE_RECENT_KEY, recent_searches) if type is None and len(entities) > 0: if len(recent_searches) == 0 or query != recent_searches[0][0]: recent_searches.insert(0, (query, datetime.datetime.now(), cherrypy.request.user.login)) if len(recent_searches) > Search.MAX_RECENT: recent_searches.pop() entities = sorted(entities, key=lambda entity: entity._SEARCH_SCORE, reverse=True) hierarchy = Library._produce_track_hierarchy(entities) for key, result_artist in hierarchy['artists'].items(): for key, result_album in result_artist['albums'].items(): for track_id in library_dao.get_track_ids_by_album_id(result_album['entity'].id): album_track_ids.add(track_id) return { 'query': query, 'hierarchy': hierarchy, 'tracks': tracks, 'albums': albums, 'artists': artists, 'track_ids': track_ids, 'album_track_ids': list(album_track_ids), 'recent_searches': recent_searches }