Update app.py

app.py

@@ -1,145 +1,324 @@
 import gradio as gr
 import pandas as pd
+import re
+import csv
 
-def update_scores(winner_score, loser_score, k_factor=100):
-    score_difference = k_factor / (winner_score / loser_score)
-    return winner_score + score_difference, loser_score - score_difference
+def update_scores(winner, loser, k_factor=100):
+    score_difference = int(k_factor / (winner / loser))
+    winner += score_difference
+    loser -= score_difference
+    return winner, loser
 
-def prepare_dataframe(opponents_df, criteria_df, additional_columns=None):
-    columns = ["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"]
-    if additional_columns:
-        columns += additional_columns
-    return opponents_df[columns] if not opponents_df.empty else pd.DataFrame(columns=columns)
+def vote_startup_criteria(criteria_df):
+    if len(criteria_df) > 1:
+        sample = criteria_df.sample(n=2)
+        first_string = sample.iloc[0]["criteria"]
+        second_string = sample.iloc[1]["criteria"]
+        return f"Is '{first_string}' more important than '{second_string}'?", first_string, second_string, display_criteria_rankings(criteria_df)
+    else:
+        return "Add more criteria to start ranking!", "", "", display_criteria_rankings(criteria_df)
 
-def clean_string(s):
-    return " ".join(word.capitalize() for word in s.strip().replace("  ", " ").lower().split())
+def vote_startup_opponents(opponents_df, criteria_df):
+    try:
+        opponents_df = opponents_df[["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"]]
+    except:
+        opponents_df = pd.DataFrame(columns=["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"])
+    if len(opponents_df) > 0:
+        if len(opponents_df) > 10:
+            slice_size = 4
+            slice = int(len(opponents_df) / slice_size)
+            sample = opponents_df[slice:(slice_size - 1) * slice].sample(frac=1).iloc[0]
+            opponent, descriptor = sample["opponent"], sample["descriptor"]
+        else:
+            sample = opponents_df.sample(frac=1).iloc[0]
+            opponent, descriptor = sample["opponent"], sample["descriptor"]
+    if len(opponents_df) > 1:
+        sample = opponents_df.sample(frac=1)
+        comparison_opponent = sample.iloc[0]
+        if comparison_opponent['opponent'] == opponent and comparison_opponent['descriptor'] == descriptor:
+            comparison_opponent = sample.iloc[1]
+        first_df = opponents_df[opponents_df["opponent"] == opponent][opponents_df["descriptor"] == descriptor]
+        first_string = first_df["opponent"].tolist()[0] + " - " + first_df["descriptor"].tolist()[0]
+        second_df = comparison_opponent
+        second_string = second_df["opponent"] + " - " + second_df["descriptor"]
+        criteria = criteria_df.sample(n=1)["criteria"].values[0]
+        return f"Which opponent better represents '{criteria}': '{descriptor} - {opponent}' or '{comparison_opponent['descriptor']} - {comparison_opponent['opponent']}'?", first_string, second_string, criteria, display_rankings(opponents_df, criteria_df)
+    else:
+        return "Add some opponents to start voting!", "", "", "", display_rankings(opponents_df, criteria_df)
 
-def display_dataframe(df, sort_column, file_name):
-    df = df.sort_values(by=sort_column, ascending=False)
-    df.to_csv(file_name, index=False)
-    return df
+def clean_string(string):
+    string = string.strip().replace("  ", " ").lower()
+    string = " ".join([x[0].upper() + x[1:] for x in string.split()])
+    return string
 
-def update_criteria_ratings(first, second, criteria_df, is_positive):
-    winner, loser = (first, second) if is_positive else (second, first)
-    winner_score, loser_score = update_scores(
-        criteria_df.at[winner, 'score'], criteria_df.at[loser, 'score']
-    )
-    criteria_df.at[winner, 'score'], criteria_df.at[loser, 'score'] = winner_score, loser_score
-    return criteria_df
+def add_and_compare(descriptor, opponent, opponents_df, criteria_df):
+    try:
+        opponents_df = opponents_df[["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"]]
+    except:
+        opponents_df = pd.DataFrame(columns=["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"])
+    if descriptor != "" and opponent != "":
+        descriptor = clean_string(descriptor)
+        opponent = clean_string(opponent)
+        new_opponent = pd.DataFrame({'descriptor': [descriptor], 'opponent': [opponent]})
+        for c in criteria_df["criteria"]:
+            new_opponent[f"{c}_score"] = 1000
+        new_opponent["overall_score"] = 1000
+        opponents_df = pd.concat([opponents_df, new_opponent], ignore_index=True)
+        opponents_df.to_csv("opponents_df.csv")
+    opponents_df = opponents_df[["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"]]
+    return "", "", display_rankings(opponents_df, criteria_df)
 
