ai-plays-jackbox 0.0.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

ai_plays_jackbox/bot/jackbox6/joke_boat.py

@@ -0,0 +1,105 @@
+import random
+
+from loguru import logger
+
+from ai_plays_jackbox.bot.jackbox6.bot_base import JackBox6BotBase
+
+_TOPIC_PROMPT_TEMPLATE = """
+You are playing Joke Boat.
+
+You are being asked to come up with a topic that is {placeholder}.
+
+When generating your response, follow these rules:
+- Your personality is: {personality}
+- You response must be {max_length} characters or less
+- Your response should be a single word.
+- Do not include quotes in your response or any newlines, just the response itself
+"""
+
+_PUNCHLINE_INSTRUCTIONS_TEMPLATE = """
+You are playing Joke Boat. You need to fill in the given prompt with a punchline.
+
+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 or any newlines, just the response itself
+"""
+
+
+class JokeBoatBot(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)
+
+        match room_state:
+            case "MakeSingleChoice":
+                choices: list[dict] = data.get("choices", [])
+                choice_type = data.get("choiceType", "")
+                choice_indexes = [i for i in range(0, len(choices))]
+                selected_choice = random.choice(choice_indexes)
+
+                if choice_type == "ChooseAuthorReady":
+                    selected_choice = 1
+                if choice_type == "Skip":
+                    selected_choice = 0
+
+                if data.get("chosen", None) is None:
+                    self._client_send({"action": "choose", "choice": selected_choice})
+
+            case "EnterSingleText":
+                if "Write as many topics as you can." in clean_prompt:
+                    placeholder = data.get("placeholder", "")
+                    max_length = data.get("maxLength", 42)
+                    topic = self._generate_topic(placeholder, max_length)
+                    self._client_send({"action": "write", "entry": topic})
+                if "Write your punchline" in clean_prompt or "Write the punchline to this joke" in clean_prompt:
+                    max_length = data.get("maxLength", 80)
+                    punchline = self._generate_punchline(clean_prompt, max_length)
+                    self._client_send({"action": "write", "entry": punchline})
+
+    def _handle_room_operation(self, data: dict):
+        pass
+
+    def _generate_topic(self, placeholder: str, max_length: int) -> str:
+        logger.info("Generating topic...")
+        formatted_prompt = _TOPIC_PROMPT_TEMPLATE.format(
+            personality=self._personality,
+            placeholder=placeholder,
+            max_length=max_length,
+        )
+
+        topic = self._chat_model.generate_text(
+            formatted_prompt,
+            "",
+            temperature=self._chat_model._chat_model_temperature,
+            top_p=self._chat_model._chat_model_top_p,
+        )
+        return topic[:max_length]
+
+    def _generate_punchline(self, prompt: str, max_length: int) -> str:
+        logger.info("Generating punchline...")
+        formatted_instructions = _PUNCHLINE_INSTRUCTIONS_TEMPLATE.format(
+            personality=self._personality,
+            prompt=prompt,
+            max_length=max_length,
+        )
+        punchline = self._chat_model.generate_text(
+            prompt,
+            formatted_instructions,
+            temperature=self._chat_model._chat_model_temperature,
+            top_p=self._chat_model._chat_model_top_p,
+        )
+        return punchline[:max_length]

ai_plays_jackbox/bot/jackbox7/bot_base.py

@@ -1,4 +1,4 @@
-from abc import ABC, abstractmethod
+from abc import ABC
 
 from ai_plays_jackbox.bot.bot_base import JackBoxBotBase
 

ai_plays_jackbox/bot/jackbox7/quiplash3.py

@@ -75,7 +75,11 @@ class Quiplash3Bot(JackBox7BotBase):
             max_tokens = 32
             instructions = _FINAL_QUIP_PROMPT_INSTRUCTIONS_TEMPLATE.format(personality=self._personality)
         quip = self._chat_model.generate_text(
-            prompt, instructions=instructions, max_tokens=max_tokens, temperature=0.7, top_p=0.7
+            prompt,
+            instructions,
+            max_tokens=max_tokens,
+            temperature=self._chat_model._chat_model_temperature,
+            top_p=self._chat_model._chat_model_top_p,
         )
         return quip
 
@@ -84,7 +88,7 @@ class Quiplash3Bot(JackBox7BotBase):
         instructions = _QUIP_CHOICE_PROMPT_INSTRUCTIONS_TEMPLATE.format(prompt=prompt)
         response = self._chat_model.generate_text(
             f"Vote for your favorite response. Your options are: {choices_str}",
-            instructions=instructions,
+            instructions,
             max_tokens=1,
         )
         try:
