def _build_playlist(self): """Search all the file reader paths for movie files with the provided extensions. """ # Get list of paths to search from the file reader. paths = self._reader.search_paths() # Enumerate all movie files inside those paths. movies = [] for ex in self._extensions: for path in paths: # Skip paths that don't exist or are files. if not os.path.exists(path) or not os.path.isdir(path): continue # Ignore hidden files (useful when file loaded on usb # key from an OSX computer movies.extend(['{0}/{1}'.format(path.rstrip('/'), x) \ for x in os.listdir(path) \ if re.search('\.{0}$'.format(ex), x, flags=re.IGNORECASE) and \ x[0] is not '.']) # Get the video volume from the file in the usb key sound_vol_file_path = '{0}/{1}'.format(path.rstrip('/'), self._sound_vol_file) if os.path.exists(sound_vol_file_path): with open(sound_vol_file_path, 'r') as sound_file: sound_vol_string = sound_file.readline() if self._is_number(sound_vol_string): self._sound_vol = int(float(sound_vol_string)) # Create a playlist with the sorted list of movies. return Playlist(sorted(movies), self._is_random)
def post(self): """Create new playlist""" youtify_user_model = get_current_youtify_user_model() if youtify_user_model == None: self.error(403) return json_playlist = simplejson.loads(self.request.get('json')) if json_playlist is None: self.error(500) playlist_model = Playlist(owner=youtify_user_model, json=None) playlist_model.private = json_playlist.get('isPrivate', False) playlist_model.tracks_json = simplejson.dumps(json_playlist['videos']) playlist_model.title = json_playlist['title'] playlist_model.put() youtify_user_model.playlists.append(playlist_model.key()) youtify_user_model.save() self.response.headers['Content-Type'] = 'application/json' self.response.out.write( simplejson.dumps( get_playlist_struct_from_playlist_model(playlist_model)))
def create_playlist(playlist_name): """Creates a playlist and adds to DB.""" playlist = Playlist(playlist_name=playlist_name) db.session.add(playlist) db.session.commit() return playlist
def create_playlist(playlist_name, user_id): """Create and return a new playlist""" playlist = Playlist(playlist_name=playlist_name, user_id=user_id) db.session.add(playlist) db.session.commit() return playlist
def show_playlist(): username = spotify_username() playlists = spotify.user_playlists(username) playlists_list = [] for playlist in playlists['items']: # print(playlist) if playlist['images'] == []: play_list = Playlist(name=playlist['name'], uri=playlist['uri'], total=playlist['tracks']['total']) else: play_list = Playlist(name=playlist['name'], uri=playlist['uri'], total=playlist['tracks']['total'], image=playlist['images'][2]['url']) playlists_list.append(play_list.to_dict()) return {'playlists': playlists_list}
def show_top_tracks(artist_name): # default: top10 tracks_list = [] artist = get_artist(artist_name) results = spotify.artist_top_tracks(artist['uri']) for track in results['tracks']: playlist = Playlist(name=track['name'], uri=track['uri'], image=track['album']['images'][1]['url']) tracks_list.append(playlist.to_dict()) return {'playlists': tracks_list}
def get_playlist_from_context(self, context): """Return an Playlist from a Context. Args: context (dict): The Context to convert from. Returns: Playlist: The Playlist. """ if context["uri"] == common.SAVED_TRACKS_CONTEXT_URI: # TODO: Consider creating a common/factory function for # obtaining the Saved PLaylist. return Playlist({ "uri":common.SAVED_TRACKS_CONTEXT_URI, "name": "Saved" }) playlist_id = id_from_uri(context["uri"]) result = self.get_api_v1("playlists/{}".format(playlist_id)) return Playlist(result or {})
def add_playlist_to_db(user_id, sp_playlist_id, playlist_name): """Add a playlist to database""" playlist = Playlist(user_id=user_id, sp_playlist_id=sp_playlist_id, name=playlist_name) db.session.add(playlist) db.session.commit() print "Added to DB:", playlist return playlist
def create_playlist(channel_name, playlist_name, number_of_videos, last_updated): playlist = Playlist(channel_name=channel_name, playlist_name=playlist_name, number_of_videos=number_of_videos, last_updated=last_updated) db.session.add(playlist) db.session.commit() return playlist
def populatePlaylists(): """Populates the playlist tables with dummy data. """ Base.metadata.bind = engine DBSession = sessionmaker(bind=engine) session = DBSession() user1 = User(email="*****@*****.**", password="******") user2 = User(email="*****@*****.**", password="******") user3 = User(email="*****@*****.**", password="******") session.add(user1) session.add(user2) session.add(user3) p1 = Playlist(name="Kaan's list", user_id=user1.id, user=user1) p2 = Playlist(name="Ryan's list", user_id=user1.id, user=user2) p3 = Playlist(name="Paul's list", user_id=user1.id, user=user3) session.add(p1) session.add(p2) session.add(p3) session.commit()
def get_user_playlists(self, user, progress=None): """Get the Playlists from the current user. Args: user (User): The User. progress (Progress): Progress associated with this call. Return: tuple: The Playlists. """ q = {"limit": 50} url = "users/{}/playlists".format(user['id']) page = self.get_api_v1(url, q) return tuple([Playlist(p) for p in self.extract_page(page, progress)])
def load_playlists(): print("Loading playlists") Playlist.query.delete() for row in open("seed_data/playlist_data.csv"): row = row.rstrip() playlist_id, user_id, title = row.split(",") playlist = Playlist(playlist_id=playlist_id, user_id=user_id, title=title) db.session.add(playlist) db.session.commit()
def newPlaylist(): if request.method == 'POST': user_id_form = session.query(User).filter_by( email=request.form['user_email']).one() newPlaylistName = Playlist(name=request.form['name'], user_id=user_id_form.id) session.add(newPlaylistName) session.commit() flash("New playlist was created!") return redirect(url_for('index')) else: playlists = session.query(Playlist).all() users = session.query(User).all() return render_template('createNewPlaylist.html', title='Create a playlist', playlists=playlists, users=users)
def get(self): user = get_current_youtify_user_model() if ON_PRODUCTION: return for type, username in EXTERNAL_USERS: url = 'http://soundcloud.com/' + username response = urlfetch.fetch( 'https://api.soundcloud.com/resolve.json?consumer_key=206f38d9623048d6de0ef3a89fea1c4d&url=' + url) response = simplejson.loads(response.content) external_user_model = ExternalUser( type=type, external_user_id=str(response['id']), username=username, avatar_url=response['avatar_url']) external_user_model.save() user.external_user_subscriptions.append(external_user_model.key()) user.save() external_user_model.subscribers.append(user.key()) external_user_model.save() self.redirect('/') return for i in range(0, 50): tracks_json = [] for j in range(0, 100): tracks_json.append({ "videoId": 27985183, "title": "Oceanic Crust", "duration": 106331, "type": "soundcloud" }) m = Playlist(owner=user, title="Mosaik " + str(i), tracks_json=simplejson.dumps(tracks_json), json=None) m.put() user.playlists.append(m.key()) user.save() self.redirect('/')
def get_playlists(self, include_tracks=False) -> Generator[Playlist, None, None]: continue_ = True current_offset = 0 while continue_: r = self._spotipy.user_playlists(self._user_id, offset=current_offset) for item in r["items"]: playlist = Playlist(item["name"], item["id"]) if include_tracks: playlist.extend(self.get_playlist_tracks(playlist)) yield playlist continue_ = (r["offset"] + r["limit"]) < r["total"] current_offset = r["offset"] + 1
def add_new_playlist(): """ Add a new playlist. """ title = request.form.get("playlist-name") username = session.get('username') user = User.query.filter_by(username=username).first() user_id = user.user_id playlist = Playlist(user_id=user_id, title=title) db.session.add(playlist) db.session.commit() playlists = Playlist.query.filter_by(user_id=user_id).all() flash("Playlist added.") return redirect("/user")
def create_playlist_return_as_dict(user_id, search_id, created_at, last_updated_at, playlist_title, spotify_playlist_id=None): """Create a new playlist and return as dict""" playlist = Playlist(user_id=user_id, search_id=search_id, created_at=created_at, last_updated_at=last_updated_at, playlist_title=playlist_title, spotify_playlist_id=spotify_playlist_id) db.session.add(playlist) db.session.commit() return playlist.as_dict()
def _build_playlist(self): """Search all the file reader paths for movie files with the provided extensions. """ # Get list of paths to search from the file reader. paths = self._reader.search_paths() # Enumerate all movie files inside those paths. movies = [] for ex in self._extensions: for path in paths: # Skip paths that don't exist or are files. if not os.path.exists(path) or not os.path.isdir(path): continue movies.extend(['{0}/{1}'.format(path.rstrip('/'), x) \ for x in os.listdir(path) \ if re.search('\.{0}$'.format(ex), x, flags=re.IGNORECASE)]) # Create a playlist with the sorted list of movies. return Playlist(sorted(movies))
def create_playlist_in_db(playlist_title, user_id): """Creates playlist in db if not already in db.""" user = User.query.get(user_id) #check if user logged in #check if no user, no playlists #check if user has no playlists if not Playlist.query.filter_by(playlist_title=playlist_title, user_id=user_id).first(): playlist = Playlist(playlist_title=playlist_title) user.playlists.append(playlist) db.session.commit() else: playlist = Playlist.query.filter_by( playlist_title=playlist_title).first() return playlist
def show_artist_albums(artist_name): albums_list = [] albums = [] artist = get_artist(artist_name) results = spotify.artist_albums(artist['id'], album_type='album') albums.extend(results['items']) while results['next']: results = spotify.next(results) albums.extend(results['items']) seen = set() # to avoid dups albums.sort(key=lambda album: album['name'].lower()) for album in albums: name = album['name'] if name not in seen: playlist = Playlist(name=name, uri=album['uri'], image=album['images'][2]['url'], total=album['total_tracks']) albums_list.append(playlist.to_dict()) seen.add(name) return {'playlists': albums_list}
def create_playlist(auth_header, user_id, playlist_tracks, mood, playlist_name): """ Create playlist and add tracks to playlist. """ name = f'{playlist_name}' payload = {'name': name, 'description': 'Mood generated playlist'} playlist_request = f'{SPOTIFY_API_URL}/users/{user_id}/playlists' playlist_data = requests.post(playlist_request, data=json.dumps(payload), headers=auth_header).json() playlist_id = playlist_data['id'] session['playlist'] = playlist_id playlist_exist = db.session.query(Playlist).filter( Playlist.id == playlist_id).all() if not playlist_exist: new_playlist = Playlist(id=playlist_id, user_id=user_id, mood=mood) db.session.add(new_playlist) for track in playlist_tracks: playlist_track_exist = db.session.query(PlaylistTrack).filter( PlaylistTrack.playlist_id == playlist_id, PlaylistTrack.track_uri == track).all() if not playlist_track_exist: new_playlist_track = PlaylistTrack(playlist_id=playlist_id, track_uri=track) db.session.add(new_playlist_track) db.session.commit() track_uris = '%2C'.join(playlist_tracks) add_tracks = f'{SPOTIFY_API_URL}/playlists/{playlist_id}/tracks?uris={track_uris}' tracks_added = requests.post(add_tracks, headers=auth_header).json() # tracks_added = post_spotify_data(add_tracks, auth_header) return playlist_data['external_urls']['spotify']
def main(): parser = argparse.ArgumentParser() parser.add_argument("--size", type=int, help="Size of the generated playlist") parser.add_argument("--name", type=str, help="Name of the generated playlist") parser.add_argument("--user", type=str, help="User for whom to create the playlist") parser.add_argument("--seed", type=str, help="ID of the seed track") args = parser.parse_args() logging.basicConfig(level=logging.INFO, stream=sys.stdout) client = SpotifyClient(args.user) seed_track = client.get_track(args.seed) factory = ArtistChainFactory(client, seed_track, DriftingWeight(seed_track), unique_artists=False) # If a playlist of this name exists, use it, otherwise create one. for playlist_ in client.get_playlists(): if playlist_.name == args.name: playlist = playlist_ break else: playlist = Playlist(name=args.name) for _, track in zip(range(args.size), factory): playlist.append(track) LOG.info("Finished generating playlist %s", str(playlist)) client.store_playlist(playlist)
from model import Filme, Serie, Playlist vingadores = Filme('vingadores - guerra infinita', 2018, 160) atlanta = Serie('atlanta - um teste', 2018, 2) the_office = Serie('The Office', 2005, 9) titanic = Filme('titanic', 1996, 210) vingadores.dar_like() atlanta.dar_like() atlanta.dar_like() titanic.dar_like() the_office.dar_like() the_office.dar_like() the_office.dar_like() the_office.dar_like() the_office.dar_like() filmes_e_series = [vingadores, atlanta, titanic, the_office] playlist_fds = Playlist('fim de semana', filmes_e_series) print(f'Tamnanho da Playlist: {len(playlist_fds)}') for programa in playlist_fds: # detalhes = programa.duracao if hasattr(programa, 'duracao') else programa.temporadas # print(f'{programa.nome} - {detalhes} D - {programa.likes}') print(programa)
def add_playlist(name, desc): playlist = Playlist(name=name, description=desc) session.add(playlist) session.commit()
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)
from model import Filme, Serie, Playlist vingadores = Filme('vingadores', 2018, 160) vingadores.dar_likes() vingadores.dar_likes() atlanta = Serie('atlanta', 2018, 2) enola_holmes = Serie('Enola Holmes', 2020, 124) enola_holmes.dar_likes() enola_holmes.dar_likes() enola_holmes.dar_likes() enola_holmes.dar_likes() lista_filmes_e_series = [vingadores, atlanta, enola_holmes] playlist = Playlist('Minha Playlist', lista_filmes_e_series) print(f'Tamanho da playlist: {len(playlist)}') for programa in playlist: print(programa)
} self._print(order + " - " + name + " - " + screen_time + " - " + str(play_restriction)) fullPath = self._content_path + '/' + name if not os.path.exists(fullPath): continue playlistTh.append(fullPath) playlistRestrictions.append(play_restriction) except Exception, err: self._print("error") if hasattr(err, 'message'): self._print(err.message) else: self._print(err) pass return Playlist(playlistTh, playlistRestrictions, self._is_random) def _blank_screen(self): """Render a blank screen filled with the background color.""" self._screen.fill(self._bgcolor) pygame.display.update() def _blank_screen_no_update(self): """Render a blank screen filled with the background color.""" self._screen.fill(self._bgcolor) def _set_background_image(self, playlist): """Render background image and load bg from disk if playlist index =0 """ try: