I'm trying to make a bot for a discord server that simply listens for specific messages, deletes them and then refers the user to a different text channel (in a clickable link by mentioning it)
Here's what I have now:
import Discord
import asyncio
client = discord.Client()
#client.event
async def on_message(message):
msg = '{0.author.mention}\nWrong text channel\nUse '.format(message)
if message.content.startswith('!p'):
await client.delete_message(message)
await client.send_message(message.channel, msg)
return
client.run('')
Ideally, I'd also want to search through a list with startswith() instead of just ('!p') & to ignore all messages from a specific text channel as well but I'm not sure how to do those either
Don't know if your problem is solved or not, but for all future developers looking on this thread. A super simple way to get a bot to mention a channel is like this...
<#channelID>
were the channel ID is the discord ID of the specific channel you wish to mention.
and in an example
await message.channel.send("Please go to <#channelID>")
I'm honestly a bit confused that no one on this thread has already mentioned this, so I feel like I'm missing something that y'all already know lol.
Sure, just add text_channel = client.get_channel('1234567890') and reference its mention with text_channel.mention (where 1234567890 is the id of the channel you want to link to)
So the code would end up looking something like this
#client.event
async def on_message(message):
text_channel = client.get_channel('1234567890')
msg = '{0.author.mention}\nWrong text channel\nUse {1.mention}'.format(message,text_channel)
if message.content.startswith('!p'):
await client.delete_message(message)
await client.send_message(message.channel, msg)
return
Regarding your second question, you could do something like this
arr = ['!p','!a','!b']
for a in arr:
if message.content.startswith(a):
break
else:
return
and remove the if message.content.startswith('!p'): altogether
To ignore a specific channel just do if message.channel.id == "9876543210": at the top of the function (9876543210 is the id of the channel you want to ignore commands from)
With those changes the code looks like this
#client.event
async def on_message(message):
if message.channel.id == "9876543210":
return
arr = ['!p','!a','!b']
for a in arr:
if message.content.startswith(a):
break
else:
return
text_channel = client.get_channel('1234567890')
msg = '{0.author.mention}\nWrong text channel\nUse {1.mention}'.format(message,text_channel)
await client.delete_message(message)
await client.send_message(message.channel, msg)
return
import discord
from discord.ext import commands
client = commands.Bot(command_prefix='>')
#client.event
async def on_ready():
print("Log : "+str(client.user))
#client.command()
async def mention(ctx):
ch = await client.fetch_channel(enter channel id)
await ctx.send(f"Mention your channel -> {ch}")
client.run("token")
Related
Outcome
To snipe messages sent in X channel instead of all the channels within the Discord guild. That is, it should only track message deletions in that one channel (identified by its ID), and only respond to the !snipe command in that same channel. The current code I have here snipes every message sent within the Discord guild.
Question
How can I snipe messages sent in X channel instead of the entire guild?
I mostly intend to run this bot in one guild. However, it would be nice if it could scale to multiple guilds if needed.
The code I have so far is below.
import discord
from discord.ext import commands
from tokens import token
client = commands.Bot(command_prefix="!", self_bot=False)
client.sniped_messages = {}
#client.event
async def on_ready():
print("Your bot is ready.")
#client.event
async def on_message_delete(message):
print(f'sniped message {message}')
client.sniped_messages[message.guild.id] = (
message.content, message.author, message.channel.name, message.created_at)
#client.command()
async def snipe(ctx):
try:
contents, author, channel_name, time = client.sniped_messages[ctx.guild.id]
except:
await ctx.channel.send("Couldn't find a message to snipe!")
return
embed = discord.Embed(description=contents,
color=discord.Color.purple(), timestamp=time)
embed.set_author(
name=f"{author.name}#{author.discriminator}", icon_url=author.avatar_url)
embed.set_footer(text=f"Deleted in : #{channel_name}")
await ctx.channel.send(embed=embed)
client.run(token, bot=True)
I'm going to suggest two slightly different solutions, because the code can be simpler if you're only running this bot on one guild. What's common to both is that you need to check in what channel messages are deleted, and in what channel the !snipe command is sent.
Single-Guild Version
If you're only monitoring/sniping one channel on one guild, then you can only ever have one deleted message to keep track of. Thus, you don't need a dictionary like in your posted code; you can just keep a single message or None.
You're already importing your token from a separate file, so you might as well put the channel ID (which is an int, unlike the bot token) there too for convenience. Note that, by convention, constants (variables you don't intend to change) are usually named in all caps in Python. tokens.py would look something like this:
TOKEN = 'string of characters here'
CHANNEL_ID = 123456789 # actually a 17- or 18-digit integer
And the bot itself:
import discord
from discord.ext import commands
from tokens import TOKEN, CHANNEL_ID
client = commands.Bot(command_prefix='!')
client.sniped_message = None
#client.event
async def on_ready():
print("Your bot is ready.")
#client.event
async def on_message_delete(message):
# Make sure it's in the watched channel, and not one of the bot's own
# messages.
if message.channel.id == CHANNEL_ID and message.author != client.user:
print(f'sniped message: {message}')
client.sniped_message = message
#client.command()
async def snipe(ctx):
# Only respond to the command in the watched channel.
if ctx.channel.id != CHANNEL_ID:
return
if client.sniped_message is None:
await ctx.channel.send("Couldn't find a message to snipe!")
return
message = client.sniped_message
embed = discord.Embed(
description=message.content,
color=discord.Color.purple(),
timestamp=message.created_at
)
embed.set_author(
name=f"{message.author.name}#{message.author.discriminator}",
icon_url=message.author.avatar_url
)
embed.set_footer(text=f"Deleted in: #{message.channel.name}")
await ctx.channel.send(embed=embed)
client.run(TOKEN)
Multi-Guild Version
If you're monitoring one channel each in multiple guilds, then you need to keep track of them separately. Handily, channel IDs are globally unique, not just within a single guild. So you can keep track of them by ID alone, without having to include the guild ID as well.
You could keep them in a list, but I recommend a set, because checking whether something is in a set or not is faster. Comments to help yourself remember which one is which are probably also a good idea.
TOKEN = 'string of characters here'
# Not a dictionary, even though it uses {}
CHANNEL_IDS = {
# That one guild
123456789,
# The other guild
987654322,
}
Then instead of checking against the single channel ID, you check if it's in the set of multiple IDs.
import discord
from discord.ext import commands
from tokens import TOKEN, CHANNEL_IDS
client = commands.Bot(command_prefix='!')
client.sniped_messages = {}
#client.event
async def on_ready():
print("Your bot is ready.")
#client.event
async def on_message_delete(message):
# Make sure it's in a watched channel, and not one of the bot's own
# messages.
if message.channel.id in CHANNEL_IDS and message.author != client.user:
print(f'sniped message: {message}')
client.sniped_messages[message.channel.id] = message
#client.command()
async def snipe(ctx):
# Only respond to the command in a watched channel.
if ctx.channel.id not in CHANNEL_IDS:
return
try:
message = client.sniped_messages[ctx.channel.id]
# See note below
except KeyError:
await ctx.channel.send("Couldn't find a message to snipe!")
return
embed = discord.Embed(
description=message.content,
color=discord.Color.purple(),
timestamp=message.created_at
)
embed.set_author(
name=f"{message.author.name}#{message.author.discriminator}",
icon_url=message.author.avatar_url
)
embed.set_footer(text=f"Deleted in: #{message.channel.name}")
await ctx.channel.send(embed=embed)
client.run(TOKEN)
Note: bare except clauses, like in your original code, are not generally a good idea. Here we only want to catch KeyError, which is what is raised if the requested key isn't in the dictionary.
You could, optionally, implement the same logic in a different way:
message = client.sniped_messages.get(ctx.channel.id)
if message is None:
await ctx.channel.send("Couldn't find a message to snipe!")
return
A dictionary's .get() method returns the corresponding item just like normal indexing. However, if there is no such key, instead of raising an exception, it returns a default value (which is None if you don't specify one in the call to get).
If you're using Python 3.8+, the first two lines could also be combined using an assignment expression (using the "walrus operator"), which assigns and checks all at once:
if (message := client.sniped_messages.get(ctx.channel.id)) is None:
await ctx.channel.send("Couldn't find a message to snipe!")
return
These alternative options are mentioned for completeness; all of these ways of doing it are perfectly fine.
Code:
import discord
class MyClient(discord.Client):
async def on_ready(self):
print('Logged in as')
print(self.user.name)
print(self.user.id)
print('------')
async def on_message(self, message):
words = [] # List of words to look for
if message.author.id == self.user.id:
return
for i in words:
if i in message.content.lower():
await message.channel.send(f"Hey <#{message.author.id}>, i have noticed that in your message is a word on a list")
break
await message.add_reaction("✅")
await client.wait_for("reaction_add")
await message.delete()
client = MyClient()
client.run("TOKEN")
How Could i make the bot add reaction to its own message and if the user uses it delete its own message
i did look for the answer but god is discord.py messy, i have seen 6 answers that did not work and all of them seemed like they use different modules
i apologize if the answer was easy to find, but i just couldnt
First of all, you should always try to find your answer in the documentation (discord.py documentation). (Off-topic: it's not discord.py that's messy; it's likely the method you are using to find answers which is messy.)
The TextChannel.send() method returns the message which was sent. So, you could just assign that return value to a variable.
For the other issue, there is an event listener which detects message deletions, on_message_delete()
import discord
class MyClient(discord.Client):
async def on_ready(self):
...
async def on_message(self, message):
words = []
if message.author.id == self.user.id:
return
for i in words:
if i in message.content.lower():
sent_message = await message.channel.send(
f"Hey {message.author.mention}, I have noticed that in your message is a word on a list"
)
break
await sent_message.add_reaction("reaction")
await message.add_reaction("✅")
await client.wait_for("reaction_add")
await message.delete()
async def on_message_delete(self, message):
# Do stuff here
client = MyClient()
client.run("TOKEN")
(On a side note, you can use Member.mention to mention/ping a member, instead of "<#{message.author.id}>".)
In my opinion, it is preferable to use the #client.event method decorator above your event methods instead of putting them in their own class. You would declare the client object as client=discord.Client() at the top, then put #client.event above your event handling methods. The on_reaction_add method can have reaction and message parameters to respond.
how do I get the name of a channel so that this bot will work on any server its put on with no changes to code necessary? ( in the code where I put "what do I put here" is where I want the name to be in a variable)Thanks
from discord.ext.commands import Bot
import time, asyncio
TOKEN = 'Its a secret'
BOT_PREFIX = ["!"]
client = Bot(command_prefix=BOT_PREFIX)
#client.event
async def on_message(message):
if message.author == client.user:
return
#client.event
async def on_ready():
print('Logged in as')
print(client.user.name)
print(client.user.id)
print('------')
await start()
while True:
currentTime = time.strftime("%M%S", time.gmtime(time.time()))
if currentTime == "30:00":
await start()
await asyncio.sleep(1)
async def start():
mainChannel = #What do i put here?
print(mainChannel.name)
await client.send_message(mainChannel, "Starting countdown", tts = True)
client.run(TOKEN)
Getting channel from ID (Recommended)
First, get the ID of the channel
(Right click the channel and select "Copy ID")
Second, put the ID in the following code:
client.get_channel("ID")
For example:
client.get_channel("182583972662")
Note: The channel ID is a string in discord.py async, and an integer in rewrite
(Thanks to Ari24 for pointing this out)
Getting channel from name (Not reccomended)
First, get the server using either:
server = client.get_server("ID")
OR
for server in client.servers:
if server.name == "Server name":
break
Second, get the channel:
for channel in server.channels:
if channel.name == "Channel name":
break
What not to do
Try to always use the ID for each server, as it is much faster and more efficient.
Try to avoid using discord.utils.get, such as:
discord.utils.get(guild.text_channels, name="Channel name")
Although it does work, it is bad practise as it has to iterate through the entire list of channels. This can be slow and take much more time than using the ID.
From the discord API docs:
discord.utils.get is a helper that returns the first element in the
iterable that meets all the traits passed in attrs
Now in rewrite there's a method called discord.utils.get where you can actually getting discord objects with specific parameters
In your case with a channel name:
import discord
channel = discord.utils.get(guild.text_channels, name="Name of channel")
Should be None if discord couldn't find a textchannel with that name
It is actually really easy:
You can simply do message.channel.name
Example:
print(message.channel.name)
Well, it's simple to do. However your code can be improved by several way. It will be easier to read your code.
to get the channel and send a message to it, use this
ch = client.get_channel(channel id)
await ch.send("message")
few optimizations to your code
from discord.ext import commands
import discord
import time
TOKEN = "token"
client = commands.Client(command_prefix="!")
#client.event
async def on_ready():
print(f"Logged in as {client.user}")
print(f"ID: {client.id}")
how do I get the name of a channel so that this bot will work on any server its put on with no changes to code necessary? ( in the code where I put "what do I put here" is where I want the name to be in a variable)Thanks
from discord.ext.commands import Bot
import time, asyncio
TOKEN = 'Its a secret'
BOT_PREFIX = ["!"]
client = Bot(command_prefix=BOT_PREFIX)
#client.event
async def on_message(message):
if message.author == client.user:
return
#client.event
async def on_ready():
print('Logged in as')
print(client.user.name)
print(client.user.id)
print('------')
await start()
while True:
currentTime = time.strftime("%M%S", time.gmtime(time.time()))
if currentTime == "30:00":
await start()
await asyncio.sleep(1)
async def start():
mainChannel = #What do i put here?
print(mainChannel.name)
await client.send_message(mainChannel, "Starting countdown", tts = True)
client.run(TOKEN)
Getting channel from ID (Recommended)
First, get the ID of the channel
(Right click the channel and select "Copy ID")
Second, put the ID in the following code:
client.get_channel("ID")
For example:
client.get_channel("182583972662")
Note: The channel ID is a string in discord.py async, and an integer in rewrite
(Thanks to Ari24 for pointing this out)
Getting channel from name (Not reccomended)
First, get the server using either:
server = client.get_server("ID")
OR
for server in client.servers:
if server.name == "Server name":
break
Second, get the channel:
for channel in server.channels:
if channel.name == "Channel name":
break
What not to do
Try to always use the ID for each server, as it is much faster and more efficient.
Try to avoid using discord.utils.get, such as:
discord.utils.get(guild.text_channels, name="Channel name")
Although it does work, it is bad practise as it has to iterate through the entire list of channels. This can be slow and take much more time than using the ID.
From the discord API docs:
discord.utils.get is a helper that returns the first element in the
iterable that meets all the traits passed in attrs
Now in rewrite there's a method called discord.utils.get where you can actually getting discord objects with specific parameters
In your case with a channel name:
import discord
channel = discord.utils.get(guild.text_channels, name="Name of channel")
Should be None if discord couldn't find a textchannel with that name
It is actually really easy:
You can simply do message.channel.name
Example:
print(message.channel.name)
Well, it's simple to do. However your code can be improved by several way. It will be easier to read your code.
to get the channel and send a message to it, use this
ch = client.get_channel(channel id)
await ch.send("message")
few optimizations to your code
from discord.ext import commands
import discord
import time
TOKEN = "token"
client = commands.Client(command_prefix="!")
#client.event
async def on_ready():
print(f"Logged in as {client.user}")
print(f"ID: {client.id}")
I have searched around a lot for this answer, and I haven't found it. I want to use a suggestion command, that whenever someone uses it to suggest an idea, it DMs me, and me only.
You'll have to use the send_message method. Prior to that, you have to find which User correspond to yourself.
#client.event
async def on_message(message):
# we do not want the bot to reply to itself
if message.author == client.user:
return
# can be cached...
me = await client.get_user_info('MY_SNOWFLAKE_ID')
await client.send_message(me, "Hello!")
#client.event
async def on_message(message):
if message.content.startswith("#whatever you want it to be")
await client.send_message(message.author, "#The message")
Replace the hashtagged things with the words that you want it to be. eg.: #whatever you want it to be could be "!help". #The message could be "The commands are...".
discord.py v1.0.0+
Since v1.0.0 it's no longer client.send_message to send a message, instead you use send() of abc.Messageable which implements the following:
discord.TextChannel
discord.DMChannel
discord.GroupChannel
discord.User
discord.Member
commands.Context
Example
With bot.command() (recommended):
from discord.ext import commands
bot = commands.Bot(command_prefix="!")
#bot.command()
async def suggest(ctx, *, text: str):
me = bot.get_user(YOUR_ID)
await me.send(text) # or whatever you want to send here
With on_message:
from discord.ext import commands
bot = commands.Bot()
#bot.event
async def on_message(message: discord.Message):
if message.content.startswith("!suggest"):
text = message.content.replace("!suggest", "")
me = bot.get_user(YOUR_ID)
await me.send(text) # or whatever you want to send here