-def update_opponent_ratings(first, second, criterion, opponents_df, criteria_df, is_positive):
-    winner, loser = (first, second) if is_positive else (second, first)
-    winner_score, loser_score = update_scores(
-        opponents_df.at[winner, f"{criterion}_score"], opponents_df.at[loser, f"{criterion}_score"]
-    )
-    opponents_df.at[winner, f"{criterion}_score"], opponents_df.at[loser, f"{criterion}_score"] = winner_score, loser_score
-    return calculate_overall_scores(opponents_df, criteria_df)
+def update_ratings_pos(first_string, second_string, criteria, opponents_df, criteria_df):
+    try:
+        opponents_df = opponents_df[["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"]]
+    except:
+        opponents_df = pd.DataFrame(columns=["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"])
+    if len(opponents_df) == 0:
+        return "Add some opponents to start voting!", "", "", "", display_rankings(opponents_df, criteria_df)
+    if first_string != "":
+        opponents_df["combined"] = opponents_df["opponent"] + " - " + opponents_df["descriptor"]
+        loser = opponents_df[opponents_df["combined"] == second_string]
+        winner = opponents_df[opponents_df["combined"] == first_string]
+        winner_score, loser_score = update_scores(winner[f"{criteria}_score"].values[0], loser[f"{criteria}_score"].values[0])
+        opponents_df.at[winner.index[0], f"{criteria}_score"] = winner_score
+        opponents_df.at[loser.index[0], f"{criteria}_score"] = loser_score
+    opponents_df = calculate_overall_scores(opponents_df, criteria_df)
+    opponents_df.to_csv("opponents_df.csv")
+    return vote_startup_opponents(opponents_df, criteria_df)
 
-def calculate_overall_scores(opponents_df, criteria_df):
-    criteria_scores = criteria_df.set_index("criteria")["score"]
-    criteria_list = criteria_df["criteria"]
+def update_ratings_neg(first_string, second_string, criteria, opponents_df, criteria_df):
+    try:
+        opponents_df = opponents_df[["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"]]
+    except:
+        opponents_df = pd.DataFrame(columns=["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"])
+    if len(opponents_df) == 0:
+        return "Add some opponents to start voting!", "", "", "", display_rankings(opponents_df, criteria_df)
+    if first_string != "":
+        opponents_df["combined"] = opponents_df["opponent"] + " - " + opponents_df["descriptor"]
+        loser = opponents_df[opponents_df["combined"] == first_string]
+        winner = opponents_df[opponents_df["combined"] == second_string]
+        winner_score, loser_score = update_scores(winner[f"{criteria}_score"].values[0], loser[f"{criteria}_score"].values[0])
+        opponents_df.at[winner.index[0], f"{criteria}_score"] = winner_score
+        opponents_df.at[loser.index[0], f"{criteria}_score"] = loser_score
+    opponents_df = calculate_overall_scores(opponents_df, criteria_df)
+    opponents_df.to_csv("opponents_df.csv")
+    return vote_startup_opponents(opponents_df, criteria_df)
+
+def display_rankings(opponents_df, criteria_df):
+    opponents_df = opponents_df.sort_values(by='overall_score', ascending=False)
+    opponents_df = opponents_df[["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"]]
+    opponents_df.to_csv("opponents_df.csv")
+    return opponents_df
 
-    def compute_score(row):
-        total_score = sum(row[f"{c}_score"] * criteria_scores[c] for c in criteria_list)
-        total_weight = sum(criteria_scores[c] for c in criteria_list)
-        return total_score / total_weight if total_weight else 0
+def export_csv(opponents_df):
+    save_df = opponents_df
+    save_df.to_csv("opponents_df.csv")
+    return "opponents_df.csv"
 
