import urllib2 import json import spotipy import spotipy.util as util import requests import base64 from spotipy.oauth2 import SpotifyClientCredentials ci='clientid' cs='clientsecret' #replace with actual stuff ccm=SpotifyClientCredentials(client_id='ba8d2826c2824677b73ebff71ca27785', client_secret='f4e3f64683e84da8a616c6da083fa287') token=ccm.get_access_token() sp=spotipy.Spotify(auth=token) def get_new_albums(): ''' Fetches new album data from Spotify. Returns list of albums. Each album is a dictionary containing values for the name, artist, album art, and a list of tracks. Each track in the list is a dictionary containing values for the name, artist, and Spotify URI (to be implemented with playing tracks). ''' print 'INSIIIDE' data=sp.new_releases(country=None, limit=20, offset=0) albums_data=data['albums']['items'] #print albums_data[0].keys() albums_uris=[]
!pip install spotipy import argparse import pprint import sys import os import subprocess import json import spotipy import spotipy.util as util import pandas as pd import time from spotipy.oauth2 import SpotifyClientCredentials client_credentials_manager = SpotifyClientCredentials(client_id= '77fbff4d863a482d82ce8fa6dbbc9f1b', client_secret='55c4c40ecaf445c0b9d742b5099d6888') username = "******" def show_tracks(tracks): for i, item in enumerate(tracks['items']): track = item['track'] print (" %d %s %s" % (i, track['artists'][0]['name'],track['name'])) def get_track_features(track_id,sp): if track_id is None: return None else: features = sp.audio_features([track_id])
# -*- coding: utf-8 -*- import random import spotipy import spotipy.util as util from spotipy.oauth2 import SpotifyClientCredentials keys = dict([line.split() for line in open('keys')]) SPOTIPY_CLIENT_ID = keys['SpotifyID'] SPOTIPY_CLIENT_SECRET = keys['SpotifySecret'] client_credentials_manager = SpotifyClientCredentials(SPOTIPY_CLIENT_ID, SPOTIPY_CLIENT_SECRET) sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager) emotions = { 'neutral': ['neutral', 'popular', 'hits', 'dance', 'hot'], 'happiness': ['happiness', 'happy', 'cheerful', 'summer', 'upbeat'], 'anger': ['angry', 'anger', 'rage', 'upset'], 'sadness': ['sad', 'sadness', 'emo', 'winter'], 'fear': ['calm', 'calming', 'relax'] } def get_playlist(emotion): keyword = random.choice(emotions[emotion]) random_int = random.randint(0, 75) playlist_list = sp.search(keyword, limit=10, offset=random_int, type='playlist',
from pandas.io import sql import pandas as pd from sqlalchemy import create_engine import spotipy as s from spotipy.oauth2 import SpotifyClientCredentials from keys import client_ID, client_secret, oauth_token client_credentials_manager = SpotifyClientCredentials( client_id=client_ID, client_secret=client_secret) spotify = s.Spotify(client_credentials_manager=client_credentials_manager) # Establish link to the database engine = create_engine('postgresql://jamesrogol@localhost:5432/bond') tracks = sql.read_sql("SELECT track_id FROM songs;", engine) tid = tracks['track_id'][0] analysis = spotify.audio_analysis(tid)
def spotipy_api(): sp = spotipy.Spotify(client_credentials_manager=SpotifyClientCredentials( client_id=client_id, client_secret=client_secret)) return sp
def spotify_dl(): """Main entry point of the script.""" parser = argparse.ArgumentParser(prog='spotify_dl') parser.add_argument('-l', '--url', action="store", help="Spotify Playlist link URL", type=str, required=True) parser.add_argument('-o', '--output', type=str, action='store', help='Specify download directory.', required=True) parser.add_argument('-d', '--download', action='store_true', help='Download using youtube-dl', default=True) parser.add_argument('-f', '--format_str', type=str, action='store', help='Specify youtube-dl format string.', default='bestaudio/best') parser.add_argument('-m', '--skip_mp3', action='store_true', help='Don\'t convert downloaded songs to mp3') parser.add_argument('-s', '--scrape', action="store", help="Use HTML Scraper for YouTube Search", default=True) parser.add_argument('-V', '--verbose', action='store_true', help='Show more information on what''s happening.') parser.add_argument('-v', '--version', action='store_true', help='Shows current version of the program') args = parser.parse_args() if args.version: print("spotify_dl v{}".format(VERSION)) exit(0) db.connect() db.create_tables([Song]) if os.path.isfile(os.path.expanduser('~/.spotify_dl_settings')): with open(os.path.expanduser('~/.spotify_dl_settings')) as file: config = json.loads(file.read()) for key, value in config.items(): if value and (value.lower() == 'true' or value.lower() == 't'): setattr(args, key, True) else: setattr(args, key, value) if args.verbose: log.setLevel(DEBUG) log.info('Starting spotify_dl') log.debug('Setting debug mode on spotify_dl') if not check_for_tokens(): exit(1) sp = spotipy.Spotify(auth_manager=SpotifyClientCredentials()) log.debug('Arguments: {}'.format(args)) if args.url: valid_item = validate_spotify_url(args.url) if not valid_item: sys.exit(1) if args.output: item_type, item_id = parse_spotify_url(args.url) directory_name = get_item_name(sp, item_type, item_id) save_path = Path(PurePath.joinpath(Path(args.output), Path(directory_name))) save_path.mkdir(parents=True, exist_ok=True) log.info("Saving songs to: {}".format(directory_name)) songs = fetch_tracks(sp, item_type, args.url) if args.download is True: download_songs(songs, save_path, args.format_str, args.skip_mp3)
import logging import random import sys import spotipy import os import time import numpy as np import pandas as pd from spotipy.oauth2 import SpotifyClientCredentials import os.path import multiprocessing # spotify credentials client_credentials_manager = SpotifyClientCredentials() sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager) # open the file and read the contents-List of artists to find discography f = open("ticket_concert_artists.csv") lines = f.readlines() # don't read in header results = [] for x in lines: results.append(x.split(',')[0]) f.close() random.shuffle(results) # results.sort() # print(results) # failed_searches = []
def autentica(client_id, client_secret): client_credentials_manager = SpotifyClientCredentials( client_id, client_secret) return spotipy.Spotify( client_credentials_manager=client_credentials_manager)
import spotipy from spotipy.oauth2 import SpotifyClientCredentials import json import requests dates = [year for year in range(2008, 2017)] danceability = [] energy = [] speechiness = [] successes = [] for year in dates: _id_ = [] chart = billboard.ChartData('hot-100', date=str(year) + '-12-31') for song in chart: _id_.append(str(song.spotifyID)) client_credentials_manager = SpotifyClientCredentials( 'Client ID', 'Client Secret') sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager) for i in _id_: try: tid = 'spotify:track:' + i analysis = sp.audio_features(tid) results = json.dumps(analysis, indent=4) results = json.loads(results) danceability.append(results[0]['danceability']) energy.append(results[0]['energy']) speechiness.append(results[0]['speechiness']) except requests.exceptions.HTTPError: pass except TypeError: pass for song in chart:
market = ["US"] # spotipy keys, put in env file SP_CLIENT_ID = "--keys--" SP_CLIENT_SECRET = "--keys--" # genius keys GENIUS_ACCESS_TOKEN = "--keys--" genius_api = genius.Genius(GENIUS_ACCESS_TOKEN) genius.verbose = True # Keep status messages on genius.remove_section_headers = False # Remove section headers (e.g. [Chorus]) from lyrics when searching genius.excluded_terms = ["(Remix)", "(Live)" ] # Exclude songs with these words in their title # creds credentials = SpotifyClientCredentials(client_id=SP_CLIENT_ID, client_secret=SP_CLIENT_SECRET) # token access token = credentials.get_access_token() spotify = spotipy.Spotify(auth=token) @app.route('/') def index(): return render_template('index.html') @app.route('/output', methods=['POST']) def output(): # connecting html to request # user inputs song name here
def getSpotifyClient(clientID, clientSecret): client_credentials_manager = SpotifyClientCredentials( clientID, clientSecret) return spotipy.Spotify( client_credentials_manager=client_credentials_manager)
for task in queue_iter(q, block=False): try: search_artist(conn, spotify, task) conn.commit() # print(task) except Exception as e: print("Error %s : %s" % (e, traceback.format_exc())) conn.close() if __name__ == "__main__": import argparse parser = argparse.ArgumentParser() parser.add_argument("--count", type=int, default=1) parser.add_argument("--threads", type=int, default=10) args = parser.parse_args() client_credentials_manager = SpotifyClientCredentials( client_id=config.config["SPOTIFY_CLIENTID"], client_secret=config.config["SPOTIFY_SECRET"] ) queue = Queue() conn = psycopg2.connect(config.connstr()) for task in get_tasks(conn, args.count): queue.put(task) conn.close() queue_thread_exec(queue, func=worker, thread_count=args.threads)
try: from bs4 import BeautifulSoup except ImportError: print('beautifulsoup4 is not installed. You can install this by executing the following in a terminal:') print('\t"{0}" -m pip install beautifulsoup4'.format(PYTHON_EXECUTABLE)) input() sys.exit(1) # Get Keys with open('settings.json') as data_file: settings = json.load(data_file) # Create Spotify object print('[Top Level] Setting up Spotify object...') client_credentials_manager = SpotifyClientCredentials(client_id=settings['spotify']['client_id'], client_secret=settings['spotify']['client_secret']) sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager) sp.trace=False def chunks(l, n): # Thanks to http://stackoverflow.com/questions/312443/how-do-you-split-a-list-into-evenly-sized-chunks """Yield successive n-sized chunks from l.""" for i in range(0, len(l), n): yield l[i:i + n] def stripString(text): return "".join([i for i in text if i not in [i for i in '/\\:*?"><|']]) def my_hook(d): if '_percent_str' in d:
def spotify_connection(self): client_credentials_manager = SpotifyClientCredentials( self.CLIENT_ID, self.CLIENT_SECRET) sp = spotipy.Spotify( client_credentials_manager=client_credentials_manager) return sp
from flask import Flask, render_template, request, Response import spotipy from spotipy.oauth2 import SpotifyClientCredentials import json sp = spotipy.Spotify(auth_manager=SpotifyClientCredentials( client_id="your api id", client_secret="your client secret")) app = Flask(__name__) @app.route('/', methods=['GET', 'POST']) def main(): songs = [] error = False if request.method == "GET": return render_template("index.html") elif request.method == "POST": song_name = request.form["music"].lower() results = sp.search(q=song_name, type="track", limit=1) if len(results["tracks"]["items"]) == 0: error = True else: id_song = results['tracks']['items'][0]['id'] name_song = results["tracks"]["items"][0]["external_urls"][ "spotify"] print("id song ", name_song) songs = sp.recommendations(seed_tracks=[id_song], limit=20)["tracks"] if (len(songs) == 0): error = True
def get_sp_token(client_id, client_secret): s = SpotifyClientCredentials(client_id, client_secret) token = s.get_access_token() return token
#---------------------------------------------------------------------------- if __name__ == '__main__': #Username username = '******' #Settings cmd1 = "export SPOTIPY_CLIENT_ID='5c7e874f0455484fa7f083ddfb00d6d3'" cmd2 = "export SPOTIPY_CLIENT_SECRET='aa12f51eb9be4159b7419d628f99a9ee'" cmd3 = "export SPOTIPY_REDIRECT_URI='http://www.gijsjoostbrouwer.com'" cmd4 = "export YOUTUBE_DEV_KEY='AIzaSyDygNhHkHUQLWSNz-AFDFe33eU4n2FdFyU'" #Init my_client_id, my_client_secret = clientIds() client_credentials_manager = SpotifyClientCredentials( client_id=my_client_id, client_secret=my_client_secret) sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager) # #Get Playlists # idlist = [] # playlists = sp.user_playlists(username) # for playlist in playlists['items']: # if playlist['owner']['id'] == username: # idlist.append(playlist['id']) # print(playlist['id'],playlist['name']) # #Download Command # # playlist_id = '3OcLmMGOaKBhDAPji7mTf3' # playlist_id = '624HWemwkr07H8B6GyLC9y' playlist_id = '0NLAC7syToc2g6ImWybVB4' cmd5 = 'spotify_dl -d -u ' + username + ' -p ' + playlist_id + ' -o . '
print("Question 1") # 1 Import the spotipy API to be able to use it in this challenge import spotipy from spotipy.oauth2 import SpotifyClientCredentials # We'll need this to print the resulting data nicely import json # To access authorized Spotify data, do not edit these next few lines, they are just needed to make our function calls actually work from spotipy.oauth2 import SpotifyClientCredentials # Do not edit these unless you have your own Spotify Developer account CLIENT_ID = '99b361927f674edfb28a342956235d47' CLIENT_SECRET = '3657ba71ed0d480fb415e96b4cbef89c' client_credentials_manager = SpotifyClientCredentials( client_id=CLIENT_ID, client_secret=CLIENT_SECRET) # spotify object to access API sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager) # The results for the function calls we will be making are a little bit hard to parse, so formatting a string from the Python JSON object might help here. Here, we've provided a function called `jprint()` that you can call on the output of your search to try to look at the search result as a formatted string # you do not have to edit this function at all!!! def jprint(obj): # create a formatted string of the Python JSON object text = json.dumps(obj, sort_keys=True, indent=4) print(text) # IMPORTANT NOTE: FOR THIS CHALLENGE, EVERY FUNCTION YOU CALL WILL HAVE TO START WITH sp (i.e. sp.search() and whatever else), BECAUSE THAT IS THE NAME OF THE SPOTIPY OBJECT WE CREATED! WITHOUT THE sp, YOUR FUNCTION CALLS WILL NOT WORK!!! print("Question 2")
import pandas as pd import numpy as np import sqlite3 import re import spotipy from spotipy.oauth2 import SpotifyClientCredentials #importing local class from spotipy_query import spotipy_query, search_loop sp = spotipy.Spotify(client_credentials_manager=SpotifyClientCredentials()) all_songs = pd.read_csv('Music.txt', sep='\t', header=0, engine='python') with open('missing_track_insert.sql') as f: failed_to_find = f.read() missing_db = sqlite3.connect('spotipy.db') #triming and renaming columns first_range = list(range(0, 5)) second_range = [7, 12] total_range = first_range + second_range all_songs = all_songs.iloc[:, total_range] #converting dtypes str_list = ['Name', 'Artist', 'Album', 'Year']
def isPlaying(): try: if spoyifyObj.currently_playing()["is_playing"]: return True return False except: return False trackLists = [] address = '127.0.0.1' port = 8000 bsize = 1024 scope = 'playlist-modify-public streaming user-modify-playback-state user-read-playback-state user-read-currently-playing' client_credentials_manager = SpotifyClientCredentials( '221e9a5fac5c4f40bb2de9c33ce7a863', '8c5e85b7165840bbb605b43924952889') sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager) name = input("enter username ") def addToQueue(): artistName = input("enter an artist name ") results = spoyifyObj.search(artistName, 1, 0, "artist") artist = results['artists']['items'][0] print(artist['name'] + " has " + str(artist['followers']['total']) + " followers , and his genre is " + artist['genres'][0]) webbrowser.open(artist['images'][0]['url']) artistId = artist["id"] trackUri = [] trackArt = [] z = 1
'''This class parses retrieved Spotify API data for both playlists and albums''' import os import spotipy from spotipy.oauth2 import SpotifyClientCredentials import qrcode import PIL as pillow import re os.environ["SPOTIPY_CLIENT_ID"] = '19d46d1de89a44c9813248a047e1788f' os.environ["SPOTIPY_CLIENT_SECRET"] = 'bdffc7ce17c34d2fb13883afb54d7cf2' auth_manager = SpotifyClientCredentials() sp = spotipy.Spotify(auth_manager=auth_manager) def get_playlist_id(playlist_url): result = re.search('playlist/(.*)', playlist_url) get_id = result.group(1).split('?')[0] playlist_id = 'spotify:playlist:' + get_id return playlist_id def get_album_id(album_url): result = re.search('album/(.*)', album_url) get_id = result.group(1).split('?')[0] album_id = 'spotify:album:' + get_id return album_id def get_playlist_title(playlist_id): results = sp.playlist(playlist_id)
import datetime import spotipy import spotipy.util from spotipy import oauth2 from spotipy.oauth2 import SpotifyClientCredentials app = Bottle() # globals logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s") CLIENT_ID = "e29426dfb22c41cdbc92122fbb9c398c" CLIENT_SECRET = "837fd2824bec47e5a003419165674bdd" SCOPE = "user-top-read user-read-recently-played playlist-modify-public playlist-modify-private" CACHE = ".spotifyoauthcache" CLIENT_CREDENTIALS = SpotifyClientCredentials(client_id=CLIENT_ID, client_secret=CLIENT_SECRET) SP_OAUTH2 = oauth2.SpotifyOAuth(client_id=CLIENT_ID, client_secret=CLIENT_SECRET, redirect_uri="http://localhost:8000/verified", scope=SCOPE, cache_path=CACHE) LIMIT = 50 OFFSET = 0 TEMPLATE_PATH.insert(0, "") # global functions def get_token(): access_token = ""
import os import re import pandas as pd from tqdm.notebook import tqdm from bs4 import BeautifulSoup from urllib.parse import urljoin import spotipy import requests from spotipy.oauth2 import SpotifyClientCredentials from dotenv import load_dotenv load_dotenv() client_credentials_manager = SpotifyClientCredentials( client_id=os.environ['SPOTIPY_CLIENT_ID'], client_secret=os.environ['SPOTIPY_CLIENT_SECRET'] ) sp = spotipy.Spotify( client_credentials_manager=client_credentials_manager ) def find_band_spotify(band_name): """ For a given band name, find Spotify profile """ results = sp.search(q='artist:' + band_name, type='artist') items = results['artists']['items'] return items
import spotipy import sys from spotipy.oauth2 import SpotifyClientCredentials spotify = spotipy.Spotify(auth_manager=SpotifyClientCredentials()) if len(sys.argv) > 1: name = ' '.join(sys.argv[1:]) else: name = 'Radiohead' results = spotify.search(q='artist:' + name, type='artist') items = results['artists']['items'] if len(items) > 0: artist = items[0] print(artist['name'], artist['images'][0]['url'])
import spotipy from spotipy.oauth2 import SpotifyClientCredentials import os SPOTIPY_CLIENT_ID = os.getenv("SPOTIPY_CLIENT_ID") SPOTIPY_CLIENT_SECRET = os.getenv("SPOTIPY_CLIENT_SECRET") sp = spotipy.Spotify(client_credentials_manager=SpotifyClientCredentials( client_id=SPOTIPY_CLIENT_ID, client_secret=SPOTIPY_CLIENT_SECRET)) def spotify_first_search(keyword): results = sp.search(q=keyword, limit=1) result_dict = {} result_dict["name"] = results['tracks']['items'][0]['name'] result_dict["artist_name"] = results['tracks']['items'][0]['album'][ 'artists'][0]['name'] result_dict["artist_url"] = results['tracks']['items'][0]['album'][ 'artists'][0]['external_urls']['spotify'] result_dict["album_name"] = results['tracks']['items'][0]['album']['name'] result_dict["album_url"] = results['tracks']['items'][0]['album'][ 'external_urls']['spotify'] result_dict["image_url"] = results['tracks']['items'][0]['album'][ 'images'][0]['url'] result_dict["release_date"] = results['tracks']['items'][0]['album'][ 'release_date'] result_dict["popularity"] = results['tracks']['items'][0]['popularity'] result_dict["available_country"] = str( results['tracks']['items'][0]['available_markets'])[1:-1] result_dict["preview_url"] = results['tracks']['items'][0]['preview_url'] result_dict["total_result"] = results['tracks']['total']
def getsphandle(): client_credentials_manager = SpotifyClientCredentials(client_secret='0d2e381e77fa48c9b0504b4559eb1613', client_id='60512ae1d0614bea93fab9ba5f58e73a') sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager) return sp
def recommendations(artist, title): #TODO: store songdata in a json file so we don't have to do this over and over #TODO: add album art to each track in this csv docLabels = [] with open('data/songdata.csv') as csv_file: csv_reader = csv.reader(csv_file, delimiter=',') line_count = 0 for row in csv_reader: if line_count != 0: docLabels.append(row[1] + " ~ " + row[0]) if len(docLabels) % 100 == 0: print("\rReading documents: %d" % len(docLabels), end='', flush=True) line_count += 1 url = 'matcher.track.get?q_track={}&q_artist={}&format={}'.format( title, artist, 'json') req_url = 'http://api.musixmatch.com/ws/1.1/{}&apikey={}'.format( url, os.environ.get("MUSIX_API_KEY")) data = requests.get(req_url) data = json.loads(data.text) if data["message"]["header"]["status_code"] == 200: matched_artist = data["message"]["body"]["track"]["artist_name"] matched_title = data["message"]["body"]["track"]["track_name"] flash('requested song: {} ~ {}'.format(matched_artist, matched_title)) client_credentials_manager = SpotifyClientCredentials( client_id=os.environ.get("SPOTIFY_CLIENT_ID"), client_secret=os.environ.get("SPOTIFY_CLIENT_SECRET")) spotify = spotipy.Spotify( client_credentials_manager=client_credentials_manager) results = spotify.search(q='track:' + matched_title + ' artist:' + matched_artist, type='track') track = results['tracks']['items'][0] message = Markup("<img src='{url}' />".format( url=track["album"]["images"][1]["url"])) flash(message, category='success') message = Markup( "<audio controls src='{url}' />".format(url=track["preview_url"])) flash(message, category='success') matched_artist = matched_artist.lower() matched_title = matched_title.lower() # remove all except alphanumeric characters from matched_artist and matched_title matched_artist = re.sub('[^A-Za-z0-9]+', "", matched_artist) matched_title = re.sub('[^A-Za-z0-9]+', "", matched_title) if matched_artist.startswith( "the" ): # remove starting 'the' from matched_artist e.g. the who -> who matched_artist = matched_artist[3:] matched_id = data["message"]["body"]["track"]["track_id"] url = 'track.lyrics.get?track_id={}&format={}'.format( matched_id, 'json') req_url = 'http://api.musixmatch.com/ws/1.1/{}&apikey={}'.format( url, os.environ.get("MUSIX_API_KEY")) data = requests.get(req_url) data = json.loads(data.text) lyrics = data["message"]["body"]["lyrics"]["lyrics_body"].split( "...")[0] lyrics = lyrics.strip() lyrics = lyrics.replace('\n', ' ') lyrics = re.sub("[\(\[].*?[\)\]]", "", lyrics) model = Doc2Vec.load("d2v.model") #to find the vector of a document which is not in training data test_data = word_tokenize(lyrics.lower()) v1 = model.infer_vector(doc_words=test_data, alpha=0.025, min_alpha=0.001, steps=55) similar_v1 = model.docvecs.most_similar(positive=[v1]) for song in similar_v1: flash('recommended song: {}'.format(docLabels[int(song[0])])) else: flash('Sorry, we did not find the track "{}" by {}. Try again?'.format( title, artist)) return render_template('recommendations.html', title='Your recommendations')
def __init__(self): # the_secret_function() # credenciales # podriamos usar herencia, de momento asi vale: self.sp = spotipy.Spotify( client_credentials_manager=SpotifyClientCredentials())
from spotipy.oauth2 import SpotifyClientCredentials import spotipy from youtube_search import YoutubeSearch PLAYLISTS = [['Accidental','https://open.spotify.com/playlist/0zJ8hC8YJOcHYuk5nMPFm8?si=U6Kyom3XQ32reSuVgl2uhA', "PL59eqqQABruMQOPlUVcVsIid685ZdwDjf"], ['TimePass','https://open.spotify.com/playlist/6gADLrLFK1kXgEEOsENi1c', "PL59eqqQABruMSx6VSy1hbkBhG4XwtgSuy"], ['CHILLS','https://open.spotify.com/playlist/3zs3QOLX8bASY5oV2dmEQw', 'PL59eqqQABruN3GyAPiPnQ6Jq-TngWjT-Y'], ['Programming & Coding Music','https://open.spotify.com/playlist/6vWEpKDjVitlEDrOmLjIAj', 'PL59eqqQABruNew5O0cRvomfbU6FI0RGyl'], ['Spanish','https://open.spotify.com/playlist/75QJ1JeFaeSm0uH1znWxb0?si=Lt4kd-RARBu2TQz35RAQiQ', 'PL59eqqQABruM3TLAGthvgW10c1R6omGwq'] ] client_credentials_manager = SpotifyClientCredentials(client_id='{client_id}', client_secret='{client_secret}') sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager) CONTAINER = [] for playlist in PLAYLISTS: Name,Link,playlistid = playlist playlistcard = [] count = 0 PlaylistLink = "http://www.youtube.com/watch_videos?video_ids=" for i in (sp.playlist_tracks(Link)['items']): if count == 50: break try: song = i['track']['name'] + i['track']['artists'][0]['name'] songdic = (YoutubeSearch(song, max_results=1).to_dict())[0] playlistcard.append([songdic['thumbnails'][0],songdic['title'],songdic['channel'],songdic['id']]) PlaylistLink += songdic['id'] + ',' except:
import sys from spotipy.oauth2 import SpotifyClientCredentials import spotipy import pprint import pandas as pd import pdb import re # client_id = "fac9c94efcc04895b83bd73aa53bbbf8" # client_secret = "15a3224aa35242cba201e933284aedc5" client_credentials_manager = SpotifyClientCredentials( client_id="CLIENT_ID_HERE", client_secret="CLIENT_SECRET_HERE") sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager) def getRelated(id): label = [] popularity = [] followers = [] ids = [] for i in sp.artist_related_artists(id)['artists']: # print(i['id'],i['name'],i['followers'],i['href'],sep=' === ') label.append(i['name']) followers.append(i['followers']["total"]) ids.append(i['id']) popularity.append(i["popularity"]) dataf = pd.DataFrame({ 'Id': ids,
def __init__(self): oauth = SpotifyClientCredentials(self.client_id, self.client_secret) token = oauth.get_access_token() self.sp = spotipy.Spotify(auth=token)
#%% import spotipy from spotipy.oauth2 import SpotifyClientCredentials import pandas as pd import numpy as np import secret client_id = secret.client_id client_secret = secret.client_secret username = secret.username p_id = secret.playlist_id credentials = SpotifyClientCredentials(client_id, client_secret) sp = spotipy.Spotify(client_credentials_manager = credentials) NaN = np.nan #%% def show_tracks(results, array): for i, item in enumerate(results['items']): track = item['track'] array.append(track['id']) def get_track_ids(username, playlist_id): ids = [] playlist = sp.user_playlist(username, playlist_id) tracks = playlist['tracks'] show_tracks(tracks, ids) while tracks['next']: tracks = sp.next(tracks) show_tracks(tracks, ids) return ids