From e614b373df0b6ed864a149d5fbe2892bd361c7a0 Mon Sep 17 00:00:00 2001
From: Chris Shyi <chris.shyi@mail.utoronto.ca>
Date: Fri, 22 Jun 2018 16:28:47 -0400
Subject: [PATCH 1/9] Fix program crash when AudioFeatures is missing

Fixes #32. AudioFeatures object query is now wrapped in a try/except
block to account for the scenario where the object doesn't exist.
---
 spotifyvis/utils.py | 2 +-
 spotifyvis/views.py | 7 +++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/spotifyvis/utils.py b/spotifyvis/utils.py
index b7a95c7..7898141 100644
--- a/spotifyvis/utils.py
+++ b/spotifyvis/utils.py
@@ -127,7 +127,7 @@ def save_audio_features(headers, track_id, track):
     
     response = requests.get("https://api.spotify.com/v1/audio-features/{}".format(track_id), headers = headers).json()
     if 'error' in response:
-        return {}
+        return
 
     # Data that we don't need
     useless_keys = [ 
diff --git a/spotifyvis/views.py b/spotifyvis/views.py
index 8b9e3b8..a21b6d3 100644
--- a/spotifyvis/views.py
+++ b/spotifyvis/views.py
@@ -203,8 +203,11 @@ def get_audio_feature_data(request, audio_feature, client_secret):
         'data_points': [],
     }
     for track in user_tracks:
-        audio_feature_obj = AudioFeatures.objects.get(track=track)
-        response_payload['data_points'].append(getattr(audio_feature_obj, audio_feature))
+        try:
+            audio_feature_obj = AudioFeatures.objects.get(track=track)
+            response_payload['data_points'].append(getattr(audio_feature_obj, audio_feature))
+        except AudioFeatures.DoesNotExist:
+            continue
     return JsonResponse(response_payload)
 
 #  }}} get_audio_feature_data # 

From de93bd7b0ad4ca486e3c355dd22ff13e70651712 Mon Sep 17 00:00:00 2001
From: Kevin Mok <kevin.mok@live.ca>
Date: Sun, 24 Jun 2018 02:30:19 -0400
Subject: [PATCH 2/9] Store counts for genres in Genre model

Have not assigned most common genre to Track models yet (currently
blank).
---
 recreate-db.txt      |  8 ++++++++
 requirements.txt     |  2 +-
 spotifyvis/models.py | 17 +++++++++++++++--
 spotifyvis/utils.py  | 35 +++++++++++++++++++++++++++++------
 4 files changed, 53 insertions(+), 9 deletions(-)
 create mode 100644 recreate-db.txt

diff --git a/recreate-db.txt b/recreate-db.txt
new file mode 100644
index 0000000..5c1e574
--- /dev/null
+++ b/recreate-db.txt
@@ -0,0 +1,8 @@
+# https://stackoverflow.com/a/34576062/8811872
+
+sudo su postgres
+psql
+drop database spotifyvis;
+create database spotifyvis with owner django;
+\q
+exit
diff --git a/requirements.txt b/requirements.txt
index 7eba139..59c9dc6 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -7,7 +7,7 @@ idna==2.6
 isort==4.3.4
 lazy-object-proxy==1.3.1
 mccabe==0.6.1
-psycopg2==2.7.4
+psycopg2-binary==2.7.4
 pylint==1.8.4
 pytz==2018.4
 requests==2.18.4
diff --git a/spotifyvis/models.py b/spotifyvis/models.py
index 99f93d8..398647e 100644
--- a/spotifyvis/models.py
+++ b/spotifyvis/models.py
@@ -35,6 +35,18 @@ class User(models.Model):
 
 #  }}} User # 
 
+class Genre(models.Model):
+            
+    class Meta:
+        verbose_name = "Genre"
+        verbose_name_plural = "Genres"
+
+    name = models.CharField(primary_key=True, max_length=50)
+    num_songs = models.PositiveIntegerField()
+
+    def __str__(self):
+        return self.name
+
 #  Track {{{ # 
 
 class Track(models.Model):
@@ -51,7 +63,9 @@ class Track(models.Model):
     runtime = models.PositiveSmallIntegerField()
     name = models.CharField(max_length=200)
     users = models.ManyToManyField(User, blank=True)
-    genre = models.CharField(max_length=30)
+    #  genre = models.CharField(max_length=30)
+    genre = models.ForeignKey(Genre, on_delete=models.CASCADE, blank=True,
+            null=True)
 
     def __str__(self):
         return self.name 
@@ -60,7 +74,6 @@ class Track(models.Model):
 
 #  AudioFeatures {{{ # 
 
-
 class AudioFeatures(models.Model):
         
     class Meta:
diff --git a/spotifyvis/utils.py b/spotifyvis/utils.py
index 7898141..e4dc4ec 100644
--- a/spotifyvis/utils.py
+++ b/spotifyvis/utils.py
@@ -3,8 +3,8 @@ import requests
 import math
 import pprint
 
-from .models import Artist, User, Track, AudioFeatures
-from django.db.models import Count, Q
+from .models import *
+from django.db.models import Count, Q, F
 from django.http import JsonResponse
 from django.core import serializers
 import json
@@ -13,7 +13,6 @@ import json
 
 #  parse_library {{{ # 
 
-
 def parse_library(headers, tracks, user):
     """Scans user's library for certain number of tracks to update library_stats with.
 
@@ -48,6 +47,8 @@ def parse_library(headers, tracks, user):
                     artist_id=artist_dict['id'],
                     name=artist_dict['name'],
                     )
+                if artist_created:
+                    tally_artist_genres(headers, artist_dict['id'])
 
                 #  update_artist_genre(headers, artist_obj)
                 # get_or_create() returns a tuple (obj, created)
@@ -59,8 +60,8 @@ def parse_library(headers, tracks, user):
                     track_artists, top_genre, user)
 
             # if a new track is not created, the associated audio feature does not need to be created again
-            if track_created:
-                save_audio_features(headers, track_dict['track']['id'], track_obj)
+            #  if track_created:
+            save_audio_features(headers, track_dict['track']['id'], track_obj)
             """
             TODO: Put this logic in another function
             # Audio analysis could be empty if not present in Spotify database
@@ -100,7 +101,7 @@ def save_track_obj(track_dict, artists, top_genre, user):
             popularity=int(track_dict['popularity']),
             runtime=int(float(track_dict['duration_ms']) / 1000),
             name=track_dict['name'],
-            genre=top_genre,
+            #  genre=top_genre,
             )
 
         # have to add artists and user after saving object since track needs to
