first commit

.gitignore

@@ -0,0 +1 @@
+jeopardy.json

README.md

@@ -1,13 +1,12 @@
 ---
 title: Crossword
-emoji: 💩
+emoji: 🧩
 colorFrom: indigo
 colorTo: gray
 sdk: gradio
 sdk_version: 3.16.1
-app_file: app.py
+app_file: run.py
 pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

formatters.py

@@ -0,0 +1,44 @@
+from game_manager import Clue
+from typing import List, Optional
+import time
+from game_manager import GUESS_TIMEOUT
+
+
+def crossword(grid: List[List[Optional[str]]], clues: List[Clue]):
+    clue_grid = [[[] for _ in range(len(grid[0]))] for _ in range(len(grid))]
+    for clue_id, clue in enumerate(clues):
+        if clue is None:
+            continue
+        if clue.across:
+            for i, _ in enumerate(clue.answer):
+                clue_grid[clue.location[0]][clue.location[1] + i].append(clue_id)
+        else:
+            for i, _ in enumerate(clue.answer):
+                clue_grid[clue.location[0] + i][clue.location[1]].append(clue_id)
+    output = "<div class='crossword'>"
+    for i, row in enumerate(grid):
+        output += "<div class='c-row'>"
+        for j, cell in enumerate(row):
+            clue_ids = clue_grid[i][j]
+            output += f"""<div class='cell {"" if cell is None else "filled"} {"" if len(clue_ids) == 0 else f"clue {' '.join('clue-' + str(clue_id+1) for clue_id in clue_ids)}"}'>"""
+            if cell == None:
+                output += "&nbsp;"
+            else:
+                output += cell
+            output += "</div>"
+        output += "</div>"
+    output += "</div>"
+    return output
+
+
+def clue_riddle(clue):
+    if clue is None:
+        return "..."
+
+    time_remaining = GUESS_TIMEOUT - (time.time() - clue.create_time)
+    return (
+        "\n".join(line for line in clue.riddle.splitlines() if line.strip() != "")
+        + " - "
+        + str(round(max(0, time_remaining)))
+        + "s"
+    )

game_manager.py

