changes

README.md

@@ -1,13 +1,11 @@
 ---
-title: Gpt Who
-emoji: 🐠
-colorFrom: green
-colorTo: green
+title: Gpt Who?
+emoji: 🦹🏼
+colorFrom: white
+colorTo: purple
 sdk: gradio
 sdk_version: 3.23.0
-app_file: app.py
+app_file: run.py
 pinned: false
 license: openrail
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

game_manager.py

@@ -0,0 +1,212 @@
+import threading
+import openai
+import os
+import time
+import random
+
+openai.api_key = os.environ["OPENAI_KEY"]
+
+games = {}
+all_games_lock = threading.Lock()
+TIME_TO_SUBMIT = 30
+TIME_TO_VOTE = 30
+TIME_TO_REVEAL = 10
+
+GUESS_AI_PTS = 2
+GUESSED_AS_AI_PTS = 1
+
+with open("prompt.txt", "r") as f:
+    PROMPT = f.read()
+
+
+def new_minigame():
+    return "Write a poem about mice!"
+
+
+def ai_response(question):
+    prompt = PROMPT.format(
+        question,
+    )
+    completions = openai.Completion.create(
+        engine="gpt-3.5-turbo", prompt=prompt, max_tokens=200, n=1, temperature=0.5
+    )
+    response = completions["choices"][0]["text"]
+    return response
+
+
+class Game:
+    def __init__(self, room_name):
+        self.room_name = room_name
+        self.command = None
+        self.players = []
+        self.prompts = []
+        self.prompts_completed = 0
+        self.responses = {}
+        self.response_list = []
+        self.ai_response_index = None
+        self.lock = threading.Lock()
+        self.started = False
+        self.stage = None
+        self.stage_start_time = None
+        self.stage_time_remaining = None
+        self.total_stage_time = None
+        self.complete = False
+        self.last_update_index = 0
+        self.input_allowed = False
+        self.last_update_time = time.time()
+        self.chat = []
+        self.player_status = {}
+        self.player_scores = {}
+        self.player_guess = {}
+        self.ai_answer = None
+
+        games[room_name] = self
+
+    def update(self):
+        self.last_update_index += 1
+        self.last_update_time = time.time()
+
+    def start(self):
+        self.started = True
+        self.stage = "START"
+        self.update()
+
+    def get_player_state(self):
+        return [
+            [player, self.player_status[player], self.player_scores[player]]
+            for player in self.players
+        ]
+
+    def format_chat(self, player_name):
+        formatted_chat = [[None, self.command]]
+        if self.stage == "COLLECTING_RESPONSSES":
+            if player_name in self.responses:
+                formatted_chat.append([self.responses[player_name], None])
+        elif self.stage == "COLLECTING_VOTES":
+            for msg_player, msg in self.response_list:
+                if msg_player == player_name:
+                    formatted_chat.append([msg, None])
+                else:
+                    formatted_chat.append([None, msg])
+        elif self.stage == "REVEALING":
+            for msg_player, msg in self.response_list:
+                output_msg = f"**{msg_player or 'GPT'}**: {msg}\nGuessed by: {', '.join(player for player, guess in self.player_guess.items() if guess == msg_player)}"
+                if msg_player == player_name:
+                    formatted_chat.append([output_msg, None])
+                else:
+                    formatted_chat.append([None, output_msg])
+        return formatted_chat
+
+    def add_player(self, player_name, player_prompt):
+        with self.lock:
+            self.players.append(player_name)
+            self.prompts.append(player_prompt)
+            self.player_status[player_name] = None
+            self.player_scores[player_name] = 0
+            if len(self.players) == 1:
+                self.command = f"You have entered the game."
+            else:
+                self.command = f"{', '.join(self.players[:-1])} and {self.players[-1]} are in this room."
+            self.update()
+
+    def add_chat(self, player, message):
+        with self.lock:
+            self.player_status[player] = "Submitted"
+            self.responses[player] = message
+
+    def select_chat(self, player, index):
+        with self.lock:
+            if self.stage != "COLLECTING_VOTES":
+                return
+            index = index - 1
+            selected_player = self.response_list[index][0]
+            self.player_guess[player] = selected_player
+            self.player_status[player] = "Voted"
+
+
+def new_game(room_name):
+    with all_games_lock:
+        if room_name in games:
+            game = games[room_name]
+            return game
+        return Game(room_name)
+
+
+def game_thread():
+    while True:
+        now = time.time()
+        for room_name, game in games.items():
+            if not game.started or game.complete:
+                continue
+            with game.lock:
+                if game.stage == "START":
+                    prompt = game.prompts[game.prompts_completed]
+                    game.command = (
+                        f"**{game.players[game.prompts_completed]}**: {prompt}"
+                    )
+                    game.input_allowed = True
+                    game.player_status = {player: None for player in game.players}
+                    game.player_guess = {player: None for player in game.players}
+                    game.ai_answer = ai_response(prompt)
+                    game.stage = "COLLECTING_RESPONSES"
+                    game.responses = {}
+                    game.stage_start_time = now
+                    game.total_stage_time = TIME_TO_SUBMIT
+                    game.stage_time_remaining = TIME_TO_SUBMIT
+                    game.update()
+
+                stage_time_remaining = int(
+                    game.total_stage_time - (now - game.stage_start_time)
+                )
+                if stage_time_remaining != game.stage_time_remaining:
+                    game.stage_time_remaining = stage_time_remaining
+                    game.update()
+                out_of_time = stage_time_remaining <= 0
+
+                if game.stage == "COLLECTING_RESPONSES":
+                    if out_of_time or all(
+                        val == "Submitted" for val in game.player_status.values()
+                    ):
+                        game.stage = "COLLECTING_VOTES"
+                        game.stage_start_time = now
+                        game.total_stage_time = TIME_TO_VOTE
+                        game.command = "Select the AI response!"
+                        game.player_status = {player: None for player in game.players}
+                        game.response_list = list(game.responses.items())
+                        game.input_allowed = False
+                        ai_answer = (None, game.ai_answer)
+                        game.response_list.append(ai_answer)
+                        random.shuffle(game.response_list)
+                        game.ai_response_index = game.response_list.index(ai_answer)
+                        game.update()
+
+                if game.stage == "COLLECTING_VOTES":
+                    if out_of_time or all(
+                        val == "Voted" for val in game.player_status.values()
+                    ):
+                        game.stage = "REVEALING"
+                        game.command = "Here's the results!"
+                        game.stage_start_time = now
+                        game.total_stage_time = TIME_TO_REVEAL
+                        for player, guess in game.player_guess.items():
+                            if guess == None:
+                                game.player_scores[player] += GUESS_AI_PTS
+                            else:
+                                game.player_scores[guess] += GUESSED_AS_AI_PTS
+                        game.update()
+
+                if game.stage == "REVEALING":
+                    if out_of_time:
+                        game.stage = "START"
+                        game.prompts_completed += 1
+                        if game.prompts_completed == len(game.players):
+                            game.complete = True
+                            game.command = f"Game complete! Winners: {', '.join(player for player, score in game.player_scores.items() if score == max(game.player_scores.values()))}"
+                        game.update()
+
+        time.sleep(0.1)
+
+
+thread = threading.Thread(target=game_thread)
+thread.daemon = True
+thread.start()