@@ -126,6 +127,8 @@ def save_audio_features(headers, track_id, track):
     """
     
     response = requests.get("https://api.spotify.com/v1/audio-features/{}".format(track_id), headers = headers).json()
+    if track_id is '5S1IUPueD0xE0vj4zU3nSf':
+        pprint.pprint(response)
     if 'error' in response:
         return
 
@@ -330,6 +333,7 @@ def get_top_genre(headers, top_artist_id):
     """
     artist_response = requests.get('https://api.spotify.com/v1/artists/' +
             top_artist_id, headers=headers).json()
+    #  pprint.pprint(artist_response)
     if len(artist_response['genres']) > 0:
         return artist_response['genres'][0]
     else:
@@ -337,6 +341,25 @@ def get_top_genre(headers, top_artist_id):
 
 #  }}} # 
 
+def tally_artist_genres(headers, artist_id):
+    """Tallies up genres for artist for the respective Genre models. Should be
+    called when new Artist object is created.
+
+    :headers: For making the API call.
+    :artist_id: Artist ID for which to tally up genres for.
+
+    :returns: None
+
+    """
+    artist_response = requests.get('https://api.spotify.com/v1/artists/' +
+            artist_id, headers=headers).json()
+    for genre in artist_response['genres']:
+        genre_obj, created = Genre.objects.get_or_create(name=genre,
+                defaults={'num_songs':1})
+        if not created:
+            genre_obj.num_songs = F('num_songs') +1
+            genre_obj.save()
+
 #  process_library_stats {{{ # 
 
 def process_library_stats(library_stats):

From 4e1a6df89e5fdd33e7feeb63541fde6be20cfb41 Mon Sep 17 00:00:00 2001
From: Kevin Mok <kevin.mok@live.ca>
Date: Sun, 24 Jun 2018 07:05:54 -0400
Subject: [PATCH 3/9] Store genres in artists as m2m field (#34)

---
 spotifyvis/models.py | 29 +++++++++++++++++------------
 spotifyvis/utils.py  | 14 ++++++++------
 2 files changed, 25 insertions(+), 18 deletions(-)

diff --git a/spotifyvis/models.py b/spotifyvis/models.py
index 398647e..b6563ed 100644
--- a/spotifyvis/models.py
+++ b/spotifyvis/models.py
@@ -3,6 +3,22 @@ from django.db import models
 # id's are 22 in length in examples but set to 30 for buffer
 MAX_ID = 30
 
+#  Genre {{{ # 
+
+class Genre(models.Model):
+            
+    class Meta:
+        verbose_name = "Genre"
+        verbose_name_plural = "Genres"
+
+    name = models.CharField(primary_key=True, max_length=50)
+    num_songs = models.PositiveIntegerField()
+
+    def __str__(self):
+        return self.name
+
+#  }}} Genre # 
+
 #  Artist {{{ # 
 
 
@@ -14,6 +30,7 @@ class Artist(models.Model):
     artist_id = models.CharField(primary_key=True, max_length=MAX_ID)
     # unique since only storing one genre per artist right now
     name = models.CharField(unique=True, max_length=50)
+    genres = models.ManyToManyField(Genre, blank=True)
 
     def __str__(self):
         return self.name
@@ -35,18 +52,6 @@ class User(models.Model):
 
 #  }}} User # 
 
-class Genre(models.Model):
-            
-    class Meta:
-        verbose_name = "Genre"
-        verbose_name_plural = "Genres"
-
-    name = models.CharField(primary_key=True, max_length=50)
-    num_songs = models.PositiveIntegerField()
-
-    def __str__(self):
-        return self.name
-
 #  Track {{{ # 
 
 class Track(models.Model):
diff --git a/spotifyvis/utils.py b/spotifyvis/utils.py
index e4dc4ec..7c4c088 100644
--- a/spotifyvis/utils.py
+++ b/spotifyvis/utils.py
@@ -48,7 +48,7 @@ def parse_library(headers, tracks, user):
                     name=artist_dict['name'],
                     )
                 if artist_created:
-                    tally_artist_genres(headers, artist_dict['id'])
+                    add_artist_genres(headers, artist_obj)
 
                 #  update_artist_genre(headers, artist_obj)
                 # get_or_create() returns a tuple (obj, created)
@@ -341,24 +341,26 @@ def get_top_genre(headers, top_artist_id):
 
 #  }}} # 
 
-def tally_artist_genres(headers, artist_id):
-    """Tallies up genres for artist for the respective Genre models. Should be
-    called when new Artist object is created.
+def add_artist_genres(headers, artist_obj):
+    """Adds genres to artist_obj and increases the count the respective Genre
+    object. Should be called when a new Artist object is created.
 
     :headers: For making the API call.
-    :artist_id: Artist ID for which to tally up genres for.
+    :artist_obj: Artist object for which to add/tally up genres for.
 
     :returns: None
 
     """
     artist_response = requests.get('https://api.spotify.com/v1/artists/' +
-            artist_id, headers=headers).json()
+            artist_obj.artist_id, headers=headers).json()
     for genre in artist_response['genres']:
         genre_obj, created = Genre.objects.get_or_create(name=genre,
                 defaults={'num_songs':1})
         if not created:
             genre_obj.num_songs = F('num_songs') +1
             genre_obj.save()
+        artist_obj.genres.add(genre_obj)
+        artist_obj.save()
 
 #  process_library_stats {{{ # 
 

From 709ed9b491f985ca59422f8d54b3786c56a98e8e Mon Sep 17 00:00:00 2001
From: Kevin Mok <kevin.mok@live.ca>
Date: Mon, 25 Jun 2018 03:14:39 -0400
Subject: [PATCH 4/9] Added most common genre for tracks with 1 artist

Still have to find shared genres for songs with multiple artists (see #34).
---
 spotifyvis/utils.py | 22 ++++++++++++++++++++++
 spotifyvis/views.py |  6 ++++--
 2 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/spotifyvis/utils.py b/spotifyvis/utils.py
index 7c4c088..35160a8 100644
--- a/spotifyvis/utils.py
+++ b/spotifyvis/utils.py
@@ -76,9 +76,27 @@ def parse_library(headers, tracks, user):
         # calculates num_songs with offset + songs retrieved
         offset += limit
     #  pprint.pprint(library_stats)
+    update_track_genres(user)
 
 #  }}} parse_library # 
 
+def update_track_genres(user):
+    """Updates user's tracks with the most common genre associated with the
+    songs' artist(s).
+
+    :user: User object who's tracks are being updated.
+
+    :returns: None
+
+    """
+    user_tracks = Track.objects.filter(users__exact=user)
+    for track in user_tracks:
+        track_artists = list(track.artists.all())
+        if len(track_artists) == 1:
+            track.genre = track_artists[0].genres.all().order_by('-num_songs').first()
+            track.save()
+            #  print(track_artists, track.genre)
+
 #  save_track_obj {{{ # 
 
 def save_track_obj(track_dict, artists, top_genre, user):
@@ -341,6 +359,8 @@ def get_top_genre(headers, top_artist_id):
 
 #  }}} # 
 
+#  add_artist_genres {{{ # 
+
 def add_artist_genres(headers, artist_obj):
     """Adds genres to artist_obj and increases the count the respective Genre
     object. Should be called when a new Artist object is created.