@@ -0,0 +1,259 @@
+import threading
+import random
+from typing import Tuple
+import re
+import copy
+import os
+import json
+import openai
+import time
+
+openai.api_key = os.environ["OPENAI_KEY"]
+
+SIZE = 15
+RIDDLE_COUNT = 3
+MIN_WORD_SIZE = 4
+MAX_WORD_SIZE = 10
+WORD_LIMIT = 7500
+COMPLETE_GAME_TIMEOUT = 60 * 60
+INCOMPLETE_GAME_TIMEOUT = 60 * 60 * 24
+GUESS_TIMEOUT = 20
+
+
+with open("words.json", "r") as f:
+    words = json.loads(f.read())
+
+with open("prompt.txt", "r") as f:
+    RIDDLE_PROMPT = f.read()
+
+search_text = "\n".join(words)
+games = {}
+all_games_lock = threading.Lock()
+
+
+def get_riddle(answer):
+    prompt = RIDDLE_PROMPT.format(
+        answer,
+    )
+    while True:
+        try:
+            completions = openai.Completion.create(
+                engine="text-davinci-003", prompt=prompt, max_tokens=200, n=1, temperature=0.5
+            )
+            riddle = completions["choices"][0]["text"]
+            return riddle
+        except Exception as e:
+            print("OpenAI Error", e, "Retrying...")
+            time.sleep(0.5)
+
+
+class Clue:
+    def __init__(self, answer, location, across, solved):
+        self.answer: str = answer
+        self.location: Tuple[int, int] = location
+        self.across: bool = across
+        self.solved: bool = solved
+        self.riddle: str = ""
+        self.create_time: int
+
+    def __repr__(self):
+        return f"{self.answer}: {self.location}, {'Across' if self.across else 'Down'}, {'Solved' if self.solved else 'Unsolved'}"
+
+
+class Game:
+    def __init__(self, room_name, competitive, init_word):
+        self.room_name = room_name
+        self.competitive = competitive
+        self.player_scores = {}
+        self.grid = [[None for i in range(SIZE)] for j in range(SIZE)]
+        self.grid = place_on_grid(
+            self.grid, init_word, (SIZE // 2, SIZE // 2 - len(init_word) // 2), True
+        )
+        self.clues = [None]  * RIDDLE_COUNT
+        self.previous_clues = []
+        self.lock = threading.Lock()
+        self.complete = False
+        self.last_update_index = 0
+        self.last_update_time = time.time()
+        self.last_riddle_update_time = None
+        self.pending_request = False
+
+        games[room_name] = self
+
+    def update(self):
+        self.last_update_index += 1
+        self.last_update_time = time.time()
+
+    def replace_clue(self, index):
+        clue_grid = copy.deepcopy(self.grid)
+        for j, clue in enumerate(self.clues):
+            if clue and index != j:
+                clue_grid = place_on_grid(clue_grid, clue.answer, clue.location, clue.across)
+
+        if self.clues[index]:
+            self.previous_clues.append(self.clues[index])
+        clue = find_clue(clue_grid)
+        if clue is None:
+            self.complete = True
+            return
+        clue.create_time = time.time()
+        self.pending_request = True
+        clue.riddle = get_riddle(clue.answer)
+        self.pending_request = False
+        self.last_riddle_update_time = time.time()
+        self.clues[index] = clue
+
+    def add_player(self, player_name):
+        with self.lock:
+            self.update()
+            if player_name not in self.player_scores:
+                self.player_scores[player_name] = 0
+
+    def player_guess(self, player_name, guess):
+        guess = guess.lower()
+        if self.pending_request:
+            return
+        with self.lock:
+            self.update()
+            matched_clues = [
+                clue for clue in self.clues if not clue.solved and clue.answer == guess
+            ]
+            if len(matched_clues) == 0:
+                return False
+            for clue in matched_clues:
+                clue.solved = True
+                place_on_grid(self.grid, clue.answer, clue.location, clue.across)
+                self.player_scores[player_name] += 1
+        
+    def time_left(self):
+        return INCOMPLETE_GAME_TIMEOUT - (time.time() - self.last_update_time)
+
+
+def place_on_grid(grid, word, location, across):
+    x, y = location
+    if across:
+        grid[x][y : y + len(word)] = word
+    else:
+        for i, letter in enumerate(word):
+            grid[x + i][y] = letter
+    return grid
+
+
+def find_clue(grid) -> Clue:
+    all_coordinate_pairs = [
+        (i, j) for i in range(SIZE) for j in range(SIZE) if grid[i][j] is not None
+    ]
+    random.shuffle(all_coordinate_pairs)
+    for i, j in all_coordinate_pairs:
+        regexes = []
+        if (j == 0 or grid[i][j - 1] is None) and (
+            j + 1 == SIZE or grid[i][j + 1] is None
+        ):
+            running_regex = ""
+            possible_across_regexes = []
+            for k in range(j, -1, -1):
+                if (
+                    (i != 0 and grid[i - 1][k] is not None)
+                    or (i != SIZE - 1 and grid[i + 1][k] is not None)
+                ) and grid[i][k] is None:
+                    break
+                valid = k == 0 or grid[i][k - 1] is None
+                running_regex = (grid[i][k] or ".") + running_regex
+                possible_across_regexes.append(((i, k), running_regex, valid))
+            possible_across_regexes = [p for p in possible_across_regexes if p[2]]
+            for k in range(j + 1, SIZE):
+                if (
+                    (i != 0 and grid[i - 1][k] is not None)
+                    or (i != SIZE - 1 and grid[i + 1][k] is not None)
+                ) and grid[i][k] is None:
+                    break
+                valid = k == SIZE - 1 or grid[i][k + 1] is None
+                for start, possible_across_regex, _ in possible_across_regexes[:]:
+                    if start[1] + len(possible_across_regex) == k:
+                        possible_across_regexes.append(
+                            (start, possible_across_regex + (grid[i][k] or "."), valid)
+                        )
+            possible_across_regexes = [
+                (loc, regex, True)
+                for loc, regex, valid in possible_across_regexes
+                if len(regex) >= MIN_WORD_SIZE and valid
+            ]
+            regexes.extend(possible_across_regexes)
+        elif (i == 0 or grid[i - 1][j] is None) and (
+            i + 1 == SIZE or grid[i + 1][j] is None
+        ):
+            running_regex = ""
+            possible_down_regexes = []
+            for k in range(i, -1, -1):
+                if (
+                    (j != 0 and grid[k][j - 1] is not None)
+                    or (j != SIZE - 1 and grid[k][j + 1] is not None)
+                ) and grid[k][j] is None:
+                    break
+                valid = k == 0 or grid[k - 1][j] is None
+                running_regex = (grid[k][j] or ".") + running_regex
+                possible_down_regexes.append(((k, j), running_regex, valid))
+            possible_down_regexes = [p for p in possible_down_regexes if p[2]]
+            for k in range(i + 1, SIZE):
+                if (
+                    (j != 0 and grid[k][j - 1] is not None)
+                    or (j != SIZE - 1 and grid[k][j + 1] is not None)
+                ) and grid[k][j] is None:
+                    break
+                valid = k == SIZE - 1 or grid[k + 1][j] is None
+                for start, possible_down_regex, _ in possible_down_regexes[:]:
+                    if start[0] + len(possible_down_regex) == k:
+                        possible_down_regexes.append(
+                            (start, possible_down_regex + (grid[k][j] or "."), valid)
+                        )
+            possible_down_regexes = [
+                (loc, regex, False)
+                for loc, regex, valid in possible_down_regexes
+                if len(regex) >= MIN_WORD_SIZE and valid
+            ]
+            regexes.extend(possible_down_regexes)
+
+        random.shuffle(regexes)
+        for loc, regex, across in regexes:
+            matches = re.findall("^" + regex + "$", search_text, re.MULTILINE)
+            if len(matches) > 1:
+                random.shuffle(matches)
+                answer = matches[0]
+                clue = Clue(answer, loc, across, False)
+                return clue
+    return None
+
+
+def new_game(room_name):
+    competitive = room_name != ""
+    with all_games_lock:
+        if room_name in games:
+            return games[room_name]
+        if not competitive:
+            while room_name == "" or room_name in games:
+                room_name = str(random.randint(0, 999999))
+            init_word = random.choice(words)
+        else:
+            init_word = room_name
+        return Game(room_name, competitive, init_word)
+
+
+def game_thread():
+    while True:
+        now = time.time()
+        for room_name, game in games.items():
+            idle_time = now - game.last_update_time
+            if (game.complete and idle_time > COMPLETE_GAME_TIMEOUT) or (
+                idle_time > INCOMPLETE_GAME_TIMEOUT
+            ):
+                del games[room_name]
+                continue
+            for i, clue in enumerate(game.clues):
+                if clue is None or clue.solved or now - clue.create_time > GUESS_TIMEOUT:
+                    game.replace_clue(i)
+
+        time.sleep(0.1)
+
+thread = threading.Thread(target=game_thread)
+thread.daemon = True
+thread.start()

prompt.txt

@@ -0,0 +1,10 @@
+I will give you a word. Write a rhyming poem of 4 lines that gives clues to the word. Do not use the word itself in the riddle. For example:
+
+WORD: tick
+
+This is the sound
+of time marching on
+Or a type of bug
+you surely will want gone!
+
+WORD: {}

requirements.txt

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

run.py

@@ -0,0 +1,102 @@
+import gradio as gr
+import formatters
+from game_manager import games, new_game
+
+with gr.Blocks(css="style.css") as app:
+    started = gr.Variable(False)
+    player = gr.Variable()
+    last_update = gr.Variable(0)
+
+    with gr.Column() as opening:
+        gr.Markdown("# Crossword GPT")
+        gr.Markdown(
+            """
+        Welcome to Crossword GPT, a game that dynamically creates a crossword and uses GPT to create clues.
+
+        - At the start of the game, a crossword puzzle will be created, with single word already solved.
+        
+        - At any time, a riddle with three clues will be shown, corresponding to three words that branch off the solved part of the puzzle. Riddles are regenerated every 20 seconds, with unsolved words removed. 
+
+        - You can play against friends, in which case enter a shared room name below. To play alone, leave the fields blank and start the game.
+
+        - Game ends when there is no more space to add words. Winner in competitive mode is the player with the most words.
+        """
+        )
+
+        room_name = gr.Text(label="Room Name")
+        player_name = gr.Text(label="Player Name")
+        start_btn = gr.Button("Let's Go!")
+
+    with gr.Column(visible=False) as game_col:
+        with gr.Row():
+            with gr.Column(min_width=500):
+                grid = gr.HTML()
+                score_table = gr.DataFrame(headers=["team", "score"], label="Scores")
+
+            with gr.Column():
+                clue1 = gr.Textbox(label="Clue 1", elem_id="clue-1")
+                clue2 = gr.Textbox(label="Clue 2", elem_id="clue-2")
+                clue3 = gr.Textbox(label="Clue 3", elem_id="clue-3")
+                guess = gr.Textbox(
+                    label="Guess",
+                    placeholder="Answer any clue here...",
+                    elem_id="guess",
+                )
+                prev_answers = gr.DataFrame(
+                    headers=None, row_count=1, col_count=3, label="Previous Answers"
+                )
+
+    def start_game(data):
+        game = new_game(data[room_name])
+        game.add_player(data[player_name])
+
+        return {
+            game_col: gr.update(visible=True),
+            opening: gr.update(visible=False),
+            room_name: game.room_name,
+            player: data[player_name],
+        }
+
+    start_btn.click(
+        start_game,
+        {room_name, player_name},
+        [game_col, opening, player, room_name],
+    )
+
+    def submit_guess(data):
+        game = games[data[room_name]]
+        game.player_guess(data[player], data[guess])
+
+    guess.submit(submit_guess, {room_name, player, guess}, None)
+    guess.submit(
+        None,
+        None,
+        None,
+        _js="""() => {document.querySelector("gradio-app").shadowRoot.querySelector("#guess textarea").setSelectionRange(0, 9999)}""",
+        status_tracker=None,
+    )
+
+    def update_game(data):
+        if data[room_name] is None or data[room_name] not in games:
+            return {grid: gr.skip()}
+        game = games[data[room_name]]
+        no_up = data[last_update] == game.last_update_index
+        return {
+            grid: gr.skip() if no_up else formatters.crossword(game.grid, game.clues),
+            prev_answers: gr.skip() if no_up else [[clue.answer for clue in game.previous_clues[-3:]]],
+            score_table: [[k, v] for k, v in game.player_scores.items()],
+            clue1: formatters.clue_riddle(game.clues[0]),
+            clue2: formatters.clue_riddle(game.clues[1]),
+            clue3: formatters.clue_riddle(game.clues[2]),
+            
+        }
+
+    start_btn.click(
+        update_game,
+        {room_name, last_update},
+        [grid, prev_answers, clue1, clue2, clue3, score_table],
+        every=1,
+    )
+
+
+app.queue().launch()

style.css

@@ -0,0 +1,101 @@
+.crossword {
+    font-family: monospace;
+    font-weight: bold;
+    display: flex;
+    flex-direction: column;
+    overflow-x: auto;
+}
+.crossword .c-row {
+    display: flex;
+}
+.cell {
+    border: 1px solid black;
+    background-color: white;
+    color: black;
+    display: inline-flex;
+    justify-content: center;
+    align-items: center;
+    padding: 0.25em 0.75em;
+}
+.dark .cell {
+    border: 1px solid gray;
+    background-color: black;
+    color: white;
+}
+.crossword .cell.filled :not([clue]) {
+    background-color: gainsboro;
+}
+.dark .crossword .cell.filled :not([clue]) {
+    background-color: dimgray;
+}
+.clue-1, #clue-1 textarea {
+    background-color: lightpink;
+}
+.clue-2, #clue-2 textarea {
+    background-color: lightgreen;
+}
+.clue-3, #clue-3 textarea {
+    background-color: lightblue;
+}
+.clue-1.clue-2 {
+    background: linear-gradient(45deg, lightpink 50%, lightgreen 50%);
+}
+.clue-1.clue-3 {
+    background: linear-gradient(45deg, lightpink 50%, lightblue 50%);
+}
+.clue-2.clue-3 {
+    background: linear-gradient(45deg, lightgreen 50%, lightblue 50%);
+}
+
+.dark .clue-1, .dark #clue-1 textarea {
+    background-color: darkred;
+}
+.dark .clue-2, .dark #clue-2 textarea {
+    background-color: darkgreen;
+}
+.dark .clue-3, .dark #clue-3 textarea {
+    background-color: darkblue;
+}
+#clue-1 textarea, #clue-2 textarea, #clue-3 textarea {
+    font-size: 1.4em;
+}
+.dark .clue-1.clue-2 {
+    background: linear-gradient(45deg, darkred 50%, darkgreen 50%);
+}
+.dark .clue-1.clue-3 {
+    background: linear-gradient(45deg, darkred 50%, darkblue 50%);
+}
+.dark .clue-2.clue-3 {
+    background: linear-gradient(45deg, darkgreen 50%, darkblue 50%);
+}
+
+
+.cell.clue {
+    -webkit-animation: glow 1s ease-in-out infinite alternate;
+    -moz-animation: glow 1s ease-in-out infinite alternate;
+    animation: glow 1s ease-in-out infinite alternate;  
+}
+@-webkit-keyframes glow {
+    from {
+        opacity: 1;
+    }
+    to {
+        opacity: 0.75;
+    }
+}
+#clue1 textarea, #clue2 textarea, #clue3 textarea {
+    font-weight: bold;
+    font-size: 1.4em;
+}
+
+.textspan {
+    display: block !important;
+    margin: 4px 0 0 0 !important;
+    font-size: 1.25em;
+}
+.textspan .label {
+    display: none;
+}
+.generating {
+    display: none !important;
+}

