refactor: refactor the naming

app.py

@@ -170,20 +170,20 @@ with demo:
                             with gr.Column():
                                 models = get_reranking_dropdown(datastore.reranking_models)
                         #  shown_table
-                        lb_table = get_leaderboard_table(datastore.qa_fmt_df, datastore.qa_types)
+                        qa_df_elem_ret_rerank = get_leaderboard_table(datastore.qa_fmt_df, datastore.qa_types)
                         # Dummy leaderboard for handling the case when the user uses backspace key
-                        hidden_lb_table = get_leaderboard_table(datastore.qa_raw_df, datastore.qa_types, visible=False)
+                        qa_df_elem_ret_rerank_hidden = get_leaderboard_table(datastore.qa_raw_df, datastore.qa_types, visible=False)
 
                         version.change(
                             update_qa_version,
                             version,
-                            [domains, langs, models, lb_table, hidden_lb_table],
+                            [domains, langs, models, qa_df_elem_ret_rerank, qa_df_elem_ret_rerank_hidden],
                         )
 
                         set_listeners(
                             "qa",
-                            lb_table,
-                            hidden_lb_table,
+                            qa_df_elem_ret_rerank,
+                            qa_df_elem_ret_rerank_hidden,
                             search_bar,
                             version,
                             domains,
@@ -197,136 +197,114 @@ with demo:
                         metric.change(
                             update_qa_metric,
                             [metric, domains, langs, models, search_bar, show_anonymous, show_rev_ts],
-                            lb_table,
+                            qa_df_elem_ret_rerank,
                             queue=True,
                         )
 
                     with gr.TabItem("Retrieval Only", id=11):
                         with gr.Row():
                             with gr.Column(scale=1):
-                                search_bar_retriever = get_search_bar()
+                                search_bar_ret = get_search_bar()
                             with gr.Column(scale=1):
-                                selected_noreranker = get_noreranking_dropdown()
+                                models_ret = get_noreranking_dropdown()
 
-                        lb_df_retriever = datastore.qa_fmt_df[
-                            datastore.qa_fmt_df[COL_NAME_RERANKING_MODEL] == "NoReranker"
-                            ]
-                        lb_df_retriever = reset_rank(lb_df_retriever)
-                        lb_table_retriever = get_leaderboard_table(lb_df_retriever, datastore.qa_types)
+                        _qa_df_ret = datastore.qa_fmt_df[datastore.qa_fmt_df[COL_NAME_RERANKING_MODEL] == "NoReranker"]
+                        _qa_df_ret = reset_rank(_qa_df_ret)
+                        qa_df_elem_ret = get_leaderboard_table(_qa_df_ret, datastore.qa_types)
 
                         # Dummy leaderboard for handling the case when the user uses backspace key
-                        hidden_lb_df_retriever = datastore.qa_raw_df[
-                            datastore.qa_raw_df[COL_NAME_RERANKING_MODEL] == "NoReranker"
-                            ]
-                        hidden_lb_df_retriever = reset_rank(hidden_lb_df_retriever)
-                        hidden_lb_table_retriever = get_leaderboard_table(
-                            hidden_lb_df_retriever, datastore.qa_types, visible=False
-                        )
+                        _qa_df_ret_hidden = datastore.qa_raw_df[datastore.qa_raw_df[COL_NAME_RERANKING_MODEL] == "NoReranker"]
+                        _qa_df_ret_hidden = reset_rank(_qa_df_ret_hidden)
+                        qa_df_elem_ret_hidden = get_leaderboard_table(_qa_df_ret_hidden, datastore.qa_types, visible=False)
 
                         version.change(
                             update_qa_version,
-                            [
-                                version,
-                            ],
-                            [
-                                domains,
-                                langs,
-                                selected_noreranker,
-                                lb_table_retriever,
-                                hidden_lb_table_retriever,
-                            ],
+                            version,
+                            [domains, langs, models_ret, qa_df_elem_ret, qa_df_elem_ret_hidden, ],
                         )
 
                         set_listeners(
                             "qa",
-                            lb_table_retriever,
-                            hidden_lb_table_retriever,
-                            search_bar_retriever,
+                            qa_df_elem_ret,
+                            qa_df_elem_ret_hidden,
+                            search_bar_ret,
                             version,
                             domains,
                             langs,
-                            selected_noreranker,
+                            models_ret,
                             show_anonymous,
                             show_rev_ts,
                         )
 
-                        # set metric listener
                         metric.change(
                             update_qa_metric,
                             [
                                 metric,
                                 domains,
                                 langs,
-                                selected_noreranker,
-                                search_bar_retriever,
+                                models_ret,
+                                search_bar_ret,
                                 show_anonymous,
                                 show_rev_ts,
                             ],
-                            lb_table_retriever,
+                            qa_df_elem_ret,
                             queue=True,
                         )
+
                     with gr.TabItem("Reranking Only", id=12):
-                        lb_df_reranker = datastore.qa_fmt_df[
+                        _qa_df_rerank = datastore.qa_fmt_df[
                             datastore.qa_fmt_df[COL_NAME_RETRIEVAL_MODEL] == BM25_LINK
                             ]
-                        lb_df_reranker = reset_rank(lb_df_reranker)
-                        reranking_models_reranker = (
-                            lb_df_reranker[COL_NAME_RERANKING_MODEL].apply(remove_html).unique().tolist()
+                        _qa_df_rerank = reset_rank(_qa_df_rerank)
+                        qa_rerank_models = (
+                            _qa_df_rerank[COL_NAME_RERANKING_MODEL].apply(remove_html).unique().tolist()
                         )
                         with gr.Row():
                             with gr.Column(scale=1):
-                                selected_rerankings_reranker = get_reranking_dropdown(reranking_models_reranker)
+                                qa_models_rerank = get_reranking_dropdown(qa_rerank_models)
                             with gr.Column(scale=1):
-                                search_bar_reranker = gr.Textbox(show_label=False, visible=False)
-                        lb_table_reranker = get_leaderboard_table(lb_df_reranker, datastore.qa_types)
+                                qa_search_bar_rerank = gr.Textbox(show_label=False, visible=False)
+                        qa_df_elem_rerank = get_leaderboard_table(_qa_df_rerank, datastore.qa_types)
 
-                        hidden_lb_df_reranker = datastore.qa_raw_df[
+                        _qa_df_rerank_hidden = datastore.qa_raw_df[
                             datastore.qa_raw_df[COL_NAME_RETRIEVAL_MODEL] == BM25_LINK
                             ]
-                        hidden_lb_df_reranker = reset_rank(hidden_lb_df_reranker)
-                        hidden_lb_table_reranker = get_leaderboard_table(
-                            hidden_lb_df_reranker, datastore.qa_types, visible=False
+                        _qa_df_rerank_hidden = reset_rank(_qa_df_rerank_hidden)
+                        qa_df_elem_rerank_hidden = get_leaderboard_table(
+                            _qa_df_rerank_hidden, datastore.qa_types, visible=False
                         )
 
                         version.change(
                             update_qa_version,
-                            [
-                                version,
-                            ],
-                            [
-                                domains,
-                                langs,
-                                selected_rerankings_reranker,
-                                lb_table_reranker,
-                                hidden_lb_table_reranker,
-                            ],
+                            version,
+                            [domains, langs, qa_models_rerank, qa_df_elem_rerank, qa_df_elem_rerank_hidden],
                         )
 
                         set_listeners(
                             "qa",
-                            lb_table_reranker,
-                            hidden_lb_table_reranker,
-                            search_bar_reranker,
+                            qa_df_elem_rerank,
+                            qa_df_elem_rerank_hidden,
+                            qa_search_bar_rerank,
                             version,
                             domains,
                             langs,
-                            selected_rerankings_reranker,
+                            qa_models_rerank,
                             show_anonymous,
                             show_rev_ts,
                         )
-                        # set metric listener
+
                         metric.change(
                             update_qa_metric,
                             [
                                 metric,
                                 domains,
                                 langs,
-                                selected_rerankings_reranker,
-                                search_bar_reranker,
+                                qa_models_rerank,
+                                qa_search_bar_rerank,
                                 show_anonymous,
                                 show_rev_ts,
                             ],
-                            lb_table_reranker,
+                            qa_df_elem_rerank,
                             queue=True,
                         )
             with gr.TabItem("Long Doc", elem_id="long-doc-benchmark-tab-table", id=1):
@@ -354,33 +332,25 @@ with demo:
                             with gr.Column():
                                 models = get_reranking_dropdown(datastore.reranking_models)
 
-                        lb_table_long_doc = get_leaderboard_table(
+                        doc_df_elem_ret_rerank = get_leaderboard_table(
                             datastore.doc_fmt_df, datastore.doc_types
                         )
 
                         # Dummy leaderboard for handling the case when the user uses backspace key
-                        hidden_lb_table_long_doc = get_leaderboard_table(
+                        doc_df_elem_ret_rerank_hidden = get_leaderboard_table(
                             datastore.doc_raw_df, datastore.doc_types, visible=False
                         )
 
                         version.change(
                             update_doc_version,
-                            [
-                                version,
-                            ],
-                            [
-                                domains,
-                                langs,
-                                models,
-                                lb_table_long_doc,
-                                hidden_lb_table_long_doc,
-                            ],
+                            version,
+                            [domains, langs, models, doc_df_elem_ret_rerank, doc_df_elem_ret_rerank_hidden],
                         )
 
                         set_listeners(
                             "long-doc",
-                            lb_table_long_doc,
-                            hidden_lb_table_long_doc,
+                            doc_df_elem_ret_rerank,
+                            doc_df_elem_ret_rerank_hidden,
                             search_bar,
                             version,
                             domains,
@@ -402,54 +372,47 @@ with demo:
                                 show_anonymous,
                                 show_rev_ts,
                             ],
-                            lb_table_long_doc,
+                            doc_df_elem_ret_rerank,
                             queue=True,
                         )
                     with gr.TabItem("Retrieval Only", id=21):
                         with gr.Row():
                             with gr.Column(scale=1):
-                                search_bar_retriever = get_search_bar()
+                                search_bar_ret = get_search_bar()
                             with gr.Column(scale=1):
-                                selected_noreranker = get_noreranking_dropdown()
-                        lb_df_retriever_long_doc = datastore.doc_fmt_df[
+                                models_ret = get_noreranking_dropdown()
+
+                        _doc_df_ret = datastore.doc_fmt_df[
                             datastore.doc_fmt_df[COL_NAME_RERANKING_MODEL] == "NoReranker"
                             ]
-                        lb_df_retriever_long_doc = reset_rank(lb_df_retriever_long_doc)
-                        lb_table_retriever_long_doc = get_leaderboard_table(
-                            lb_df_retriever_long_doc, datastore.doc_types
+                        _doc_df_ret = reset_rank(_doc_df_ret)
+                        doc_df_elem_ret = get_leaderboard_table(
+                            _doc_df_ret, datastore.doc_types
                         )
 
-                        hidden_lb_df_retriever_long_doc = datastore.doc_raw_df[
+                        _doc_df_ret_hidden = datastore.doc_raw_df[
                             datastore.doc_raw_df[COL_NAME_RERANKING_MODEL] == "NoReranker"
                             ]
-                        hidden_lb_df_retriever_long_doc = reset_rank(hidden_lb_df_retriever_long_doc)
-                        hidden_lb_table_retriever_long_doc = get_leaderboard_table(
-                            hidden_lb_df_retriever_long_doc, datastore.doc_types, visible=False
+                        _doc_df_ret_hidden = reset_rank(_doc_df_ret_hidden)
+                        doc_df_elem_ret_hidden = get_leaderboard_table(
+                            _doc_df_ret_hidden, datastore.doc_types, visible=False
                         )
 
                         version.change(
                             update_doc_version,
-                            [
-                                version,
-                            ],
-                            [
-                                domains,
-                                langs,
-                                selected_noreranker,
-                                lb_table_retriever_long_doc,
-                                hidden_lb_table_retriever_long_doc,
-                            ],
+                            version,
+                            [domains, langs, models_ret, doc_df_elem_ret, doc_df_elem_ret_hidden],
                         )
 
                         set_listeners(
                             "long-doc",
-                            lb_table_retriever_long_doc,
-                            hidden_lb_table_retriever_long_doc,
-                            search_bar_retriever,
+                            doc_df_elem_ret,
+                            doc_df_elem_ret_hidden,
+                            search_bar_ret,
                             version,
                             domains,
                             langs,
-                            selected_noreranker,
+                            models_ret,
                             show_anonymous,
                             show_rev_ts,
                         )
@@ -460,76 +423,69 @@ with demo:
                                 metric,
                                 domains,
                                 langs,
-                                selected_noreranker,
-                                search_bar_retriever,
+                                models_ret,
+                                search_bar_ret,
                                 show_anonymous,
                                 show_rev_ts,
                             ],
-                            lb_table_retriever_long_doc,
+                            doc_df_elem_ret,
                             queue=True,
                         )
                     with gr.TabItem("Reranking Only", id=22):
-                        lb_df_reranker_ldoc = datastore.doc_fmt_df[
+                        _doc_df_rerank = datastore.doc_fmt_df[
                             datastore.doc_fmt_df[COL_NAME_RETRIEVAL_MODEL] == BM25_LINK
                             ]
-                        lb_df_reranker_ldoc = reset_rank(lb_df_reranker_ldoc)
-                        reranking_models_reranker_ldoc = (
-                            lb_df_reranker_ldoc[COL_NAME_RERANKING_MODEL].apply(remove_html).unique().tolist()
+                        _doc_df_rerank = reset_rank(_doc_df_rerank)
+                        doc_rerank_models = (
+                            _doc_df_rerank[COL_NAME_RERANKING_MODEL].apply(remove_html).unique().tolist()
                         )
                         with gr.Row():
                             with gr.Column(scale=1):
-                                selected_rerankings_reranker_ldoc = get_reranking_dropdown(
-                                    reranking_models_reranker_ldoc
+                                doc_models_rerank = get_reranking_dropdown(
+                                    doc_rerank_models
                                 )
                             with gr.Column(scale=1):
-                                search_bar_reranker_ldoc = gr.Textbox(show_label=False, visible=False)
-                        lb_table_reranker_ldoc = get_leaderboard_table(lb_df_reranker_ldoc, datastore.doc_types)
-                        hidden_lb_df_reranker_ldoc = datastore.doc_raw_df[
+                                doc_search_bar_rerank = gr.Textbox(show_label=False, visible=False)
+                        doc_df_elem_rerank = get_leaderboard_table(_doc_df_rerank, datastore.doc_types)
+                        _doc_df_rerank_hidden = datastore.doc_raw_df[
                             datastore.doc_raw_df[COL_NAME_RETRIEVAL_MODEL] == BM25_LINK
                             ]
-                        hidden_lb_df_reranker_ldoc = reset_rank(hidden_lb_df_reranker_ldoc)
-                        hidden_lb_table_reranker_ldoc = get_leaderboard_table(
-                            hidden_lb_df_reranker_ldoc, datastore.doc_types, visible=False
+                        _doc_df_rerank_hidden = reset_rank(_doc_df_rerank_hidden)
+                        doc_df_elem_rerank_hidden = get_leaderboard_table(
+                            _doc_df_rerank_hidden, datastore.doc_types, visible=False
                         )
 
                         version.change(
                             update_doc_version,
-                            [
-                                version,
-                            ],
-                            [
-                                domains,
-                                langs,
-                                selected_rerankings_reranker_ldoc,
-                                lb_table_reranker_ldoc,
-                                hidden_lb_table_reranker_ldoc,
-                            ],
+                            version,
+                            [domains, langs, doc_models_rerank, doc_df_elem_rerank, doc_df_elem_rerank_hidden],
                         )
 
                         set_listeners(
                             "long-doc",
-                            lb_table_reranker_ldoc,
-                            hidden_lb_table_reranker_ldoc,
-                            search_bar_reranker_ldoc,
+                            doc_df_elem_rerank,
+                            doc_df_elem_rerank_hidden,
+                            doc_search_bar_rerank,
                             version,
                             domains,
                             langs,
-                            selected_rerankings_reranker_ldoc,
+                            doc_models_rerank,
                             show_anonymous,
                             show_rev_ts,
                         )
+
                         metric.change(
                             update_doc_metric,
                             [
                                 metric,
                                 domains,
                                 langs,
-                                selected_rerankings_reranker_ldoc,
-                                search_bar_reranker_ldoc,
+                                doc_models_rerank,
+                                doc_search_bar_rerank,
                                 show_anonymous,
                                 show_rev_ts,
                             ],
-                            lb_table_reranker_ldoc,
+                            doc_df_elem_rerank,
                             queue=True,
                         )