def createNewPlaylist(artist_name):
cur = db.cursor()
sql_create_playlists = '''CREATE TABLE IF NOT EXISTS playlist (id INTEGER PRIMARY KEY AUTO_INCREMENT,rootArtist VARCHAR(128));'''
sql_create_songs = '''CREATE TABLE IF NOT EXISTS songs (playlistId INTEGER, songOrder INTEGER,artistName VARCHAR(128), albumName VARCHAR(256), trackName VARCHAR(256));'''
cur.execute(sql_create_playlists)
cur.execute(sql_create_songs)
sql_insert_artist_name = '''INSERT INTO playlist (rootArtist) VALUES ('%s');''' % (
artist_name)
cur.execute(sql_insert_artist_name)
playlistId = cur.lastrowid
root_artist_id = fetchArtistId(artist_name)
edgelist = getEdgeList(root_artist_id, 2)
g = pandasToNetworkX(edgelist)
songs = []
for i in range(30):
artist_id = (randomCentralNode(g))
songOrder = i + 1
artist_name = fetchArtistInfo(artist_id)['name']
album_ids = fetchAlbumIds(artist_id)
random_album = np.random.choice(album_ids)
random_album_name = fetchAlbumInfo(random_album)['name']
random_track_name = fetchARandomTrack(random_album)[1]
songs.append((playlistId, songOrder, artist_name, random_album_name,
random_track_name))
insertSongs = '''INSERT INTO songs
(playlistId, songOrder, artistName, albumName, trackName)
VALUES
(%s, %s, %s, %s, %s)'''
cur.executemany(insertSongs, songs)
db.commit()
print "playlists updated"
def createNewPlaylist(artist_name):
cur = db.cursor()
cur.execute('''CREATE TABLE IF NOT EXISTS playlists (id INTEGER PRIMARY KEY AUTO_INCREMENT, rootArtist VARCHAR(128));''')
cur.execute('''CREATE TABLE IF NOT EXISTS songs (playlistId INTEGER, songOrder INTEGER, artistName VARCHAR(128), albumName VARCHAR(256));''')
artists_id = fetchArtistId(artist_name)
edge_list = getEdgeList(artists_id, 2)
g = pandasToNetworkX(edge_list)
randomArtists=[]
limit = 30
while limit > 0:
random_artist = randomCentralNode(G)
album_id_list = fetchAlbumIds(random_artist)
if album_id_list == []:
pass
else:
randomArtists.append(random_artist)
limit -= 1
def createNewPlaylist(input_name):
cur = db.cursor()
make_table_playlists = '''CREATE TABLE IF NOT EXISTS playlists (id INTEGER PRIMARY KEY AUTO_INCREMENT, rootArtist VARCHAR(128));'''
make_table_songs = '''CREATE TABLE IF NOT EXISTS songs (playlistId INTEGER, songOrder INTEGER, artistName VARCHAR(128), albumName VARCHAR(256), trackName VARCHAR(256));'''
cur.execute(make_table_playlists)
cur.execute(make_table_songs)
depth = 2
artists_id = fetchArtistId(input_name)
edge_list = getEdgeList(artists_id,depth)
G = pandasToNetworkX(edge_list)
random_artists = []
limit = 30
while limit > 0:
random_artist = randomCentralNode(G)
album_id_list = fetchAlbumIds(random_artist)
if album_id_list == []:
pass
else:
random_artists.append(random_artist)
limit = limit -1
artist_names = []
album_list = []
for artist_id in random_artists:
artist = fetchArtistInfo(artist_id)
artist_name = artist['name']
artist_names.append(artist_name)
album_id_list = fetchAlbumIds(artist_id)
random_album = (random.choice(album_id_list))
random_album_info = fetchAlbumInfo(random_album)
random_album_name = random_album_info['name']
tupl = (random_album_name, random_album)
album_list.append(tupl)
random_track_list = []
for album in album_list:
get_album_tracks_url = 'https://api.spotify.com/v1/albums/' + album[1] + '/tracks'
req = requests.get(get_album_tracks_url)
if req.ok == False:
print "Error in get_album_tracks_url Request"
req.json()
myjson = req.json()
get_items = myjson.get('items')
track_list = []
for i in range(len(get_items)):
get_track_name = get_items[i]['name']
track_list.append(get_track_name)
random_track = (random.choice(track_list))
random_track_list.append(random_track)
artist_name_in = """INSERT INTO playlists (rootArtist) VALUES ('%s')""" % (input_name)
#playlistId = cur.lastrowid
cur.execute(artist_name_in)
com_play = """SELECT MAX(id) FROM playlists;"""
cur.execute(com_play)
playlistId = cur.fetchall()
playlistId = playlistId[0][0]
for i in range(len(random_track_list)):
songOrder = i+1
Artist_Name = '"' + artist_names[i] + '"'
Artist_Name.replace('\'', "")
Album_Name = '"' + album_list[i][0] + '"'
Album_Name.replace('\'', "")
Track_Name = '"' + random_track_list[i] + '"'
Track_Name.replace('\'', "")
#print Artist_Name, Album_Name, Track_Name
sql = """INSERT INTO songs (playlistId, songOrder, artistName, albumName, trackName) VALUES (%s, %s, %s, %s, %s)""" % (playlistId, songOrder, Artist_Name, Album_Name, Track_Name)
cur.execute(sql)
db.commit()
cur.close()
ID = fetchArtistId(a)
combined_Edge_List = getEdgeList(ID, 2)
if len(artist_names) > 1:
for artist_name in artist_names:
ID = fetchArtistId(artist_name)
edgeList1 = getEdgeList(ID, 2)
combined_Edge_List = combineEdgelists(combined_Edge_List,
edgeList1)
b = combined_Edge_List
c = pandasToNetworkX(b)
nodes = []
albums = []
tracks = []
tracks_names = []
for i in range(30):
d = randomCentralNode(c)
nodes.append(d)
for i in range(30):
e = nodes[i]
f = fetchAlbumIds(e)
i = len(f) - 1
g = randint(0, i)
h = f[g]
albums.append(h)
for i in range(30):
album_id = albums[i]
url = "https://api.spotify.com/v1/albums/" + album_id + "/tracks"
req = requests.get(url)
json_data = req.json()
j = len(json_data['items']) - 1
k = json_data['items'][j]['id']
def createNewPlaylist(artist_name):
cur = db.cursor()
cur.execute('''CREATE TABLE IF NOT EXISTS songs(
playlistId INTEGER,
songOrder VARCHAR(255),
artistName VARCHAR(255),
albumName VARCHAR(255),
trackName VARCHAR(255));''')
cur.execute('''CREATE TABLE IF NOT EXISTS playlists(
id INTEGER PRIMARY KEY
AUTO_INCREMENT,
rootArtist VARCHAR(255));''')
a = artist_name
ID = fetchArtistId(a)
combined_Edge_List = getEdgeList(ID, 2)
b = combined_Edge_List
c = pandasToNetworkX(b)
cur.execute('''
INSERT INTO playlists
(rootArtist)
VALUES
(%s)''', (artist_name))
g = cur.lastrowid
nodes = []
albums = []
tracks = []
tracks_names = []
while len(albums) < 30:
e = randomCentralNode(c)
f = fetchAlbumIds(e)
if len(f) == 0:
continue
i = len(f) - 1
g = randint(0, i)
h = f[g]
albums.append(h)
for i in range(30):
album_id = albums[i]
url = "https://api.spotify.com/v1/albums/" + album_id + "/tracks"
req = requests.get(url)
json_data = req.json()
j = len(json_data['items']) - 1
k = json_data['items'][j]['id']
tracks.append(k)
for i in range(30):
track_id = tracks[i]
url = "https://api.spotify.com/v1/tracks/" + track_id
req = requests.get(url)
json_data = req.json()
names = json_data['name']
tracks_names.append(names)
for i in range(30):
x = fetchAlbumInfo(albums[i])
ALBUM_NAME = x['name']
print(x['artist_id'])
y = fetchArtistInfo(x['artist_id'])
ARTIST_NAME = y['name']
TRACK_NAME = tracks_names[i]
x = i + 1
cur.execute(
'''
INSERT INTO songs
(playlistId, songOrder, artistName, albumName, trackName)
VALUES
(%s, %s, %s, %s, %s )''', (g, x, ARTIST_NAME, ALBUM_NAME, TRACK_NAME))
db.commit()
while counter2 < numberoffiles:
combinededgelist.append(anN.readEdgeList(listoffilenm[subsequentindex]))
subsequentindex += 1
counter2 += 1
combinededgelist.to_csv("combinededgelist.csv", index=False)
combinededgelistdf = anN.readEdgeList("combinededgelist.csv")
network = anN.pandasToNetworkX(combinededgelistdf)
listof30artists = []
while len(listof30artists) != 30:
artist = anN.randomCentralNode(network)
listof30artists.append(artist)
listof30albums = []
singleslist = []
for artist in listof30artists:
albums = fAl.fetchAlbumIds(artist)
if len(albums) == 0:
url = "https://api.spotify.com/v1/artists/" + artist + "/albums?&album_type=single"
req = requests.get(url)
singledata = req.json()['items']
for x in singledata:
singleslist.append(x['id'])
random_single = np.random.choice(singleslist)
listof30albums.append(random_single)
for i in range(len(artists_ids)): artist_id = artists_ids[i] edge_list = getEdgeList(artist_id,depth) edgeList_list.append(edge_list) concat_Edgelists = edgeList_list[0] #concat_Edgelists.columns = ['artist', 'related_artist'] for i in range(len(edgeList_list)): put_together = combineEdgeLists(concat_Edgelists, edgeList_list[i]) concat_Edgelists = put_together g = pandasToNetworkX(concat_Edgelists) random_artists = [] for i in range(30): random_artist = randomCentralNode(g) random_artists.append(random_artist) artist_names = [] album_list = [] for artist_id in random_artists: artist = fetchArtistInfo(artist_id) artist_name = artist['name'] artist_names.append(artist_name) album_id_list = fetchAlbumIds(artist_id) random_album = (random.choice(album_id_list)) random_album_info = fetchAlbumInfo(random_album) random_album_name = random_album_info['name'] tupl = (random_album_name, random_album) album_list.append(tupl)
print "input artists are ", artist_names
artistID_list = [fetchArtistId(artist_name) for artist_name in artist_names]
for artistID in artistID_list:
writeEdgeList(artistID, 2, artistID + '.csv')
combinedEdgeList = readEdgeList(artistID_list[0] + '.csv')
for artistID in artistID_list[1:]:
edgeList = readEdgeList(artistID + '.csv')
combinedEdgeList = combineEdgeLists(combinedEdgeList, edgeList)
g = pandasToNetworkX(combinedEdgeList)
sample = []
for i in range(30):
sample.append(randomCentralNode(g))
outfile = open('playlist.csv', 'w', encoding = 'utf-8')
outfile.write(u'artist_name,album_name,track_name\n')
def fetchARandomTrack(album_id):
url = 'https://api.spotify.com/v1/albums/'+ album_id +'/tracks'
req = requests.get(url)
data = req.json()
items = data['items']
row = np.random.choice(items)
track_id = row['id']
track_name = row['name']
return (track_id, track_name)
def createnewPlaylist(artistName):
cur = db.cursor()
maketableplaylists = """CREATE TABLE IF NOT EXISTS playlists (id INTEGER PRIMARY KEY AUTO_INCREMENT, rootArtist VARCHAR(255));"""
maketablesongs = """CREATE TABLE IF NOT EXISTS songs (playlistId INTEGER, songOrder INTEGER, artistName VARCHAR(255), albumName VARCHAR(255), trackName VARCHAR(255));"""
cur.execute(maketableplaylists)
cur.execute(maketablesongs)
#db.commit()
artist_names = artistName
depth = 2 #change depth at will
artists_id = fetchArtistId(artistName)
edge_list = getEdgeList(artists_id, depth)
g = pandasToNetworkX(edge_list)
random_artists = []
for i in range(30):
random_artist = randomCentralNode(g)
random_artists.append(random_artist)
artist_names = []
album_list = []
for artist_id in random_artists:
artist = fetchArtistInfo(artist_id)
artist_name = artist['name']
artist_names.append(artist_name)
album_id_list = fetchAlbumIds(artist_id)
random_album = (random.choice(album_id_list))
while random_album == False:
random_album = (random.choice(album_id_list))
random_album_info = fetchAlbumInfo(random_album)
random_album_name = random_album_info['name']
tupl = (random_album_name, random_album)
album_list.append(tupl)
random_track_list = []
for album in album_list:
get_album_tracks_url = 'https://api.spotify.com/v1/albums/' + album[
1] + '/tracks'
req = requests.get(get_album_tracks_url)
if req.ok == False:
print "Error in get_album_tracks_url Request"
req.json()
myjson = req.json()
get_items = myjson.get('items')
track_list = []
for i in range(len(get_items)):
get_track_name = get_items[i]['name']
track_list.append(get_track_name)
random_track = (random.choice(track_list))
while random_track == False:
random_track = (random.choice(track_list))
random_track_list.append(random_track)
#playlist = """INSERT INTO playlists (id);"""
#cur.execute(playlist)
#db.commit()?
playlistID = 1
#get_id_number = """SELECT MAX(id) from playlists;"""
#cur.execute(get_id_number)
#playlist_id = cur.fetchall()
#playlistID = playlist_id[0][0]
#print playlistID
artist_name_in = """INSERT INTO playlists (rootArtist) VALUES ('%s')""" % (
artistName)
cur.execute(artist_name_in)
#playlistID = cur.lastrowid
#db.commit()
for i in range(len(random_track_list)):
Artist_Name = '"' + artist_names[i] + '"'
Artist_Name.replace('\'', "")
#Artist_Name.replace("'", "")
Artist_Name.replace("\"", "")
Album_Name = '"' + album_list[i][0] + '"'
Album_Name.replace('\'', "")
#Album_Name.replace('(', "")
#Album_Name.replace(')', "")
#Album_Name.replace("'", "")
Album_Name.replace("\"", "")
Track_Name = '"' + random_track_list[i] + '"'
Track_Name.replace('\'', "")
#Track_Name.replace('(', "")
#Track_Name.replace(')', "")
#Track_Name.replace("'", "")
Track_Name.replace("\"", "")
songOrder = i + 1
playlistID = cur.lastrowid
print Artist_Name
print Album_Name
print Track_Name
sql = """INSERT INTO songs (playlistId, songOrder, artistName, albumName, trackName)
VALUES ('%s', '%s', '%s', '%s', '%s')""" % (
playlistID, songOrder, Artist_Name, Album_Name, Track_Name
) #could undo quotes around %s's
cur.execute(sql)
db.commit()
cur.close()
def createNewPlaylist(ArtistName):
c = db.cursor()
#create tables"
make_table_playlists = '''CREATE TABLE IF NOT EXISTS playlists (id INTEGER PRIMARY KEY AUTO_INCREMENT, \
rootArtist VARCHAR(128));'''
make_table_songs = '''CREATE TABLE IF NOT EXISTS songs (playlistId INTEGER, \
songOrder INTEGER, \
artistName VARCHAR(128), \
albumName VARCHAR(256), \
trackName VARCHAR(256));'''
c.execute(make_table_playlists)
c.execute(make_table_songs)
#generate centered network
depth = 2
artists_id = fetchArtistId(ArtistName)
edge_list = getEdgeList(artists_id,depth)
random_artists = []
i = 30
while i != 0:
random_artist = randomCentralNode(pandasToNetworkX(edge_list))
album_id_list = fetchAlbumIds(random_artist)
if album_id_list == []:#check if this artist has albums
pass
else:
random_artists.append(random_artist)
i = i -1
#fetch 30 data
artist_names = []
album_list = []
for artist_id in random_artists:
artist = fetchArtistInfo(artist_id)
artist_name = artist['name']
artist_names.append(artist_name)
album_id_list = fetchAlbumIds(artist_id)
random_album = (random.choice(album_id_list))
random_album_info = fetchAlbumInfo(random_album)
random_album_name = random_album_info['name']
tupl = (random_album_name, random_album)
album_list.append(tupl)
random_track_list = []
for album in album_list:
url = 'https://api.spotify.com/v1/albums/' + album[1] + '/tracks'
req = requests.get(url)
if req.ok == False:
print "Error in request"
req.json()
myjson = req.json()
info = myjson.get('items')
track_list = []
for i in range(len(info)):
track_name = info[i]['name']
track_list.append(track_name)
random_track = (random.choice(track_list))
random_track_list.append(random_track)
artist_name_in = """INSERT INTO playlists (rootArtist) VALUES ('%s')""" % (ArtistName)
c.execute(artist_name_in)
com_play = """SELECT MAX(id) FROM playlists;"""
c.execute(com_play)
playlistId = c.fetchall()
#print playlistId
playlistId = playlistId[0][0]
for i in range(len(random_track_list)):
songOrder = i+1
Artist_Name = '"' + artist_names[i] + '"'
Artist_Name.replace('\'', "")
Album_Name = '"' + album_list[i][0] + '"'
Album_Name.replace('\'', "")
Track_Name = '"' + random_track_list[i] + '"'
Track_Name.replace('\'', "")
sql = """INSERT INTO songs (playlistId, songOrder, artistName, albumName, trackName) VALUES (%s, %s, %s, %s, %s)""" % (playlistId, songOrder, Artist_Name, Album_Name, Track_Name)
c.execute(sql)
db.commit()
c.close()
# I addend in an exception to deal with invalid artists in fetchArtistId
Artist_IDs = [x for x in Artist_IDs if x is not None]
# Combines edge lists into one master list
depth = 2
edgeList = getEdgeList(Artist_IDs[0], depth)
if len(Artist_IDs) > 1:
for artist in Artist_IDs[1:]:
temp = getEdgeList(artist,depth)
edgeList = combineEdgeLists(edgeList,temp)
g = pandasToNetworkX(edgeList)
rndm_artists = []
for artist in range(30):
rndm_artists.append(randomCentralNode(g))
# creates a list of tuples of related (artist,album,song)
# I altered the code from assignment 5 so that album name
# is part of the returned dictionary in fetchAlbumInfo and
# created a new function in fetchAlbums that chooses a random
# song from an album
to_write = []
for artist in rndm_artists:
albums = fetchAlbumIds(artist)
rndm_album_id = np.random.choice(albums)
song_name = fetchRndmSong(rndm_album_id)
album_info = fetchAlbumInfo(rndm_album_id)
artist_name = album_info['name']
album_name = album_info['album_name']
#generate the network
old_edgelist = None
artistidlist = [fetchArtistId(i) for i in artist_names]
for i in artistidlist:
edgelist = getEdgeList(i, 2)
new_edgelist = combineEdgeLists(edgelist, old_edgelist)
old_edgelist = new_edgelist
#pick tracks
k = 0
artist_list = []
while k != 30:
artist_dict = {}
artist_dict['artist_name'] = fetchArtistInfo(
randomCentralNode(pandasToNetworkX(old_edgelist)))['name']
#print artist_dict['artist_name']
album_id = np.random.choice(
fetchAlbumIds(fetchArtistId(artist_dict['artist_name'])))
#print album_id
artist_dict['album_name'] = fetchAlbumInfo(album_id)['name']
#print artist_dict['album_name']
track_id = np.random.choice(fetchTrackIds(album_id))
#print track_id
artist_dict['track_name'] = fetchTrackInfo(track_id)['name']
#print artist_dict['track_name']
artist_list.append(artist_dict)
k += 1
#write to csv
f = open("playlist.csv", 'w', encoding='utf-8')
