Replace ENTRANCE.SOUND menu with dropdowns

/instantbuttons displays a soundboard via a button ui

bot.py

@@ -1,8 +1,10 @@
 # Example: https://github.com/Rapptz/discord.py/blob/master/examples/app_commands/basic.py
 
+from ast import Call
 import random, logging
+from discord import DMChannel
 from discord.app_commands import Choice
-from typing import Dict, List, Optional, Union, Callable, Any
+from typing import Awaitable, Dict, List, Optional, Union, Callable, Any
 from rich.traceback import install
 
 from heidi_client import *
@@ -11,9 +13,7 @@ from heidi_client import *
 install(show_locals=True)
 
 
-# @todo Only post in heidi-spam channel
 # @todo yt-dlp music support
-# @todo Somehow upload voicelines more easily (from discord voice message?)
 
 
 # Log to file
@@ -85,6 +85,59 @@ async def on_voice_state_update(
 # Config Commands --------------------------------------------------------------------------------
 
 
+class EntranceSoundSoundSelect(discord.ui.Select):
+    def __init__(self, board: str, on_sound_select_callback):
+        self.board = board
+        self.on_sound_select_callback = on_sound_select_callback
+
+        options: List[discord.SelectOption] = [
+            discord.SelectOption(label=sound.split(".")[0], value=sound)
+            for sound in os.listdir(f"{SOUNDDIR}/{board}")
+        ]
+
+        super().__init__(
+            placeholder="Select Sound", min_values=1, max_values=1, options=options
+        )
+
+    async def callback(self, interaction: Interaction):
+        await self.on_sound_select_callback(interaction, self.board, self.values[0])
+
+
+class EntranceSoundSoundView(discord.ui.View):
+    def __init__(self, board: str, on_sound_select_callback):
+        super().__init__(timeout=600)
+
+        self.add_item(EntranceSoundSoundSelect(board, on_sound_select_callback))
+
+
+class EntranceSoundBoardSelect(discord.ui.Select):
+    def __init__(self, on_sound_select_callback):
+        self.on_sound_select_callback = on_sound_select_callback
+
+        options: List[discord.SelectOption] = [
+            discord.SelectOption(label=board, value=board)
+            for board in os.listdir(f"{SOUNDDIR}")
+        ]
+
+        super().__init__(
+            placeholder="Select Board", min_values=1, max_values=1, options=options
+        )
+
+    async def callback(self, interaction: Interaction):
+        await interaction.response.send_message(
+            f"Welchen sound willst du?",
+            view=EntranceSoundSoundView(self.values[0], self.on_sound_select_callback),
+            ephemeral=True,
+        )
+
+
+class EntranceSoundBoardView(discord.ui.View):
+    def __init__(self, on_sound_select_callback):
+        super().__init__(timeout=600)
+
+        self.add_item(EntranceSoundBoardSelect(on_sound_select_callback))
+
+
 async def user_config_key_autocomplete(
     interaction: Interaction, current: str
 ) -> List[Choice[str]]:
@@ -98,45 +151,6 @@ async def user_config_key_autocomplete(
     ]
 
 
-async def user_config_value_autocomplete(
-    interaction: Interaction, current: str
-) -> List[Choice[str]]:
-    """
-    Calls an autocomplete function depending on the entered config_key.
-    """
-    autocompleters = {"ENTRANCE.SOUND": user_entrance_sound_autocomplete}
-    autocompleter = autocompleters[interaction.namespace.option]
-
-    print(f"config_value_autocomplete: calling {autocompleter.__name__}")
-
-    return autocompleter(interaction, current)
-
-
-def user_entrance_sound_autocomplete(
-    interaction: Interaction, current: str
-) -> List[Choice[str]]:
-    """
-    Generates autocomplete options for the ENTRANCE.SOUND config key.
-    """
-    boards: List[str] = os.listdir(SOUNDDIR)
-    all_sounds: Dict[str, List[str]] = {
-        board: os.listdir(f"{SOUNDDIR}/{board}/") for board in boards
-    }  # These are all sounds, organized per board, without file extension
-
-    # @todo Initially only suggest boards, because there are too many sounds to show them all
-    completions: List[Choice[str]] = []
-    for (
-        board,
-        board_sounds,
-    ) in all_sounds.items():  # Iterate over all sounds, organized per board
-        for sound in board_sounds:  # Iterate over board specific sounds
-            soundpath = f"{board}/{sound}"
-            if soundpath.lower().startswith(current.lower()):
-                completions += [Choice(name=soundpath.split(".")[0], value=soundpath)]
-
-    return completions
-
-
 @client.tree.command(
     name="userconfig",
     description="User-spezifische Heidi-Einstellungen (Heidi merkt sie sich in ihrem riesigen Gehirn).",
@@ -144,30 +158,42 @@ def user_entrance_sound_autocomplete(
 @app_commands.rename(config_key="option")
 @app_commands.describe(config_key="Die Option, welche du ändern willst.")
 @app_commands.autocomplete(config_key=user_config_key_autocomplete)
-@app_commands.rename(config_value="wert")
-@app_commands.describe(
-    config_value="Der Wert, auf welche die Option gesetzt werden soll."
-)
-@app_commands.autocomplete(config_value=user_config_value_autocomplete)
-async def user_config(
-    interaction: Interaction, config_key: str, config_value: str
-) -> None:
+@enforce_channel(HEIDI_SPAM_ID)
+async def user_config(interaction: Interaction, config_key: str) -> None:
     """
     Set a user config value for the calling user.
     """
     # Only Members can set settings
     if not isinstance(interaction.user, Member):
         print("User not a member")
-        await interaction.response.send_message("Heidi sagt: Komm in die Gruppe!")
+        await interaction.response.send_message(
+            "Heidi sagt: Komm in die Gruppe!", ephemeral=True
+        )
         return
 
     member: Member = interaction.user
 
-    client.user_config[config_key][member.name] = config_value
+    async def on_sound_select_callback(interaction, board: str, sound: str):
+        """
+        This function is called, when an EntrySoundSoundSelect option is selected.
+        """
+        client.user_config[config_key][member.name] = f"{board}/{sound}"
         client.write_user_config()
 
         await interaction.response.send_message(
-        f"Ok, ich schreibe {member.name}={config_value} in mein fettes Gehirn!"
+            f"Ok, ich schreibe {member.name}={board}/{sound} in mein fettes Gehirn!",
+            ephemeral=True,
+        )
+
+    # Views for different user config options are defined here
+    views = {"ENTRANCE.SOUND": (EntranceSoundBoardView, on_sound_select_callback)}
+
+    view, select_callback = views[config_key]
+
+    await interaction.response.send_message(
+        f"Aus welchem Soundboard soll dein sound sein?",
+        view=view(select_callback),
+        ephemeral=True,
     )
 
 
@@ -175,6 +201,7 @@ async def user_config(
 
 
 @client.tree.command(name="heidi", description="Heidi!")
+@enforce_channel(HEIDI_SPAM_ID)
 async def heidi_exclaim(interaction: Interaction) -> None:
     """
     Print a random Heidi quote.
@@ -198,6 +225,7 @@ async def heidi_exclaim(interaction: Interaction) -> None:
 @client.tree.command(name="miesmuschel", description="Was denkt Heidi?")
 @app_commands.rename(question="frage")
 @app_commands.describe(question="Heidi wird es beantworten!")
+@enforce_channel(HEIDI_SPAM_ID)
 async def magic_shell(interaction: Interaction, question: str) -> None:
     """
     Answer a yes/no question.
@@ -232,6 +260,7 @@ async def magic_shell(interaction: Interaction, question: str) -> None:
 @app_commands.describe(option_a="Ist es vielleicht dies?")
 @app_commands.rename(option_b="oder")
 @app_commands.describe(option_b="Oder doch eher das?")
+@enforce_channel(HEIDI_SPAM_ID)
 async def choose(interaction: Interaction, option_a: str, option_b: str) -> None:
     """
     Select an answer from two options.
@@ -282,6 +311,7 @@ async def sound_autocomplete(
 @app_commands.describe(sound="Was soll Heidi sagen?")
 @app_commands.autocomplete(board=board_autocomplete)
 @app_commands.autocomplete(sound=sound_autocomplete)
+@enforce_channel(HEIDI_SPAM_ID)
 async def say_voiceline(interaction: Interaction, board: str, sound: str) -> None:
     """
     Play a voiceline in the calling member's current voice channel.
@@ -289,7 +319,9 @@ async def say_voiceline(interaction: Interaction, board: str, sound: str) -> Non
     # Only Members can access voice channels
     if not isinstance(interaction.user, Member):
         print("User not a member")
-        await interaction.response.send_message("Heidi sagt: Komm in die Gruppe!")
+        await interaction.response.send_message(
+            "Heidi sagt: Komm in die Gruppe!", ephemeral=True
+        )
         return
 
     member: Member = interaction.user
@@ -297,6 +329,49 @@ async def say_voiceline(interaction: Interaction, board: str, sound: str) -> Non
     await play_voice_line_for_member(interaction, member, board, sound)
 
 
+class InstantButton(discord.ui.Button):
+    def __init__(self, label: str, board: str, sound: str):
+        super().__init__(style=discord.ButtonStyle.red, label=label)
+
+        self.board = board
+        self.sound = sound
+
+    async def callback(self, interaction: Interaction):
+        """
+        Handle a press of the button.
+        """
+        if not isinstance(interaction.user, Member):
+            await interaction.response.send_message(
+                "Heidi mag keine discord.User, nur discord.Member!", ephemeral=True
+            )
+            return
+
+        await play_voice_line_for_member(
+            interaction, interaction.user, self.board, self.sound
+        )
+
+
+class InstantButtonsView(discord.ui.View):
+    def __init__(self, board: str, timeout=None):
+        super().__init__(timeout=timeout)
+
+        sounds = os.listdir(f"{SOUNDDIR}/{board}")
+        for sound in sounds:
+            self.add_item(InstantButton(sound.split(".")[0], board, sound))
+
+
+@client.tree.command(
+    name="instantbuttons", description="Heidi malt Knöpfe für Sounds in den Chat."
+)
+@app_commands.describe(board="Welches Soundboard soll knöpfe bekommen?")
+@app_commands.autocomplete(board=board_autocomplete)
+@enforce_channel(HEIDI_SPAM_ID)
+async def soundboard_buttons(interaction: Interaction, board: str) -> None:
+    await interaction.response.send_message(
+        f"Soundboard: {board.capitalize()}", view=InstantButtonsView(board)
+    )
+
+
 # Contextmenu ------------------------------------------------------------------------------------
 
 
@@ -313,7 +388,9 @@ async def insult(
 
     if not member.dm_channel:
         print("Error creating DMChannel!")
-        await interaction.response.send_message("Heidi sagt: Gib mal DM Nummer süße*r!")
+        await interaction.response.send_message(
+            "Heidi sagt: Gib mal DM Nummer süße*r!", ephemeral=True
+        )
         return
 
     insults = [
@@ -334,7 +411,7 @@ async def insult(
 
     await member.dm_channel.send(random.choice(insults))
     await interaction.response.send_message(
-        "Anzeige ist raus!"
+        "Anzeige ist raus!", ephemeral=True
     )  # with ephemeral = True only the caller can see the answer
 
 

heidi_constants.py

@@ -24,3 +24,6 @@ SOUNDDIR: str = "/sounds" if DOCKER else "./heidi-sounds"
 # IDs of the servers Heidi is used on
 LINUS_GUILD = discord.Object(id=431154792308408340)
 TEST_GUILD = discord.Object(id=821511861178204161)
+
+# Channel IDs
+HEIDI_SPAM_ID = 822223476101742682

heidi_helpers.py

@@ -1,4 +1,5 @@
 import asyncio
+import functools
 from typing import Union
 
 import discord
@@ -9,6 +10,39 @@ from heidi_constants import *
 print("Debug: Importing heidi_helpers.py")
 
 
+# Checks -----------------------------------------------------------------------------------------
+
+
+# 1. @enforce_channel(ID) is added to a function, which evaluates to decorate with the channel_id in its closure
+# 2. The function is passed to decorate(function),
+def enforce_channel(channel_id):
+    """
+    Only run a function if called from the correct channel.
+    """
+    def decorate(function):
+
+        @functools.wraps(function)
+        async def wrapped(*args, **kwargs):
+            """
+            Sends an interaction response if the interaction is not triggered from the heidi_spam channel.
+            """
+            interaction: Interaction = args[0]
+
+            # Do not call the decorated function if the channel_id doesn't match
+            if not interaction.channel_id == channel_id:
+                await interaction.response.send_message("Heidi sagt: Geh in heidi_spam du dulli", ephemeral=True)
+                return
+
+            await function(*args, **kwargs)
+
+        return wrapped
+
+    return decorate
+
+
+# Sounds -----------------------------------------------------------------------------------------
+
+
 # @todo Normalize volume when playing
 async def play_voice_line(
     interaction: Union[Interaction, None],
@@ -25,12 +59,13 @@ async def play_voice_line(
         print(f"Error: Invalid soundfile {SOUNDDIR}/{board}/{sound}!")
         if interaction is not None:
             await interaction.response.send_message(
-                f'Heidi sagt: "{board}/{sound}" kanninich finden bruder'
+                f'Heidi sagt: "{board}/{sound}" kanninich finden bruder',
+                ephemeral=True
             )
         return
 
     if interaction is not None:
-        await interaction.response.send_message(f'Heidi sagt: "{board}/{sound}"')
+        await interaction.response.send_message(f'Heidi sagt: "{board}/{sound}"', ephemeral=True)
 
     audio_source = discord.FFmpegPCMAudio(
         f"{SOUNDDIR}/{board}/{sound}"
@@ -62,7 +97,7 @@ async def play_voice_line_for_member(
     ):
         print("User not in (valid) voice channel!")
         if interaction is not None:
-            await interaction.response.send_message("Heidi sagt: Komm in den Channel!")
+            await interaction.response.send_message("Heidi sagt: Komm in den Channel!", ephemeral=True)
         return
 
     voice_channel: VoiceChannel = member.voice.channel