feat: Updated arena format

app.py

@@ -44,45 +44,53 @@ def new_comparison(dialog_dict: dict) -> Tuple[str, str, str, str, gr.Row, gr.Ro
 
 
 
-def record_vote(choice: str, 
-                m1: str,
-                m2: str,
-                d1: str,
-                d2: str,
-                dialog_dict: dict,
-                is_dev: bool,
-                result_file_path: Optional[str] = None) -> Tuple[str, str, str, str, gr.Row, str, gr.Button]:
+def update_scores(score_a: Optional[int],
+                  score_b: Optional[int],
+                  m1: str,
+                  m2: str,
+                  d1: str,
+                  d2: str,
+                  dialog_dict: dict,
+                  score_state: dict,
+                  result_file_path: str):
     """
-    Record the user's vote and generate a new comparison.
-
-    Args:
-        choice (str): User's choice ('A' or 'B').
-        m1 (str): Model 1 name.
-        m2 (str): Model 2 name.
-        d1 (str): Dialog 1.
-        d2 (str): Dialog 2.
-        dialog_dict (dict): Dictionary of dialogs per model.
-        is_dev (bool): Flag indicating if in development mode.
-        result_file_path (str, optional): Path to save the results.
-
-    Returns:
-        Tuple[str, str, str, str, gr.Row, str, gr.Button]:
-            (New model1 name, new dialog1, new model2 name, new dialog2, arena row visibility update, message)
+    Update score_state. If both scores exist, record and sample new dialog pair.
     """
-    log(f"{choice=} | A: {m1} vs B: {m2}")
-
-    # Vote data saving
-    if not is_dev:
+    scores = score_state.copy()
+    if score_a is not None:
+        scores["A"] = score_a
+    if score_b is not None:
+        scores["B"] = score_b
+    print(scores)
+
+    # Save the data
+    if "A" in scores and "B" in scores:
+        # if not is_dev:
         with open(result_file_path, "a") as f:
-            if choice == "A":
-                f.write(f"1\t0\t{m1}\t{m2}\n")
-            else:
-                f.write(f"0\t1\t{m1}\t{m2}\n")
-
-    # New pair sampling
-    new_m1, new_d1, new_m2, new_d2 = sample_pair(dialog_dict)
+            f.write(f"{scores['A']}\t{scores['B']}\t{m1}\t{m2}\n")
+
+        new_m1, new_d1, new_m2, new_d2 = sample_pair(dialog_dict)
+        return (
+            new_m1, new_d1, new_m2, new_d2, 
+            gr.update(visible=True),    # arena
+            gr.update(visible=False),   # rate A button
+            gr.update(visible=False),   # rate B button
+            gr.update(visible=True),    # vote A button
+            gr.update(visible=True),    # vote B button
+            "✅ Both scores recorded!", {}
+        )
     
-    return new_m1, new_d1, new_m2, new_d2, gr.update(visible=True), "✅ Vote recorded! Next comparison ready!"
+    # Waiting the other score
+    else:
+        return (
+            m1, d1, m2, d2, 
+            gr.update(visible=True),    # arena
+            gr.update(visible=True),    # rate A button
+            gr.update(visible=True),    # rate B button
+            gr.update(visible=False),   # vote A button
+            gr.update(visible=False),   # vote B button
+            "🕐 Waiting for the other score...", scores
+        )
 
 
 
@@ -139,20 +147,28 @@ with gr.Blocks(title="1:1 Outpatient Model Simulation Arena", css=css) as demo:
 
     # New comparison button
     btn_new = gr.Button("🥊 Start Arena!! 🥊")
-    msg = gr.Markdown("")
     state_dict = gr.State(dialog_dict)
 
     # Showing two model simulations side by side
     with gr.Row(visible=False) as arena_row:
         with gr.Column():
             model1_name = gr.Textbox(label="Model A", interactive=False, visible=is_dev)
-            dialog1_box = gr.Markdown(label="Simulation A", elem_classes="dialog-box")  # Textbox → Markdown
-            vote1 = gr.Button("👍 Choose A")
+            dialog1_box = gr.Markdown(label="Simulation A", elem_classes="dialog-box")
+            with gr.Row(visible=True) as vote1_row:
+                vote1 = gr.Button("👍 Choose A")
+            with gr.Row(visible=False) as scoreA_row:
+                scoreA_buttons = [gr.Button(str(i)) for i in range(1, 6)]
 
         with gr.Column():
             model2_name = gr.Textbox(label="Model B", interactive=False, visible=is_dev)
-            dialog2_box = gr.Markdown(label="Simulation B", elem_classes="dialog-box")  # Textbox → Markdown
-            vote2 = gr.Button("👍 Choose B")
+            dialog2_box = gr.Markdown(label="Simulation B", elem_classes="dialog-box")
+            with gr.Row(visible=True) as vote2_row:
+                vote2 = gr.Button("👍 Choose B")
+            with gr.Row(visible=False) as scoreB_row:
+                scoreB_buttons = [gr.Button(str(i)) for i in range(1, 6)]
+    
+    # Showing the status
+    msg = gr.Markdown("")
 
     # Submit button
     with gr.Row(visible=False) as submit_row:
@@ -166,23 +182,37 @@ with gr.Blocks(title="1:1 Outpatient Model Simulation Arena", css=css) as demo:
         outputs=[model1_name, dialog1_box, model2_name, dialog2_box, arena_row, submit_row, btn_new],
     )
 