@@ -362,6 +382,8 @@ def add_artist_genres(headers, artist_obj):
         artist_obj.genres.add(genre_obj)
         artist_obj.save()
 
+#  }}}  add_artist_genres # 
+
 #  process_library_stats {{{ # 
 
 def process_library_stats(library_stats):
diff --git a/spotifyvis/views.py b/spotifyvis/views.py
index a21b6d3..1cf89f5 100644
--- a/spotifyvis/views.py
+++ b/spotifyvis/views.py
@@ -13,7 +13,7 @@ from datetime import datetime
 from django.shortcuts import render, redirect
 from django.http import HttpResponse, HttpResponseBadRequest, JsonResponse
 from django.db.models import Count, Q
-from .utils import parse_library, process_library_stats, get_artists_in_genre
+from .utils import parse_library, process_library_stats, get_artists_in_genre, update_track_genres
 from .models import User, Track, AudioFeatures, Artist 
 
 #  }}} imports # 
@@ -165,10 +165,12 @@ def test_db(request):
     """TODO
     """
     user_id = "polarbier"
+    user_obj = User.objects.get(user_id=user_id)
     #  user_id = "35kxo00qqo9pd1comj6ylxjq7"
     context = {
-        'user_secret': User.objects.get(user_id=user_id).user_secret,
+        'user_secret': user_obj.user_secret,
     }
+    update_track_genres(user_obj)
     return render(request, 'spotifyvis/test_db.html', context)
 
 #  }}} test_db # 

From df9547293fa1f41fcd052f1efa61280ffb960b48 Mon Sep 17 00:00:00 2001
From: Kevin Mok <kevin.mok@live.ca>
Date: Mon, 25 Jun 2018 04:20:55 -0400
Subject: [PATCH 5/9] Changed all existing pages to use a dark bg

---
 spotifyvis/static/spotifyvis/css/dark_bg.css   | 8 ++++++++
 spotifyvis/templates/spotifyvis/index.html     | 6 +++---
 spotifyvis/templates/spotifyvis/test_db.html   | 2 ++
 spotifyvis/templates/spotifyvis/user_data.html | 1 +
 4 files changed, 14 insertions(+), 3 deletions(-)
 create mode 100644 spotifyvis/static/spotifyvis/css/dark_bg.css

diff --git a/spotifyvis/static/spotifyvis/css/dark_bg.css b/spotifyvis/static/spotifyvis/css/dark_bg.css
new file mode 100644
index 0000000..a472959
--- /dev/null
+++ b/spotifyvis/static/spotifyvis/css/dark_bg.css
@@ -0,0 +1,8 @@
+body {
+background-color: #1e1e1e;
+}
+
+h1,p {
+color: grey;
+}
+
diff --git a/spotifyvis/templates/spotifyvis/index.html b/spotifyvis/templates/spotifyvis/index.html
index 5964b34..28a9301 100644
--- a/spotifyvis/templates/spotifyvis/index.html
+++ b/spotifyvis/templates/spotifyvis/index.html
@@ -4,6 +4,7 @@
   <head>
     <title>User Login</title>
     <link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.1.1/css/bootstrap.min.css">
+    <link rel="stylesheet" href="{% static 'spotifyvis/css/dark_bg.css' %}">
     <style type="text/css">
       .text-overflow {
         overflow: hidden;
@@ -18,10 +19,9 @@
   <body>
     <div class="container">
       <div id="login">
-        <h1>This is an example of the Authorization Code flow</h1>
-        <a href="/login" class="btn btn-primary">Log In (Original)</a>
+        <h1>spotify-lib-vis</h1>
+        <a href="/login" class="btn btn-primary">Scan Library</a>
 		<a href="/test_db" class="btn btn-primary">Test DB</a>
-        <button id="login-btn">Log In</button>
       </div>
 
       <div id="data-container">
diff --git a/spotifyvis/templates/spotifyvis/test_db.html b/spotifyvis/templates/spotifyvis/test_db.html
index 74ecd70..a33edae 100644
--- a/spotifyvis/templates/spotifyvis/test_db.html
+++ b/spotifyvis/templates/spotifyvis/test_db.html
@@ -5,6 +5,7 @@
 <!--[if IE 7]>         <html class="no-js lt-ie9 lt-ie8"> <![endif]-->
 <!--[if IE 8]>         <html class="no-js lt-ie9"> <![endif]-->
 	<!--[if gt IE 8]><!--> 
+{% load static %}
 <html class="no-js"> <!--<![endif]-->
 <head>
 	<meta charset="utf-8">
@@ -12,6 +13,7 @@
 	<title>Test DB Page</title>
 	<meta name="description" content="">
 	<meta name="viewport" content="width=device-width, initial-scale=1">
+    <link rel="stylesheet" href="{% static 'spotifyvis/css/dark_bg.css' %}">
 </head>
 
 <!-- }}} header -->
diff --git a/spotifyvis/templates/spotifyvis/user_data.html b/spotifyvis/templates/spotifyvis/user_data.html
index ce4799d..440d756 100644
--- a/spotifyvis/templates/spotifyvis/user_data.html
+++ b/spotifyvis/templates/spotifyvis/user_data.html
@@ -10,6 +10,7 @@
         <title>User Spotify Data</title>
         <meta name="description" content="">
         <meta name="viewport" content="width=device-width, initial-scale=1">
+		<link rel="stylesheet" href="{% static 'spotifyvis/css/dark_bg.css' %}">
     </head>
     <body>
         <!--[if lt IE 7]>

From bd597cdc235271b7011a06969367e0b33c6789b2 Mon Sep 17 00:00:00 2001
From: Kevin Mok <kevin.mok@live.ca>
Date: Mon, 25 Jun 2018 04:47:39 -0400
Subject: [PATCH 6/9] Use "several" API call to get artist genres

---
 spotifyvis/utils.py | 65 +++++++++++++++++++++++++++------------------
 spotifyvis/views.py |  4 +--
 2 files changed, 41 insertions(+), 28 deletions(-)

diff --git a/spotifyvis/utils.py b/spotifyvis/utils.py
index 35160a8..a97a916 100644
--- a/spotifyvis/utils.py
+++ b/spotifyvis/utils.py
@@ -11,6 +11,11 @@ import json
 
 #  }}} imports # 
 
+USER_TRACKS_LIMIT = 50
+#  ARTIST_LIMIT = 50
+ARTIST_LIMIT = 25
+FEATURES_LIMIT = 100
+
 #  parse_library {{{ # 
 
 def parse_library(headers, tracks, user):