test.py

@@ -0,0 +1,21 @@
+import game_manager
+import random
+random.seed(2)
+
+game_manager.SIZE = 8
+
+XXX = None
+grid = [
+    [XXX, "s", XXX, XXX, XXX, XXX, XXX, XXX],
+    [XXX, "h", XXX, XXX, XXX, "t", XXX, XXX],
+    ["l", "o", "n", "e", "l", "y", XXX, XXX],
+    [XXX, "n", XXX, XXX, XXX, "l", XXX, XXX],
+    [XXX, "e", XXX, XXX, XXX, "e", "n", "d"],
+    [XXX, XXX, XXX, XXX, XXX, "r", XXX, XXX],
+    [XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX],
+    [XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX],
+]
+
+clues = game_manager.find_clues(grid, 7)
+for c in clues:
+    print(c)

wordmaker.py

@@ -0,0 +1,48 @@
+from nltk import FreqDist
+from nltk.corpus import brown
+from nltk.stem.lancaster import LancasterStemmer
+import json
+
+WORD_LIMIT = 10000
+MIN_WORD_SIZE, MAX_WORD_SIZE = 4, 10
+
+# stem = LancasterStemmer()
+# frequency_list = FreqDist(i.lower() for i in brown.words())
+# words = [
+#     w.lower()
+#     for w, _ in frequency_list.most_common()[:WORD_LIMIT]
+#     if w.isalpha() and len(w) >= MIN_WORD_SIZE and len(w) <= MAX_WORD_SIZE
+# ]
+# stem_to_words = {}
+# for word in words:
+#     stemmed = stem.stem(word)
+#     if stemmed not in stem_to_words:
+#         stem_to_words[stemmed] = set()
+#     stem_to_words[stemmed].add(word)
+
+# final_words = []
+# for stem, words in stem_to_words.items():
+#     shortest = min(words, key=len)
+#     final_words.append(shortest)
+
+# with open("words.json", "w") as f:
+#     f.write(json.dumps(final_words))
+
+with open("jeopardy.json", "r") as f:
+    jeopardy = json.loads(f.read())
+
+answers = set()
+for row in jeopardy:
+    answer = row["answer"].lower()
+    if not answer.isalpha():
+        continue
+    if answer.startswith("the "):
+        answer = answer[4:]
+    elif answer.startswith("a "):
+        answer = answer[2:]
+    if len(answer) < MIN_WORD_SIZE or len(answer) > MAX_WORD_SIZE:
+        continue
+    answers.add(answer)
+
+with open("words.json", "w") as f:
+    f.write(json.dumps(list(answers)))