original files

.gitignore

@@ -0,0 +1,9 @@
+/venv
+/venv/bin/*
+.cache
+*.ipynb
+/src/config
+/data/spotify_million_playlist_dataset_challenge
+/data/songs_new.csv
+__pycache__
+*.code-workspace

app.py

@@ -0,0 +1,17 @@
+from src.playlist_builder import PlaylistBuilder
+"""
+NOTES:
+TODO NEXT:
+- add seeding through api search.
+- put on huggingface before presentation.
+"""
+
+
+def main():
+    """ Run an instance of the PlaylistBuilder class developed using Gradio and Spotipy.
+    """
+    playlist_app = PlaylistBuilder()
+    playlist_app.launch()
+
+if __name__ == '__main__':
+    main()

data/SpotifyAudioFeaturesApril2019.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6e49bb679851e58726ac74bf75ae50f5c10fce07fa9e6538ccb99a357d24648
+size 20399954

data/reduced_audio_profiles.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aef94dacf666d357a0dfa9456c51e22057b66102d4e7194a3dba6b84997cd24d
+size 6664964

requirements.txt

@@ -0,0 +1,2 @@
+gradio
+numpy

src/evolutionary_alrogithm.py

@@ -0,0 +1,310 @@
+import pandas as pd
+import numpy as np
+import gradio as gr
+import plotly.express as px
+from plotly.graph_objects import Figure
+from copy import deepcopy
+from random import choice
+from typing import List, Set
+import itertools
+from sklearn.preprocessing import StandardScaler
+from src.spotipy_utils import SpotifyTrack
+
+# Initial data cleaning.
+SONG_DF = pd.read_csv("data/SpotifyAudioFeaturesApril2019.csv")
+REDUCED_DF = pd.read_csv("data/reduced_audio_profiles.csv")
+AUDIO_DF = SONG_DF.drop(["artist_name", "track_id", "track_name", "duration_ms", "key", "mode", "time_signature", "popularity"], axis=1) # TODO: Normalize these feature-wise!
+AUDIO_FEATURE_NAMES = AUDIO_DF.columns
+history_df = pd.DataFrame({"x": REDUCED_DF.iloc[..., 0],
+    "y": REDUCED_DF.iloc[..., 1],
+    "status": ["none" for i in range(REDUCED_DF.shape[0])],
+    "name": SONG_DF["track_name"].values,
+    "artist": SONG_DF["artist_name"].values,
+    "key": SONG_DF["key"].values})
+
+# Symbols for track statuses.
+THUMBS_UP = "👍"
+THUMBS_DOWN = "👎"
+ADD_TO_PLAYLIST = "➕ to ⏯️"
+COLOR_MAP_DISCRETE = {"none": 'grey', THUMBS_UP: "blue", THUMBS_DOWN: 'red', ADD_TO_PLAYLIST: "green"}
+
+# Normalizing audio profile features to be able to control mutation size more precisely.
+scaler = StandardScaler()
+audio_features = scaler.fit_transform(AUDIO_DF.values)
+sample_inds = list(np.arange(audio_features.shape[0])) # index list for easy sampling
+
+# Mutation and crossover options.
+MUTATION_OPTIONS = ["None", "Random", "Differential"]
+CROSSOVER_OPTIONS = ["None", "Two-Point"]
+
+
+class Individual:
+    """ Individual representing a track in the Evolutionary algorithm population.
+    """
+    def __init__(self, song_index:int):
+        """Constructor for an Individual.
+
+        Args:
+            song_index (int): Index of the track in the dataset.
+        """
+        self.index = song_index
+        self.spotify_id = SONG_DF.loc[song_index, ["track_id"]][0]
+        self.spotify_track = SpotifyTrack(self.spotify_id) # Init a spotify track instance.
+        self.name = SONG_DF.loc[song_index, ["track_name"]][0]
+        self.artist = SONG_DF.loc[song_index, ["artist_name"]][0]
+        self.genome = audio_features[song_index,...] # NOTE: For now, the only genome used is the audio profile of the track.
+        self.status = None
+
+
+    def get_image_url(self) -> str:
+        """ Get the image for the track available on through the API.
+
+        Returns:
+            str: URL to the track image.
+        """
+        return self.spotify_track.track_image
+
+
+    def get_preview_url(self) -> str:
+        """ Get the preview audio for the track available on through the API.
+
+        Returns:
+            str: URL to the preview audio.
+        """
+        return self.spotify_track.track_preview_url
+
+
+    def get_track_as_block(self) -> str:
+        """Get track name and artist name in a string.
+
+        Returns:
+            str: Track name and artist name.
+        """
+        return gr.TextArea(value=f"{self.name} by {self.artist}")
+
+    def get_track_id(self) -> str:
+        """Get track ID for Spotify API.
+
+        Returns:
+            str: Spotify track ID.
+        """
+        return self.spotify_track.track_id
+
+
+class Population:
+    """ Population of tracks to be evolved through interaction with a user in an effort to build a curated playlist.
+    """
+    def __init__(self, num_songs:int, mutation_size:float, crossover_function=None, mutation_function=None):
+        """ Constructor of the population initializing all the tracks in the first generation.
+
+        Args:
+            num_songs (int): Number of tracks in the population.
+            mutation_size (float): Value to scale mutations.
+            crossover_function (function, optional): Function to perform crossover with. Defaults to None.
+            mutation_function (function, optional): Function to perform mutation with. Defaults to None.
+        """
+        self.seed_track = None
+        self.size = num_songs
+        self.init_inds = np.random.choice(sample_inds, self.size)
+        self.pop = [Individual(ind) for ind in self.init_inds]
+        self.playlist_selected_songs = []
+        self.playlist_inds = set()
+        self.mutation_function = mutation_function
+        self.crossover_function = crossover_function
+        self.mutation_size = mutation_size
+        self.history_df = deepcopy(history_df)
+
+
+    def mutate(self, thumbs_up:List[Individual], thumbs_down:List[Individual], added_songs:List[Individual]):
+        """ Method to call assigned mutation function through.
+
+        Args:
+            thumbs_up (List[Individual]): List of individuals given the thumbs up.
+            thumbs_down (List[Individual]): List of individuals given the thumbs down.
+            added_songs (List[Individual]): List of individuals added to the playlist.
+        """
+        self.mutation_function(self, thumbs_up, thumbs_down, added_songs)
+
+
+    def crossover(self, thumbs_up:List[Individual], thumbs_down:List[Individual], added_songs:List[Individual]):
+        """ Method to call assigned crossover function through.
+
+        Args:
+            thumbs_up (List[Individual]): List of individuals given the thumbs up.
+            thumbs_down (List[Individual]): List of individuals given the thumbs down.
+            added_songs (List[Individual]): List of individuals added to the playlist.
+        """
+        self.crossover_function(self, thumbs_up, thumbs_down, added_songs)
+
+
+    def add_to_playlist(self, track:Individual):
+        """ Add a given track to the population's playlist.
+
+        Args:
+            track (Individual): Track that the user has chosen to add to the playlist.
+        """
+        self.playlist_selected_songs.append(track)
+        self.playlist_inds.add(track.index)
+
+
+    def get_tracks_with_status(self, status:str):
+        """ Get tracks in the current population matching some status.
+
+        Args:
+            status (str): Status to be matched on.
+        """
+        return list(filter(lambda x: x.status == status, self.pop))
+
+
+    def get_playlist_block_value(self) -> str:
+        """ Get population represented as a string.
+
+        Returns:
+            str: Tracks listed with name and artist name, one per line.
+        """
+        val_string = ""
+        for track in self.playlist_selected_songs:
+            val_string += f"{track.name} by {track.artist}\n"
+        return val_string
+
+
+    def reinitialize_pop(self):
+        """ Randomly re-initialize the population.
+        """
+        self.init_inds = np.random.choice(sample_inds, self.size)
+        self.pop = [Individual(ind) for ind in self.init_inds]
+
+
+    def generate_traversal_viz(self) -> Figure:
+        """ Generate a scatter plot marking the tracks which have been used so far and their categories.
+
+        Returns:
+            Figure: Plotly scatter plot.
+        """
+        return px.scatter(self.history_df, "x", "y", color="status", color_discrete_map=COLOR_MAP_DISCRETE,labels={
+                     "x": "",
+                     "y": "",
+                 },)
+
+
+    def update_population_history(self, thumbs_up:List[Individual], thumbs_down:List[Individual], added_songs:List[Individual]):
+        """ Update the DF keeping track of the traversal history.
+
+        Args:
+            thumbs_up (List[Individual]): List of individuals given the thumbs up.
+            thumbs_down (List[Individual]): List of individuals given the thumbs down.
+            added_songs (List[Individual]): List of individuals added to the playlist.
+        """
+        for track in thumbs_up:
+            self.history_df.at[track.index, "status"] = THUMBS_UP
+        for track in thumbs_down:
+            self.history_df.at[track.index, "status"] = THUMBS_DOWN
+        for track in added_songs:
+            self.history_df.at[track.index, "status"] = ADD_TO_PLAYLIST
+
+
+def get_closest_song_to_genome(population: Population, genome: np.ndarray, new_track_inds: Set[int]) -> int:
+    """ Find the song in the audio profile matrix that is most similar to the supplied one.
+
+    Args:
+        population (Population): Population of tracks.
+        genome (np.ndarray): Vector of audio profile features.
+        new_track_inds (Set[int]): Set of the track indices being added for the new generation.
+
+    Returns:
+        int: Index of the most similar track in the audio matrix that is not already in the population or added to the playlist.
+    """
+    track_distances = np.mean(np.abs(genome - audio_features), axis=1)
+    sorted_distance_inds = np.argsort(track_distances)
+    current_distance_index = 0
+    while sorted_distance_inds[current_distance_index] in new_track_inds or sorted_distance_inds[current_distance_index] in population.playlist_inds:
+        current_distance_index += 1
+
+    child_index = sorted_distance_inds[current_distance_index]
+    child = Individual(child_index)
+    new_track_inds.add(child_index)
+    return child
+
+
+def simple_crossover(population: Population, thumbs_up:List[Individual], thumbs_down:List[Individual], added_songs:List[Individual]):
+    """ Performs simple two point crossover.
+
+    Args:
+        population (Population): Population to assign new children to.
+        thumbs_up (List[Individual]): List of individuals given the thumbs up.
+        thumbs_down (List[Individual]): List of individuals given the thumbs down.
+        added_songs (List[Individual]): List of individuals added to the playlist.
+    """
+    liked_tracks = list(itertools.chain(*[thumbs_up, added_songs]))
+    if len(liked_tracks) < 2: # Not enough tracks to perform crossover.
+        return
+
+    new_track_inds = set()
+    population_index = 0
+    while len(new_track_inds) < population.size:
+        track_a, track_b = np.random.choice(liked_tracks, 2)
+        crossover_point1, crossover_point2 = sorted(np.random.randint(0,len(track_a.genome),2))
+
+        track_a.genome[crossover_point1:crossover_point2+1] = track_b.genome[crossover_point1:crossover_point2+1]
+        track_b.genome[crossover_point1:crossover_point2+1] = track_a.genome[crossover_point1:crossover_point2+1]
+
+        child1 = get_closest_song_to_genome(population, track_a.genome, new_track_inds)
+        population.pop[population_index] = child1
+        population_index += 1
+
+        if population_index < population.size:
+            child2 = get_closest_song_to_genome(population, track_b.genome, new_track_inds)
+            population.pop[population_index] = child2
+            population_index += 1
+
+
+def simple_mutation(population: Population, thumbs_up:List[Individual], thumbs_down:List[Individual], added_songs:List[Individual]):
+    """ Perform simple random mutation on a population of individuals.
+
+    Args:
+        population (Population): Population to assign new children to.
+        thumbs_up (List[Individual]): List of individuals given the thumbs up.
+        thumbs_down (List[Individual]): List of individuals given the thumbs down.
+        added_songs (List[Individual]): List of individuals added to the playlist.
+    """
+    liked_tracks = list(itertools.chain(*[thumbs_up, added_songs]))
+    new_track_inds = set()
+    for i in range(population.size):
+        liked_track = choice(liked_tracks)
+        mutated_track_genome = liked_track.genome + np.random.uniform(size=(population.size))*population.mutation_size
+        child = get_closest_song_to_genome(population, mutated_track_genome, new_track_inds)
+        population.pop[i] = child
+
+
+def differential_mutation(population: Population, thumbs_up:List[Individual], thumbs_down:List[Individual], added_songs:List[Individual]):
+    """ Perform differential mutation based on the user's decisions.
+
+    Args:
+        population (Population): Population to assign new children to.
+        thumbs_up (List[Individual]): List of individuals given the thumbs up.
+        thumbs_down (List[Individual]): List of individuals given the thumbs down.
+        added_songs (List[Individual]): List of individuals added to the playlist.
+    """
+    new_track_inds = set()
+    for i in range(population.size):
+        if thumbs_down:
+            disliked_track = choice(thumbs_down)
+        else:
+            disliked_track = Individual(np.random.choice(sample_inds, 1)[0])
+
+        if thumbs_up:
+            seed_track = choice(thumbs_up)
+        else:
+            seed_track = Individual(np.random.choice(sample_inds, 1)[0])
+
+        if added_songs:
+            attracting_track = choice(added_songs)
+        elif population.playlist_selected_songs:
+            attracting_track = choice(population.playlist_selected_songs)
+        else:
+            attracting_track = Individual(np.random.choice(sample_inds, 1)[0])
+
+        gene_distances = attracting_track.genome - disliked_track.genome
+        resulting_genome = seed_track.genome + gene_distances*population.mutation_size
+        child = get_closest_song_to_genome(population, resulting_genome, new_track_inds)
+        population.pop[i] = child

src/playlist_builder.py

@@ -0,0 +1,308 @@
+import gradio as gr
+from src.evolutionary_alrogithm import Population, simple_mutation, simple_crossover, differential_mutation, MUTATION_OPTIONS, CROSSOVER_OPTIONS, \
+THUMBS_UP, THUMBS_DOWN, ADD_TO_PLAYLIST
+from src.spotipy_utils import add_tracks_to_playlist, get_auth_manager, search_for_track
+
+# IMGs
+ADDED_TO_PLAYLIST = "✅ Added to Library!"
+FAILED_TO_ADD = """❌ Failed to connect to your account. Make sure to that you clicked the link in the description to login and use the app from the window that opens there.\n
+Also check to make sure have entered a valid playlist name and have reached out to the listed email to be added to the user list."""
+
+# Evolutionary Algorithm Parameters.
+NUM_SONGS = 9
+DEFAULT_MUTATION_SIZE = 0.25 # NOTE: This could be turned into a parameter which is set by a slider.
+SONG_CHOICES = [THUMBS_UP, THUMBS_DOWN, ADD_TO_PLAYLIST]
+SEED_OPTIONS = ["yes", "no"]
+
+APP_HEADER = """# Evolutionary Playlist Builder"""
+OPTIONS_TITLE = """# 🧬 Options"""
+EXPLORATION_HEADER = """## Rate of Exploration"""
+PLAYLIST_HEADER = """## Current Playlist"""
+
+
+def change_seed_option(seed_option):
+    if seed_option == SEED_OPTIONS[0]:
+        return gr.Textbox.update(visible=True), gr.Dropdown.update(visible=True)
+    else:
+        return gr.Textbox.update(visible=False), gr.Dropdown.update(visible=False)
+
+
+class PlaylistBuilder():
+    """Evolutionary interactive playlist builder via the Spotify API, Gradio, and a static dataset of audio profile features.
+    """
+    def __init__(self):
+        self.demo = gr.Blocks()
+        with self.demo:
+            gr.Markdown(APP_HEADER)
+
+            with gr.Row():
+                # Initialize app attributes
+                self.do_crossover = False
+                self.do_mutation = False
+                self.population = Population(NUM_SONGS, DEFAULT_MUTATION_SIZE, mutation_function=simple_mutation, crossover_function=simple_crossover)
+
+                # Generate blank traversal visualization.
+                initial_traversal_history = self.population.generate_traversal_viz()
+
+                # Layout first column.
+                with gr.Column():
+                    auth_manager = get_auth_manager() # Need auth manager to generate Spotify API authentication url.
+                    gr.Markdown(
+                        f"""
+                        Please click this link to login: [login]({auth_manager.get_authorize_url()})\n
+                        This app is still in development mode so if you want the ability to add a playlist to your library, email carterward4@gmail.com with your name, spotify email, and the subject as PLAYLIST ACCESS REQUEST.
+                        """)
+
+                    gr.Markdown(OPTIONS_TITLE)
+
+                    crossover_radio = gr.Radio(choices=CROSSOVER_OPTIONS, value=CROSSOVER_OPTIONS[0], label="Crossover?") # radio button for crossover options.
+
+                    mutation_radio = gr.Radio(choices=MUTATION_OPTIONS, value=MUTATION_OPTIONS[0], label="Mutate?") # radio button for mutation options.
+
+                    gr.Markdown(EXPLORATION_HEADER, visible=False)
+
+                    mutation_size_slider = gr.Slider(minimum=0.0, maximum=1.0, value=DEFAULT_MUTATION_SIZE
+                    , interactive=True, show_label=False, visible=False) # slider controlling mutation slide. Values restricted between 0 and 1.
+
+                    history_block = gr.Plot(initial_traversal_history, label="Search History") # Plot block for blank viz.
+
+                    gr.Markdown(PLAYLIST_HEADER)
+
+                    playlist_display = gr.TextArea(value=self.population.get_playlist_block_value(), max_lines=10000, show_label=False) # Blank playlist display.
+
+                    spotify_playlist_textbox = gr.Textbox(interactive=True, label="Enter Playlist Name Here") # Username entry.
+                    add_to_library = gr.Button(value="Add Playlist to Spotify Library") # Button to add to playlist
+                    playlist_added_message = gr.Markdown(ADDED_TO_PLAYLIST, visible=False)
+
+                # Build grid layout with initial song art and options.
+                index_blocks = []
+                name_blocks = []
+                image_blocks = []
+                dropdown_blocks = []
+                preview_blocks = []
+
+                with gr.Column():
+                    # Init seed options
+                    seed_option = gr.Radio(SEED_OPTIONS, value=SEED_OPTIONS[-1], label="Seed generation?", show_label=True)
+                    seed_search = gr.Textbox(interactive=True, label="Search for seed track by name", show_label=True, visible=False)
+                    search_results = gr.Dropdown(label="Search result options", visible=False, interactive=True)
+
+                    # Init population grid.
+                    with gr.Box():
+                        for row in range(0, self.population.size, 3): # Iterate over track rows.
+                            with gr.Row():
+                                for col in range(3): # Iterate over track columns.
+                                    with gr.Box():
+                                        track_index = row + col
+                                        current_song = self.population.pop[track_index]
+                                        song_preview = current_song.get_preview_url()
+
+                                        index_blocks.append(gr.TextArea(value=track_index, visible=False)) # Init index blocks to keep track of everything.
+                                        # Render initial images.
+                                        image_blocks.append(gr.Image(value=current_song.get_image_url(), show_label=False, visible=True).style(height=175, width=175))
+                                        # Add names.
+                                        name_blocks.append(gr.Markdown(value=f"{current_song.name} by {current_song.artist}", show_label=False))
+                                        # Dropdown for song options.
+                                        dropdown_blocks.append(gr.Dropdown(SONG_CHOICES, label = track_index, show_label=False))
+                                        # Add song preview if it exists.
+                                        if song_preview:
+                                            preview_blocks.append(gr.Audio(value=song_preview, show_label=False))
+                                        else:
+                                            preview_blocks.append(gr.Audio(value=song_preview, show_label=False, visible=False))
+
+                        next_generation = gr.Button(value="Next Generation").style(full_width=True)
+
+            # Mapping change functions to class methods.
+
+            crossover_radio.change(
+                fn=self.set_crossover_option,
+                inputs=[crossover_radio]
+            )
+
+            mutation_radio.change(
+                fn=self.set_mutation_option,
+                inputs=[mutation_radio],
+                outputs=[mutation_size_slider, crossover_radio]
+            )
+
+            mutation_size_slider.change(
+                fn=self.update_mutation_size,
+                inputs=[mutation_size_slider]
+            )
+
+
+            seed_option.change(
+                fn=change_seed_option,
+                inputs=[seed_option],
+                outputs=[seed_search, search_results]
+            )
+
+            seed_search.change(
+                fn=self.search_for_seed,
+                inputs=[seed_search],
+                outputs=search_results
+            )
+
+            # Set function to hangle change in dropdown value for each track.
+            for index_block, dropdown_block in zip(index_blocks, dropdown_blocks):
+                dropdown_block.change(
+                    fn=self.set_track_state,
+                    inputs=[index_block, dropdown_block]
+                )
+
+            # Set function to generate next generation of tracks.
+            next_generation.click(
+                fn=self.get_next_generation,
+                outputs=[playlist_display, *image_blocks, *name_blocks, *dropdown_blocks, *preview_blocks, history_block]
+            )
+
+            add_to_library.click(
+                fn=self.add_playlist_to_spotify,
+                inputs=[spotify_playlist_textbox],
+                outputs=[playlist_added_message]
+            )
+
+
+    def set_crossover_option(self, radio_selection:str):
+        """ Set the crossover option for the internal evolutionary algorithm.
+
+        Args:
+            radio_selection (str): Selected crossover option.
+        """
+        if radio_selection == CROSSOVER_OPTIONS[0]:
+            self.do_crossover = False
+        else:
+            self.do_crossover = True
+
+
+    def set_mutation_option(self, radio_selection:str) -> bool:
+        """ Set the mutation option for the internal evolutionary algorithm.
+
+        Args:
+            radio_selection (str): Selected mutation option.
+
+        Returns:
+            tuple: Slider update for mutation rate and Radio update for crossover options.
+        """
+        if radio_selection == MUTATION_OPTIONS[0]:
+            self.do_mutation = False
+            updated_slider = gr.Slider.update(visible=False)
+            updated_crossover_button = gr.Radio.update(visible=True)
+        elif radio_selection == MUTATION_OPTIONS[2]:
+            self.do_mutation = True
+            updated_slider = gr.Slider.update(visible=True)
+            updated_crossover_button = gr.Radio.update(visible=False, value=CROSSOVER_OPTIONS[0])
+
+            self.do_crossover = False
+            self.population.mutation_function = differential_mutation
+        else:
+            self.do_mutation = True
+            updated_slider = gr.Slider.update(visible=True)
+            updated_crossover_button = gr.Radio.update(visible=True)
+
+        return updated_slider, updated_crossover_button
+
+
+    def update_mutation_size(self, mutation_size_slider_value:str):
+        """Update the mutation rate according the slider value.
+
+        Args:
+            mutation_size_slider_value (str): Value from the slider input.
+        """
+        self.population.mutation_size = float(mutation_size_slider_value)
+
+
+    def search_for_seed(self, search_term):
+        search_for_track(search_term)
+        return gr.Dropdown.update(choices=[f"Test {i}" for i in range(self.population.size)])
+
+
+    def set_track_state(self, track_index:str, dropdown_value:str):
+        """Sets the decision status of the track for the corresponding dropdown menu.
+
+        Args:
+            track_index (str): Index of the track in the population array.
+            dropdown_value (str): Value selected from the track's decision dropdown.
+        """
+        current_track = self.population.pop[int(track_index)]
+        current_track.status = dropdown_value
+
+
+    def get_next_generation(self):
+        """ Updates the display grid, the playlist display, and the historical tracking vizualization for the next generation.
+
+        Returns:
+            tuple: Current playlist display, track image, name, option, and preview blocks, and tracking history visualization.
+        """
+        thumbs_up = self.population.get_tracks_with_status(THUMBS_UP)
+        thumbs_down = self.population.get_tracks_with_status(THUMBS_DOWN)
+        added_songs = self.population.get_tracks_with_status(ADD_TO_PLAYLIST)
+
+        for added_track in added_songs:
+            self.population.add_to_playlist(added_track)
+
+        playlist_display = gr.TextArea.update(
+            value=self.population.get_playlist_block_value()
+        )
+
+        # HANDLING FOR IF NO SONGS ARE SELECTED!
+        if not thumbs_up and not added_songs:
+            self.population.reinitialize_pop()
+        else:
+            if self.do_crossover and self.do_mutation:
+                self.population.crossover(thumbs_up, thumbs_down, added_songs)
+                self.population.mutate(self.population.pop, [], [])
+            elif self.do_crossover:
+                self.population.crossover(thumbs_up, thumbs_down, added_songs)
+            elif self.do_mutation:
+                self.population.mutate(thumbs_up, thumbs_down, added_songs)
+
+        # GET IMAGES AND PREVIEWS FOR NEW POPULATION.
+        image_blocks = []
+        name_blocks = []
+        preview_blocks = []
+        dropdown_blocks = []
+        for track in self.population.pop:
+            image_blocks.append(gr.Image.update(value=track.get_image_url()))
+            name_blocks.append(gr.Markdown.update(value=f"{track.name} by {track.artist}"))
+            dropdown_blocks.append(gr.Dropdown.update(value=None))
+            song_preview = track.get_preview_url()
+            if song_preview:
+                preview_blocks.append(gr.Audio.update(value=song_preview, visible=True))
+            else:
+                preview_blocks.append(gr.Audio.update(value=song_preview, visible=False))
+
+        # Update historical df and traversal visualization.
+        self.population.update_population_history(thumbs_up, thumbs_down, added_songs)
+        updated_viz = self.population.generate_traversal_viz()
+        new_traversal_tracker = gr.Plot.update(updated_viz)
+
+        return (playlist_display, *image_blocks, *name_blocks, *dropdown_blocks, *preview_blocks, new_traversal_tracker)
+
+
+    def add_playlist_to_spotify(self, playlist_name:str, request:gr.Request):
+        """Add curated playlist to authenticated user's playlist library. Playlist will be added as public.
+
+        Args:
+            playlist_name (str): Name of the playlist to be created.
+            request (gr.Request): Request information containing the required key for user authentication.
+
+        Returns:
+            gr.Markdown.update: Message displaying the success of the attempt to add to library.
+        """
+        code = request.headers.get("referer").split("code=")[-1]
+        added = add_tracks_to_playlist(code, playlist_name, self.population.playlist_selected_songs)
+
+        if not added:
+            return gr.Markdown.update(FAILED_TO_ADD, visible=True)
+
+        return gr.Markdown.update(ADDED_TO_PLAYLIST, visible=True)
+
+
+    def launch(self, share=False):
+        """Launch the Gradio app.
+
+        Args:
+            share (bool, optional): Whether or not a temporary publicly accessible link should be generated. Defaults to False.
+        """
+        self.demo.launch(share=share)

src/spotipy_utils.py

@@ -0,0 +1,76 @@
+import spotipy
+from spotipy.oauth2 import SpotifyClientCredentials
+from typing import List
+from src.config.spotify_credentials import CLIENT_ID, CLIENT_SECRET # TODO: Make these environment variables in hugging face space.
+
+PLAYLIST_SCOPE = 'playlist-modify-public'
+REDIRECT_URL = "http://127.0.0.1:7860"
+
+sp_client = spotipy.Spotify(client_credentials_manager=SpotifyClientCredentials(CLIENT_ID, CLIENT_SECRET))
+
+
+class SpotifyTrack:
+    """ Object for keeping track of the information provided through the Spotify API on a particular track.
+    """
+    def __init__(self, track_id: str) -> None:
+        """ Constructor for class.
+
+        Args:
+            track_id (str): ID of the track on the Spotify API.
+        """
+        self.track_id = track_id
+        self.raw_track_info = sp_client.track(track_id)
+        self.track_image = self.raw_track_info["album"]["images"][0]["url"]
+        self.track_preview_url = self.raw_track_info["preview_url"]
+
+
+def get_auth_manager() -> spotipy.oauth2.SpotifyOAuth:
+    """ Generate authentication manager object.
+
+    Returns:
+        spotipy.oauth2.SpotifyOAuth: Spotipy authentication manager.
+    """
+    cache_handler = spotipy.cache_handler.CacheFileHandler()
+    return spotipy.oauth2.SpotifyOAuth(client_id=CLIENT_ID, client_secret=CLIENT_SECRET, scope=PLAYLIST_SCOPE, redirect_uri=REDIRECT_URL,
+                                               cache_handler=cache_handler,
+                                               show_dialog=True)
+
+
+def search_for_track(track_name):
+    search_results = sp_client.search(q = "track:" + track_name, type = "track", limit=10)
+    for track_info in search_results["tracks"]["items"]:
+        print(track_info["name"])
+
+
+def add_tracks_to_playlist(code:str, playlist_id:str, tracks:List) -> bool:
+    """ Add tracks to a given user's Spotify Library.
+
+    Args:
+        code (str): Code for authentication.
+        playlist_id (str): Name of the playlist to be created.
+        tracks (List): List of the tracks to be added to the playlist.
+
+    Returns:
+        bool: Flag indicating whether or not the playlist was added to the library succesfully.
+    """
+    auth_manager = get_auth_manager()
+    try:
+        auth_manager.get_access_token(code)
+    except spotipy.oauth2.SpotifyOauthError as e:
+        print(e)
+        return False
+
+    user_client = spotipy.Spotify(auth_manager=auth_manager)
+    username = user_client.current_user()["id"]
+
+    try:
+        playlist_result = user_client.user_playlist_create(username, playlist_id, public=True)
+    except spotipy.exceptions.SpotifyException as e:
+        print(e)
+        return False
+
+    playlist_id = playlist_result["id"]
+    tracks_to_add = ["spotify:track:" + track.get_track_id() for track in tracks]
+    if tracks_to_add:
+        user_client.user_playlist_add_tracks(username, playlist_id, tracks_to_add)
+    return True