prompt.txt

@@ -0,0 +1,3 @@
+Return a brief response around 20 words for the following prompt:
+
+{}

requirements.txt

@@ -0,0 +1 @@
+openai

run.py

@@ -0,0 +1,112 @@
+import gradio as gr
+import random
+from game_manager import games, new_game
+import uuid
+
+with gr.Blocks(css="style.css") as app:
+    game_var = gr.Variable()
+    last_update = gr.Variable(0)
+
+    with gr.Column() as opening:
+        gr.Markdown("# GPT Who?")
+        gr.Markdown(
+            """
+        Welcome to 'GPT Who?', a game played with multiple humans and one AI. Here are the rules:
+
+        - Every player in a room will submit a prompt. 
+        - For every prompt, there will be a round. Every player submits a response to the prompt of the round.
+        - GPT will also respond to the prompt.
+        - Every player will vote on which response they think is the AI's response.
+        - Player's get 2 points for guessing which response was GPT, as well 1 point for every player that thought they were GPT.
+
+        That's it!
+        """
+        )
+
+        player_name = gr.Text(label="Player Name")
+        player_prompt = gr.Text(label="Prompt", info="Pick something fun, like 'Write a joke involving a banana.' or 'Why are children so dumb?'.")
+        random_room_btn = gr.Button("Join Random Room!")
+        with gr.Row():
+            room_name = gr.Text(label="Room Name")
+            open_room_btn = gr.Button("Create / Join Room!")
+
+    with gr.Column(visible=False) as game_col:
+        chat_history = gr.Chatbot(label="Game")
+        start_game_btn = gr.Button("Start Game", visible=False)
+        with gr.Row(visible=False) as text_row:
+            text_input = gr.Textbox(label="Input")
+        with gr.Row():
+            player_states = gr.DataFrame(
+                label="Players", headers=["Player", "Status", "Score"]
+            )
+            time_remaining = gr.Label(label="Time Remaining", elem_id="time_remaining")
+
+    def add_submission(player, text, game):
+        game.add_chat(player, text)
+        return {
+            text_input: gr.Textbox.update(value=""),
+        }
+
+    text_input.submit(add_submission, [player_name, text_input, game_var], [text_input])
+
+    def select_ai_response(game, player, selected: gr.SelectData):
+        if selected.index[0] != 0 and selected.index[1] == 1:
+            game.select_chat(player, selected.index[0])
+
+    chat_history.select(select_ai_response, [game_var, player_name], None)
+
+    def open_room(data):
+        game = new_game(data[room_name])
+        game.add_player(data[player_name], data[player_prompt])
+        return {
+            opening: gr.Column.update(visible=False),
+            game_col: gr.Column.update(visible=True),
+            game_var: game,
+            chat_history: gr.Chatbot.update(label=data[room_name]),
+            start_game_btn: gr.Button.update(visible=len(game.players) == 1),
+        }
+
+    def random_room():
+        for game in random.sample(list(games.values()), len(games)):
+            if not game.started:
+                return game.room_name
+        return "room_" + str(uuid.uuid4())[:8]
+
+    def update_game(data):
+        game = data[game_var]
+        if data[last_update] == game.last_update_index:
+            return {chat_history: gr.skip()}
+        else:
+            return {
+                chat_history: game.format_chat(data[player_name]),
+                text_row: gr.Row.update(visible=game.input_allowed),
+                player_states: game.get_player_state(),
+                time_remaining: game.stage_time_remaining,
+            }
+
+    def start_game_on(evt):
+        evt(
+            open_room,
+            {room_name, player_name, player_prompt},
+            {opening, game_col, game_var, chat_history, start_game_btn},
+        ).then(
+            update_game,
+            {game_var, last_update, player_name},
+            {chat_history, text_row, player_states, time_remaining},
+            every=1,
+        )
+
+    start_game_on(open_room_btn.click)
+    start_game_on(random_room_btn.click(random_room, None, room_name).success)
+
+    def start_game_click(data):
+        game = data[game_var]
+        game.start()
+        return {
+            start_game_btn: gr.Button.update(visible=False),
+        }
+
+    start_game_btn.click(start_game_click, {game_var}, {start_game_btn, text_input})
+
+
+app.queue().launch()

style.css

@@ -0,0 +1,8 @@
+.generating {
+    border: none !important;
+}
+#time_remaining {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+}