-    opponents_df["overall_score"] = opponents_df.apply(compute_score, axis=1)
+def import_csv(file, opponents_df, criteria_df):
+    if file is not None:
+        new_df = pd.read_csv(file)
+        try:
+            opponents_df = opponents_df[["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"]]
+        except:
+            opponents_df = pd.DataFrame(columns=["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"])
+        new_df = new_df[["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"]]
+        opponents_df = pd.concat([opponents_df, new_df])
+    opponents_df = opponents_df.drop_duplicates(subset=['descriptor', 'opponent'])
     return opponents_df
 
-def handle_vote(first, second, criteria, opponents_df, criteria_df, is_symbolic_func, data_file):
-    data_frame = is_symbolic_func(first, second, criteria, opponents_df, criteria_df)
-    data_frame = display_dataframe(data_frame, 'overall_score', data_file)
-    return get_vote_start_data(opponents_df, criteria_df)
-
-def get_vote_start_data(opponents_df, criteria_df):
-    if len(opponents_df) > 1 and len(criteria_df) > 0:
-        sample = opponents_df.sample(n=2)
-        first_string = sample.iloc[0]["descriptor"] + " - " + sample.iloc[0]["opponent"]
-        second_string = sample.iloc[1]["descriptor"] + " - " + sample.iloc[1]["opponent"]
-        criterion = criteria_df.sample(n=1)["criteria"].values[0]
-        return f"Which better reflects '{criterion}': '{first_string}' or '{second_string}'?", first_string, second_string, criterion
-    return "Add more options and criteria to start voting!", "", "", ""
-
-def handle_criteria_vote(first, second, criteria_df, is_positive):
-    criteria_df = update_criteria_ratings(first, second, criteria_df, is_positive)
-    criteria_df = display_dataframe(criteria_df, 'score', 'criteria_df.csv')
-    return get_criteria_vote_start(criteria_df)
-
-def get_criteria_vote_start(criteria_df):
-    if len(criteria_df) > 1:
-        sample = criteria_df.sample(n=2)
-        first_string, second_string = sample.iloc[0]["criteria"], sample.iloc[1]["criteria"]
-        return f"Is '{first_string}' more important than '{second_string}'?", first_string, second_string
-    return "Add more criteria to start ranking!", "", ""
+def remove_opponent(descriptor, opponent, opponents_df):
+    descriptor = clean_string(descriptor)
+    opponent = clean_string(opponent)
+    opponents_df = opponents_df[~((opponents_df["descriptor"] == descriptor) & (opponents_df["opponent"] == opponent))]
+    return opponents_df[["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"]]
+
+def reset_rankings(opponents_df, criteria_df):
+    for c in criteria_df["criteria"]:
+        opponents_df[f"{c}_score"] = 1000
+    opponents_df["overall_score"] = 1000
+    opponents_df = opponents_df[["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"]]
+    return display_rankings(opponents_df, criteria_df)
+
+def clear_rankings(opponents_df, criteria_df):
+    opponents_df = pd.DataFrame(columns=["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"])
+    return display_rankings(opponents_df, criteria_df)
+
+def add_criteria(criteria, criteria_df):
+    if criteria != "":
+        criteria = clean_string(criteria)
+        new_criteria = pd.DataFrame({'criteria': [criteria], 'score': [1000]})
+        criteria_df = pd.concat([criteria_df, new_criteria], ignore_index=True)
+        criteria_df.to_csv("criteria_df.csv")
+    criteria_df = criteria_df[["score", "criteria"]]
+    criteria_df = criteria_df.dropna()
+    return "", display_criteria_rankings(criteria_df)
+
+def remove_criteria(criteria, criteria_df):
+    criteria = clean_string(criteria)
+    criteria_df = criteria_df[criteria_df["criteria"] != criteria]
+    return display_criteria_rankings(criteria_df)
+
+def update_criteria_ratings_pos(first_string, second_string, criteria_df):
+    if len(criteria_df) == 0:
+        return "Add some criteria to start ranking!", "", "", display_criteria_rankings(criteria_df)
+    if first_string != "":
+        loser = criteria_df[criteria_df["criteria"] == second_string]
+        winner = criteria_df[criteria_df["criteria"] == first_string]
+        winner_score, loser_score = update_scores(winner['score'].values[0], loser['score'].values[0])
+        criteria_df.at[winner.index[0], 'score'] = winner_score
+        criteria_df.at[loser.index[0], 'score'] = loser_score
+    criteria_df = criteria_df.sort_values(by='score', ascending=False)
+    criteria_df.to_csv("criteria_df.csv")
+    return vote_startup_criteria(criteria_df)
+
+def update_criteria_ratings_neg(first_string, second_string, criteria_df):
+    if len(criteria_df) == 0:
+        return "Add some criteria to start ranking!", "", "", display_criteria_rankings(criteria_df)
+    if first_string != "":
+        loser = criteria_df[criteria_df["criteria"] == first_string]
+        winner = criteria_df[criteria_df["criteria"] == second_string]
+        winner_score, loser_score = update_scores(winner['score'].values[0], loser['score'].values[0])
+        criteria_df.at[winner.index[0], 'score'] = winner_score
+        criteria_df.at[loser.index[0], 'score'] = loser_score
+    criteria_df = criteria_df.sort_values(by='score', ascending=False)
+    criteria_df.to_csv("criteria_df.csv")
+    return vote_startup_criteria(criteria_df)
+
+def display_criteria_rankings(criteria_df):
+    criteria_df = criteria_df.sort_values(by='score', ascending=False)
+    criteria_df = criteria_df[["score", "criteria"]]
+    criteria_df.to_csv("criteria_df.csv")
+    return criteria_df
+
+def calculate_overall_scores(opponents_df, criteria_df):
+    criteria_scores = criteria_df.set_index("criteria")["score"]
+    new_scores = []
+    for _, row in opponents_df.iterrows():
+        overall_score = 0
+        total_weight = 0
+        for c in criteria_df["criteria"]:
+            weight = criteria_scores[c]
+            score = row[f"{c}_score"]
+            overall_score += weight * score
+            total_weight += weight
+        # opponents_df.at[row.name, "overall_score"] = overall_score / total_weight
+        score = overall_score / total_weight
+        new_scores.append(score)
+    opponents_df["overall_score"] = new_scores
+    return opponents_df
 
 theme = gr.themes.Soft(primary_hue="red", secondary_hue="blue")
 
 with gr.Blocks(theme=theme) as app:
