ai-plays-jackbox 0.1.0__tar.gz → 0.2.1__tar.gz

{ai_plays_jackbox-0.1.0 → ai_plays_jackbox-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ai-plays-jackbox
-Version: 0.1.0
+Version: 0.2.1
 Summary: Bringing the dead internet theory to life. Have AI play JackBox with you; no friends required!
 License: MIT
 Author: Daniel S. Thompson
@@ -20,6 +20,7 @@ Requires-Dist: numpy (>=2.2.6,<3.0.0)
 Requires-Dist: ollama (>=0.4.4,<1.0.0)
 Requires-Dist: openai (>=1.59.8,<2.0.0)
 Requires-Dist: opencv-python (>=4.11.0.86,<5.0.0.0)
+Requires-Dist: psutil (>=7.0.0,<8.0.0)
 Requires-Dist: pydantic (>=2.10.4,<3.0.0)
 Requires-Dist: requests (>=2.23.3,<3.0.0)
 Requires-Dist: websocket-client (>=1.8.0,<2.0.0)
@@ -35,7 +36,7 @@ Description-Content-Type: text/markdown
 
 Bringing the dead internet theory to life. Have AI play JackBox with you; no friends required!
 
-![example](.github/emoji_bot_example.png)
+![example](https://github.com/SudoSpartanDan/AIPlaysJackBox/blob/main/.github/emoji_bot_example.png?raw=true)
 
 ## Installation
 
@@ -81,6 +82,7 @@ options:
 | --------------------- | ---------------------- | ---------------- |
 | JackBox Party Pack 5  | Mad Verse City         | [ ]              |
 | JackBox Party Pack 5  | Patently Stupid        | [x]              |
+| JackBox Party Pack 6  | Dictionarium           | [ ]              |
 | JackBox Party Pack 6  | Joke Boat              | [ ]              |
 | JackBox Party Pack 7  | Quiplash 3             | [ ]              |
 | Standalone            | Drawful 2              | [x]              |
@@ -149,6 +151,6 @@ Some of the games lean heavy into players interacting with each other. Could I p
 
 ### Linting
 
-- `poetry run python scripts/lint.py`
+- `poetry run python ai_plays_jackbox/scripts/lint.py`
 - `poetry run mypy ai_plays_jackbox`
 

{ai_plays_jackbox-0.1.0 → ai_plays_jackbox-0.2.1}/README.md

@@ -6,7 +6,7 @@
 
 Bringing the dead internet theory to life. Have AI play JackBox with you; no friends required!
 
-![example](.github/emoji_bot_example.png)
+![example](https://github.com/SudoSpartanDan/AIPlaysJackBox/blob/main/.github/emoji_bot_example.png?raw=true)
 
 ## Installation
 
@@ -52,6 +52,7 @@ options:
 | --------------------- | ---------------------- | ---------------- |
 | JackBox Party Pack 5  | Mad Verse City         | [ ]              |
 | JackBox Party Pack 5  | Patently Stupid        | [x]              |
+| JackBox Party Pack 6  | Dictionarium           | [ ]              |
 | JackBox Party Pack 6  | Joke Boat              | [ ]              |
 | JackBox Party Pack 7  | Quiplash 3             | [ ]              |
 | Standalone            | Drawful 2              | [x]              |
@@ -120,5 +121,5 @@ Some of the games lean heavy into players interacting with each other. Could I p
 
 ### Linting
 
-- `poetry run python scripts/lint.py`
+- `poetry run python ai_plays_jackbox/scripts/lint.py`
 - `poetry run mypy ai_plays_jackbox`

{ai_plays_jackbox-0.1.0 → ai_plays_jackbox-0.2.1}/ai_plays_jackbox/bot/bot_factory.py

@@ -1,6 +1,7 @@
 from ai_plays_jackbox.bot.bot_base import JackBoxBotBase
 from ai_plays_jackbox.bot.jackbox5.mad_verse_city import MadVerseCityBot
 from ai_plays_jackbox.bot.jackbox5.patently_stupid import PatentlyStupidBot
+from ai_plays_jackbox.bot.jackbox6.dictionarium import DictionariumBot
 from ai_plays_jackbox.bot.jackbox6.joke_boat import JokeBoatBot
 from ai_plays_jackbox.bot.jackbox7.quiplash3 import Quiplash3Bot
 from ai_plays_jackbox.bot.standalone.drawful2 import Drawful2Bot
@@ -12,6 +13,8 @@ BOT_TYPES: dict[str, type[JackBoxBotBase]] = {
     "drawful2international": Drawful2Bot,
     "rapbattle": MadVerseCityBot,
     "jokeboat": JokeBoatBot,
+    "ridictionary": DictionariumBot,
+    # "apply-yourself": JobJobBot,
 }
 
 

ai_plays_jackbox-0.2.1/ai_plays_jackbox/bot/jackbox6/dictionarium.py

@@ -0,0 +1,105 @@
+import random
+
+from loguru import logger
+
+from ai_plays_jackbox.bot.jackbox6.bot_base import JackBox6BotBase
+
+_DEFINITION_PROMPT_TEMPLATE = """
+You are playing Dictionarium.
+
+{prompt}
+
+When generating your response, follow these rules:
+- Your personality is: {personality}
+- You response must be {max_length} characters or less.
+- Do not include quotes in your response.
+"""
+
+_SYNONYM_PROMPT_TEMPLATE = """
+You are playing Dictionarium.
+
+{prompt}
+
+When generating your response, follow these rules:
+- Your personality is: {personality}
+- You response must be {max_length} characters or less.
+- Do not include quotes in your response.
+"""
+
+_SENTENCE_PROMPT_TEMPLATE = """
+You are playing Dictionarium. You need to use a made up word in a sentence.
+
+{prompt}
+
+When generating your response, follow these rules:
+- Your personality is: {personality}
+- You response must be {max_length} characters or less.
+- Do not include quotes in your response.
+"""
+
+
+class DictionariumBot(JackBox6BotBase):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def _handle_welcome(self, data: dict):
+        pass
+
+    def _handle_player_operation(self, data: dict):
+        if not data:
+            return
+        room_state = data.get("state", None)
+        if not room_state:
+            return
+
+        prompt = data.get("prompt", {})
+        prompt_html = prompt.get("html", "")
+        clean_prompt = self._html_to_text(prompt_html)
+        max_length = data.get("maxLength", 150)
+
+        match room_state:
+            case "EnterSingleText":
+                entry = data.get("entry", None)
+                entry_id = data.get("entryId", "")
+                print(data)
+                if not entry:
+                    if entry_id == "Definition":
+                        logger.info("Generating definition...")
+                        template = _DEFINITION_PROMPT_TEMPLATE
+                    elif entry_id == "Synonym":
+                        logger.info("Generating synonym...")
+                        template = _SYNONYM_PROMPT_TEMPLATE
+                    elif entry_id == "Sentence":
+                        logger.info("Generating sentence...")
+                        template = _SENTENCE_PROMPT_TEMPLATE
+                    else:
+                        return
+
+                    formatted_prompt = template.format(
+                        personality=self._personality,
+                        prompt=clean_prompt,
+                        max_length=max_length,
+                    )
+                    submission = self._chat_model.generate_text(
+                        formatted_prompt,
+                        "",
+                        temperature=self._chat_model._chat_model_temperature,
+                        top_p=self._chat_model._chat_model_top_p,
+                    )
+                    submission = submission[: max_length - 1]
+                    self._client_send({"action": "write", "entry": submission})
+
+            case "MakeSingleChoice":
+                choice_type = data.get("choiceType", "")
+                if (
+                    choice_type == "ChooseDefinition"
+                    or choice_type == "ChooseSynonym"
+                    or choice_type == "ChooseSentence"
+                ):
+                    choices: list[dict] = data.get("choices", [])
+                    choice_indexes = [i for i in range(0, len(choices))]
+                    selected_choice = random.choice(choice_indexes)
+                    self._client_send({"action": "choose", "choice": selected_choice})
+
+    def _handle_room_operation(self, data: dict):
+        pass

ai_plays_jackbox-0.2.1/ai_plays_jackbox/bot/jackbox8/bot_base.py

@@ -0,0 +1,20 @@
+from abc import ABC
+
+from ai_plays_jackbox.bot.bot_base import JackBoxBotBase
+
+
+class JackBox8BotBase(JackBoxBotBase, ABC):
+
+    @property
+    def _player_operation_key(self) -> str:
+        return f"player:{self._player_id}"
+
+    def _is_player_operation_key(self, operation_key: str) -> bool:
+        return operation_key == self._player_operation_key
+
+    @property
+    def _room_operation_key(self) -> str:
+        return "room"
+
+    def _is_room_operation_key(self, operation_key: str) -> bool:
+        return operation_key == self._room_operation_key

ai_plays_jackbox-0.2.1/ai_plays_jackbox/bot/jackbox8/job_job.py

@@ -0,0 +1,205 @@
+import random
+import string
+
+from loguru import logger
+
+from ai_plays_jackbox.bot.jackbox8.bot_base import JackBox8BotBase
+
+_RESPONSE_PROMPT_TEMPLATE = """
+You are playing Job Job. You need response to the given prompt.
+
+When generating your response, follow these rules:
+- Your personality is: {personality}
+- Your response must be {max_length} letters or less.
+- Your response must have a minimum of {min_words} words.
+- Do not include quotes in your response.
+
+{instruction}
+
+Your prompt is:
+
+{prompt}
+"""
+
+_COMPOSITION_PROMPT_TEMPLATE = """
+You are playing Job Job. You must create a response to a interview question using only specific words given.
+
+When generating your response, follow these rules:
+- Your personality is: {personality}
+- Your response must only use the allowed words or characters, nothing else
+- If you decide to use a character, you must have it separated by a space from any words
+- You can select a maximum of {max_words} words
+
+Your interview question is:
+
+{prompt}
+
+Your allowed words or characters are:
+
+{all_possible_words_str}
+"""
+
+
+class JobJobBot(JackBox8BotBase):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def _handle_welcome(self, data: dict):
+        pass
+
+    def _handle_player_operation(self, data: dict):
+        if not data:
+            return
+
+        kind = data.get("kind", "")
+        has_controls = data.get("hasControls", False)
+        response_key = data.get("responseKey", "")
+        done_key = data.get("doneKey", "")
+
+        if has_controls:
+            if "skip:" in response_key:
+                self._object_update(response_key, {"action": "skip"})
+                return
+
+        match kind:
+            case "writing":
+                instruction = data.get("instruction", "")
+                prompt = data.get("prompt", "")
+                max_length = data.get("maxLength", 128)
+                min_words = data.get("minWords", 5)
+                text_key = data.get("textKey", "")
+                response = self._generate_response(instruction, prompt, max_length, min_words)
+                self._text_update(text_key, response)
+                self._object_update(done_key, {"done": True})
+
+            case "magnets":
+                prompt = data.get("prompt", "")
+                answer_key = data.get("answerKey", "")
+                stash = data.get("stash", [[]])
+                max_words = data.get("maxWords", 12)
+                composition_list = self._generate_composition_list(prompt, stash, max_words)
+                self._object_update(
+                    answer_key,
+                    {
+                        "final": True,
+                        "text": composition_list,
+                    },
+                )
+
+            case "resumagents":
+                prompt = data.get("prompt", "")
+                answer_key = data.get("answerKey", "")
+                stash = data.get("stash", [[]])
+                max_words = data.get("maxWords", 12)
+                max_words_per_answer = data.get("maxWordsPerAnswer", 8)
+                num_answers = data.get("numAnswers", 8)
+                resume_composition_list = self._generate_resume_composition_list(
+                    prompt, stash, max_words, max_words_per_answer, num_answers
+                )
+                self._object_update(
+                    answer_key,
+                    {
+                        "final": True,
+                        "text": resume_composition_list,
+                    },
+                )
+
+            case "voting":
+                choices: list[dict] = data.get("choices", [])
+                choice_indexes = [i for i in range(0, len(choices))]
+                selected_choice = random.choice(choice_indexes)
+                self._object_update(response_key, {"action": "choose", "choice": selected_choice})
+
+    def _handle_room_operation(self, data: dict):
+        pass
+
+    def _generate_response(self, instruction: str, prompt: str, max_length: int, min_words: int) -> str:
+        formatted_prompt = _RESPONSE_PROMPT_TEMPLATE.format(
+            personality=self._personality,
+            max_length=max_length,
+            min_words=min_words,
+            instruction=instruction,
+            prompt=prompt,
+        )
+        response = self._chat_model.generate_text(
+            formatted_prompt,
+            "",
+            temperature=self._chat_model._chat_model_temperature,
+            top_p=self._chat_model._chat_model_top_p,
+        )
+        if len(response) > max_length:
+            response = response[: max_length - 1]
+        return response
+
+    def _generate_composition_list(
+        self,
+        prompt: str,
+        stash: list[list[str]],
+        max_words: int,
+    ) -> list[dict]:
+
+        possible_word_choices = []
+
+        for stash_entry in stash:
+            for word in stash_entry:
+                possible_word_choices.append(word)
+
+        all_possible_words_str = "\n".join([word for word in possible_word_choices])
+        formatted_prompt = _COMPOSITION_PROMPT_TEMPLATE.format(
+            personality=self._personality,
+            all_possible_words_str=all_possible_words_str,
+            max_words=max_words,
+            prompt=prompt,
+        )
+        response = self._chat_model.generate_text(
+            formatted_prompt,
+            "",
+            temperature=self._chat_model._chat_model_temperature,
+            top_p=self._chat_model._chat_model_top_p,
+        )
+
+        ## Listen, I know this is isn't the fastest way to search
+        ## It's 12 words, bite me with your Big O notation
+        composition_list = []
+        response_list = response.split(" ")
+        for response_word in response_list:
+            found_word = False
+            response_word = response_word.strip()
+            if not all(char in string.punctuation for char in response_word):
+                response_word = response_word.translate(str.maketrans("", "", string.punctuation)).lower()
+
+            if not found_word:
+                for stash_index, stash_entry in enumerate(stash):
+                    for check_word_index, check_word in enumerate(stash_entry):
+                        if response_word == check_word.lower():
+                            composition_list.append(
+                                {
+                                    "index": stash_index,
+                                    "word": check_word_index,
+                                }
+                            )
+                            found_word = True
+                            break
+                    if found_word:
+                        break
+
+            if not found_word:
+                logger.warning(f"Word not found in choices: {response_word}")
+
+        if len(composition_list) > max_words:
+            composition_list = composition_list[: max_words - 1]
+        return composition_list
+
+    def _generate_resume_composition_list(
+        self,
+        prompt: str,
+        stash: list[list[str]],
+        max_words: int,
+        max_words_per_answers: int,
+        num_of_answers: int,
+    ) -> list[list[dict]]:
+        # TODO Figure this out
+        resume_composition_list = []
+        for _ in range(0, num_of_answers):
+            resume_composition_list.append([{"index": 0, "word": 0}])
+        return resume_composition_list

ai_plays_jackbox-0.1.0/ai_plays_jackbox/cli.py → ai_plays_jackbox-0.2.1/ai_plays_jackbox/cli/main.py

@@ -45,7 +45,7 @@ def _validate_top_p(string_to_check: str) -> float:
     return number_value
 
 
-def cli():
+def main():
     parser = argparse.ArgumentParser()
     parser.add_argument(
         "--room-code",
@@ -104,4 +104,4 @@ def cli():
 
 
 if __name__ == "__main__":
-    cli()
+    main()

{ai_plays_jackbox-0.1.0 → ai_plays_jackbox-0.2.1}/ai_plays_jackbox/run.py

@@ -1,7 +1,7 @@
 from typing import Optional
 
 from ai_plays_jackbox.llm.chat_model_factory import ChatModelFactory
-from ai_plays_jackbox.room import JackBoxRoom
+from ai_plays_jackbox.room.room import JackBoxRoom
 
 
 def run(

ai_plays_jackbox-0.2.1/ai_plays_jackbox/scripts/lint.py

@@ -0,0 +1,18 @@
+import subprocess
+
+
+def run():
+    commands = [
+        ["autoflake", "--in-place", "--recursive", "--remove-all-unused-imports", "--verbose", "ai_plays_jackbox"],
+        ["isort", "--profile", "black", "--project=ai_plays_jackbox", "ai_plays_jackbox"],
+        ["black", "-l", "120", "ai_plays_jackbox"],
+        ["mypy", "ai_plays_jackbox"],
+    ]
+
+    for cmd in commands:
+        print(f"\n>>> Running: {' '.join(cmd)}")
+        subprocess.run(["poetry", "run"] + cmd, check=True)
+
+
+if __name__ == "__main__":
+    run()

ai_plays_jackbox-0.2.1/ai_plays_jackbox/ui/main.py

@@ -0,0 +1,12 @@
+from nicegui import app, ui
+
+from ai_plays_jackbox.ui.startup import startup
+
+
+def main(reload: bool = False):
+    app.on_startup(startup)
+    ui.run(favicon="🤖", reload=reload)
+
+
+if __name__ in {"__main__", "__mp_main__"}:
+    main(True)

ai_plays_jackbox-0.2.1/ai_plays_jackbox/ui/startup.py

@@ -0,0 +1,248 @@
+from multiprocessing import Process, Queue
+
+import psutil
+from loguru import logger
+from nicegui import app, ui
+
+from ai_plays_jackbox.bot.bot_personality import JackBoxBotVariant
+from ai_plays_jackbox.constants import (
+    DEFAULT_NUM_OF_BOTS,
+    DEFAULT_TEMPERATURE,
+    DEFAULT_TOP_P,
+)
+from ai_plays_jackbox.llm.chat_model_factory import CHAT_MODEL_PROVIDERS
+from ai_plays_jackbox.run import run
+
+LOG_QUEUE: Queue = Queue()
+LOG_DISPLAY = None
+SELECT_ALL_BOT_VARIANTS = None
+BOT_VARIANT_CHECKBOX_STATES: dict = {}
+
+
+def _format_log(record):
+    thread_name = record["thread"].name
+    color = "red"
+    colored_name = f"<{color}>{thread_name:<12}</{color}>"
+
+    return (
+        f"<green>{record['time']:YYYY-MM-DD HH:mm:ss}</green> | "
+        f"<cyan>{record['level']:<8}</cyan> | "
+        f"{colored_name} | "
+        f"{record['message']}\n"
+    )
+
+
+def _build_log_display():
+    global LOG_DISPLAY
+    with ui.row().classes("w-full"):
+        LOG_DISPLAY = ui.log(max_lines=100).classes("h-64 overflow-auto bg-black text-white")
+    ui.timer(interval=0.5, callback=_poll_log_queue)
+
+
+def _poll_log_queue():
+    global LOG_DISPLAY
+    try:
+        while not LOG_QUEUE.empty():
+            log_msg = LOG_QUEUE.get_nowait()
+            LOG_DISPLAY.push(log_msg)
+    except Exception as e:
+        LOG_DISPLAY.push(f"[ERROR] Failed to read log: {e}")
+
+
+def _start(
+    room_code: str,
+    chat_model_provider: str,
+    chat_model_name: str,
+    num_of_bots: int,
+    bots_in_play: list[str],
+    temperature: float,
+    top_p: float,
+    log_queue: Queue,
+):
+    logger.add(lambda msg: log_queue.put(msg), format=_format_log)
+
+    try:
+        run(
+            room_code.strip().upper(),
+            chat_model_provider,
+            chat_model_name=chat_model_name,
+            num_of_bots=num_of_bots,
+            bots_in_play=bots_in_play,
+            chat_model_temperature=temperature,
+            chat_model_top_p=top_p,
+        )
+    except Exception as e:
+        logger.exception("Bot startup failed")
+
+
+def _is_game_process_alive():
+    game_pid = app.storage.general.get("game_pid", None)
+    is_game_alive = game_pid is not None and psutil.pid_exists(game_pid) and psutil.Process(game_pid).is_running()
+    if not is_game_alive:
+        app.storage.general["game_pid"] = None
+    return is_game_alive
+
+
+def _handle_start_click(
+    room_code: str,
+    chat_model_provider: str,
+    chat_model_name: str,
+    num_of_bots: int,
+    temperature: float,
+    top_p: float,
+):
+    global BOT_VARIANT_CHECKBOX_STATES
+
+    if not _is_game_process_alive():
+        logger.info("Starting...")
+        game_thread = Process(
+            target=_start,
+            args=(
+                room_code,
+                chat_model_provider,
+                chat_model_name,
+                num_of_bots,
+                [k for k, v in BOT_VARIANT_CHECKBOX_STATES.items() if v.value],
+                temperature,
+                top_p,
+                LOG_QUEUE,
+            ),
+            daemon=True,
+        )
+        game_thread.start()
+        app.storage.general["game_pid"] = game_thread.pid
+
+
+def _select_all_bot_variants_changed():
+    for checkbox in BOT_VARIANT_CHECKBOX_STATES.values():
+        checkbox.value = SELECT_ALL_BOT_VARIANTS.value
+
+
+def _sync_select_all_bot_variants():
+    all_checked = all(cb.value for cb in BOT_VARIANT_CHECKBOX_STATES.values())
+    SELECT_ALL_BOT_VARIANTS.value = all_checked
+
+
+def _setup_bot_variant_display():
+    global SELECT_ALL_BOT_VARIANTS
+    with ui.list().props("bordered separator").classes("w-full"):
+        with ui.item_label("Bot Personalities").props("header").classes("text-bold"):
+            SELECT_ALL_BOT_VARIANTS = ui.checkbox(text="Select All", value=True)
+            SELECT_ALL_BOT_VARIANTS.on("update:model-value", lambda e: _select_all_bot_variants_changed())
+        ui.separator()
+        with ui.element("div").classes("overflow-y-auto h-64"):
+            for variant in list(JackBoxBotVariant):
+                with ui.item():
+                    with ui.item_section().props("avatar"):
+                        cb = ui.checkbox(value=True)
+                        cb.on("update:model-value", lambda e: _sync_select_all_bot_variants())
+                        BOT_VARIANT_CHECKBOX_STATES[variant.name] = cb
+                    with ui.item_section():
+                        ui.item_label(variant.value.name)
+                        ui.item_label(variant.value.personality).props("caption")
+
+
+def startup():
+    ui.page_title("AI Plays JackBox")
+    ui.label("🤖 AI Plays JackBox").classes("text-2xl font-bold")
+
+    _build_log_display()
+
+    with ui.grid(columns=16).classes("w-full gap-0"):
+        with ui.column().classes("col-span-1"):
+            pass
+        with ui.column().classes("col-span-7"):
+            with ui.row():
+                ui.label("Number of Bots")
+                num_of_bots_label = ui.label(str(DEFAULT_NUM_OF_BOTS))
+                num_of_bots = ui.slider(
+                    min=1,
+                    max=10,
+                    value=DEFAULT_NUM_OF_BOTS,
+                    step=1,
+                    on_change=lambda e: num_of_bots_label.set_text(f"{e.value}"),
+                )
+                chat_model_provider = ui.select(
+                    list(CHAT_MODEL_PROVIDERS.keys()),
+                    label="Chat Model Provider",
+                    value=list(CHAT_MODEL_PROVIDERS.keys())[0],
+                    on_change=lambda e: chat_model_name.set_value(CHAT_MODEL_PROVIDERS[e.value].get_default_model()),
+                ).classes("w-1/3")
+
+                chat_model_name = ui.input(
+                    label="Chat Model Name",
+                    value=CHAT_MODEL_PROVIDERS[chat_model_provider.value].get_default_model(),
+                ).classes("w-1/3")
+
+                room_code = (
+                    ui.input(
+                        label="Room Code",
+                        placeholder="ABCD",
+                        validation={
+                            "must be letters only": lambda value: value.isalpha(),
+                            "must be 4 letters": lambda value: len(value) == 4,
+                        },
+                    )
+                    .props("uppercase")
+                    .classes("w-1/4")
+                )
+                start_button = (
+                    ui.button(
+                        "Start Bots",
+                        on_click=lambda _: _handle_start_click(
+                            room_code.value,
+                            chat_model_provider.value,
+                            chat_model_name.value,
+                            num_of_bots.value,
+                            temperature.value,
+                            top_p.value,
+                        ),
+                    )
+                    .bind_enabled_from(room_code, "error", lambda error: room_code.value and not error)
+                    .classes("w-full")
+                )
+                ui.timer(
+                    interval=0.5,
+                    callback=lambda: start_button.props(
+                        f"color={'blue' if _is_game_process_alive() else 'green'}"
+                    ).set_text("Running..." if _is_game_process_alive() else "Start Bots"),
+                )
+
+                ui.label("Advanced Options").classes("w-full text-xl font-bold")
+
+                ui.label("Temperature").classes("w-1/4").tooltip(
+                    """
+                    What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
+                    make the output more random, while lower values like 0.2 will make it more
+                    focused and deterministic. We generally recommend altering this or `top_p` but
+                    not both."""
+                )
+                temperature_label = ui.label(str(DEFAULT_TEMPERATURE)).classes("w-1/6")
+                temperature = ui.slider(
+                    min=0.0,
+                    max=2.0,
+                    value=DEFAULT_TEMPERATURE,
+                    step=0.1,
+                    on_change=lambda e: temperature_label.set_text(f"{e.value}"),
+                ).classes("w-1/2")
+
+                ui.label("Top P").classes("w-1/4").tooltip(
+                    """
+                    An alternative to sampling with temperature, called nucleus sampling, where the
+                    model considers the results of the tokens with top_p probability mass. So 0.1
+                    means only the tokens comprising the top 10% probability mass are considered."""
+                )
+                top_p_label = ui.label(str(DEFAULT_TOP_P)).classes("w-1/6")
+                top_p = ui.slider(
+                    min=0.0,
+                    max=1.0,
+                    value=DEFAULT_TOP_P,
+                    step=0.1,
+                    on_change=lambda e: top_p_label.set_text(f"{e.value}"),
+                ).classes("w-1/2")
+
+        with ui.column().classes("col-span-1"):
+            pass
+
+        with ui.column().classes("col-span-6"):
+            _setup_bot_variant_display()

{ai_plays_jackbox-0.1.0 → ai_plays_jackbox-0.2.1}/pyproject.toml

@@ -21,7 +21,8 @@ dependencies = [
     "websocket-client (>=1.8.0,<2.0.0)",
     "numpy (>=2.2.6,<3.0.0)",
     "opencv-python (>=4.11.0.86,<5.0.0.0)",
-    "demoji (>=1.1.0,<2.0.0)"
+    "demoji (>=1.1.0,<2.0.0)",
+    "psutil (>=7.0.0,<8.0.0)"
 ]
 
 [project.urls]
@@ -29,8 +30,8 @@ repository = "https://github.com/SudoSpartanDan/AIPlaysJackBox"
 "Bug Tracker" = "https://github.com/SudoSpartanDan/AIPlaysJackBox/issues"
 
 [project.scripts]
-ai-plays-jackbox = "ai_plays_jackbox.cli:cli"
-ai-plays-jackbox-ui = "ai_plays_jackbox.web_ui:web_ui"
+ai-plays-jackbox = "ai_plays_jackbox.cli.main:main"
+ai-plays-jackbox-ui = "ai_plays_jackbox.ui.main:main"
 
 [tool.black]
 line-length = 120
@@ -43,7 +44,7 @@ module = ["demoji.*"]
 follow_untyped_imports = true
 
 [tool.poetry]
-version = "0.1.0"
+version = "0.2.1"
 
 [tool.poetry.group.dev.dependencies]
 autoflake = "^2.3.1"
@@ -51,6 +52,7 @@ black = "^25.1.0"
 isort = "^6.0.1"
 mypy = "^1.16.0"
 types-requests = "^2.32.0.20250602"
+types-psutil = "^7.0.0.20250601"
 
 [tool.poetry-dynamic-versioning]
 enable = true

ai_plays_jackbox-0.1.0/ai_plays_jackbox/ui/create_ui.py

@@ -1,197 +0,0 @@
-import threading
-from collections import deque
-
-from loguru import logger
-from nicegui import ui
-
-from ai_plays_jackbox.bot.bot_personality import JackBoxBotVariant
-from ai_plays_jackbox.constants import (
-    DEFAULT_NUM_OF_BOTS,
-    DEFAULT_TEMPERATURE,
-    DEFAULT_TOP_P,
-)
-from ai_plays_jackbox.llm.chat_model_factory import CHAT_MODEL_PROVIDERS
-from ai_plays_jackbox.run import run
-
-
-def _format_log(record):
-    thread_name = record["thread"].name
-    color = "red"
-    colored_name = f"<{color}>{thread_name:<12}</{color}>"
-
-    return (
-        f"<green>{record['time']:YYYY-MM-DD HH:mm:ss}</green> | "
-        f"<cyan>{record['level']:<8}</cyan> | "
-        f"{colored_name} | "
-        f"{record['message']}\n"
-    )
-
-
-# Keep a reference to the game thread
-game_thread = None
-
-
-def create_ui():
-    ui.page_title("AI Plays JackBox")
-
-    def _handle_start_click():
-        global game_thread
-
-        if game_thread and game_thread.is_alive():
-            return
-
-        def _start_in_thread():
-            bots_in_play = [k for k, v in bot_variant_checkbox_states.items() if v.value]
-            try:
-                run(
-                    room_code.value.strip().upper(),
-                    chat_model_provider.value,
-                    chat_model_name=chat_model_name.value,
-                    num_of_bots=num_of_bots.value,
-                    bots_in_play=bots_in_play,
-                    chat_model_temperature=temperature.value,
-                    chat_model_top_p=top_p.value,
-                )
-            except Exception as e:
-                logger.exception("Bot startup failed")
-
-        game_thread = threading.Thread(target=_start_in_thread, daemon=True)
-        game_thread.start()
-        start_button.disable()
-        start_button.props("color=blue")
-        start_button.text = "Running..."
-        start_button.update()
-
-    def _refresh_button_state():
-        if not game_thread or not game_thread.is_alive():
-            if start_button.props["color"] != "green":
-                start_button.enable()
-                start_button.props("color=green")
-                start_button.text = "Start Bots"
-        else:
-            if start_button.props["color"] != "blue":
-                start_button.disable()
-                start_button.props("color=blue")
-                start_button.text = "Running..."
-
-    ui.label("🤖 AI Plays JackBox").classes("text-2xl font-bold")
-
-    with ui.row().classes("w-full"):
-
-        log_display = ui.log(max_lines=100).classes("h-64 overflow-auto bg-black text-white")
-        log_buffer = deque(maxlen=100)
-
-        def _ui_log_sink(message):
-            log_buffer.append(message)
-            log_display.push(message.strip())
-
-        logger.add(_ui_log_sink, format=_format_log, level="INFO", enqueue=True)
-
-    with ui.grid(columns=16).classes("w-full gap-0"):
-        with ui.column().classes("col-span-1"):
-            pass
-        with ui.column().classes("col-span-7"):
-            with ui.row():
-                ui.label("Number of Bots")
-                num_of_bots_label = ui.label(str(DEFAULT_NUM_OF_BOTS))
-                num_of_bots = ui.slider(
-                    min=1,
-                    max=10,
-                    value=DEFAULT_NUM_OF_BOTS,
-                    step=1,
-                    on_change=lambda e: num_of_bots_label.set_text(f"{e.value}"),
-                )
-                chat_model_provider = ui.select(
-                    list(CHAT_MODEL_PROVIDERS.keys()),
-                    label="Chat Model Provider",
-                    value=list(CHAT_MODEL_PROVIDERS.keys())[0],
-                    on_change=lambda e: chat_model_name.set_value(CHAT_MODEL_PROVIDERS[e.value].get_default_model()),
-                ).classes("w-1/3")
-
-                chat_model_name = ui.input(
-                    label="Chat Model Name",
-                    value=CHAT_MODEL_PROVIDERS[chat_model_provider.value].get_default_model(),
-                ).classes("w-1/3")
-
-                room_code = (
-                    ui.input(
-                        label="Room Code",
-                        placeholder="ABCD",
-                        validation={
-                            "must be letters only": lambda value: value.isalpha(),
-                            "must be 4 letters": lambda value: len(value) == 4,
-                        },
-                    )
-                    .props("uppercase")
-                    .classes("w-1/4")
-                )
-                start_button = (
-                    ui.button("Start Bots", on_click=_handle_start_click, color="green")
-                    .bind_enabled_from(room_code, "error", lambda error: room_code.value and not error)
-                    .classes("w-full")
-                )
-
-                ui.label("Advanced Options").classes("w-full text-xl font-bold")
-
-                ui.label("Temperature").classes("w-1/4").tooltip(
-                    """
-                    What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
-                    make the output more random, while lower values like 0.2 will make it more
-                    focused and deterministic. We generally recommend altering this or `top_p` but
-                    not both."""
-                )
-                temperature_label = ui.label(str(DEFAULT_TEMPERATURE)).classes("w-1/6")
-                temperature = ui.slider(
-                    min=0.0,
-                    max=2.0,
-                    value=DEFAULT_TEMPERATURE,
-                    step=0.1,
-                    on_change=lambda e: temperature_label.set_text(f"{e.value}"),
-                ).classes("w-1/2")
-
-                ui.label("Top P").classes("w-1/4").tooltip(
-                    """
-                    An alternative to sampling with temperature, called nucleus sampling, where the
-                    model considers the results of the tokens with top_p probability mass. So 0.1
-                    means only the tokens comprising the top 10% probability mass are considered."""
-                )
-                top_p_label = ui.label(str(DEFAULT_TOP_P)).classes("w-1/6")
-                top_p = ui.slider(
-                    min=0.0,
-                    max=1.0,
-                    value=DEFAULT_TOP_P,
-                    step=0.1,
-                    on_change=lambda e: top_p_label.set_text(f"{e.value}"),
-                ).classes("w-1/2")
-
-        with ui.column().classes("col-span-1"):
-            pass
-
-        bot_variant_checkbox_states = {}
-
-        def select_all_changed():
-            for checkbox in bot_variant_checkbox_states.values():
-                checkbox.value = select_all_bot_variants.value
-
-        def sync_select_all():
-            all_checked = all(cb.value for cb in bot_variant_checkbox_states.values())
-            select_all_bot_variants.value = all_checked
-
-        with ui.column().classes("col-span-6"):
-            with ui.list().props("bordered separator").classes("w-full"):
-                with ui.item_label("Bot Personalities").props("header").classes("text-bold"):
-                    select_all_bot_variants = ui.checkbox(text="Select All", value=True)
-                    select_all_bot_variants.on("update:model-value", lambda e: select_all_changed())
-                ui.separator()
-                with ui.element("div").classes("overflow-y-auto h-64"):
-                    for variant in list(JackBoxBotVariant):
-                        with ui.item():
-                            with ui.item_section().props("avatar"):
-                                cb = ui.checkbox(value=True)
-                                cb.on("update:model-value", lambda e: sync_select_all())
-                                bot_variant_checkbox_states[variant.name] = cb
-                            with ui.item_section():
-                                ui.item_label(variant.value.name)
-                                ui.item_label(variant.value.personality).props("caption")
-
-    ui.timer(1.0, _refresh_button_state)

ai_plays_jackbox-0.1.0/ai_plays_jackbox/web_ui.py

@@ -1,12 +0,0 @@
-from nicegui import ui
-
-from ai_plays_jackbox.ui.create_ui import create_ui
-
-
-def web_ui(reload: bool = False):
-    create_ui()
-    ui.run(favicon="🤖", reload=reload)
-
-
-if __name__ in {"__main__", "__mp_main__"}:
-    web_ui(True)