ai-plays-jackbox 0.4.1__py3-none-any.whl

ai_plays_jackbox/bot/jackbox6/bot_base.py

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

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/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

@@ -0,0 +1,20 @@
+from abc import ABC
+
+from ai_plays_jackbox.bot.bot_base import JackBoxBotBase
+
+
+class JackBox7BotBase(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/jackbox7/quiplash3.py

@@ -0,0 +1,108 @@
+import random
+
+from loguru import logger
+
+from ai_plays_jackbox.bot.jackbox7.bot_base import JackBox7BotBase
+
+_QUIP_PROMPT_INSTRUCTIONS_TEMPLATE = """
+You are playing Quiplash 3. You need to fill in the given prompt.
+
+When generating your response, follow these rules:
+- Your personality is: {personality}
+- You response must be 45 letters or less.
+- Do not include quotes in your response.
+"""
+
+_FINAL_QUIP_PROMPT_INSTRUCTIONS_TEMPLATE = """
+You are playing Quiplash 3 and it is the final round. The prompt will include three blanks, all of which you need to fill in.
+
+When generating your response, follow these rules:
+- Your personality is: {personality}
+- Separate your answers by the character '|', for example 'Apple|Orange|Banana'.
+- Each answer must be 45 letters or less.
+- Do not include quotes in your response.
+"""
+
+_QUIP_CHOICE_PROMPT_INSTRUCTIONS_TEMPLATE = """
+You are playing Quiplash 3 and you need to vote for your favorite response to the prompt "{prompt}".
+Choose your favorite by responding with the number next to your choice. Only respond with the number and nothing else.
+"""
+
+
+class Quiplash3Bot(JackBox7BotBase):
+    _selected_avatar: bool = False
+
+    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_text = self._html_to_text(prompt.get("html", "")) if prompt is not None else ""
+        text_key = data.get("textKey", "")
+        match room_state:
+            case "EnterSingleText":
+                if not data["entry"]:
+                    quip = self._generate_quip(prompt_text)
+                    self._send_ws("text/update", {"key": text_key, "val": quip})
+            case "EnterTextList":
+                if not data["entries"]:
+                    quip = self._generate_quip(prompt_text, final_round=True)
+                    self._send_ws("text/update", {"key": text_key, "val": "\n".join(quip.split("|"))})
+            case "MakeSingleChoice":
+                choice = self._choose_favorite(prompt_text, data["choices"])
+                self._client_send({"action": "choose", "choice": choice})
+
+    def _handle_room_operation(self, data: dict):
+        if self._selected_avatar:
+            return
+        available_characters = [c["name"] for c in data["characters"] if c["available"]]
+        selected_character = random.choice(available_characters)
+        self._client_send({"action": "avatar", "name": selected_character})
+        self._selected_avatar = True
+
+    def _generate_quip(self, prompt: str, final_round: bool = False) -> str:
+        max_tokens = 10
+        instructions = _QUIP_PROMPT_INSTRUCTIONS_TEMPLATE.format(personality=self._personality)
+        if final_round:
+            max_tokens = 32
+            instructions = _FINAL_QUIP_PROMPT_INSTRUCTIONS_TEMPLATE.format(personality=self._personality)
+        quip = self._chat_model.generate_text(
+            prompt,
+            instructions,
+            max_tokens=max_tokens,
+            temperature=self._chat_model._chat_model_temperature,
+            top_p=self._chat_model._chat_model_top_p,
+        )
+        return quip
+
+    def _choose_favorite(self, prompt: str, choices: list[dict]) -> int:
+        choices_str = "\n".join([f"{i+1}. {v['html']}" for i, v in enumerate(choices)])
+        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,
+            max_tokens=1,
+        )
+        try:
+            choosen_prompt = int(response)
+        except ValueError:
+            logger.warning(f"Can't choose favorite since response was not an int: {response}")
+            return self._choose_random_favorite(choices)
+
+        if choosen_prompt < 1 or choosen_prompt > len(choices):
+            logger.warning(f"Can't choose favorite since response was not a valid value: {response}")
+            return self._choose_random_favorite(choices)
+        else:
+            return choosen_prompt - 1
+
+    def _choose_random_favorite(self, choices: list[dict]) -> int:
+        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