@@ -24,14 +29,13 @@ def parse_library(headers, tracks, user):
 
     """
     #  TODO: implement importing entire library with 0 as tracks param
-    # number of tracks to get with each call
-    limit = 50
     # keeps track of point to get songs from
     offset = 0
-    payload = {'limit': str(limit)}
+    payload = {'limit': str(USER_TRACKS_LIMIT)}
+    artist_genre_queue = []
 
     # iterate until hit requested num of tracks
-    for _ in range(0, tracks, limit):
+    for _ in range(0, tracks, USER_TRACKS_LIMIT):
         payload['offset'] = str(offset)
         # get current set of tracks
         saved_tracks_response = requests.get('https://api.spotify.com/v1/me/tracks', headers=headers, params=payload).json()
@@ -48,14 +52,18 @@ def parse_library(headers, tracks, user):
                     name=artist_dict['name'],
                     )
                 if artist_created:
-                    add_artist_genres(headers, artist_obj)
+                    artist_genre_queue.append(artist_obj)
+                    if len(artist_genre_queue) == ARTIST_LIMIT:
+                        add_artist_genres(headers, artist_genre_queue)
+                        artist_genre_queue = []
 
                 #  update_artist_genre(headers, artist_obj)
                 # get_or_create() returns a tuple (obj, created)
                 track_artists.append(artist_obj)
             
-            top_genre = get_top_genre(headers,
-                    track_dict['track']['artists'][0]['id'])
+            #  top_genre = get_top_genre(headers,
+                    #  track_dict['track']['artists'][0]['id'])
+            top_genre = ""
             track_obj, track_created = save_track_obj(track_dict['track'], 
                     track_artists, top_genre, user)
 
@@ -74,8 +82,12 @@ def parse_library(headers, tracks, user):
                             feature_data_points, library_stats)
             """
         # calculates num_songs with offset + songs retrieved
-        offset += limit
+        offset += USER_TRACKS_LIMIT
     #  pprint.pprint(library_stats)
+
+    # update artists left in queue since there will be probably be leftover
+    # artists that didn't hit ARTIST_LIMIT
+    add_artist_genres(headers, artist_genre_queue)
     update_track_genres(user)
 
 #  }}} parse_library # 
@@ -359,30 +371,31 @@ def get_top_genre(headers, top_artist_id):
 
 #  }}} # 
 
-#  add_artist_genres {{{ # 
-
-def add_artist_genres(headers, artist_obj):
-    """Adds genres to artist_obj and increases the count the respective Genre
-    object. Should be called when a new Artist object is created.
+def add_artist_genres(headers, artist_objs):
+    """Adds genres to artist_objs and increases the count the respective Genre
+    object. artist_objs should contain the API limit for a single call
+    (ARTIST_LIMIT) for maximum efficiency.
 
     :headers: For making the API call.
-    :artist_obj: Artist object for which to add/tally up genres for.
+    :artist_objs: List of Artist objects for which to add/tally up genres for.
 
     :returns: None
 
     """
-    artist_response = requests.get('https://api.spotify.com/v1/artists/' +
-            artist_obj.artist_id, headers=headers).json()
-    for genre in artist_response['genres']:
-        genre_obj, created = Genre.objects.get_or_create(name=genre,
-                defaults={'num_songs':1})
-        if not created:
-            genre_obj.num_songs = F('num_songs') +1
-            genre_obj.save()
-        artist_obj.genres.add(genre_obj)
-        artist_obj.save()
-
-#  }}}  add_artist_genres # 
+    artist_ids = str.join(",", [artist_obj.artist_id for artist_obj in artist_objs])
+    #  print(len(artist_objs), artist_ids)
+    params = {'ids': artist_ids}
+    artists_response = requests.get('https://api.spotify.com/v1/artists/',
+            headers=headers, params=params).json()['artists']
+    for i in range(len(artist_objs)):
+        for genre in artists_response[i]['genres']:
+            genre_obj, created = Genre.objects.get_or_create(name=genre,
+                    defaults={'num_songs':1})
+            if not created:
+                genre_obj.num_songs = F('num_songs') +1
+                genre_obj.save()
+            artist_objs[i].genres.add(genre_obj)
+            artist_objs[i].save()
 
 #  process_library_stats {{{ # 
 
diff --git a/spotifyvis/views.py b/spotifyvis/views.py
index 1cf89f5..d1a212b 100644
--- a/spotifyvis/views.py
+++ b/spotifyvis/views.py
@@ -19,7 +19,7 @@ from .models import User, Track, AudioFeatures, Artist
 #  }}} imports # 
 
 TIME_FORMAT = '%Y-%m-%d-%H-%M-%S'
-TRACKS_TO_QUERY = 100
+TRACKS_TO_QUERY = 50
 
 #  generate_random_string {{{ # 
 
@@ -65,8 +65,8 @@ def index(request):
 
 #  login {{{ # 
 
+# uses Authorization Code flow
 def login(request):
-
     # use a randomly generated state string to prevent cross-site request forgery attacks
     state_str = generate_random_string(16)
     request.session['state_string'] = state_str 

From 3fe52343aa72a2dbdfca09db19c0cb88a677501e Mon Sep 17 00:00:00 2001
From: Kevin Mok <kevin.mok@live.ca>
Date: Wed, 27 Jun 2018 00:34:38 -0400
Subject: [PATCH 7/9] Use "several" API call to get audio features

Closes #20. Also close #38 since parse_library is a bit cleaner now with
some folds, and there's not much to be refactored any more.
---
 spotifyvis/utils.py | 101 +++++++++++++++++++++++++++++---------------
 1 file changed, 67 insertions(+), 34 deletions(-)

diff --git a/spotifyvis/utils.py b/spotifyvis/utils.py
index a97a916..e8244b6 100644
--- a/spotifyvis/utils.py
+++ b/spotifyvis/utils.py
@@ -14,7 +14,8 @@ import json
 USER_TRACKS_LIMIT = 50
 #  ARTIST_LIMIT = 50
 ARTIST_LIMIT = 25
-FEATURES_LIMIT = 100
+#  FEATURES_LIMIT = 100
+FEATURES_LIMIT = 25
 
 #  parse_library {{{ # 
 
@@ -33,61 +34,66 @@ def parse_library(headers, tracks, user):
     offset = 0
     payload = {'limit': str(USER_TRACKS_LIMIT)}
     artist_genre_queue = []
+    features_queue = []
 
     # iterate until hit requested num of tracks
     for _ in range(0, tracks, USER_TRACKS_LIMIT):
         payload['offset'] = str(offset)
-        # get current set of tracks
-        saved_tracks_response = requests.get('https://api.spotify.com/v1/me/tracks', headers=headers, params=payload).json()
+        saved_tracks_response = requests.get('https://api.spotify.com/v1/me/tracks', 
+                headers=headers,
+                params=payload).json()
 
-        # TODO: refactor the for loop body into helper function
-        # iterate through each track
         for track_dict in saved_tracks_response['items']:
+            #  add artists {{{ # 
+            
             # update artist info before track so that Track object can reference
             # Artist object
             track_artists = []
             for artist_dict in track_dict['track']['artists']:
                 artist_obj, artist_created = Artist.objects.get_or_create(
-                    artist_id=artist_dict['id'],
-                    name=artist_dict['name'],
-                    )
+                        artist_id=artist_dict['id'],
+                        name=artist_dict['name'],)
+                # only add/tally up artist genres if new
                 if artist_created:
                     artist_genre_queue.append(artist_obj)
                     if len(artist_genre_queue) == ARTIST_LIMIT:
                         add_artist_genres(headers, artist_genre_queue)
                         artist_genre_queue = []
-
-                #  update_artist_genre(headers, artist_obj)
-                # get_or_create() returns a tuple (obj, created)
                 track_artists.append(artist_obj)
             
-            #  top_genre = get_top_genre(headers,
-                    #  track_dict['track']['artists'][0]['id'])
+            #  }}} add artists # 
+            
+            # WIP: get most common genre
             top_genre = ""
             track_obj, track_created = save_track_obj(track_dict['track'], 
                     track_artists, top_genre, user)
 
-            # if a new track is not created, the associated audio feature does not need to be created again
-            #  if track_created:
-            save_audio_features(headers, track_dict['track']['id'], track_obj)
-            """
-            TODO: Put this logic in another function
-            # Audio analysis could be empty if not present in Spotify database
-            if len(audio_features_dict) != 0:
-                # Track the number of audio analyses for calculating
-                # audio feature averages and standard deviations on the fly
-                feature_data_points += 1
-                for feature, feature_data in audio_features_dict.items():
-                    update_audio_feature_stats(feature, feature_data, 
-                            feature_data_points, library_stats)
-            """
+            #  add audio features {{{ # 
+            
+            # if a new track is not created, the associated audio feature does
+            # not need to be created again
+            if track_created:
+                features_queue.append(track_obj)
+                if len(features_queue) == FEATURES_LIMIT:
+                    get_audio_features(headers, features_queue)
+                    features_queue = []
+            
+            #  }}} add audio features # 
+
         # calculates num_songs with offset + songs retrieved
         offset += USER_TRACKS_LIMIT
-    #  pprint.pprint(library_stats)
 
-    # update artists left in queue since there will be probably be leftover
-    # artists that didn't hit ARTIST_LIMIT
-    add_artist_genres(headers, artist_genre_queue)
+    #  clean-up {{{ # 
+    
+    # update remaining artists without genres and songs without features if
+    # there are any
+    if len(artist_genre_queue) > 0:
+        add_artist_genres(headers, artist_genre_queue)
+    if len(features_queue) > 0:
+        get_audio_features(headers, features_queue)
+    
+    #  }}} clean-up # 
+
     update_track_genres(user)
 
 #  }}} parse_library # 
@@ -118,6 +124,7 @@ def save_track_obj(track_dict, artists, top_genre, user):
     :artists: artists of the song, passed in as a list of Artist objects.
     :top_genre: top genre associated with this track (see get_top_genre).
     :user: User object for which this Track is to be associated with.
+
     :returns: (The created/retrieved Track object, created) 
 
     """