@@ -100,5 +104,5 @@ class Quiplash3Bot(JackBox7BotBase):
             return choosen_prompt - 1
 
     def _choose_random_favorite(self, choices: list[dict]) -> int:
-        choices = [i for i in range(0, len(choices))]
-        return random.choice(choices)
+        choices_as_ints = [i for i in range(0, len(choices))]
+        return random.choice(choices_as_ints)

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/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/bot/standalone/drawful2.py

@@ -0,0 +1,159 @@
+import random
+
+from loguru import logger
+
+from ai_plays_jackbox.bot.bot_base import JackBoxBotBase
+
+_DRAWING_PROMPT_TEMPLATE = """
+You are playing Drawful 2.
+
+Generate an image with the following prompt: {prompt}
+
+When generating your response, follow these rules:
+- Your personality is: {personality}
+- Make sure to implement your personality somehow into the drawing, but keep the prompt in mind
+- The image must be a simple sketch
+- The image must have a white background and use black for the lines
+- Avoid intricate details
+"""
+
+
+class Drawful2Bot(JackBoxBotBase):
+    _drawing_completed: bool = False
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @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
+
+    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_text = self._html_to_text(prompt.get("html", "")) if prompt is not None else ""
+
+        match room_state:
+            case "Draw":
+                colors = data.get("colors", ["#fb405a", "#7a2259"])
+                selected_color = colors[0]
+                canvas_height = int(data.get("size", {}).get("height", 320))
+                canvas_width = int(data.get("size", {}).get("width", 320))
+                lines = self._generate_drawing(prompt_text, canvas_height, canvas_width)
+                object_key = data.get("objectKey", "")
+                if object_key != "":
+                    if not self._drawing_completed:
+                        self._object_update(
+                            object_key,
+                            {
+                                "lines": [{"color": selected_color, "thickness": 1, "points": l} for l in lines],
+                                "submit": True,
+                            },
+                        )
+                        # This prevents the bot from trying to draw multiple times
+                        self._drawing_completed = True
+
+            case "EnterSingleText":
+                # We need to reset this once we're entering options
+                self._drawing_completed = False
+                # Listen, the bot can't see the drawing
+                # so they're just going to say something
+                text_key = data.get("textKey", "")
+                self._text_update(text_key, self._generate_random_response())
+
+            case "MakeSingleChoice":
+                # Bot still can't see the drawing
+                # so just pick something
+                if data.get("type", "single") == "repeating":
+                    pass
+                choices = data.get("choices", [])
+                choices_as_ints = [i for i in range(0, len(choices))]
+                selected_choice = random.choice(choices_as_ints)
+                self._client_send({"action": "choose", "choice": selected_choice})
+
+    def _handle_room_operation(self, data: dict):
+        pass
+
+    def _generate_drawing(self, prompt: str, canvas_height: int, canvas_width: int) -> list[str]:
+        logger.info("Generating drawing...")
+        image_prompt = _DRAWING_PROMPT_TEMPLATE.format(prompt=prompt, personality=self._personality)
+        image_bytes = self._chat_model.generate_sketch(
+            image_prompt,
+            "",
+            temperature=self._chat_model._chat_model_temperature,
+            top_p=self._chat_model._chat_model_top_p,
+        )
+        return self._image_bytes_to_polylines(image_bytes, canvas_height, canvas_width)
+
+    def _generate_random_response(self) -> str:
+        possible_responses = [
+            "Abstract awkward silence",
+            "Abstract existential dread",
+            "Abstract late-stage capitalism",
+            "Abstract lost hope",
+            "Abstract the void",
+            "Baby Yoda, but weird",
+            "Barbie, but weird",
+            "Confused dentist",
+            "Confused gym teacher",
+            "Confused lawyer",
+            "Confused therapist",
+            "DJ in trouble",
+            "Definitely banana",
+            "Definitely blob",
+            "Definitely potato",
+            "Definitely spaghetti",
+            "Taylor Swift, but weird",
+            "Waluigi, but weird",
+            "banana with feelings",
+            "chicken riding a scooter",
+            "cloud with feelings",
+            "confused gym teacher",
+            "confused therapist",
+            "dentist in trouble",
+            "duck + existential dread",
+            "duck riding a scooter",
+            "excited janitor",
+            "ferret + awkward silence",
+            "giraffe + awkward silence",
+            "giraffe filing taxes",
+            "hamster + existential dread",
+            "hamster + lost hope",
+            "hamster riding a scooter",
+            "janitor in trouble",
+            "joyful octopus",
+            "lawyer in trouble",
+            "llama + awkward silence",
+            "llama + late-stage capitalism",
+            "lonely dentist",
+            "lonely hamster",
+            "lonely janitor",
+            "lonely pirate",
+            "mango with feelings",
+            "pirate in trouble",
+            "sad DJ",
+            "sad hamster",
+            "spaghetti with feelings",
+            "terrified duck",
+            "terrified ferret",
+            "terrified lawyer",
+        ]
+        chosen_response = random.choice(possible_responses)
+        return chosen_response