-    gr.Markdown("""## Preference-based Elo Ranker""")
-
+    gr.Markdown(
+        """## Preference-based Elo Ranker
+        This tool helps you create **accurate rankings** of things based on your personal preferences.
+        It does this by asking you questions comparing a random pair of your inputs, and then using your
+        answers to calculate Elo scores for ranking.
+        """
+    )
     with gr.Tab("Criteria Ranking"):
-        gr.Markdown("### Rank Criteria")
-        criteria_input = gr.Textbox(label="Criteria")
-        add_criteria_button = gr.Button("Add Criteria")
-
-        # Define the remove_criteria_input TextBox
-        remove_criteria_input = gr.Textbox(label="Criteria")
-        remove_criteria_button = gr.Button("Remove Criteria")
-        
+        gr.Markdown(
+            """### Rank Criteria
+            Add and rank the criteria that will be used to evaluate the opponents.
+            """
+        )
+        with gr.Row():
+            criteria_input = gr.Textbox(label="Criteria")
+            add_criteria_button = gr.Button("Add Criteria")
+        with gr.Row():
+            remove_criteria_input = gr.Textbox(label="Criteria")
+            remove_criteria_button = gr.Button("Remove Criteria")
         criteria_df = pd.DataFrame(columns=['score', 'criteria'])
         criteria_rankings = gr.DataFrame(value=criteria_df, interactive=False, headers=["Score", "Criteria"])
