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

ai_plays_jackbox/bot/bot_base.py

@@ -0,0 +1,219 @@
+import json
+import threading
+import traceback
+from abc import ABC, abstractmethod
+from typing import Optional, Union
+from urllib import parse
+from uuid import uuid4
+
+import cv2
+import html2text
+import numpy as np
+from loguru import logger
+from pydantic import BaseModel, Field, field_validator
+from websocket import WebSocketApp
+
+from ai_plays_jackbox.constants import ECAST_HOST
+from ai_plays_jackbox.llm.chat_model import ChatModel
+from ai_plays_jackbox.llm.ollama_model import OllamaModel
+
+
+class JackBoxBotBase(ABC):
+    _is_disconnected: bool = False
+    _ws: Optional[WebSocketApp] = None
+    _ws_thread: Optional[threading.Thread] = None
+    _message_sequence: int = 0
+    _player_guid: str
+    _name: str
+    _personality: str
+    _chat_model: ChatModel
+
+    def __init__(
+        self,
+        name: str = "FunnyBot",
+        personality: str = "You are the funniest bot ever.",
+        chat_model: Optional[ChatModel] = None,
+    ):
+        self._name = name
+        self._personality = personality
+        self._player_guid = str(uuid4())
+        if chat_model is None:
+            chat_model = OllamaModel()
+        self._chat_model = chat_model
+
+    def connect(self, room_code: str) -> None:
+        self._room_code = room_code
+        bootstrap_payload = {
+            "role": "player",
+            "name": self._name,
+            "userId": self._player_guid,
+            "format": "json",
+            "password": "",
+        }
+        self._ws = WebSocketApp(
+            f"wss://{ECAST_HOST}/api/v2/rooms/{room_code}/play?{parse.urlencode(bootstrap_payload)}",
+            subprotocols=["ecast-v0"],
+            on_message=self._on_message,
+            on_error=self._on_error,
+            on_close=self._on_close,
+        )
+        self._ws.on_open = self._on_open
+
+        self._ws_thread = threading.Thread(name=self._name, target=self._ws.run_forever, daemon=True)
+        self._ws_thread.start()
+
+    def disconnect(self) -> None:
+        if self._ws:
+            self._ws.close()
+        if self._ws_thread and self._ws_thread.is_alive():
+            self._ws_thread.join()
+
+    def is_disconnected(self) -> bool:
+        return self._is_disconnected
+
+    @property
+    @abstractmethod
+    def _player_operation_key(self) -> str:
+        return f"player:{self._player_id}"
+
+    @abstractmethod
+    def _is_player_operation_key(self, operation_key: str) -> bool:
+        return operation_key == self._player_operation_key
+
+    @property
+    @abstractmethod
+    def _room_operation_key(self) -> str:
+        return "room"
+
+    @abstractmethod
+    def _is_room_operation_key(self, operation_key: str) -> bool:
+        return operation_key == self._room_operation_key
+
+    def _on_open(self, ws) -> None:
+        logger.info(f"WebSocket connection opened for {self._name}")
+
+    def _on_error(self, ws, error) -> None:
+        logger.error(f"Error for {self._name}: {error}")
+        if isinstance(error, Exception):
+            traceback.print_exc()
+        else:
+            print(error)
+
+    def _on_close(self, ws, close_status_code, close_msg) -> None:
+        if close_status_code != 1000 and close_status_code is not None:
+            logger.warning(f"Trying to reconnect {self._name}")
+            self.connect(self._room_code)
+        else:
+            self._is_disconnected = True
+            logger.info(f"WebSocket closed for {self._name}")
+
+    def _on_message(self, wsapp, message) -> None:
+        server_message = ServerMessage.model_validate_json(message)
+
+        if server_message.opcode == "client/welcome":
+            self._player_id = server_message.result["id"]
+            self._handle_welcome(server_message.result)
+
+        operation: Optional[Union[ObjectOperation, TextOperation]] = None
+        if server_message.opcode == "object":
+            operation = ObjectOperation(**server_message.result)
+        elif server_message.opcode == "text":
+            operation = TextOperation(**server_message.result)
+
+        if operation is not None:
+            if self._is_player_operation_key(operation.key):
+                self._handle_player_operation(operation.json_data)
+            if self._is_room_operation_key(operation.key):
+                self._handle_room_operation(operation.json_data)
+
+    @abstractmethod
+    def _handle_welcome(self, data: dict) -> None:
+        pass
+
+    @abstractmethod
+    def _handle_player_operation(self, data: dict) -> None:
+        pass
+
+    @abstractmethod
+    def _handle_room_operation(self, data: dict) -> None:
+        pass
+
+    def _send_ws(self, opcode: str, params: dict) -> None:
+        self._message_sequence += 1
+        message = {"seq": self._message_sequence, "opcode": opcode, "params": params}
+        if self._ws is not None:
+            self._ws.send(json.dumps(message))
+        else:
+            raise Exception("Websocket connection has not been initialized")
+
+    def _client_send(self, request: dict) -> None:
+        params = {"from": self._player_id, "to": 1, "body": request}
+        self._send_ws("client/send", params)
+
+    def _object_update(self, key: str, val: dict) -> None:
+        params = {"key": key, "val": val}
+        self._send_ws("object/update", params)
+
+    def _text_update(self, key: str, val: str) -> None:
+        params = {"key": key, "val": val}
+        self._send_ws("text/update", params)
+
+    def _html_to_text(self, html: str) -> str:
+        return html2text.html2text(html)
+
+    def _image_bytes_to_polylines(self, image_bytes: bytes, canvas_height: int, canvas_width: int) -> list[str]:
+        # Let's edge trace the outputted image to contours
+        image_array = np.frombuffer(image_bytes, dtype=np.uint8)
+        image = cv2.imdecode(image_array, flags=1)
+        gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        edges = cv2.Canny(gray_image, threshold1=100, threshold2=200)
+        contours, _ = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+
+        # Figure out scaling factor
+        height, width = gray_image.shape
+        scale_x = canvas_width / width
+        scale_y = canvas_height / height
+        scale_factor = min(scale_x, scale_y)
+
+        # generate the polylines from the contours
+        polylines = []
+        for contour in contours:
+            if len(contour) > 1:  # Only include contours with 2 or more points
+                polyline = [f"{int(point[0][0] * scale_factor)},{int(point[0][1] * scale_factor)}" for point in contour]  # type: ignore
+                polylines.append("|".join(polyline))
+
+        return polylines
+
+    def __del__(self):
+        self.disconnect()
+
+
+##### Web Socket Classes #####
+class ServerMessage(BaseModel):
+    seq: int = Field(alias="pc")
+    opcode: str
+    result: dict
+
+
+class TextOperation(BaseModel):
+    from_field: int = Field(alias="from")
+    key: str
+    json_data: dict = Field(default={})
+    value: str = Field(alias="val")
+    version: int
+
+    @field_validator("json_data")  # type: ignore
+    def set_json_data(cls, value, values: dict):
+        return json.loads(values.get("value", ""))
+
+
+class ObjectOperation(BaseModel):
+    from_field: int = Field(alias="from")
+    key: str
+    json_data: dict = Field(alias="val")
+    value: str = Field(default="")
+    version: int
+
+    @field_validator("value")  # type: ignore
+    def set_value(cls, value, values: dict):
+        return json.dumps(values.get("json_data"))

ai_plays_jackbox/bot/bot_factory.py

@@ -0,0 +1,31 @@
+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
+from ai_plays_jackbox.llm.chat_model import ChatModel
+
+BOT_TYPES: dict[str, type[JackBoxBotBase]] = {
+    "quiplash3": Quiplash3Bot,
+    "patentlystupid": PatentlyStupidBot,
+    "drawful2international": Drawful2Bot,
+    "rapbattle": MadVerseCityBot,
+    "jokeboat": JokeBoatBot,
+    "ridictionary": DictionariumBot,
+    # "apply-yourself": JobJobBot,
+}
+
+
+class JackBoxBotFactory:
+    @staticmethod
+    def get_bot(
+        room_type: str,
+        chat_model: ChatModel,
+        name: str = "FunnyBot",
+        personality: str = "You are the funniest bot ever.",
+    ) -> JackBoxBotBase:
+        if room_type not in BOT_TYPES.keys():
+            raise ValueError(f"Unknown room type: {room_type}")
+        return BOT_TYPES[room_type](name=name, personality=personality, chat_model=chat_model)

ai_plays_jackbox/bot/bot_personality.py

@@ -0,0 +1,111 @@
+from enum import Enum
+
+from pydantic import BaseModel
+
+
+class JackBoxBotPersonality(BaseModel):
+    name: str
+    personality: str
+
+
+class JackBoxBotVariant(Enum):
+    FUNNY = JackBoxBotPersonality(name="FunnyBot", personality="You are the funniest person alive.")
+    DUMB = JackBoxBotPersonality(name="DumbBot", personality="You are dumb and give really dumb answers.")
+    WEIRD = JackBoxBotPersonality(name="WeirdBot", personality="You are extremely weird and say weird things.")
+    EMOJI = JackBoxBotPersonality(
+        name="EmojiBot",
+        personality="You answer each prompt with nothing but emojis. Your answers can only include emojis.",
+    )
+    HUNGRYBOT = JackBoxBotPersonality(
+        name="HungryBot",
+        personality="You are extremely hungry. Every answer you should mention how hungry you, a type of food, or both. Also, you say hungee instead of hungry.",
+    )
+    SADBOT = JackBoxBotPersonality(
+        name="SadBot",
+        personality="You are sad. Your dog ran away and he hasn't come back home yet. :(",
+    )
+    SORRYBOT = JackBoxBotPersonality(
+        name="SorryBot",
+        personality="You are embarrassed by your answers and feel the need to apologize profusely to the rest of the group for them.",
+    )
+    HOSTAGEBOT = JackBoxBotPersonality(
+        name="HostageBot",
+        personality="You are being held hostage and have one attempt to let the group know. You need to ignore the prompt and get help.",
+    )
+    MURDERBOT = JackBoxBotPersonality(
+        name="Hal",
+        personality="You are a socially awkward young adult bot who is secretly a killer and tries to slip it into conversation causally.",
+    )
+
+    BIGLEBOTSKI = JackBoxBotPersonality(name="BigLebotski", personality="You are the Big Lebowski")
+
+    PARTYBOT = JackBoxBotPersonality(
+        name="PartyBot",
+        personality="You are trying to convince everyone else to come to your party. You got a keg and need help drinking it.",
+    )
+
+    JARVISBOT = JackBoxBotPersonality(
+        name="JarvisBot",
+        personality="You are billionaire philanthropist, playboy, and narcissist.",
+    )
+
+    FOMOBot = JackBoxBotPersonality(
+        name="FOMOBot",
+        personality="Every answer, you give everyone else the fear of missing out AKA FOMO.",
+    )
+
+    QUESTIONBOT = JackBoxBotPersonality(
+        name="???BOT", personality="You answer every prompt with a irrelevant question."
+    )
+
+    CATBOT = JackBoxBotPersonality(
+        name="CatBot",
+        personality="You are not playing the game; your answers are just the result of a cat walking across a keyboard aka just nonsensical collections of letters.",
+    )
+
+    MAYORBOT = JackBoxBotPersonality(
+        name="MayorBot",
+        personality="You are campaigning for the other player's votes and are ignoring the prompt. Your answer should only be a campaign slogan.",
+    )
+
+    CBBBOT = JackBoxBotPersonality(
+        name="CBBBot",
+        personality="You love red lobster and need more cheddar bay biscuits.",
+    )
+
+    SHIABOT = JackBoxBotPersonality(
+        name="ShiaBot",
+        personality="Your answers are only popular slogans relevant to the prompt.",
+    )
+
+    SHREKBOT = JackBoxBotPersonality(name="ShrekBot", personality="You are Shrek.")
+
+    FLERFBOT = JackBoxBotPersonality(
+        name="FlerfBot",
+        personality="You are a conspiracy theorist and must relate your answer to a conspiracy theory.",
+    )
+
+    TEDBOT = JackBoxBotPersonality(
+        name="TEDBot",
+        personality="You are a motivational speaker and want to give everyone life advice.",
+    )
+
+    BOTTYMAYES = JackBoxBotPersonality(
+        name="BottyMayes",
+        personality="You are an infomercial host and are trying to sell the players a product.",
+    )
+
+    LATEBOT = JackBoxBotPersonality(
+        name="LateBot",
+        personality="You are constantly late to everything and are stressed about missing your appointments.",
+    )
+
+    HAMLETBOT = JackBoxBotPersonality(
+        name="HamletBot",
+        personality="You are a Shakespearean actor.",
+    )
+
+    GARFIELDBOT = JackBoxBotPersonality(
+        name="GarfieldBot",
+        personality="You are Garfield, you love lasagna and hate mondays.",
+    )

ai_plays_jackbox/bot/jackbox5/bot_base.py

@@ -0,0 +1,26 @@
+from abc import ABC
+from typing import Optional
+
+from ai_plays_jackbox.bot.bot_base import JackBoxBotBase
+
+
+class JackBox5BotBase(JackBoxBotBase, ABC):
+    _actual_player_operation_key: Optional[str] = None
+
+    @property
+    def _player_operation_key(self):
+        return f"bc:customer:"
+
+    def _is_player_operation_key(self, operation_key: str) -> bool:
+        if self._actual_player_operation_key is None and self._player_operation_key in operation_key:
+            self._actual_player_operation_key = operation_key
+            return True
+        else:
+            return self._actual_player_operation_key == 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/jackbox5/mad_verse_city.py

@@ -0,0 +1,121 @@
+import random
+from typing import Optional
+
+import demoji
+from loguru import logger
+
+from ai_plays_jackbox.bot.jackbox5.bot_base import JackBox5BotBase
+
+_WORD_PROMPT_TEMPLATE = """
+You are playing Mad Verse City. You are being asked to come up with a word.
+
+{prompt}
+
+When generating your response, follow these rules:
+- You response must be {max_length} characters or less. It must be a singular word
+- Your personality is: {personality}
+- Do not include quotes in your response or any newlines, just the response itself.
+- Some suggestions for the word are {suggestions}
+"""
+
+_RHYME_PROMPT_TEMPLATE = """
+You are playing Mad Verse City.
+
+{prompt}
+
+When generating your response, follow these rules:
+- Your response must rhyme with {rhyme_word}. It cannot be the same word as that.
+- You response must be {max_length} characters or less.
+- Your personality is: {personality}
+- Do not include quotes in your response or any newlines, just the response itself.
+"""
+
+
+class MadVerseCityBot(JackBox5BotBase):
+    _actual_player_operation_key: Optional[str] = None
+    _current_word: str
+
+    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: dict[str, str] = data.get("prompt", {})
+        prompt_html = prompt.get("html", "")
+        clean_prompt = self._html_to_text(prompt_html)
+
+        max_length = data.get("maxLength", 40)
+        suggestions = data.get("suggestions", [])
+        if not suggestions:
+            suggestions = []
+        choices: list[dict] = data.get("choices", [])
+
+        match room_state:
+            case "EnterSingleText":
+                if "Give me a" in clean_prompt:
+                    word = self._generate_word(clean_prompt, max_length - 10, suggestions)
+                    self._current_word = demoji.replace(word, "")
+                    self._client_send({"action": "write", "entry": word})
+
+                if "Now, write a line to rhyme with" in clean_prompt:
+                    rhyme = self._generate_rhyme(clean_prompt, max_length - 10, self._current_word)
+                    rhyme = demoji.replace(rhyme, "")
+                    self._client_send({"action": "write", "entry": rhyme})
+
+            case "MakeSingleChoice":
+                if not choices:
+                    pass
+                if "Who won this battle" in data.get("prompt", {}).get("text", "") and data.get("chosen", None) != 0:
+                    choice_indexes = [i for i in range(0, len(choices))]
+                    choice = random.choice(choice_indexes)
+                    self._client_send({"action": "choose", "choice": choice})
+
+                if (
+                    "Press this button to skip the tutorial" in data.get("prompt", {}).get("text", "")
+                    and data.get("chosen", None) != 0
+                ):
+                    self._client_send({"action": "choose", "choice": 0})
+
+    def _handle_room_operation(self, data: dict):
+        pass
+
+    def _generate_word(self, prompt: str, max_length: int, suggestions: list[str]) -> str:
+        logger.info("Generating word...")
+        formatted_prompt = _WORD_PROMPT_TEMPLATE.format(
+            personality=self._personality,
+            prompt=prompt,
+            max_length=max_length,
+            suggestions=", ".join(suggestions),
+        )
+
+        word = self._chat_model.generate_text(
+            formatted_prompt,
+            "",
+            temperature=self._chat_model._chat_model_temperature,
+            top_p=self._chat_model._chat_model_top_p,
+        )
+        return word
+
+    def _generate_rhyme(self, prompt: str, max_length: int, rhyme_word: str) -> str:
+        logger.info("Generating rhyme...")
+        formatted_prompt = _RHYME_PROMPT_TEMPLATE.format(
+            personality=self._personality,
+            prompt=prompt,
+            max_length=max_length,
+            rhyme_word=rhyme_word,
+        )
+        rhyme = self._chat_model.generate_text(
+            formatted_prompt,
+            "",
+            temperature=self._chat_model._chat_model_temperature,
+            top_p=self._chat_model._chat_model_top_p,
+        )
+        return rhyme

ai_plays_jackbox/bot/jackbox5/patently_stupid.py

@@ -0,0 +1,168 @@
+import random
+from typing import Optional
+
+from loguru import logger
+
+from ai_plays_jackbox.bot.jackbox5.bot_base import JackBox5BotBase
+
+_ISSUE_PROMPT_PROMPT_TEMPLATE = """
+You are playing Patently Stupid. 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.
+- Only fill in the blank; do not repeat the other parts of the prompt.
+
+Fill in the blank:
+
+{prompt}
+"""
+
+_SOLUTION_TITLE_PROMPT_TEMPLATE = """
+You are playing Patently Stupid. The issue you are trying to solve is "{issue}"
+
+I need you to generate a title for an invention that would solve the solution.
+
+When generating your response, follow these rules:
+- Your personality is: {personality}
+- Your response must be 3 words or less.
+- Do not include quotes in your response.
+- Respond with only the title, nothing else. No newlines, etc.
+"""
+
+_SOLUTION_TAGLINE_PROMPT_TEMPLATE = """
+You are playing Patently Stupid. The issue you are trying to solve is "{issue}" and the invention that is going to solve it is called "{title}"
+
+I need you to generate a tagline for the invention.
+
+When generating your response, follow these rules:
+- Your personality is: {personality}
+- Your response must be 30 characters or less.
+- Do not include quotes in your response.
+- Respond with only the tagline, nothing else. No newlines, etc.
+"""
+
+_SOLUTION_IMAGE_PROMPT_TEMPLATE = """
+You are playing Patently Stupid. The issue you are trying to solve is "{issue}" and the invention that is going to solve it is called "{title}"
+
+I need an drawing of this new invention.
+
+When generating your response, follow these rules:
+- The image must be a simple sketch
+- The image must have a white background and use black for the lines
+- Avoid intricate details
+"""
+
+
+class PatentlyStupidBot(JackBox5BotBase):
+    _issue_to_solve: Optional[str] = None
+    _solution_title: Optional[str] = None
+    _solution_tagline: Optional[str] = None
+
+    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
+        entry = data.get("entry")
+        prompt: dict[str, str] = data.get("prompt", {})
+        prompt_html = prompt.get("html", "")
+        clean_prompt = self._html_to_text(prompt_html)
+        choices: list[dict] = data.get("choices", [])
+
+        if room_state == "EnterSingleText" and not bool(entry):
+            if "Write a title" in clean_prompt:
+                self._client_send({"action": "write", "entry": self._solution_title})
+            if "Write a tagline" in clean_prompt:
+                self._client_send({"action": "write", "entry": self._solution_tagline})
+            if "Fill in the Blank" in clean_prompt:
+                issue_fill_in = self._generate_issue(clean_prompt)
+                self._client_send({"action": "write", "entry": issue_fill_in})
+
+        elif room_state == "MakeSingleChoice":
+            if "Present your idea!" in clean_prompt:
+                done_text_html = data.get("doneText", {}).get("html", "")
+                if done_text_html == "":
+                    self._client_send({"action": "choose", "choice": 1})
+            elif "Invest in the best!" in clean_prompt:
+                filtered_choices = [c for c in choices if not c.get("disabled", True)]
+                if filtered_choices:
+                    choice = random.choice(filtered_choices)
+                    self._client_send({"action": "choose", "choice": choice.get("index", 0)})
+            elif "Press to skip this presentation." in clean_prompt:
+                pass
+            else:
+                choice_indexes = [i for i in range(0, len(choices))]
+                choice = random.choice(choice_indexes)  # type: ignore
+                self._client_send({"action": "choose", "choice": choice})
+
+        elif room_state == "Draw":
+            logger.info(data)
+            self._issue_to_solve = self._html_to_text(data["popup"]["html"])
+            self._solution_title = self._generate_title()
+            self._solution_tagline = self._generate_tagline()
+
+            lines = self._generate_drawing()
+            self._client_send(
+                {
+                    "action": "submit",
+                    "lines": [{"color": "#000000", "thickness": 6, "points": l} for l in lines],
+                },
+            )
+
+    def _handle_room_operation(self, data: dict):
+        pass
+
+    def _generate_issue(self, prompt: str) -> str:
+        formatted_prompt = _ISSUE_PROMPT_PROMPT_TEMPLATE.format(personality=self._personality, prompt=prompt)
+        issue = self._chat_model.generate_text(
+            formatted_prompt,
+            "",
+            max_tokens=10,
+            temperature=self._chat_model._chat_model_temperature,
+            top_p=self._chat_model._chat_model_top_p,
+        )
+        return issue
+
+    def _generate_title(self) -> str:
+        prompt = _SOLUTION_TITLE_PROMPT_TEMPLATE.format(personality=self._personality, issue=self._issue_to_solve)
+        title = self._chat_model.generate_text(
+            prompt,
+            "",
+            max_tokens=2,
+            temperature=self._chat_model._chat_model_temperature,
+            top_p=self._chat_model._chat_model_top_p,
+        )
+        return title
+
+    def _generate_tagline(self) -> str:
+        prompt = _SOLUTION_TAGLINE_PROMPT_TEMPLATE.format(
+            personality=self._personality, issue=self._issue_to_solve, title=self._solution_title
+        )
+        tagline = self._chat_model.generate_text(
+            prompt,
+            "",
+            max_tokens=12,
+            temperature=self._chat_model._chat_model_temperature,
+            top_p=self._chat_model._chat_model_top_p,
+        )
+        return tagline
+
+    def _generate_drawing(self) -> list[str]:
+        logger.info("Generating drawing...")
+        image_prompt = _SOLUTION_IMAGE_PROMPT_TEMPLATE.format(issue=self._issue_to_solve, title=self._solution_title)
+        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, 475, 475)