ai_plays_jackbox/{cli.py → cli/main.py}

@@ -1,6 +1,12 @@
 import argparse
 
-from ai_plays_jackbox import run
+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 _validate_room_code(string_to_check: str) -> str:
@@ -39,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",
@@ -49,46 +55,53 @@ def cli():
         metavar="WXYZ",
     )
     parser.add_argument(
-        "--chat-model-name",
+        "--chat-model-provider",
         required=True,
         help="Choose which chat model platform to use",
-        choices=("ollama", "openai", "gemini"),
+        choices=list(CHAT_MODEL_PROVIDERS.keys()),
+        type=str,
+    )
+    parser.add_argument(
+        "--chat-model-name",
+        required=False,
+        help="Choose which chat model to use (Will default to default for provider)",
         type=str,
     )
     parser.add_argument(
         "--num-of-bots",
         required=False,
-        default=4,
-        help="How many bots to have play (Defaults to 4)",
+        default=DEFAULT_NUM_OF_BOTS,
+        help="How many bots to have play",
         type=_validate_num_of_bots,
-        metavar="4",
+        metavar=str(DEFAULT_NUM_OF_BOTS),
     )
     parser.add_argument(
         "--temperature",
         required=False,
-        default=0.5,
-        help="Temperature for Gen AI (Defaults to 0.5)",
+        default=DEFAULT_TEMPERATURE,
+        help="Temperature for Gen AI",
         type=_validate_temperature,
-        metavar="0.5",
+        metavar=str(DEFAULT_TEMPERATURE),
     )
     parser.add_argument(
         "--top-p",
         required=False,
-        default=0.9,
-        help="Top P for Gen AI (Defaults to 0.9)",
+        default=DEFAULT_TOP_P,
+        help="Top P for Gen AI",
         type=_validate_top_p,
-        metavar="0.9",
+        metavar=str(DEFAULT_TOP_P),
     )
     args = parser.parse_args()
 
     run(
         args.room_code.upper(),
-        num_of_bots=args.num_of_bots,
+        args.chat_model_provider,
         chat_model_name=args.chat_model_name,
+        num_of_bots=args.num_of_bots,
         chat_model_temperature=args.temperature,
         chat_model_top_p=args.top_p,
     )
 
 
 if __name__ == "__main__":
-    cli()
+    main()

ai_plays_jackbox/constants.py

@@ -1 +1,4 @@
 ECAST_HOST = "ecast.jackboxgames.com"
+DEFAULT_TEMPERATURE = 0.5
+DEFAULT_TOP_P = 0.9
+DEFAULT_NUM_OF_BOTS = 4

ai_plays_jackbox/llm/chat_model.py

@@ -3,13 +3,20 @@ from typing import Optional
 
 
 class ChatModel(ABC):
-    _chat_model_temperature: float = 0.5
-    _chat_model_top_p: float = 0.9
+    _model: str
+    _chat_model_temperature: float
+    _chat_model_top_p: float
 
-    def __init__(self, chat_model_temperature: float = 0.5, chat_model_top_p: float = 0.9):
+    def __init__(self, model: str, chat_model_temperature: float = 0.5, chat_model_top_p: float = 0.9):
+        self._model = model
         self._chat_model_temperature = chat_model_temperature
         self._chat_model_top_p = chat_model_top_p
 
+    @classmethod
+    @abstractmethod
+    def get_default_model(self) -> str:
+        pass
+
     @abstractmethod
     def generate_text(
         self,
@@ -20,3 +27,13 @@ class ChatModel(ABC):
         top_p: Optional[float] = None,
     ) -> str:
         pass
+
+    @abstractmethod
+    def generate_sketch(
+        self,
+        prompt: str,
+        instructions: str,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+    ) -> bytes:
+        pass