@@ -144,6 +151,33 @@ def save_track_obj(track_dict, artists, top_genre, user):
 
 #  }}} save_track_obj # 
 
+def get_audio_features(headers, track_objs):
+    """Creates and saves a new AudioFeatures objects for the respective
+    track_objs. track_objs should contain the API limit for a single call
+    (FEATURES_LIMIT) for maximum efficiency.
+
+    :headers: headers containing the API token
+    :track_objs: Track objects to associate with the new AudioFeatures object
+        
+    :returns: None
+    """
+    track_ids = str.join(",", [track_obj.track_id for track_obj in track_objs])
+    params = {'ids': track_ids}
+    features_response = requests.get("https://api.spotify.com/v1/audio-features",
+            headers=headers,params=params).json()['audio_features']
+    #  pprint.pprint(features_response)
+
+    useless_keys = [ "key", "mode", "type", "liveness", "id", "uri", "track_href", "analysis_url", "time_signature", ]
+    for i in range(len(track_objs)):
+        if features_response[i] is not None:
+            # Data that we don't need
+            cur_features_obj = AudioFeatures()
+            cur_features_obj.track = track_objs[i]
+            for key, val in features_response[i].items():
+                if key not in useless_keys:
+                    setattr(cur_features_obj, key, val)
+            cur_features_obj.save()
+
 #  get_audio_features {{{ # 
 
 def save_audio_features(headers, track_id, track):
@@ -157,8 +191,6 @@ def save_audio_features(headers, track_id, track):
     """
     
     response = requests.get("https://api.spotify.com/v1/audio-features/{}".format(track_id), headers = headers).json()
-    if track_id is '5S1IUPueD0xE0vj4zU3nSf':
-        pprint.pprint(response)
     if 'error' in response:
         return
 
@@ -383,10 +415,11 @@ def add_artist_genres(headers, artist_objs):
 
     """
     artist_ids = str.join(",", [artist_obj.artist_id for artist_obj in artist_objs])
-    #  print(len(artist_objs), artist_ids)
+    print(len(artist_objs), artist_ids)
     params = {'ids': artist_ids}
     artists_response = requests.get('https://api.spotify.com/v1/artists/',
             headers=headers, params=params).json()['artists']
