DEV Community: Blue

How to add Buttons to your command [interactions.py]

Blue — Wed, 15 Jun 2022 16:38:47 +0000

Last time, we created a simple slash command with interactions.py. However, if you go around Discord and use different bots, you will see that there are some commands that use buttons to let you interact with the bot. This is pretty cool, and you may want to do the same, so let's see how it can be done with interactions.py.

Disclaimer: I will create a new sample file for this post, however, you can add it in your main one if you like.

Assuming that you have already imported the main library, declare the client and start the bot from the previous post, we will walk straight in with creating button.

Button

First, let's create a global variable for the button.



button = interactions.Button(
    style=interactions.ButtonStyle.PRIMARY,
    label="Click me!",
    custom_id="click_me",
)

interactions.Button: This object forms the button that we will send to Discord API.
style: The style of the button. Currently, Discord supports a variety of styles that you can use. You can have a look in this image below.
label: The label of the button. This is the text that displays on the button.
custom_id: This is the customized ID that we will receive when someone clicks on the button. We will need this for the component callback to do the job we want to.

We have a button now, so what's next? Send it, of course.



@client.command(
    name="button",
    description="Send a button",
)
async def _button(ctx: interactions.CommandContext):
    await ctx.send(components=button)

components=button: components is used to form the component in the message.

Run the bot and use the command. If you see something like this, congratulations, you just create a button with interactions.py, but hold on, when you click on it, nothing happens and you get a "This interaction failed".

The reason for this is because we haven't added a button callback yet. When we click on the button, it creates an INTERACTIONS_CREATE dispatch gateway event and we need a button callback to handle that event.



@client.component("click_me")
async def _click_me(ctx: interactions.ComponentContext):
    await ctx.send("Clicked!")

@client.component(): This is the decorator that handles specifically component event. click_me is the custom_id that we create above. What this will do is listening to the INTERACTIONS_CREATE dispatch gateway event and see if it matches with the custom_id that we create.

Now that we have a button, a command and a callback event, let's run the bot again and test it. If you have something like this, congratulations, you just create a functioning command with button that you can interact with interactions.py.

Action Rows

Action Rows is a way to organize your components into rows. According to Discord, you can have up to 5 Action Rows per message and each Action Row cannot contain another Action Row.

Now that you have a good look with Action Rows, let's do it with interactions.py.



button =[
    interactions.ActionRow(
        components=[
            interactions.Button(
                style=interactions.ButtonStyle.PRIMARY,
                label="Click me!",
                custom_id="click_me",
            ),
            interactions.Button(
                style=interactions.ButtonStyle.DANGER,
                label="Do not click!",
                custom_id="do_not_click",
            ),
        ]
    )
]

@client.command(
    name="button",
    description="Send a button",
)
async def _button(ctx: interactions.CommandContext):
    await ctx.send(components=button)

@client.component("click_me")
async def click_me(ctx: interactions.ComponentContext):
    await ctx.send("Clicked!")

@client.component("do_not_click")
async def do_not_click(ctx: interactions.ComponentContext):
    await ctx.send("You clicked the wrong button!")

interactions.ActionRow(): this object is responsible for creating an Action Row and send it to Discord.
components: this is a list of Button that we will send to Discord API.

Once you finish with copying the above code into your bot file, run the bot and execute the command. If you see something like this, congratulations, you just created an Action Row with interactions.py.

Stay tuned with upcoming post about interactions.py and how you can take advantage of the library. If you like this post, be sure to give a heart. If you have any question, let me know in the comment section. Alternatively, you can join the official interactions.py Discord server for further help.

How to create a Discord Bot in Python [interactions.py]

Blue — Tue, 14 Jun 2022 16:59:22 +0000

So, you have seen those fancy bots with different slash commands on Discord and you want to make one for yourself, but you don't know where to start.

In this post, I will guide you how to make a simple Discord Bot in Python, using a library called interactions.py.
Requirements: You need to have a good view with Python first as making a Discord Bot isn't exactly considered as beginner-friendly.

Disclaimer: I will skip most part with creating an Application and inviting your bot to your server as it can be found in other online contents. We will walk straight in.

First, you need to install the library, using pip:
pip install -U discord-py-interactions

We will create a simple connection first so the bot can be alive. Create a new file in your IDE ending with .py and copy this piece of code.

import interactions

client = interactions.Client(token="your_bot_token_here")

@client.event
async def on_ready():
    print("Ready!")

client.start()

Note: If you encounter an error ModuleNotFoundError, check your installed version of discord-py-interactions again. This library requires Python 3.8.6+.

The terminal should show "Ready!" and your bot should be online now, but wait, it doesn't do much. Let's add a basic command to it.

import interactions

client = interactions.Client(token="your_bot_token_here")

@client.command(
    name="ping",
    description="Ping pong",
    scope=your_guild_id_here
)
async def _ping(ctx: interactions.CommandContext):
    await ctx.send("Pong!")

@client.event
async def on_ready():
    print("Ready!")

client.start()

@client.command(), this is called a decorator in Python. This handles the request to Discord API to register a new command.
name: The name of your command. Do notice that a command name cannot contain special character or space.
description: The description of the command.
scope: This is optional. Discord has 2 types of command: guild command and global command. Guild command will appear immediately in the registered guild and cannot be used in other guilds. Global command can be used in all servers that the bot is in, but it can takes up to 1 hour to appear in all guilds. Global command should be used when you have finished with the command while guild command should be used for testing purposes.
async def _ping(ctx: interactions.CommandContext):: This is known as a coroutine.
await ctx.send("Pong!"): Starting after the coroutine, the command will be executed. This line will send a message with the content "Hi there!" when someone invokes the slash command.

Now, re-run your bot and in your test server, use the command by typing / and the name. If the bot sends the message, congratulations, you just create a first command in interactions.py.

Stay tuned with upcoming post about interactions.py and how you can take advantage of the library to create an advanced bot for your server or a public one.

If you have any question with the library, let me know in the comment section or join the official interactions.py Discord server for further help.