def post(self): artist = cgi.escape(self.request.get('artist')) title = cgi.escape(self.request.get('title')) requested_by = cgi.escape(self.request.get('requested_by')) ip = self.request.remote_addr old_user = memcache.get(ip) if old_user is None: new_user = model.SongRequester(ip=ip, username=requested_by) new_user.put() memcache.set(ip, new_user) elif old_user != requested_by: previous_user = model.SongRequester.all().filter('ip = ', ip).get() previous_user.username = requested_by previous_user.put() memcache.set(ip, previous_user) if title == '' and artist == '': self.redirect('/musicrequest?error=1') else: #lets check last.fm for this song search_lastfm = True if title == '': title = 'Any song' search_lastfm = False elif artist == '': artist = 'Unknown artist' if requested_by == '': requested_by = 'Anonymous' search_lastfm = False #if search_lastfm: # song_url = self.get_song_url(title, artist) song = Song(artist=artist, title=title, requested_by = requested_by)#, url=song_url) song.put() memcache.delete("songs") self.redirect('/musicrequest')
def not_error(item): try: Song.byPath(str(item.attrib['ref'])) return 1 except: turbogears.flash("Missing one or more songs, last missing song: " + item.attrib['ref'].replace('songs/','') + ' . . - song(s) not loaded') return 0
def insert_song(type: str, meta: dict): if (type=='song'): temp = Song(meta) elif (type=='podcast'): temp = Podcast(meta) elif (type=='audiobook'): temp = AudioBook(meta) id = db.insert_file("song", temp.convert_dict()) return {"id": id}
def play_all(self): songs = [] for song in self.songs: songs.append(song) for band in self.bands: for song in band.songs: songs.append(song) from model import Song Song.play_song_list(songs)
def playlist_add_confirmed(): is_uploaded = yt_re.search(request.form['uri']) is None # we'll clean up duplicates manually song = Song(uri=request.form['uri'], title=request.form['title'], artist=request.form['artist']) song.submitter = request.form['submitter'] song.is_uploaded = is_uploaded song.created = datetime.datetime.now() db.session.add(song) db.session.commit() return render_template('playlist/add_confirmed.html', song=song)
def songbook_view(self, path=c.ALL_SONGS_PATH): # we check to see if the user is trying to hack us with a bad path pathcheck(path) if path == c.ALL_SONGS_PATH: #create songbook all songs from scratch and save in location. Then pass it to be viewed title = "All Songs" songbook_content = '''<songbook format-version="0.1">\n<title>''' + title.strip() + "</title>" #get all paths and sort them songs = [songs for songs in Song.select(orderBy=Song.q.title)] songs.sort(key=lambda x: x.title.lower() or 'No Title') for song in songs: songbook_content = songbook_content + '\n<songref ref="' + song.path +'" status="n"/>' songbook_content = songbook_content + '\n</songbook>' write = open(path, "w") write.write(songbook_content) write.close() try: all_songs_songbook = Songbook.byPath(str(path)) except SQLObjectNotFound: all_songs_songbook = Songbook(title=title, path=str(path)) try: if path != c.ALL_SONGS_PATH: #look up title from database songbook = Songbook.byPath(str(path)) title = songbook.title except SQLObjectNotFound: raise cherrypy.HTTPRedirect(URL("/notfound?path=%s" % path)) sb_xml = parse(path) #same as in songbook_edit below item_els = sb_xml.getroot().getchildren() songbook_items=[] for item in item_els: if item.tag == 'songref': songbook_items.append((Song.byPath(str(item.attrib['ref'])).title, item.attrib['ref'], item.get('status','n'))) if item.tag == 'section': songbook_items.append((item.attrib['title'],'','section')) return dict(title=title, path=path, songbook_items=songbook_items, songbooks=db.songbooks())
def get(self): #the only purpose of this is to clear all music #should be disabled except when debugging songs = Song.all() for song in songs: song.delete() self.redirect('/musicrequest')
def populateSongs(session, album_db_obj, album): """Populates the song database table with data from the Spotify API. Keyword arguments: session -- the database session. album_db_obj -- the album database object. album -- the album object containing Spotify data. """ song_objects = [] # Populate album information based on the album search. for track in album['tracks']['items']: track_info = sp.track(track['uri']) track_features = sp.audio_features(track['id'])[0] song = Song(uri=track_info['uri'], track_number=track_info['track_number'], name=track_info['name'], popularity=track_info['popularity'], duration=track_info['duration_ms'], explicit=track_info['explicit'], danceability=track_features['danceability'], tempo=track_features['tempo'], energy=track_features['energy'], instrumentalness=track_features['instrumentalness'], time_signature=track_features['time_signature'], valence=track_features['valence'], album_id=album_db_obj.id, album=album_db_obj) song_objects.append(song) session.add_all(song_objects) session.commit()
def songbook_edit(self, path): # we check to see if the user is trying to hack us with a bad path pathcheck(path) songbook = Songbook.byPath(str(path)) path = songbook.path songbook_content = open(songbook.path, "rU").read() title = c.grab_title(songbook_content) sb_xml = parse(songbook.path) #same as in songbook_view above item_els = sb_xml.getroot().getchildren() songbook_items=[] for item in item_els: if item.tag == 'songref': songbook_items.append((Song.byPath(str(item.attrib['ref'])).title, item.attrib['ref'], item.get('status','n'))) if item.tag == 'section': songbook_items.append((item.attrib['title'],'','section')) password = '' if sb_xml.find('password') != None: password = sb_xml.find('password').text return dict(title=title, path=path, new=False, songs_list=db.songs(), songbooks=db.songbooks(), songbook_items=songbook_items, password=password, def_title="New Songbook")
def load_songs(song_filename): """Load songs from songs.txt into database.""" print("Songs") for i, row in enumerate(open(song_filename)): row = row.rstrip() song_id, song_title, song_release_date_str, song_release_year_str, song_release_month_str, song_release_day_str, apple_music_player_url = row.split( "|") if not song_release_year_str or song_release_year_str in ( 'None', 'None"', '') or len(song_release_year_str) != 4: song_release_year_str = None if not song_release_month_str or song_release_month_str in ('None', 'None"', ''): song_release_month_str = None else: if len(song_release_month_str) == 1: song_release_month_str = "0" + song_release_month_str if not song_release_day_str or song_release_day_str in ('None', 'None"', ''): song_release_day_str = None else: if len(song_release_day_str) == 1: song_release_day_str = "0" + song_release_day_str if song_release_year_str and song_release_month_str and song_release_day_str: song_release_date_str = " ".join([ song_release_year_str, song_release_month_str, song_release_day_str ]) song_release_date = datetime.datetime.strptime( song_release_date_str, "%Y %m %d") song = Song(song_id=song_id, song_title=song_title, song_release_year=song_release_year_str, song_release_date=song_release_date, apple_music_player_url=apple_music_player_url) db.session.add(song) if i % 1000 == 0: print(i) # An optimization: if commit after every add, the database # will do a lot of work committing each record. However, # waiting until the end may be quite the load on computers with # smaller amounts of memory; it might thrash around. Committing # every 1,000th add is a good balance. db.session.commit() db.session.commit()
def add_songs_to_db(artist, db_setlist_list): """Add songs from list of strings to db with primary_artist id.""" if db_setlist_list: for song in db_setlist_list: try: artist.songs.append(Song(song_name=song)) db.session.commit() except IntegrityError: db.session.rollback() continue
def song_view_content(self, path): # we check to see if the user is trying to hack us with a bad path pathcheck(path) try: song = Song.byPath(str(path)) except SQLObjectNotFound: raise cherrypy.HTTPRedirect(URL("/notfound?path=%s" % path)) songXML = open(song.path).read() return songXML
def export_form(self, path="songs/jesujesu.son", selected="simple.cfg"): # we check to see if the user is trying to hack us with a bad path pathcheck(path) try: if 'songbook'in path: exportS = Songbook.byPath(str(path)) elif 'song' in path: exportS = Song.byPath(str(path)) else: raise cherrypy.HTTPRedirect(URL("/notfound?path=%s" % path)) except SQLObjectNotFound: raise cherrypy.HTTPRedirect(URL("/notfound?path=%s" % path)) title = exportS.title cf_dir = "config_files/" # grab all the paths for the config files config_paths = glob.glob(cf_dir + "*") config_files = dict() # for loop reads stylesheets and packages them in a list of dictionaries for c_path in config_paths: tmp_dict = dict() # read path and dump contents in tmp for line in open(c_path, "rU"): line = line.replace('--','').replace('-','_').split() if len(line) == 2: tmp_dict[line[0]]=line[1].replace('_','-') #config_files[c_path.replace(cf_dir,'')]=tmp_dict config_files[os.path.basename(c_path)]=tmp_dict songbook_configs = dict() songbook_xml = parse(path) for format_config in songbook_xml.findall('//formatter'): key = format_config.get('name') config_val = dict() # parse the config_val dict from the xml element content raw_args = format_config.text.replace('--', '').replace('-', '_').split() for i in range(0, len(raw_args), 2): if i+1 < len(raw_args): # can't go out of bounds config_val[raw_args[i]] = raw_args[i+1].replace('_', '-') # lets store this key and config songbook_configs[key] = config_val # done parsing songbook_configs #DEBUG: print config_files return dict(title=title, path=path, config_files=config_files, songbook_configs=songbook_configs, songbooks=db.songbooks(), selected=selected)
def song_edit(self, path): # we check to see if the user is trying to hack us with a bad path pathcheck(path) song = Song.byPath(str(path)) path = song.path song_xml = ET.parse(path) # get information from song_xml title = 'Untitled' author = '' scripture_ref ='' intro = '' key = '' copyrights = '' cclis = None categories = '' if song_xml.find('stitle') != None: title = song_xml.find('stitle').text if song_xml.find('author') != None: author = song_xml.find('author').text if song_xml.find('scripture_ref') != None: scripture_ref = song_xml.find('scripture_ref').text if song_xml.find('introduction') != None: intro = song_xml.find('introduction').text if song_xml.find('key') != None: key = song_xml.find('key').text if song_xml.find('copyright') != None: copyrights = song_xml.find('copyright').text if song_xml.find('cclis') != None: cclis = song_xml.find('cclis').text if song_xml.find('categories') != None and song_xml.find('categories').text != None: categories = [cat.strip() for cat in song_xml.find('categories').text.split(',')] chunks = song_xml.findall('chunk') for chunk in chunks: chunk_text=[] lines = chunk.findall('line') for line in lines: if song2mono.is_chord_line(ET.tostring(line))==1: chunk_text.append(song2mono.expand_chord(ET.tostring(line))) else: chunk_text.append(line.text or "") chunk.text = '\n'.join(chunk_text) return dict(title=title, author=author, scripture_ref=scripture_ref, introduction=intro, key=key, copyrights=copyrights, chunks=chunks, path=path, new=False, songbooks=db.songbooks(), cclis=cclis, categories=categories, def_title="New Song")
def get(self): # IMPLEMENT MEMCACHE HERE songlist = memcache.get("songs") ip = self.request.remote_addr previous_user = memcache.get(ip) if previous_user is None: previous_user = model.SongRequester.all().filter('ip=', ip).get() if songlist is None: songs = Song.all().order('-date') songlist = songs.fetch(20) memcache.add("songs", songlist) template_values = {'songs' : songlist, 'heading' : 'Song Request', 'previous_user' : previous_user} if self.request.get('error') == '1': template_values['error'] = 'At the very least, I need the title of the song, or an artist.' self.generate('music.html', template_values)
def load_songs(song_list): """Load songs from Guitar Party API into database.""" print "Songs" for item in song_list: if Song.query.filter_by(song_id=item['id']).first() == None: song = Song(song_id=item['id'], title=item['title'], body=item['body'], body_chords_html=item['body_chords_html'], permalink=item['permalink']) db.session.add(song) db.session.commit()
def view_playlist_details(playlist_id): """Returns the playlist details.""" # get playlist name playlist_name = playlist.get_playlist_name(playlist_id) #get songs in playlist song_ids = playlist_song.get_playlist_songs(playlist_id) songs_list = [] for item in song_ids: song = crud.get_song(item) songs_list.append(song) #store in the dict song_dict = [] for song in songs_list: x = Song.as_dict(song) song_dict.append(x) return jsonify({'songs': song_dict, 'playlist_name': playlist_name})
def add_song(path): getcontext().prec = 3 tag = tiny.get(path) artist = session.query(Artist).filter_by(name=tag.artist).first() if artist == None: artist = Artist(name=tag.artist) session.add(artist) album = session.query(Album).filter_by(name=tag.album).first() if album == None: album = Album(name=tag.album, num_songs=0, artist=artist) session.add(album) album.num_songs += 1 duration = Decimal(tag.duration) / Decimal(60) song = Song(name=tag.title, release_date=tag.year, genre=tag.genre, length=duration, album=album, path=path) session.add(song) song.artists.append(artist) session.commit()
def create_song(song_title, song_uri, tempo, valence, danceability, energy, loudness, acousticness, speechiness, song_artist): """Creates a Song and adds it to the database.""" song = Song(song_title=song_title, song_uri=song_uri, tempo=tempo, valence=valence, danceability=danceability, energy=energy, loudness=loudness, acousticness=acousticness, speechiness=speechiness, song_artist=song_artist) # makes sure the song isn't already in the db if get_song_id(song_uri) == None: db.session.add(song) db.session.commit() return song else: return song
def generate_playlist(): original_spotify_info = spotify.base_playlist( spotify.generate_token(), session["genre"].lower(), session["minimum_danceability"], session["maximum_danceability"]) clean_array = [] index = 0 for track in original_spotify_info["tracks"]: if track["preview_url"] is not None: clean_array.append(track) index += 1 spotify_info = {"tracks": clean_array} if len(spotify_info.get("tracks")) <= 0: flash( "Change the search parameters of danceability. No playlist was generated." ) return redirect("/create") else: playlist = Playlist( user_id=session["user_id"], playlist_image=spotify_info["tracks"][0]["album"]["images"][1] ["url"], playlist_genre=session["genre"].lower(), playlist_mindanceability=session["minimum_danceability"], playlist_maxdanceability=session["maximum_danceability"]) db.session.add(playlist) db.session.commit() #store songs into Song database and song-playlist data into SongPlaylist database for track in spotify_info["tracks"]: #if Song database is empty, add generated song as new song in the database if len(db.session.query(Song).all()) <= 0: song = Song( track_id=track["id"], track_title=track["name"], artist=[artist["name"] for artist in track["artists"]]) db.session.add(song) db.session.commit() #if a song(s) exists in the database, check to see if there is a match with generated song #and existing song(s) match. If there is no match, add generated song as new song in the database. #Both if statements check to make sure new songs that are added into database do not already #exist in the database. if len( db.session.query(Song).filter( Song.track_id == track["id"]).all()) <= 0: song = Song( track_id=track["id"], track_title=track["name"], artist=[artist["name"] for artist in track["artists"]]) db.session.add(song) db.session.commit() songplaylist = SongPlaylist(track_id=track["id"], playlist_id=playlist.playlist_id) db.session.add(songplaylist) db.session.commit() #reveal newly generated playlist on generate_playlist.html page based on stored session from user input above #create json format that in the form that Amplitude.js can read spotify_info_list = [] for track in spotify_info["tracks"]: spotify_info_dict = {} millis = int(track["duration_ms"]) minutes = millis / (1000 * 60) minutes = int(minutes) seconds = (millis % (1000 * 60)) / 1000 seconds = int(seconds) if seconds == 0: seconds = "00" if seconds == 1: seconds = "01" if seconds == 2: seconds = "02" if seconds == 3: seconds = "03" if seconds == 4: seconds = "04" if seconds == 5: seconds = "05" if seconds == 6: seconds = "06" if seconds == 7: seconds = "07" if seconds == 8: seconds = "08" if seconds == 9: seconds = "09" track["duration_ms"] = f'{minutes}:{seconds}' spotify_info_dict["name"] = track["name"] spotify_info_dict["artist"] = [ f' {artist["name"]}' for artist in track["artists"] ] spotify_info_dict["album"] = track["album"]["name"] spotify_info_dict["url"] = track["preview_url"] spotify_info_dict["cover_art_url"] = track["album"]["images"][0]["url"] spotify_info_list.append(spotify_info_dict) fin_spotify_dict = {} fin_spotify_dict["songs"] = spotify_info_list return render_template("amplitude_generate_playlist.html", spotify_info=spotify_info, fin_spotify_dict=fin_spotify_dict)
def get(self): full_list = memcache.get("songs_full_list") if full_list is None: full_list = Song.all().order('artist') template_values = {'songs' : full_list} self.generate('full_music_list.html', template_values)
def populateDataManually(): """Populates the database tables with dummy data. """ # Populate starter data in the database # Bind the engine to the metadata of the Base class (enables declaratives to be accessed through a DBSession # instance) Base.metadata.bind = engine DBSession = sessionmaker(bind=engine) # A DBSession() instance establishes all conversations with the database and represents a "staging zone" # for all the objects loaded into the database session object. Any change made against the objects in the # session won't be persisted into the database until you call session.commit(). If you're not happy about the # changes, you can revert all of them back to the last commit by calling session.rollback() session = DBSession() # Initial dummy data. user1 = User(email="*****@*****.**", password="******") user2 = User(email="*****@*****.**", password="******") user3 = User(email="*****@*****.**", password="******") session.add(user1) session.add(user2) session.add(user3) session.commit() artist1 = Artist(name="Purity Ring", uri="dummy", followers=1) session.add(artist1) session.commit() album1 = Album(name="Another Eternity", uri="dummyuri", release_date=date.today, artist_id=artist1.id, artist=artist1) session.add(album1) session.commit() song_objects = [ Song(uri="dummyuri", track_number=1, name="Heartsigh", popularity=100, duration=189000, danceability=1.0, explicit=False, tempo=1.0, energy=1.0, instrumentalness=1.0, time_signature=100, valence=1.0, album_id=album1.id, album=album1), Song(uri="dummyuri", track_number=2, name="Bodyache", popularity=100, duration=179000, danceability=1.0, explicit=False, tempo=1.0, energy=1.0, instrumentalness=1.0, time_signature=100, valence=1.0, album_id=album1.id, album=album1), Song(uri="dummyuri", track_number=3, name="Push Pull", popularity=100, duration=169000, danceability=1.0, explicit=False, tempo=1.0, energy=1.0, instrumentalness=1.0, time_signature=100, valence=1.0, album_id=album1.id, album=album1), Song(uri="dummyuri", track_number=4, name="Repetition", popularity=100, duration=159000, danceability=1.0, explicit=False, tempo=1.0, energy=1.0, instrumentalness=1.0, time_signature=100, valence=1.0, album_id=album1.id, album=album1), Song(uri="dummyuri", track_number=5, name="Stranger than Earth", popularity=100, duration=149000, danceability=1.0, explicit=False, tempo=1.0, energy=1.0, instrumentalness=1.0, time_signature=100, valence=1.0, album_id=album1.id, album=album1), Song(uri="dummyuri", track_number=6, name="Begin Again", popularity=100, duration=139000, danceability=1.0, explicit=False, tempo=1.0, energy=1.0, instrumentalness=1.0, time_signature=100, valence=1.0, album_id=album1.id, album=album1), Song(uri="dummyuri", track_number=7, name="Dust Hymn", popularity=100, duration=129000, danceability=1.0, explicit=False, tempo=1.0, energy=1.0, instrumentalness=1.0, time_signature=100, valence=1.0, album_id=album1.id, album=album1), Song(uri="dummyuri", track_number=8, name="Flood on the Floor", popularity=100, duration=119000, danceability=1.0, explicit=False, tempo=1.0, energy=1.0, instrumentalness=1.0, time_signature=100, valence=1.0, album_id=album1.id, album=album1), Song(uri="dummyuri", track_number=9, name="Sea Castle", popularity=100, duration=144000, danceability=1.0, explicit=False, tempo=1.0, energy=1.0, instrumentalness=1.0, time_signature=100, valence=1.0, album_id=album1.id, album=album1), Song(uri="dummyuri", track_number=10, name="Stillness in Woe", popularity=100, duration=155000, danceability=1.0, explicit=False, tempo=1.0, energy=1.0, instrumentalness=1.0, time_signature=100, valence=1.0, album_id=album1.id, album=album1) ] session.add_all(song_objects) session.commit()
def song_title(f): try: return Song.byPath(str(f)).title, except SQLObjectNotFound: return '[SONG NOT IN DATABASE -- REPORT THIS]'