+    #  pprint.pprint(artists_response)
     for i in range(len(artist_objs)):
         for genre in artists_response[i]['genres']:
             genre_obj, created = Genre.objects.get_or_create(name=genre,

From 85c178f2b3ce89fc299d87f9ad96c75c44fdd8b2 Mon Sep 17 00:00:00 2001
From: Kevin Mok <kevin.mok@live.ca>
Date: Wed, 27 Jun 2018 00:49:29 -0400
Subject: [PATCH 8/9] Resolves #39

---
 spotifyvis/utils.py | 269 ++------------------------------------------
 spotifyvis/views.py |  16 ++-
 2 files changed, 21 insertions(+), 264 deletions(-)

diff --git a/spotifyvis/utils.py b/spotifyvis/utils.py
index e8244b6..f8e2599 100644
--- a/spotifyvis/utils.py
+++ b/spotifyvis/utils.py
@@ -98,6 +98,8 @@ def parse_library(headers, tracks, user):
 
 #  }}} parse_library # 
 
+#  update_track_genres {{{ # 
+
 def update_track_genres(user):
     """Updates user's tracks with the most common genre associated with the
     songs' artist(s).
@@ -115,6 +117,8 @@ def update_track_genres(user):
             track.save()
             #  print(track_artists, track.genre)
 
+#  }}}  update_track_genres # 
+
 #  save_track_obj {{{ # 
 
 def save_track_obj(track_dict, artists, top_genre, user):
@@ -151,6 +155,8 @@ def save_track_obj(track_dict, artists, top_genre, user):
 
 #  }}} save_track_obj # 
 
+#  get_audio_features {{{ # 
+
 def get_audio_features(headers, track_objs):
     """Creates and saves a new AudioFeatures objects for the respective
     track_objs. track_objs should contain the API limit for a single call
@@ -178,212 +184,9 @@ def get_audio_features(headers, track_objs):
                     setattr(cur_features_obj, key, val)
             cur_features_obj.save()
 
-#  get_audio_features {{{ # 
-
-def save_audio_features(headers, track_id, track):
-    """Creates and saves a new AudioFeatures object
-
-    Args:
-        headers: headers containing the API token
-        track_id: the id of the soundtrack, needed to query the Spotify API
-        track: Track object to associate with the new AudioFeatures object
-        
-    """
-    
-    response = requests.get("https://api.spotify.com/v1/audio-features/{}".format(track_id), headers = headers).json()
-    if 'error' in response:
-        return
-
-    # Data that we don't need
-    useless_keys = [ 
-        "key", "mode", "type", "liveness", "id", "uri", "track_href", "analysis_url", "time_signature",
-    ]
-    audio_features_entry = AudioFeatures()
-    audio_features_entry.track = track
-    for key, val in response.items():
-        if key not in useless_keys:
-            setattr(audio_features_entry, key, val)
-    audio_features_entry.save()
-
-
 #  }}} get_audio_features # 
 
-#  update_std_dev {{{ # 
-
-def update_std_dev(cur_mean, cur_std_dev, new_data_point, sample_size):
-    """Calculates the standard deviation for a sample without storing all data points
-
-    Args:
-        cur_mean: the current mean for N = (sample_size - 1)
-        cur_std_dev: the current standard deviation for N = (sample_size - 1)
-        new_data_point: a new data point
-        sample_size: sample size including the new data point
-    
-    Returns:
-        (new_mean, new_std_dev)
-    """
-    # This is an implementation of Welford's method
-    # http://jonisalonen.com/2013/deriving-welfords-method-for-computing-variance/
-    new_mean = ((sample_size - 1) * cur_mean + new_data_point) / sample_size
-    delta_variance = (new_data_point - new_mean) * (new_data_point - cur_mean)
-    new_std_dev = math.sqrt(
-        (math.pow(cur_std_dev, 2) * (sample_size - 2) + delta_variance) / (
-        sample_size - 1
-    ))
-    return new_mean, new_std_dev
-
-#  }}} update_std_dev # 
-
-#  update_audio_feature_stats {{{ # 
-
-def update_audio_feature_stats(feature, new_data_point, sample_size, library_stats):
-    """Updates the audio feature statistics in library_stats
-
-    Args:
-        feature: the audio feature to be updated (string)
-        new_data_point: new data to update the stats with
-        sample_size: sample size including the new data point
-        library_stats Dictionary containing the data mined from user's Spotify library
-
-    
-    Returns:
-        None
-    """
-    # first time the feature is considered
-    if sample_size < 2:
-        library_stats['audio_features'][feature] = {
-            "average": new_data_point,
-            "std_dev": 0,
-        }
-    else:
-        cur_mean = library_stats['audio_features'][feature]['average']
-        cur_std_dev = library_stats['audio_features'][feature]['std_dev']
-        new_mean, new_std_dev = update_std_dev(cur_mean, cur_std_dev, new_data_point, sample_size)
-
-        library_stats['audio_features'][feature] = {
-            "average": new_mean,
-            "std_dev": new_std_dev
-        }
-
-#  }}} update_audio_feature_stats # 
-
-#  increase_nested_key {{{ # 
-
-def increase_nested_key(top_key, nested_key, library_stats, amount=1):
-    """Increases count for the value of library_stats[top_key][nested_key]. Checks if nested_key exists already and takes
-    appropriate action.
-
-    :top_key: First key of library_stats.
-    :nested_key: Key in top_key's dict for which we want to increase value of.
-    :library_stats: Dictionary containing the data mined from user's Spotify library
-
-    :returns: None
-
-    """
-    if nested_key not in library_stats[top_key]:
-        library_stats[top_key][nested_key] = amount
-    else:
-        library_stats[top_key][nested_key] += amount
-
-#  }}} increase_nested_key # 
-
-#  increase_artist_count {{{ # 
-
-def increase_artist_count(headers, artist_name, artist_id, library_stats):
-    """Increases count for artist in library_stats and stores the artist_id. 
-
-    :headers: For making the API call.
-    :artist_name: Artist to increase count for.
-    :artist_id: The Spotify ID for the artist.
-    :library_stats: Dictionary containing the data mined from user's Spotify library
-
-    :returns: None
-
-    """
-    if artist_name not in library_stats['artists']:
-        library_stats['artists'][artist_name] = {}
-        library_stats['artists'][artist_name]['count'] = 1
-        library_stats['artists'][artist_name]['id'] = artist_id
-    else:
-        library_stats['artists'][artist_name]['count'] += 1
-
-#  }}} increase_artist_count # 
-
-#  update_popularity_stats {{{ # 
-
-def update_popularity_stats(new_data_point, library_stats, sample_size):
-    """Updates the popularity statistics in library_stats
-
-    Args:
-        new_data_point: new data to update the popularity stats with
-        library_stats: Dictionary containing data mined from user's Spotify library
-        sample_size: The sample size including the new data
-    
-    Returns:
-        None
-    """
-    if sample_size < 2:
-        library_stats['popularity'] = {
-            "average": new_data_point,
-            "std_dev": 0,
-        }
-    else :
-        cur_mean_popularity = library_stats['popularity']['average']
-        cur_popularity_stdev = library_stats['popularity']['std_dev']
-        new_mean, new_std_dev = update_std_dev(
-            cur_mean_popularity, cur_popularity_stdev, new_data_point, sample_size)
-        library_stats['popularity'] = {
-            "average": new_mean,
-            "std_dev": new_std_dev,
-        }
-
-#  }}}  update_popularity_stats # 
-
-#  get_track_info {{{ # 
-
-def get_track_info(track_dict, library_stats, sample_size):
-    """Get all the info from the track_dict directly returned by the API call in parse_library.
-
-    :track_dict: Dict returned from the API call containing the track info.
-    :library_stats: Dictionary containing the data mined from user's Spotify library
-    :sample_size: The sample size so far including this track
-
-    :returns: None
-
-    """
-    # popularity
-    update_popularity_stats(track_dict['popularity'], library_stats, sample_size)
-        
-    # year
-    year_released = track_dict['album']['release_date'].split('-')[0]
-    increase_nested_key('year_released', year_released, library_stats)
-    
-    # runtime
-    library_stats['total_runtime'] += float(track_dict['duration_ms']) / (1000 * 60)
-
-#  }}} get_track_info # 
-
-#  update_artist_genre {{{ # 
-
-def update_artist_genre(headers, artist_obj):
-    """Updates the top genre for an artist by querying the Spotify API
-
-    :headers: For making the API call.
-    :artist_obj: the Artist object whose genre field will be updated 
-
-    :returns: None
-
-    """
-    artist_response = requests.get('https://api.spotify.com/v1/artists/' + artist_obj.artist_id, headers=headers).json()
-    # update genre for artist in database with top genre
-    if len(artist_response['genres']) > 0:
-        artist_obj.genre = artist_response['genres'][0]
-        artist_obj.save()
-
-#  }}} # 
-
-# get_top_genre {{{ # 
-
+# WIP: is this being removed to redo genre data?
 def get_top_genre(headers, top_artist_id):
     """Updates the top genre for a track by querying the Spotify API
 
@@ -401,7 +204,7 @@ def get_top_genre(headers, top_artist_id):
     else:
         return "undefined"
 
-#  }}} # 
+#  add_artist_genres {{{ # 
 
 def add_artist_genres(headers, artist_objs):
     """Adds genres to artist_objs and increases the count the respective Genre
@@ -415,7 +218,6 @@ def add_artist_genres(headers, artist_objs):
 
     """
     artist_ids = str.join(",", [artist_obj.artist_id for artist_obj in artist_objs])
-    print(len(artist_objs), artist_ids)
     params = {'ids': artist_ids}
     artists_response = requests.get('https://api.spotify.com/v1/artists/',
             headers=headers, params=params).json()['artists']
@@ -430,60 +232,7 @@ def add_artist_genres(headers, artist_objs):
             artist_objs[i].genres.add(genre_obj)
             artist_objs[i].save()
 
-#  process_library_stats {{{ # 
-
-def process_library_stats(library_stats):
-    """Processes library_stats into format more suitable for D3 consumption
-
-    Args:
-        library_stats: Dictionary containing the data mined from user's Spotify library
-    
-    Returns:
-        A new dictionary that contains the data in library_stats, in a format more suitable for D3 consumption
-    """
-    processed_library_stats = {}
-    for key in library_stats:
-        if key == 'artists' or key == 'genres' or key == 'year_released':
-            for inner_key in library_stats[key]:
-                if key not in processed_library_stats:
-                    processed_library_stats[key] = []
-                processed_item_key = '' # identifier key for each dict in the list
-                count = 0
-                if 'artist' in key:
-                    processed_item_key = 'name'
-                    count = library_stats[key][inner_key]['count']
-                elif 'genre' in key:
-                    processed_item_key = 'genre'
-                    count = library_stats[key][inner_key]
-                else:
-                    processed_item_key = 'year'
-                    count = library_stats[key][inner_key]
-
-                processed_library_stats[key].append({
-                    processed_item_key: inner_key,
-                    "count": count
-                })
-        elif key == 'audio_features':
-            for audio_feature in library_stats[key]:
-                if 'audio_features' not in processed_library_stats:
-                    processed_library_stats['audio_features'] = []
-                processed_library_stats['audio_features'].append({
-                    'feature': audio_feature,
-                    'average': library_stats[key][audio_feature]['average'],
-                    'std_dev': library_stats[key][audio_feature]['std_dev']
-                })
-        # TODO: Not sure about final form for 'popularity'
-        # elif key == 'popularity':
-        #     processed_library_stats[key] = []
-        #     processed_library_stats[key].append({
-
-        #     })
-        elif key == 'num_songs' or key == 'total_runtime' or key == 'popularity':
-            processed_library_stats[key] = library_stats[key]
-    
-    return processed_library_stats
-
-#  }}} process_library_stats # 
+#  }}}  add_artist_genres # 
 
 #  get_artists_in_genre {{{ # 
 
diff --git a/spotifyvis/views.py b/spotifyvis/views.py
index d1a212b..79f9854 100644
--- a/spotifyvis/views.py
+++ b/spotifyvis/views.py
@@ -13,7 +13,7 @@ from datetime import datetime
 from django.shortcuts import render, redirect
 from django.http import HttpResponse, HttpResponseBadRequest, JsonResponse
 from django.db.models import Count, Q
-from .utils import parse_library, process_library_stats, get_artists_in_genre, update_track_genres
+from .utils import parse_library, get_artists_in_genre, update_track_genres
 from .models import User, Track, AudioFeatures, Artist 
 
 #  }}} imports # 
@@ -42,7 +42,6 @@ def generate_random_string(length):
 
 #  token_expired {{{ # 
 
-
 def token_expired(token_obtained_at, valid_for):
     """Returns True if token expired, False if otherwise
 
@@ -119,6 +118,9 @@ def callback(request):
 #  user_data {{{ # 
 
 def user_data(request):
+
+    #  get user token {{{ # 
+    
     token_obtained_at = datetime.strptime(request.session['token_obtained_at'], TIME_FORMAT)
     valid_for = int(request.session['valid_for'])
 
@@ -133,6 +135,8 @@ def user_data(request):
         refresh_token_response = requests.post('https://accounts.spotify.com/api/token', data = req_body).json()
         request.session['access_token'] = refresh_token_response['access_token']
         request.session['valid_for'] = refresh_token_response['expires_in']
+    
+    #  }}} get user token # 
 
     auth_token_str = "Bearer " + request.session['access_token']
     headers = {
@@ -140,14 +144,18 @@ def user_data(request):
     }
 
     user_data_response = requests.get('https://api.spotify.com/v1/me', headers = headers).json()
-    request.session['user_id'] = user_data_response['id']  # store the user_id so it may be used to create model
-    #  request.session['user_name'] = user_data_response['display_name']
+    # store the user_id so it may be used to create model
+    request.session['user_id'] = user_data_response['id']  
 
+    #  create user obj {{{ # 
+    
     try:
         user = User.objects.get(user_id=user_data_response['id'])
     except User.DoesNotExist:
         user = User(user_id=user_data_response['id'], user_secret=generate_random_string(30))
         user.save()
+    
+    #  }}} create user obj # 
 
     context = {
         'id': user_data_response['id'],

From 0c0520af8cf4ce51bfad965f457d8b0dc342641a Mon Sep 17 00:00:00 2001
From: Kevin Mok <kevin.mok@live.ca>
Date: Wed, 27 Jun 2018 02:06:17 -0400
Subject: [PATCH 9/9] Added most common genre to all tracks (closes #34)

Resolved issue of there being multiple artists on a track and "manually
created" an undefined genre for artists that don't have a genre.
---
 .../templates/spotifyvis/user_data.html       |  5 --
 spotifyvis/utils.py                           | 75 +++++++++++--------
 spotifyvis/views.py                           |  3 +-
 3 files changed, 45 insertions(+), 38 deletions(-)

diff --git a/spotifyvis/templates/spotifyvis/user_data.html b/spotifyvis/templates/spotifyvis/user_data.html
index 440d756..67c99db 100644
--- a/spotifyvis/templates/spotifyvis/user_data.html
+++ b/spotifyvis/templates/spotifyvis/user_data.html
@@ -17,10 +17,5 @@
             <p class="browsehappy">You are using an <strong>outdated</strong> browser. Please <a href="#">upgrade your browser</a> to improve your experience.</p>
         <![endif]-->
         <p>Logged in as {{ id }}</p>
-        <script src="{% static "spotifyvis/scripts/user_data.js" %}"></script>
-        <script>
-            sessionStorage.setItem('user_secret', "{{ user_secret }}");
-            getAudioFeatureData('instrumentalness', sessionStorage.getItem('user_secret'));
-        </script>
     </body>
 </html>
diff --git a/spotifyvis/utils.py b/spotifyvis/utils.py
index f8e2599..fae4439 100644
--- a/spotifyvis/utils.py
+++ b/spotifyvis/utils.py
@@ -12,10 +12,10 @@ import json
 #  }}} imports # 
 
 USER_TRACKS_LIMIT = 50
-#  ARTIST_LIMIT = 50
-ARTIST_LIMIT = 25
-#  FEATURES_LIMIT = 100
-FEATURES_LIMIT = 25
+ARTIST_LIMIT = 50
+FEATURES_LIMIT = 100
+#  ARTIST_LIMIT = 25
+#  FEATURES_LIMIT = 25
 
 #  parse_library {{{ # 
 
@@ -37,7 +37,7 @@ def parse_library(headers, tracks, user):
     features_queue = []
 
     # iterate until hit requested num of tracks
-    for _ in range(0, tracks, USER_TRACKS_LIMIT):
+    for i in range(0, tracks, USER_TRACKS_LIMIT):
         payload['offset'] = str(offset)
         saved_tracks_response = requests.get('https://api.spotify.com/v1/me/tracks', 
                 headers=headers,
@@ -80,6 +80,12 @@ def parse_library(headers, tracks, user):
             
             #  }}} add audio features # 
 
+            # temporary console logging
+            print("#{}-{}: {} - {}".format(offset + 1,
+                offset + USER_TRACKS_LIMIT, 
+                track_obj.artists.first(), 
+                track_obj.name))
+
         # calculates num_songs with offset + songs retrieved
         offset += USER_TRACKS_LIMIT
 
@@ -111,11 +117,18 @@ def update_track_genres(user):
     """
     user_tracks = Track.objects.filter(users__exact=user)
     for track in user_tracks:
-        track_artists = list(track.artists.all())
-        if len(track_artists) == 1:
-            track.genre = track_artists[0].genres.all().order_by('-num_songs').first()
-            track.save()
-            #  print(track_artists, track.genre)
+        # just using this variable to save another call to db
+        track_artists = track.artists.all()
+        # set genres to first artist's genres then find intersection with others
+        shared_genres = track_artists.first().genres.all()
+        for artist in track_artists:
+            shared_genres.intersection(artist.genres.all())
+
+        most_common_genre = shared_genres.order_by('-num_songs').first()
+        track.genre = most_common_genre if most_common_genre is not None \
+                else "undefined"
+        track.save()
+        #  print(track.name, track.genre)
 
 #  }}}  update_track_genres # 
 
@@ -186,23 +199,22 @@ def get_audio_features(headers, track_objs):
 
 #  }}} get_audio_features # 
 
-# WIP: is this being removed to redo genre data?
-def get_top_genre(headers, top_artist_id):
-    """Updates the top genre for a track by querying the Spotify API
-
-    :headers: For making the API call.
-    :top_artist: The first artist's (listed in the track) Spotify ID.
+def process_artist_genre(genre_name, artist_obj):
+    """Increase count for correspoding Genre object to genre_name and add that
+    Genre to artist_obj. 
 
-    :returns: The first genre listed for the top_artist.
+    :genre_name: Name of genre.
+    :artist_obj: Artist object to add Genre object to.
+    :returns: None
 
     """
-    artist_response = requests.get('https://api.spotify.com/v1/artists/' +
-            top_artist_id, headers=headers).json()
-    #  pprint.pprint(artist_response)
-    if len(artist_response['genres']) > 0:
-        return artist_response['genres'][0]
-    else:
-        return "undefined"
+    genre_obj, created = Genre.objects.get_or_create(name=genre_name,
+            defaults={'num_songs':1})
+    if not created:
+        genre_obj.num_songs = F('num_songs') + 1
+        genre_obj.save()
+    artist_obj.genres.add(genre_obj)
+    artist_obj.save()
 
 #  add_artist_genres {{{ # 
 
@@ -223,14 +235,11 @@ def add_artist_genres(headers, artist_objs):
             headers=headers, params=params).json()['artists']
     #  pprint.pprint(artists_response)
     for i in range(len(artist_objs)):
-        for genre in artists_response[i]['genres']:
-            genre_obj, created = Genre.objects.get_or_create(name=genre,
-                    defaults={'num_songs':1})
-            if not created:
-                genre_obj.num_songs = F('num_songs') +1
-                genre_obj.save()
-            artist_objs[i].genres.add(genre_obj)
-            artist_objs[i].save()
+        if len(artists_response[i]['genres']) == 0:
+            process_artist_genre("undefined", artist_objs[i])
+        else:
+            for genre in artists_response[i]['genres']:
+                process_artist_genre(genre, artist_objs[i])
 
 #  }}}  add_artist_genres # 
 
@@ -255,6 +264,8 @@ def get_artists_in_genre(user, genre, max_songs):
     processed_artist_counts = {}
     songs_added = 0
     for artist in artist_counts:
+        # hacky way to not have total count overflow due to there being multiple
+        # artists on a track
         if songs_added + artist.num_songs <= max_songs:
             processed_artist_counts[artist.name] = artist.num_songs
             songs_added += artist.num_songs
diff --git a/spotifyvis/views.py b/spotifyvis/views.py
index 79f9854..bf5fcc7 100644
--- a/spotifyvis/views.py
+++ b/spotifyvis/views.py
@@ -19,7 +19,7 @@ from .models import User, Track, AudioFeatures, Artist
 #  }}} imports # 
 
 TIME_FORMAT = '%Y-%m-%d-%H-%M-%S'
-TRACKS_TO_QUERY = 50
+TRACKS_TO_QUERY = 200
 
 #  generate_random_string {{{ # 
 
@@ -237,6 +237,7 @@ def get_genre_data(request, user_secret):
     for genre_dict in genre_counts:
         genre_dict['artists'] = get_artists_in_genre(user, genre_dict['genre'],
                 genre_dict['num_songs'])
+    print("*** Genre Breakdown ***")
     pprint.pprint(list(genre_counts))
     return JsonResponse(data=list(genre_counts), safe=False)