Updated project homepage

app.py

@@ -100,7 +100,7 @@ with gr.Blocks(css=css) as demo:
     with gr.Column(elem_id="col-container"):
         gr.Markdown("""# 🏟 ChatArena️<br>
 Prompting multiple AI agents to play games in a language-driven environment. 
-**[Project Homepage](https://github.com/chatarena/chatarena)**""", elem_id="header")
+**[Project Homepage](https://www.chatarena.org)**""", elem_id="header")
 
         with gr.Row():
             env_selector = gr.Dropdown(choices=list(ENV_REGISTRY.keys()), value=DEFAULT_ENV, interactive=True,
@@ -117,7 +117,8 @@ Prompting multiple AI agents to play games in a language-driven environment.
         with gr.Row():
             with gr.Column(elem_id="col-chatbox"):
                 with gr.Tab("All", visible=True):
-                    chatbot = gr.Chatbot(elem_id="chatbox", visible=True, show_label=False)
+                    chatbot = gr.Chatbot(
+                        elem_id="chatbox", visible=True, show_label=False)
 
                 player_chatbots = []
                 for i in range(MAX_NUM_PLAYERS):
@@ -131,7 +132,8 @@ Prompting multiple AI agents to play games in a language-driven environment.
 
             with gr.Column(elem_id="col-config"):  # Player Configuration
                 # gr.Markdown("Player Configuration")
-                parallel_checkbox = gr.Checkbox(label="Parallel Actions", value=False, visible=True)
+                parallel_checkbox = gr.Checkbox(
+                    label="Parallel Actions", value=False, visible=True)
                 with gr.Accordion("Moderator", open=False, visible=True):
                     moderator_components = get_moderator_components(True)
                 all_components += [parallel_checkbox, *moderator_components]
@@ -143,14 +145,14 @@ Prompting multiple AI agents to play games in a language-driven environment.
                     for i in range(MAX_NUM_PLAYERS):
                         player_name = f"Player {i + 1}"
                         with gr.Tab(player_name, visible=(i < DEFAULT_NUM_PLAYERS)) as tab:
-                            player_comps = get_player_components(player_name, visible=(i < DEFAULT_NUM_PLAYERS))
+                            player_comps = get_player_components(
+                                player_name, visible=(i < DEFAULT_NUM_PLAYERS))
 
                         players_idx2comp[i] = player_comps + [tab]
                         all_players_components += player_comps + [tab]
 
                 all_components += [num_player_slider] + all_players_components
 
-
                 def variable_players(k):
                     k = int(k)
                     update_dict = {}
@@ -158,15 +160,17 @@ Prompting multiple AI agents to play games in a language-driven environment.
                         if i < k:
                             for comp in players_idx2comp[i]:
                                 update_dict[comp] = gr.update(visible=True)
-                            update_dict[player_chatbots[i]] = gr.update(visible=True)
+                            update_dict[player_chatbots[i]
+                                        ] = gr.update(visible=True)
                         else:
                             for comp in players_idx2comp[i]:
                                 update_dict[comp] = gr.update(visible=False)
-                            update_dict[player_chatbots[i]] = gr.update(visible=False)
+                            update_dict[player_chatbots[i]
+                                        ] = gr.update(visible=False)
                     return update_dict
 
-
-                num_player_slider.change(variable_players, num_player_slider, all_players_components + player_chatbots)
+                num_player_slider.change(
+                    variable_players, num_player_slider, all_players_components + player_chatbots)
 
                 human_input_textbox = gr.Textbox(show_label=True, label="Human Input", lines=1, visible=True,
                                                  interactive=True, placeholder="Enter your input here")
@@ -176,14 +180,16 @@ Prompting multiple AI agents to play games in a language-driven environment.
 
                 all_components += [human_input_textbox, btn_step, btn_restart]
 
-
     def _convert_to_chatbot_output(all_messages, display_recv=False):
         chatbot_output = []
         for i, message in enumerate(all_messages):
-            agent_name, msg, recv = message.agent_name, message.content, str(message.visible_to)
-            new_msg = re.sub(r'\n+', '<br>', msg.strip())  # Preprocess message for chatbot output
+            agent_name, msg, recv = message.agent_name, message.content, str(
+                message.visible_to)
+            # Preprocess message for chatbot output
+            new_msg = re.sub(r'\n+', '<br>', msg.strip())
             if display_recv:
-                new_msg = f"**{agent_name} (-> {recv})**: {new_msg}"  # Add role to the message
+                # Add role to the message
+                new_msg = f"**{agent_name} (-> {recv})**: {new_msg}"
             else:
                 new_msg = f"**{agent_name}**: {new_msg}"
 
@@ -193,7 +199,6 @@ Prompting multiple AI agents to play games in a language-driven environment.
                 chatbot_output.append((None, new_msg))
         return chatbot_output
 
-
     def _create_arena_config_from_components(all_comps: dict) -> ArenaConfig:
         env_desc = all_comps[env_desc_textbox]
 
@@ -240,10 +245,10 @@ Prompting multiple AI agents to play games in a language-driven environment.
         }
 
         # arena_config = {"players": player_configs, "environment": env_config}
-        arena_config = ArenaConfig(players=player_configs, environment=env_config)
+        arena_config = ArenaConfig(
+            players=player_configs, environment=env_config)
         return arena_config
 
-
     def step_game(all_comps: dict):
         yield {btn_step: gr.update(value="Running...", interactive=False),
                btn_restart: gr.update(interactive=False)}
@@ -283,14 +288,16 @@ Prompting multiple AI agents to play games in a language-driven environment.
             all_messages = timestep.observation  # user sees what the moderator sees
             log_messages(arena, all_messages, database=DB)
 
-            chatbot_output = _convert_to_chatbot_output(all_messages, display_recv=True)
+            chatbot_output = _convert_to_chatbot_output(
+                all_messages, display_recv=True)
             update_dict = {human_input_textbox: gr.Textbox.update(value=""),
                            chatbot: chatbot_output,
                            btn_step: gr.update(value="Next Step", interactive=not timestep.terminal),
                            btn_restart: gr.update(interactive=True), state: cur_state}
             # Get the visible messages for each player
             for i, player in enumerate(arena.players):
-                player_messages = arena.environment.get_observation(player.name)
+                player_messages = arena.environment.get_observation(
+                    player.name)
                 player_output = _convert_to_chatbot_output(player_messages)
                 # Update the player's chatbot output
                 update_dict[player_chatbots[i]] = player_output
@@ -300,7 +307,6 @@ Prompting multiple AI agents to play games in a language-driven environment.
 
             yield update_dict
 
-
     def restart_game(all_comps: dict):
         cur_state = all_comps[state]
         cur_state["arena"] = None
@@ -315,9 +321,9 @@ Prompting multiple AI agents to play games in a language-driven environment.
         yield {btn_step: gr.update(value="Start", interactive=True),
                btn_restart: gr.update(interactive=True), state: cur_state}
 
-
     # Remove Accordion and Tab from the list of components
-    all_components = [comp for comp in all_components if not isinstance(comp, (gr.Accordion, gr.Tab))]
+    all_components = [comp for comp in all_components if not isinstance(
+        comp, (gr.Accordion, gr.Tab))]
 
     # If any of the Textbox, Slider, Checkbox, Dropdown, RadioButtons is changed, the Step button is disabled
     for comp in all_components:
@@ -327,7 +333,6 @@ Prompting multiple AI agents to play games in a language-driven environment.
             else:
                 return gr.update()
 
-
         if isinstance(comp,
                       (gr.Textbox, gr.Slider, gr.Checkbox, gr.Dropdown, gr.Radio)) and comp is not human_input_textbox:
             comp.change(_disable_step_button, state, btn_step)
@@ -337,8 +342,8 @@ Prompting multiple AI agents to play games in a language-driven environment.
     btn_restart.click(restart_game, set(all_components + [state]),
                       [chatbot, *player_chatbots, btn_step, btn_restart, state, human_input_textbox])
 
-
     # If an example is selected, update the components
+
     def update_components_from_example(all_comps: dict):
         example_name = all_comps[example_selector]
         example_config = EXAMPLE_REGISTRY[example_name]
@@ -346,36 +351,48 @@ Prompting multiple AI agents to play games in a language-driven environment.
 
         # Update the environment components
         env_config = example_config['environment']
-        update_dict[env_desc_textbox] = gr.update(value=example_config['global_prompt'])
+        update_dict[env_desc_textbox] = gr.update(
+            value=example_config['global_prompt'])
         update_dict[env_selector] = gr.update(value=env_config['env_type'])
-        update_dict[parallel_checkbox] = gr.update(value=env_config['parallel'])
+        update_dict[parallel_checkbox] = gr.update(
+            value=env_config['parallel'])
 
         # Update the moderator components
         if "moderator" in env_config:
             mod_role_desc, mod_terminal_condition, moderator_backend_type, mod_temp, mod_max_tokens = [
                 c for c in moderator_components if not isinstance(c, (gr.Accordion, gr.Tab))
             ]
-            update_dict[mod_role_desc] = gr.update(value=env_config['moderator']['role_desc'])
-            update_dict[mod_terminal_condition] = gr.update(value=env_config['moderator']['terminal_condition'])
-            update_dict[moderator_backend_type] = gr.update(value=env_config['moderator']['backend']['backend_type'])
-            update_dict[mod_temp] = gr.update(value=env_config['moderator']['backend']['temperature'])
-            update_dict[mod_max_tokens] = gr.update(value=env_config['moderator']['backend']['max_tokens'])
+            update_dict[mod_role_desc] = gr.update(
+                value=env_config['moderator']['role_desc'])
+            update_dict[mod_terminal_condition] = gr.update(
+                value=env_config['moderator']['terminal_condition'])
+            update_dict[moderator_backend_type] = gr.update(
+                value=env_config['moderator']['backend']['backend_type'])
+            update_dict[mod_temp] = gr.update(
+                value=env_config['moderator']['backend']['temperature'])
+            update_dict[mod_max_tokens] = gr.update(
+                value=env_config['moderator']['backend']['max_tokens'])
 
         # Update the player components
-        update_dict[num_player_slider] = gr.update(value=len(example_config['players']))
+        update_dict[num_player_slider] = gr.update(
+            value=len(example_config['players']))
         for i, player_config in enumerate(example_config['players']):
             role_desc, backend_type, temperature, max_tokens = [
                 c for c in players_idx2comp[i] if not isinstance(c, (gr.Accordion, gr.Tab))
             ]
-            update_dict[role_desc] = gr.update(value=player_config['role_desc'])
-            update_dict[backend_type] = gr.update(value=player_config['backend']['backend_type'])
-            update_dict[temperature] = gr.update(value=player_config['backend']['temperature'])
-            update_dict[max_tokens] = gr.update(value=player_config['backend']['max_tokens'])
+            update_dict[role_desc] = gr.update(
+                value=player_config['role_desc'])
+            update_dict[backend_type] = gr.update(
+                value=player_config['backend']['backend_type'])
+            update_dict[temperature] = gr.update(
+                value=player_config['backend']['temperature'])
+            update_dict[max_tokens] = gr.update(
+                value=player_config['backend']['max_tokens'])
 
         return update_dict
 
-
-    example_selector.change(update_components_from_example, set(all_components + [state]), all_components + [state])
+    example_selector.change(update_components_from_example, set(
+        all_components + [state]), all_components + [state])
 
 demo.queue()
 demo.launch(debug=DEBUG)