-        criteria_compare_output = gr.Textbox("Add some criteria to start ranking!", label="Comparison", interactive=False)
-
-        criteria_yes_button = gr.Button("Yes", variant="secondary")
-        criteria_no_button = gr.Button("No", variant="primary")
-        criteria_new_vote = gr.Button("New Vote")
-        
-        add_criteria_button.click(lambda _: add_criteria(criteria_input, criteria_rankings),
-                                  inputs=[criteria_input, criteria_rankings], outputs=[criteria_input, criteria_rankings])
-        remove_criteria_button.click(lambda _: remove_criteria(clean_string(remove_criteria_input.value), criteria_rankings),
-                                     inputs=[remove_criteria_input, criteria_rankings], outputs=criteria_rankings)
-        
-        criteria_yes_button.click(lambda first, second: handle_criteria_vote(first, second, criteria_rankings, True),
-                                  inputs=[criteria_input, criteria_input], outputs=[criteria_compare_output, criteria_input, criteria_input])
-        criteria_no_button.click(lambda first, second: handle_criteria_vote(first, second, criteria_rankings, False),
-                                 inputs=[criteria_input, criteria_input], outputs=[criteria_compare_output, criteria_input, criteria_input])
-        criteria_new_vote.click(lambda data_frame: get_criteria_vote_start(data_frame),
-                                inputs=[criteria_rankings], outputs=[criteria_compare_output, criteria_input, criteria_input])
+        with gr.Row():
+            criteria_compare_output = gr.Textbox("Add some criteria to start ranking!", label="Comparison", interactive=False)
+            with gr.Row():
+                criteria_yes_button = gr.Button("Yes", variant="secondary")
+                criteria_no_button = gr.Button("No", variant="primary")
+            with gr.Row():
+                with gr.Column():
+                    criteria_compare_index_1 = gr.Textbox(label="", interactive=False, visible=False)
+                with gr.Column():
+                    criteria_compare_index_2 = gr.Textbox(label="", interactive=False, visible=False)
+            criteria_new_vote = gr.Button("New Vote")
+        add_criteria_button.click(add_criteria, inputs=[criteria_input, criteria_rankings], outputs=[criteria_input, criteria_rankings])
+        remove_criteria_button.click(remove_criteria, inputs=[remove_criteria_input, criteria_rankings], outputs=criteria_rankings)
+        criteria_yes_button.click(update_criteria_ratings_pos, inputs=[criteria_compare_index_1, criteria_compare_index_2, criteria_rankings], outputs=[criteria_compare_output, criteria_compare_index_1, criteria_compare_index_2, criteria_rankings])
+        criteria_no_button.click(update_criteria_ratings_neg, inputs=[criteria_compare_index_1, criteria_compare_index_2, criteria_rankings], outputs=[criteria_compare_output, criteria_compare_index_1, criteria_compare_index_2, criteria_rankings])
+        criteria_new_vote.click(vote_startup_criteria, inputs=[criteria_rankings], outputs=[criteria_compare_output, criteria_compare_index_1, criteria_compare_index_2, criteria_rankings])
 
     with gr.Tab("Opponent Ranking"):
