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()
import sys
from fetchArtist import fetchArtistId, fetchArtistInfo
from fetchAlbums import fetchAlbumIds, fetchAlbumInfo
from artistNetworks import getRelatedArtists, getDepthEdges, getEdgeList, writeEdgeList
from analyzeNetworks import readEdgeList, degree, combineEdgelists, pandasToNetworkX, randomCentralNode
from random import randint
import requests
from io import open
import csv
if __name__ == '__main__':
artist_names = sys.argv[1:]
a = artist_names[0]
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):
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()
if __name__ == '__main__': artist_names = sys.argv[1:] print "input artists are", artist_names depth = 2 #change depth at will artists_ids = [] for artist in artist_names: artists_id = fetchArtistId(artist) artists_ids.append(artists_id) edgeList_list = [] 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)
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()
if __name__ == '__main__':
artist_names = sys.argv[1:]
# Turns the artist names into artist IDs
Artist_IDs = []
for artist in artist_names:
Artist_IDs.append(fetchArtistId(artist))
# Removes None from lists created by invalid artists
# 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
testsong=getRandomSong("7gS8ozSkvPW3VBPLnXOZ7S")
print testsong
if __name__=="__main__":
artistnames=sys.argv[1:]
print "The artists are", artistnames
listofartIDs=[]
for name in artistnames:
artID=fetchArtistId(name)
listofartIDs.append(artID)
edgeList_list=[]
for artist in listofartIDs:
edgeList=getEdgeList(artist,2)
edgeList_list.append(edgeList)
combinedlists=edgeList_list[0]
for lists in edgeList_list[1:]:
newlist=combineEdgeLists(combinedlists,lists)
combinedlists=newlist
g=pandasToNetworkX(combinedlists)
random_artists=[]
for i in range(30):
newartist=randomCentralNode(g)
random_artists.append(newartist)
#print random_artists
Continue
info = result_list[0].json()
data = {}
data['name'] = info['name']
return (data)
if __name__ == '__main__':
artist_names = sys.argv[1:]
print "input artists are ", artist_names
#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']
