Resolves #39

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 {{{ # 
+# WIP: is this being removed to redo genre data?
-
-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 {{{ # 
-
 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 {{{ # 
+#  }}}  add_artist_genres # 
-
-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 # 
 
 #  get_artists_in_genre {{{ # 
 

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'])
 
@@ -134,14 +136,18 @@ def user_data(request):
         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 = {
         'Authorization': auth_token_str
     }
 
     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
+    # store the user_id so it may be used to create model
-    #  request.session['user_name'] = user_data_response['display_name']
+    request.session['user_id'] = user_data_response['id']  
+
+    #  create user obj {{{ # 
     
     try:
         user = User.objects.get(user_id=user_data_response['id'])
@@ -149,6 +155,8 @@ def user_data(request):
         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'],
         'user_secret': user.user_secret,