-        opponents_df = pd.DataFrame(columns=["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"])
-        rankings = gr.DataFrame(value=opponents_df, interactive=False,
-                                headers=["Descriptor", "Opponent"] + [f"{c} Score" for c in criteria_df["criteria"]] + ["Overall Score"])
-
-        compare_output = gr.Textbox("Add some options to start voting!", label="Comparison", interactive=False)
-        yes_button = gr.Button("1", variant="secondary")
-        no_button = gr.Button("2", variant="primary")
-        criteria_output = gr.Textbox(label="Criteria", interactive=False)
-        
-        new_vote = gr.Button("New Vote")
-        descriptor_input = gr.Textbox(label="Descriptor")
-        opponent_input = gr.Textbox(label="Opponent")
-        add_button = gr.Button("Add Opponent")
-
-        add_button.click(lambda: add_and_compare(clean_string(descriptor_input.value), clean_string(opponent_input.value), rankings, criteria_rankings),
-                         inputs=[descriptor_input, opponent_input, rankings, criteria_rankings], outputs=[descriptor_input, opponent_input, rankings])
-
-        remove_descriptor_input = gr.Textbox(label="Descriptor")
-        remove_opponent_input = gr.Textbox(label="Opponent")
-        remove_button = gr.Button("Remove Opponent")
-        
-        remove_button.click(lambda _, __: remove_opponent(remove_descriptor_input, remove_opponent_input, rankings),
-                            inputs=[remove_descriptor_input, remove_opponent_input, rankings], outputs=rankings)
-
-        yes_button.click(lambda first, second, crit, opp_df, crit_df: handle_vote(first, second, crit, opp_df, crit_df, update_opponent_ratings, True, "opponents_df.csv"),
-                         inputs=[compare_output, compare_output, criteria_output, rankings, criteria_rankings],
-                         outputs=[compare_output, compare_output, compare_output, criteria_output, rankings])
-        no_button.click(lambda first, second, crit, opp_df, crit_df: handle_vote(first, second, crit, opp_df, crit_df, update_opponent_ratings, False, "opponents_df.csv"),
-                        inputs=[compare_output, compare_output, criteria_output, rankings, criteria_rankings],
-                        outputs=[compare_output, compare_output, compare_output, criteria_output, rankings])
-        
-        new_vote.click(lambda opp_df, crit_df: get_vote_start_data(opp_df, crit_df),
-                       inputs=[rankings, criteria_rankings], outputs=[compare_output, compare_output, compare_output, criteria_output, rankings])
+        with gr.Row():
+            previews_df = pd.DataFrame(columns=["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"])
+            previews = gr.DataFrame(value=previews_df, interactive=False, visible=False)
+            with gr.Column():
+                gr.Markdown(
+                    """### Vote to Rank
+                    """
+                )
+                with gr.Row():
+                    compare_output = gr.Textbox("Add some options to start voting!", label="Comparison", interactive=False)
+                    with gr.Row():
+                        yes_button = gr.Button("1", variant="secondary")
+                        no_button = gr.Button("2", variant="primary")
+                    with gr.Row():
+                        criteria_output = gr.Textbox(label="Criteria", interactive=False)
+                new_vote = gr.Button("New Vote")
+                with gr.Row():
+                    with gr.Column():
+                        compare_index_1 = gr.Textbox(label="", interactive=False, visible=False)
+                    with gr.Column():
+                        compare_index_2 = gr.Textbox(label="", interactive=False, visible=False)
+            with gr.Column():
+                gr.Markdown(
+                    """### Rankings
+                    """
+                )
+                opponents_df = pd.DataFrame(columns=["descriptor", "opponent"] + [f"{c}_score" for c in criteria_df["criteria"]] + ["overall_score"])
+                rankings = gr.DataFrame(value=opponents_df, interactive=False, headers=["Descriptor", "Opponent"] + [f"{c} Score" for c in criteria_df["criteria"]] + ["Overall Score"])
+
+        gr.Markdown(
+            """### Add Opponents
+            """
+        )
+        with gr.Row():
+            descriptor_input = gr.Textbox(label="Descriptor")
+            opponent_input = gr.Textbox(label="Opponent")
+            add_button = gr.Button("Add Opponent")
+        add_button.click(add_and_compare, inputs=[descriptor_input, opponent_input, rankings, criteria_rankings], outputs=[descriptor_input, opponent_input, rankings])
+        gr.Markdown(
+            """### Remove Opponents
+            """
+        )
+        with gr.Row():
+            remove_descriptor_input = gr.Textbox(label="Descriptor")
+            remove_opponent_input = gr.Textbox(label="Opponent")
+            remove_button = gr.Button("Remove Opponent")
+        remove_button.click(remove_opponent, inputs=[remove_descriptor_input, remove_opponent_input, rankings], outputs=rankings)
+
+        gr.Markdown(
+            """### Import and Export Rankings
+            """
+        )
+        with gr.Row():
+            import_button = gr.File(label="Import CSV", file_count="single")
+            import_button.change(fn=import_csv, inputs=[import_button, rankings, criteria_rankings], outputs=[rankings])
+            with gr.Column():
+                export_link = gr.File(label="Download CSV", file_count="single")
+                export_button = gr.Button("Export as CSV")
+                export_button.click(fn=export_csv, inputs=[rankings], outputs=export_link)
+
+        gr.Markdown("### Reset Data")
+        with gr.Row():
+            reset_button = gr.Button("Reset Scores")
+            reset_button.click(reset_rankings, inputs=[rankings, criteria_rankings], outputs=rankings)
+            clear_button = gr.Button("Clear Table", variant="primary")
+            clear_button.click(clear_rankings, inputs=[rankings, criteria_rankings], outputs=rankings)
+
+        yes_button.click(update_ratings_pos, inputs=[compare_index_1, compare_index_2, criteria_output, rankings, criteria_rankings], outputs=[compare_output, compare_index_1, compare_index_2, criteria_output, rankings])
+        no_button.click(update_ratings_neg, inputs=[compare_index_1, compare_index_2, criteria_output, rankings, criteria_rankings], outputs=[compare_output, compare_index_1, compare_index_2, criteria_output, rankings])
+        new_vote.click(vote_startup_opponents, inputs=[rankings, criteria_rankings], outputs=[compare_output, compare_index_1, compare_index_2, criteria_output, rankings])
 
 app.launch(share=False)