Buttons and select menus in your Discord bot (discord.js and discord.py)

require("dotenv").config(); // reads the token from the .env file
const { ActionRowBuilder, ButtonBuilder, ButtonStyle, Client, EmbedBuilder, Events, GatewayIntentBits, MessageFlags, SlashCommandBuilder, StringSelectMenuBuilder } = require("discord.js");

const client = new Client({ intents: [GatewayIntentBits.Guilds] });

// The pages of /rules: replace them with yours
const RULES = [
  "1. Be respectful to everyone.\n2. No spam or advertising.",
  "3. No cheats or hacks on the game server.\n4. Moderators have the final say.",
  "5. To report something, open a ticket.",
];

// The topics of /help: each option's value is its key here
const TOPICS = {
  ip: { label: "How to join the server", text: "The address is play.example.com" },
  events: { label: "Event schedule", text: "Events are on Saturdays at 18:00." },
  staff: { label: "Talk to the staff", text: "Open a ticket in #support." },
};

const commands = [
  new SlashCommandBuilder().setName("rules").setDescription("The rules, page by page"),
  new SlashCommandBuilder().setName("help").setDescription("Pick a help topic"),
];

function rulesPage(n) {
  const embed = new EmbedBuilder()
    .setTitle("Server rules")
    .setDescription(RULES[n])
    .setFooter({ text: `Page ${n + 1} of ${RULES.length}` });
  // the page each button leads to goes in its customId: nothing to store anywhere
  const row = new ActionRowBuilder().addComponents(
    new ButtonBuilder().setCustomId(`rules:${n - 1}`).setLabel("Previous").setStyle(ButtonStyle.Secondary).setDisabled(n === 0),
    new ButtonBuilder().setCustomId(`rules:${n + 1}`).setLabel("Next").setStyle(ButtonStyle.Primary).setDisabled(n === RULES.length - 1),
  );
  return { embeds: [embed], components: [row] };
}

const helpMenu = new ActionRowBuilder().addComponents(
  new StringSelectMenuBuilder()
    .setCustomId("help")
    .setPlaceholder("What do you need help with?")
    .addOptions(Object.entries(TOPICS).map(([value, t]) => ({ label: t.label, value }))),
);

client.on(Events.InteractionCreate, async (i) => {
  if (i.isChatInputCommand() && i.commandName === "rules") {
    await i.reply(rulesPage(0));
  } else if (i.isChatInputCommand() && i.commandName === "help") {
    await i.reply({ content: "Pick a topic:", components: [helpMenu], flags: MessageFlags.Ephemeral });
  } else if (i.isButton() && i.customId.startsWith("rules:")) {
    const n = Math.min(Math.max(Number(i.customId.split(":")[1]) || 0, 0), RULES.length - 1);
    await i.update(rulesPage(n)); // edits the same message instead of sending a new one
  } else if (i.isStringSelectMenu() && i.customId === "help") {
    const topic = TOPICS[i.values[0]]; // the choice: the values of the selected options
    await i.update({ content: `**${topic.label}**\n${topic.text}`, components: [helpMenu] });
  }
});

client.once(Events.ClientReady, async (c) => {
  await c.application.commands.set(commands.map((x) => x.toJSON())); // publishes /rules and /help
  console.log(`Logged in as ${c.user.tag}`);
});

client.login(process.env.DISCORD_TOKEN);

import os

import discord
from discord import app_commands
from dotenv import load_dotenv

load_dotenv()  # reads the token from the .env file

# The pages of /rules: replace them with yours
RULES = [
    "1. Be respectful to everyone.\n2. No spam or advertising.",
    "3. No cheats or hacks on the game server.\n4. Moderators have the final say.",
    "5. To report something, open a ticket.",
]

# The topics of /help: each option's value is its key here
TOPICS = {
    "ip": ("How to join the server", "The address is play.example.com"),
    "events": ("Event schedule", "Events are on Saturdays at 18:00."),
    "staff": ("Talk to the staff", "Open a ticket in #support."),
}

client = discord.Client(intents=discord.Intents.default())
tree = app_commands.CommandTree(client)


def rules_page(n: int) -> discord.Embed:
    embed = discord.Embed(title="Server rules", description=RULES[n])
    embed.set_footer(text=f"Page {n + 1} of {len(RULES)}")
    return embed


class Pages(discord.ui.View):
    def __init__(self):
        super().__init__(timeout=300)  # after 5 minutes untouched, it stops listening
        self.n = 0
        self.message = None
        self.update_buttons()

    def update_buttons(self):
        self.previous.disabled = self.n == 0
        self.next.disabled = self.n == len(RULES) - 1

    @discord.ui.button(label="Previous", style=discord.ButtonStyle.secondary)
    async def previous(self, interaction: discord.Interaction, button: discord.ui.Button):
        self.n -= 1
        self.update_buttons()
        # edits the same message instead of sending a new one
        await interaction.response.edit_message(embed=rules_page(self.n), view=self)

    @discord.ui.button(label="Next", style=discord.ButtonStyle.primary)
    async def next(self, interaction: discord.Interaction, button: discord.ui.Button):
        self.n += 1
        self.update_buttons()
        await interaction.response.edit_message(embed=rules_page(self.n), view=self)

    async def on_timeout(self):
        # disables the buttons so nobody presses one that no longer answers
        for item in self.children:
            item.disabled = True
        if self.message:
            await self.message.edit(view=self)


class Help(discord.ui.View):
    @discord.ui.select(
        placeholder="What do you need help with?",
        options=[discord.SelectOption(label=title, value=key) for key, (title, _) in TOPICS.items()],
    )
    async def topic(self, interaction: discord.Interaction, select: discord.ui.Select):
        title, text = TOPICS[select.values[0]]  # the choice: the values of the selected options
        await interaction.response.edit_message(content=f"**{title}**\n{text}", view=self)


@tree.command(name="rules", description="The rules, page by page")
async def rules(interaction: discord.Interaction):
    view_ = Pages()
    await interaction.response.send_message(embed=rules_page(0), view=view_)
    view_.message = await interaction.original_response()  # to disable it when it expires


@tree.command(name="help", description="Pick a help topic")
async def help_(interaction: discord.Interaction):
    await interaction.response.send_message("Pick a topic:", view=Help(), ephemeral=True)


@client.event
async def on_ready():
    await tree.sync()  # publishes /rules and /help
    print(f"Logged in as {client.user}")


client.run(os.environ["DISCORD_TOKEN"])

// something slow (a database, a website): first tell Discord…
await i.deferUpdate();
const data = await somethingSlow();
// …then edit the button's message (you have 15 minutes)
await i.editReply({ content: data, components: [] });

# something slow (a database, a website): first tell Discord…
await interaction.response.defer()
data = await something_slow()
# …then edit the button's message (you have 15 minutes)
await interaction.edit_original_response(content=data, view=None)

class Rules(discord.ui.View):
    def __init__(self):
        super().__init__(timeout=None)  # never expires

    # with a fixed custom_id, the bot recognises it even if the message is from before a restart
    @discord.ui.button(label="I accept the rules", style=discord.ButtonStyle.success, custom_id="rules:accept")
    async def accept(self, interaction: discord.Interaction, button: discord.ui.Button):
        await interaction.response.send_message("Thanks!", ephemeral=True)


class Bot(discord.Client):
    async def setup_hook(self):
        self.add_view(Rules())  # listens again to the buttons of messages already posted