+    # First step: Arena, Choose the only one!
     vote1.click(
-        fn=lambda m1, m2, d1, d2, state, is_dev=is_dev, result_file_path=result_save_path: record_vote("A", m1, m2, d1, d2, state, is_dev, result_file_path),
-        inputs=[model1_name, model2_name, dialog1_box, dialog2_box, state_dict],
-        outputs=[model1_name, dialog1_box, model2_name, dialog2_box, arena_row, msg],
+        fn=lambda: [gr.update(visible=True), gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)],
+        inputs=[],
+        outputs=[scoreA_row, scoreB_row, vote1_row, vote2_row],
     )
-
     vote2.click(
-        fn=lambda m1, m2, d1, d2, state, is_dev=is_dev, result_file_path=result_save_path: record_vote("B", m1, m2, d1, d2, state, is_dev, result_file_path),
-        inputs=[model1_name, model2_name, dialog1_box, dialog2_box, state_dict],
-        outputs=[model1_name, dialog1_box, model2_name, dialog2_box, arena_row, msg],
+        fn=lambda: [gr.update(visible=True), gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)],
+        inputs=[],
+        outputs=[scoreA_row, scoreB_row, vote1_row, vote2_row],
     )
 
-    submit_btn.click(
-        fn=save_data,
-        inputs=[gr.State(result_save_path)],
-        outputs=[submit_msg],
-    )
+    # Second step: Rate, Rate the each score!
+    score_state = gr.State({})
+    for btn in scoreA_buttons:
+        btn.click(
+            fn=lambda score, m1, m2, d1, d2, scores: update_scores(int(score), None, m1, m2, d1, d2, dialog_dict, scores, is_dev, result_save_path),
+            inputs=[gr.State(btn.value), model1_name, model2_name, dialog1_box, dialog2_box, score_state],
+            outputs=[model1_name, dialog1_box, model2_name, dialog2_box, arena_row, scoreA_row, scoreB_row, vote1_row, vote2_row, msg, score_state],
+        )
+    for btn in scoreB_buttons:
+        btn.click(
+            fn=lambda score, m1, m2, d1, d2, scores: update_scores(None, int(score), m1, m2, d1, d2, dialog_dict, scores, is_dev, result_save_path),
+            inputs=[gr.State(btn.value), model1_name, model2_name, dialog1_box, dialog2_box, score_state],
+            outputs=[model1_name, dialog1_box, model2_name, dialog2_box, arena_row, scoreA_row, scoreB_row, vote1_row, vote2_row, msg, score_state],
+        )
+        submit_btn.click(
+            fn=save_data,
+            inputs=[gr.State(result_save_path)],
+            outputs=[submit_msg],
+        )
 
 # Launch the app
 if is_dev:

utils/__init__.py

@@ -5,7 +5,6 @@ import logging.config
 
 base_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 try:
-    print(base_path)
     version_file_path = os.path.join(base_path, 'version.txt')
     LOGGING_NAME = f"Simulation_Arena_{open(version_file_path).read().strip()}"
 except: