mikubot 0.1.0__tar.gz

mikubot-0.1.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: mikubot
+Version: 0.1.0
+Summary: Discord bot used for the Eden-Project Discord server.
+Keywords: discord,eden,miku,vocaloid,project diva
+Author: Jay184
+Author-email: Jay184 <me@jay0.mozmail.com>
+License-Expression: 0BSD
+Requires-Dist: capstone>=5.0.6
+Requires-Dist: discord-py>=2.6.3
+Requires-Dist: emoji>=2.14.1
+Requires-Dist: googletrans>=4.0.2
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: matplotlib>=3.10.6
+Requires-Dist: msgpack>=1.1.1
+Requires-Dist: pandas>=2.3.2
+Requires-Dist: pefile>=2024.8.26
+Requires-Dist: pillow>=11.3.0
+Requires-Dist: pydantic>=2.11.9
+Requires-Dist: pydantic-settings>=2.10.1
+Requires-Dist: requests>=2.32.5
+Requires-Dist: requests-sse>=0.5.2
+Requires-Dist: rich>=14.1.0
+Requires-Dist: sqlitedict>=2.1.0
+Requires-Dist: sqlmodel>=0.0.27
+Requires-Dist: typer>=0.19.2
+Requires-Dist: uwuipy>=0.1.10
+Requires-Dist: yfinance>=0.2.66
+Maintainer: Jay184
+Maintainer-email: Jay184 <me@jay0.mozmail.com>
+Requires-Python: >=3.11
+Project-URL: Issues, https://github.com/Jay184/mikubot/issues
+Project-URL: Repository, https://github.com/Jay184/mikubot.git
+Description-Content-Type: text/markdown
+
+# MikuBot
+
+Bot used for the Eden Project discord server.
+
+## Prerequisites
+
+* Python 3.11 or above
+
+## Usage
+
+### Windows
+
+1. Create a `token.txt` which contains the bot's token.
+1. Copy the `settings.json.template` and rename it to `settings.json` and fill it out with the necessary data.
+1. run the `run.cmd`.
+
+_Note: Make sure `py` starts a Python interpreter or change the `run.cmd` to use `python` instead._
+
+## Acknowledgements
+
+* [Bot Avatar](https://cdn.discordapp.com/app-icons/1078530934766321744/65ae221617e928f3ff928e535885d66d.png?size=256)

mikubot-0.1.0/README.md

@@ -0,0 +1,21 @@
+# MikuBot
+
+Bot used for the Eden Project discord server.
+
+## Prerequisites
+
+* Python 3.11 or above
+
+## Usage
+
+### Windows
+
+1. Create a `token.txt` which contains the bot's token.
+1. Copy the `settings.json.template` and rename it to `settings.json` and fill it out with the necessary data.
+1. run the `run.cmd`.
+
+_Note: Make sure `py` starts a Python interpreter or change the `run.cmd` to use `python` instead._
+
+## Acknowledgements
+
+* [Bot Avatar](https://cdn.discordapp.com/app-icons/1078530934766321744/65ae221617e928f3ff928e535885d66d.png?size=256)

mikubot-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "mikubot"
+version = "0.1.0"
+description = "Discord bot used for the Eden-Project Discord server."
+keywords = ["discord", "eden", "miku", "vocaloid", "project diva"]
+authors = [
+  {name = "Jay184", email = "me@jay0.mozmail.com"},
+]
+maintainers = [
+  {name = "Jay184", email = "me@jay0.mozmail.com"},
+]
+license = "0BSD"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "capstone>=5.0.6",
+    "discord-py>=2.6.3",
+    "emoji>=2.14.1",
+    "googletrans>=4.0.2",
+    "jinja2>=3.1.6",
+    "loguru>=0.7.3",
+    "matplotlib>=3.10.6",
+    "msgpack>=1.1.1",
+    "pandas>=2.3.2",
+    "pefile>=2024.8.26",
+    "pillow>=11.3.0",
+    "pydantic>=2.11.9",
+    "pydantic-settings>=2.10.1",
+    "requests>=2.32.5",
+    "requests-sse>=0.5.2",
+    "rich>=14.1.0",
+    "sqlitedict>=2.1.0",
+    "sqlmodel>=0.0.27",
+    "typer>=0.19.2",
+    "uwuipy>=0.1.10",
+    "yfinance>=0.2.66",
+]
+
+[project.scripts]
+mikubot = "mikubot:main"
+
+[project.urls]
+Repository = "https://github.com/Jay184/mikubot.git"
+Issues = "https://github.com/Jay184/mikubot/issues"
+
+[build-system]
+requires = ["uv_build>=0.8.12,<0.9.0"]
+build-backend = "uv_build"

mikubot-0.1.0/src/mikubot/__init__.py

@@ -0,0 +1,16 @@
+from .config import Settings
+from .discord import Bot
+from .logger import setup_logger
+
+
+def main() -> None:
+    settings = Settings.load()
+
+    if settings.discord_key:
+        setup_logger(settings.logging)
+        client = Bot(settings)
+        client.run(settings.discord_key)
+
+
+if __name__ == "__main__":
+    main()

mikubot-0.1.0/src/mikubot/commands/__init__.py

@@ -0,0 +1,21 @@
+from .sync import *
+from .stop import *
+from .reply_commands import *
+from .settings import *
+from .code import *
+from .avatar import *
+from .clap import *
+from .edenpatch import *
+from .gamebanana import *
+from .it import *
+from .list_brazil import *
+from .purge import *
+from .rename_channel import *
+from .role import *
+from .toggle_bot_response import *
+from .user_count import *
+from .uwu import *
+from .you_are_going_to_brazil import *
+from .zoe import *
+from .guess import *
+from .goofy_translate import *

mikubot-0.1.0/src/mikubot/commands/avatar.py

@@ -0,0 +1,22 @@
+from discord import Interaction, Embed, Member
+from discord.app_commands import describe, checks
+from mikubot import Bot
+
+
+def register(bot: Bot):
+    @bot.tree.command(name="avatar", description="Get the avatar of a user.")
+    @checks.bot_has_permissions(send_messages=True)
+    @describe(user="The user to retrieve the avatar of.")
+    async def handler(interaction: Interaction, user: Member):
+        embed = Embed(
+            title=f"{user.name}'s Avatar",
+            color=0x0099ff,
+        )
+
+        embed.set_footer(text=bot.user.display_name)
+        embed.set_image(url=user.display_avatar.url)
+
+        await interaction.response.send_message(  # noqa
+            embed=embed,
+            ephemeral=True,
+        )

mikubot-0.1.0/src/mikubot/commands/clap.py

@@ -0,0 +1,19 @@
+from discord import Interaction, Message
+from discord.app_commands import describe, checks
+from mikubot import Bot
+import re
+
+
+def register(bot: Bot):
+    @bot.tree.command(name="clap", description="Adds 👏 Clap 👏 Emoji 👏 in 👏 between 👏 each 👏 word.")
+    @checks.bot_has_permissions(send_messages=True)
+    @describe(text="The text you want to add claps to.")
+    async def handler(interaction: Interaction, text: str):
+        text = re.sub(r"\s+", " 👏 ", text)
+        await interaction.response.send_message(text[:2000])  # noqa
+
+    @bot.tree.context_menu(name="clap")
+    @checks.bot_has_permissions(send_messages=True)
+    async def context_handler(interaction: Interaction, message: Message):
+        text = re.sub(r"\s+", " 👏 ", message.content)
+        await interaction.response.send_message(text[:2000], allowed_mentions=None)  # noqa

mikubot-0.1.0/src/mikubot/commands/code.py

@@ -0,0 +1,56 @@
+from discord import Interaction
+from discord.app_commands import describe, checks, choices, Choice
+from capstone import Cs as Capstone, CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL
+from pefile import PE
+from mikubot import Bot
+
+
+def register(bot: Bot):
+    def format_bytes(data: bytes, offset: int = 0) -> str:
+        lines = []
+
+        for i in range(0, len(data), 16):
+            chunk = data[i:i + 16]
+            hex_part = " ".join(f"{b:02X}" for b in chunk)
+            ascii_part = "".join(chr(b) if 32 <= b < 127 else "." for b in chunk)
+            lines.append(f"{(offset + i):08X}  {hex_part:<47}  |{ascii_part}|")
+
+        return "\n".join(lines)
+
+    @bot.tree.command(name="code", description="Display binary code of MM+.")
+    @checks.bot_has_permissions(send_messages=True)
+    @checks.has_role(1023036859883999272)
+    @describe(
+        version="The version of the game.",
+        address="The address to start reading.",
+        length="The length of the code to read.",
+        assembly="If the code should be displayed as assembly code.",
+    )
+    @choices(version=[
+        Choice(name="1.00", value=0),
+        Choice(name="1.01", value=1),
+        Choice(name="1.02", value=2),
+        Choice(name="1.03", value=3),
+    ])
+    async def handler(interaction: Interaction, address: int, length: int = 0x20, assembly: bool = True, version: Choice[int] = 3):
+        md = Capstone(CS_ARCH_X86, CS_MODE_64)
+        md.syntax = CS_OPT_SYNTAX_INTEL
+
+        length = max(0x10, min(bot.settings.mm_code.max_length, length))
+
+        file_path = bot.settings.mm_code.binaries[version.value]
+        pe = PE(file_path, fast_load=True)
+
+        image_base = pe.OPTIONAL_HEADER.ImageBase
+        rva = address - image_base
+        data = pe.get_data(rva, length)
+
+        if assembly:
+            instructions = md.disasm(data, address, length)
+            message = "\n".join(f"{i.address:08X}:  {i.mnemonic} {i.op_str}" for i in instructions)
+            await interaction.response.send_message(f"```x86asm\n{message}\n```")  # noqa
+        else:
+            message = format_bytes(data, address)
+            await interaction.response.send_message(f"```properties\n{message}\n```")  # noqa
+
+        pe.close()

mikubot-0.1.0/src/mikubot/commands/edenpatch.py

@@ -0,0 +1,20 @@
+from discord import Interaction, Embed
+from discord.app_commands import checks
+from mikubot import Bot
+
+
+def register(bot: Bot):
+    @bot.tree.command(name="edenpatch", description="Info on songlimit patch, song id patch, etc.")
+    @checks.bot_has_permissions(send_messages=True)
+    async def handler(interaction: Interaction):
+        embed = Embed(
+            description=r"The Eden \_\_\_\_\_\_\_ Patch series of mods are public releases of mods that are included within Eden Project and as a result can cause some unintended side effects when enabled with Eden Project, as the mods are effectively running twice.",
+            color=0x86cecb,
+        )
+
+        embed.set_author(name="Eden Patch", icon_url="https://images.gamebanana.com/img/ico/games/6296031c71087.png")
+        embed.set_footer(text=bot.user.display_name)
+
+        await interaction.response.send_message(  # noqa
+            embed=embed,
+        )

mikubot-0.1.0/src/mikubot/commands/gamebanana.py

@@ -0,0 +1,115 @@
+from discord import Interaction, Embed
+from discord.app_commands import describe, checks
+from urllib.parse import urljoin
+from datetime import datetime, timezone
+from mikubot import Bot
+import requests
+
+
+def register(bot: Bot):
+    def create_mod_embed(data: dict, full: bool = False) -> Embed:
+        embed = Embed(
+            title=data.get("_sName"),
+            url=data.get("_sProfileUrl"),
+            timestamp=datetime.fromtimestamp(data.get("_tsDateAdded"), timezone.utc),
+            color=0x86cecb,
+        )
+
+        # Mark obselete
+        if data.get("_bIsObsolete", False):
+            embed.title = f"~~{embed.title}~~"
+
+        embed.set_author(
+            name=data.get("_aSubmitter", {}).get("_sName"),
+            icon_url=data.get("_aRootCategory", {}).get("_sIconUrl")
+        )
+
+        first_image = data.get("_aPreviewMedia").get("_aImages")[0]
+        first_image_url = urljoin(first_image.get("_sBaseUrl", ""), first_image.get("_sFile", ""))
+
+        embed.set_thumbnail(url=first_image_url)
+        embed.set_footer(text=bot.user.display_name)
+
+        embed.add_field(
+            name="Submitter",
+            value=data.get("_aSubmitter", {}).get("_sName"),
+            inline=True,
+        )
+
+        embed.add_field(
+            name="Likes",
+            value=data.get("_nLikeCount", 0),
+            inline=True,
+        )
+
+        embed.add_field(
+            name="Views",
+            value=data.get("_nViewCount", 0),
+            inline=True,
+        )
+
+        if "_aAdditionalInfo" in data and "_sversion" in data.get("_aAdditionalInfo"):
+            embed.add_field(
+                name="Version",
+                value=data.get("_aAdditionalInfo", {}).get("_sversion", "Unknown version"),
+                inline=True,
+            )
+
+        # The following require a new API call
+        if full:
+            mod_id = data.get("_idRow")
+            profile_url = f"https://gamebanana.com/apiv10/Mod/{mod_id}/ProfilePage"
+            response = requests.get(profile_url)
+
+            if response.status_code == 200:
+                profile_data = response.json()
+
+                if "_aContentRatings" in profile_data and len(profile_data.get("_aContentRatings", {})):
+                    embed.add_field(
+                        name="Content Warnings",
+                        value=", ".join(profile_data.get("_aContentRatings", {}).values()),
+                        inline=True,
+                    )
+
+                if "_sDescription" in profile_data:
+                    embed.description = profile_data.get("_sDescription")
+
+        return embed
+
+    @bot.tree.command(name="gamebanana", description="Searches for a mod in the MegaMix+ section of Gamebanana.")
+    @checks.bot_has_permissions(send_messages=True)
+    @describe(query="The mod name or submission ID to search for.")
+    async def handler(interaction: Interaction, query: str):
+        settings = bot.settings.gamebanana_search
+
+        await interaction.response.defer()  # noqa
+
+        url = f"https://gamebanana.com/apiv10/Game/16522/Subfeed?_nPage=1&_nPerpage=10&_sSort=default&_sName={query}"
+        response = requests.get(url)
+
+        if response.status_code != 200:
+            return
+
+        results = response.json().get("_aRecords") or []
+
+        # Limit results to N entries
+        result_count = min(len(results), settings.limit)
+
+        if result_count:
+            for i in range(0, result_count, 10):
+                embeds = [create_mod_embed(result, settings.full) for result in results[i:i+10]]
+
+                await interaction.followup.send(  # noqa
+                    f"Showing {result_count} our of {len(results)} results...",
+                    embeds=embeds
+                )
+        else:
+            embed = Embed(
+                title="No results found.",
+                color=0xffc526,
+            )
+
+            embed.set_author(name="GameBanana Search", icon_url="https://images.gamebanana.com/static/img/mascots/detective.png")
+            embed.set_footer(text=bot.user.display_name)
+
+            await interaction.followup.send(embed=embed)  # noqa

mikubot-0.1.0/src/mikubot/commands/goofy_translate.py

@@ -0,0 +1,75 @@
+from discord import Interaction, Message
+from discord.app_commands import describe, checks
+from googletrans import Translator
+from googletrans.constants import LANGUAGES
+
+from mikubot import Bot
+import random
+import asyncio
+
+
+async def safe_translate(translator: Translator, text: str, src: str, dest: str, retries: int = 3) -> str:
+    """Translate text with retries and delay on failure."""
+    for attempt in range(retries):
+        try:
+            translated = await translator.translate(text, src=src, dest=dest)
+            return translated.text
+        except Exception as e:  # noqa
+            if attempt < retries - 1:
+                await asyncio.sleep(1 + attempt)  # wait longer each retry
+            else:
+                # Give up, return what we have so far
+                return text
+    return text
+
+
+async def mass_translate(text: str, hops: int = 10, initial_lang: str = "en", final_lang: str = "en") -> str:
+    current_text = text
+    hops = max(0, hops)
+
+    available_langs = list(LANGUAGES.keys())
+
+    if initial_lang in available_langs:
+        available_langs.remove(initial_lang)
+
+    if final_lang in available_langs:
+        available_langs.remove(final_lang)
+
+    async with Translator() as translator:
+        for _ in range(hops):
+            random_lang = random.choice(available_langs)
+            current_text = await safe_translate(translator, current_text, src=initial_lang, dest=random_lang)
+            initial_lang = random_lang
+            await asyncio.sleep(random.uniform(0.5, 1.5))  # small delay to reduce rate limit risk
+
+        current_text = await safe_translate(translator, current_text, src=initial_lang, dest=final_lang)
+
+    return current_text
+
+
+def register(bot: Bot):
+    @bot.tree.command(name="jumble", description="Google translates text through random languages before returning to the original language.")
+    @checks.cooldown(1, 10, key=lambda i: (i.guild_id,))
+    @checks.bot_has_permissions(send_messages=True)
+    @describe(
+        text="The text to translate",
+        hops="How many languages to translate to",
+        initial_lang="Language to start with",
+        final_lang="Language to end on",
+    )
+    async def handler(interaction: Interaction, text: str, hops: int = 10, initial_lang: str = "en", final_lang: str = "en"):
+        await interaction.response.defer()  # noqa
+        text = await mass_translate(text, hops, initial_lang, final_lang)
+        await interaction.followup.send(text[:2000])  # noqa
+
+    @bot.tree.context_menu(name="jumble")
+    @checks.bot_has_permissions(send_messages=True)
+    async def context_handler(interaction: Interaction, message: Message):
+        # We could use discord.py's modals to query for hops and languages if we need to.
+        hops = 10
+        initial_lang = "en"
+        final_lang = "en"
+
+        await interaction.response.defer()  # noqa
+        text = await mass_translate(message.content, hops, initial_lang, final_lang)
+        await interaction.followup.send(text[:2000], allowed_mentions=None)  # noqa

mikubot-0.1.0/src/mikubot/commands/guess.py

@@ -0,0 +1,202 @@
+from collections import Counter
+from datetime import datetime, timezone
+from discord import Interaction
+from discord.app_commands import describe, checks
+from pydantic import BaseModel, Field
+from sqlitedict import SqliteDict
+from mikubot import Bot
+import random
+
+
+class Guess(BaseModel):
+    user_id: int
+    guess: list[str]
+    feedback: list[str]
+
+
+class Puzzle(BaseModel):
+    solution: list[str]
+    pool: list[str]
+    guesses: list[Guess] = Field(default_factory=list)
+    solved_by: int | None = None
+    last_guess: datetime | None = None
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    is_public: bool = False
+
+    def is_solved(self) -> bool:
+        return self.solved_by is not None
+
+    def can_guess(self) -> bool:
+        return not self.is_solved() or self.is_public
+
+    def is_expired(self, max_age_minutes: int = 1440):
+        return (datetime.now(timezone.utc) - self.created_at).total_seconds() > (max_age_minutes * 60)
+
+
+def generate_sequence(pool: list[str], length: int, max_duplicates: int = 2) -> list[str]:
+    while True:
+        seq = [random.choice(pool) for _ in range(length)]
+        emoji_counts = {emoji: seq.count(emoji) for emoji in set(seq)}
+        if all(count <= max_duplicates for count in emoji_counts.values()):
+            if len(set(seq)) > 1:  # Avoid boring ones
+                return seq
+
+
+def compare_guess(answer: list[str], guess: list[str]) -> list[str]:
+    feedback = [""] * len(guess)
+    answer_counter = Counter(answer)
+
+    # First pass: check for exact matches
+    for i in range(len(guess)):
+        if guess[i] == answer[i]:
+            feedback[i] = "✅"
+            answer_counter[guess[i]] -= 1  # Reserve matched emoji
+
+    # Second pass: check for partial matches
+    for i in range(len(guess)):
+        if feedback[i]:  # Already matched
+            continue
+        if answer_counter[guess[i]] > 0:
+            feedback[i] = "⚠️"
+            answer_counter[guess[i]] -= 1
+        else:
+            feedback[i] = "❌"
+
+    return feedback
+
+
+def render_guess_history(puzzle: Puzzle) -> str:
+    if not puzzle.guesses:
+        return "_No guesses yet._"
+
+    lines = []
+    for guess in puzzle.guesses:
+        feedback = compare_guess(puzzle.solution, guess.guess)
+        guess_str = " ".join(guess.guess)
+        result_str = " ".join(feedback)
+        lines.append(f"- {guess_str} → {result_str}")
+    return "\n".join(lines)
+
+
+def extract_emojis(text: str, emoji_pool: list[str]) -> list[str]:
+    result = []
+    i = 0
+    pool_sorted = sorted(emoji_pool, key=len, reverse=True)  # match longer first
+
+    while i < len(text):
+        match = None
+        for emoji in pool_sorted:
+            if text.startswith(emoji, i):
+                match = emoji
+                break
+        if match:
+            result.append(match)
+            i += len(match)
+        else:
+            i += 1  # skip non-matching character
+
+    return result
+
+
+def register(bot: Bot):
+    def create_puzzle(user_id: int) -> Puzzle:
+        sequence = generate_sequence(
+            bot.settings.guessing_game.emoji_pool,
+            bot.settings.guessing_game.sequence_length,
+            bot.settings.guessing_game.max_duplicates,
+        )
+
+        puzzle = Puzzle(solution=sequence, pool=bot.settings.guessing_game.emoji_pool.copy())
+
+        with SqliteDict(
+            bot.settings.storage_file,
+            tablename="guessgame",
+            outer_stack=False,
+        ) as db:
+            db[str(user_id)] = puzzle.model_dump()
+            db.commit()
+
+        return puzzle
+
+    def get_puzzle(user_id: int) -> Puzzle:
+        with SqliteDict(
+                bot.settings.storage_file,
+                tablename="guessgame",
+                outer_stack=False,
+        ) as db:
+            puzzle_data = db.get(str(user_id))
+
+            if puzzle_data:
+                puzzle = Puzzle.model_validate(puzzle_data)
+
+                if puzzle.is_solved() or puzzle.is_expired():
+                    return create_puzzle(user_id)
+
+                return puzzle
+            else:
+                return create_puzzle(user_id)
+
+    @bot.tree.command(name="codebreaker", description="Start a codebreaker game or continue your current one with a guess.")
+    @checks.bot_has_permissions(send_messages=True)
+    @describe(guess="Your guess. Leave empty to see current state or generate a new puzzle.")
+    async def handler(interaction: Interaction, guess: str = ""):
+        puzzle = get_puzzle(interaction.user.id)
+
+        if not guess:
+            history = render_guess_history(puzzle)
+            emoji_list = " ".join(puzzle.pool)
+
+            await interaction.response.send_message(  # noqa
+                f"Here is your puzzle:\n\n"
+                f"Guess the sequence of {len(puzzle.solution)} emojis!\n"
+                f"Use _/codebreaker (your guess)_ to solve.\n"
+                f"Available emojis: {emoji_list}\n\n"
+                f"**Your guesses so far:**\n{history}",
+                ephemeral=True,
+            )
+
+            return
+
+        guess_emojis = extract_emojis(guess, puzzle.pool)
+
+        if len(guess_emojis) != len(puzzle.solution):
+            await interaction.response.send_message(  # noqa
+                f"You must enter exactly {len(puzzle.solution)} emojis from the allowed pool: {" ".join(puzzle.pool)}",
+                ephemeral=True
+            )
+            return
+
+        feedback = compare_guess(puzzle.solution, guess_emojis)
+        is_correct = all(symbol == "✅" for symbol in feedback)
+
+        puzzle.guesses.append(Guess(user_id=interaction.user.id, guess=guess_emojis, feedback=feedback))
+        puzzle.last_guess = datetime.now(timezone.utc)
+
+        with SqliteDict(
+            bot.settings.storage_file,
+            tablename="guessgame",
+            outer_stack=False,
+        ) as db:
+            if is_correct:
+                puzzle.solved_by = interaction.user.id
+
+                await interaction.response.send_message(  # noqa
+                    f"Correct!\n\n"
+                    f"Solution: {" ".join(guess_emojis)} → {" ".join(feedback)}\n\n"
+                    f"**Your guess history:**\n{render_guess_history(puzzle)}",
+                    ephemeral=True
+                )
+
+                del db[str(interaction.user.id)]
+                db[f"{interaction.user.id}:{hash(puzzle.created_at)}"] = puzzle.model_dump()
+            else:
+                await interaction.response.send_message(  # noqa
+                    f"Not quite!\n"
+                    f"Your guess: {" ".join(guess_emojis)} → {" ".join(feedback)}\n\n"
+                    f"**Your guess history:**\n{render_guess_history(puzzle)}",
+                    ephemeral=True
+                )
+
+                db[str(interaction.user.id)] = puzzle.model_dump()
+
+            db.commit()