Develop Reference

My mute command doesn't remove the roles properly

does anyone know if I have to use a database for a mute command now or what since if a member already has a role that lets them able to talk the muted role has no affect even regardless of the role hierarchy I made it where when I mute the member it takes all the roles away which works but when the time runs out or they get unmuted the member cant get their roles back anyone know how to deal with this?
#commands.command()
#commands.has_permissions(manage_messages=True)
async def mute(self, ctx, member: discord.Member=None, time=None, *, reason= None):
if time== None:
await ctx.send("you gotta set a duration.")
guild = ctx.guild
mutedrole=discord.utils.get(guild.roles, name="muted")
time_convert = {"s":1, "m":60, "h":3600,"d":86400}
tempmute= int(time[:-1]) * time_convert[time[-1]]
roles = [role for role in member.roles]
if not mutedrole:
mutedrole=await guild.create_role(name="muted", permissions=discord.Permissions(send_messages=False))
if reason== None:
reason= "No reason"
for channel in guild.channels:
await channel.set_permissions(mutedrole, speak=False, send_messages=False, add_reactions=False)
await member.edit(roles=[])
await member.add_roles(mutedrole, reason=reason)
embed= discord.Embed(description=f"**{member}** was muted for: {reason}")
await ctx.send(embed=embed)
embed= discord.Embed(description= f"You were muted in **{guild}** for: {reason}\n"
"\n **Tip**: don't be useless man!", color=0x000000)
await member.send(embed=embed)
await asyncio.sleep(tempmute)
await member.remove_roles(mutedrole)
await member.add_roles(roles)

add_roles() has a parameter called *roles which is an argument list of abc.SnowFlake representing a discord.Role. Means when you have multiple roles, add a * right before roles like that (same for remove_roles):
await member.add_roles(*roles)
BUT this doesn't work yet, since member.roles includes also the #everyone "role" which can't be added to a user (it's the default role). You need to remove it from the list.
The end result
roles = member.roles[1:] # discord.Member has an attribute roles
...
await asyncio.sleep(tempmute)
await member.remove_roles(mutedrole)
await member.add_roles(*roles)
References:
Member.add_roles()
Member.remove_roles()

Can not seem to get mute commands to work with Discord py

I can not find a mute command for my discord bot, and I do not know how to write one. The tutorials and pieces of code out there are not working. The most recent code produces no errors messages, but the command will not initiate. How?
#commands.has_permissions(manage_messages=True)
async def mute(ctx, member: discord.member, *, reason=None):
guild =ctx.guild
mutedRole = discord.Utils.get(guild.roles, name="Muted")
if not mutedRole == await guild.create_role(name="Muted"):
for channel in guild.channels:
await channel.set_permissions(mutedRole, speak=False, sendmessages=False, read_message_history=False, read_messages=False)
await member.add_roles(mutedRole, reason = reason)
await ctx.send(f"Muted {member.mention} for reason {reason}")
await member.send(f"You were muted in {guild.name} for {reason}")```

There are many mistakes and typos in the code. Adding #bot.command(name=name) before #commands.has_permissions(manage_messages=True) fixed it for me:
intent = discord.Intents(messages=True, message_content=True, guilds=True)
bot = commands.Bot(command_prefix="", description="", intents=intent)
#See if you have "intents=<someintentobject>" and enable them in your Discord Developer Portal
#bot.event
async def on_ready():
print("It's online!")
#bot.event
async def on_message(message: discord.Message):
await bot.process_commands(message) #Let the commands process the message
#bot.command(name="mute") #This decorator tells that the mute function is a command the bot should process
#commands.has_permissions(manage_messages=True) #Run the mute command only if the message's author has the permission to manage messages
async def mute(ctx, member: discord.Member, reason=None): #Removed the extra arguments' asterisk (*)
#It's discord.Member, not discord.member
guild = ctx.guild
mutedRole = discord.utils.get(guild.roles, name="Muted") #utils, not Utils
if not mutedRole == await guild.create_role(name="Muted"):
for channel in guild.channels:
await channel.set_permissions(mutedRole, speak=False, send_messages=False, read_message_history=False,
read_messages=False) #send_messages, not sendmessages
await member.add_roles(mutedRole, reason=reason)
await ctx.send(f"Muted {member.mention} for reason {reason}")
await member.send(f"You were muted in {guild.name} for {reason}")
Add await bot.process_commands(message) in your on_message.
I've removed the * (args); it works fine without it. You can add it if you want.
See this example of a kick command.

#bot.command()
#commands.has_permissions(manage_messages=True)
async def mute(ctx, member: discord.Member, reason=None):
if member == ctx.author:
embed = discord.Embed(
color=discord.Colour.red(),
description="You can't mute yourself !"
)
await ctx.send(embed=embed)
return
muterole = discord.utils.get(ctx.guild.roles, name="MUTED")
if muterole is None:
muterole = await ctx.guild.create_role(name="MUTED")
for channel in ctx.guild.text_channels:
await channel.set_permissions(muterole, overwrite=discord.PermissionOverwrite(send_messages=False))
if muterole in member.roles:
embed = discord.Embed(
color=discord.Colour.red(),
description=f'This member is already muted'
)
await ctx.send(embed=embed)
return
await member.add_roles(muterole)
embed = discord.Embed(
color=discord.Colour.green(),
title=' Muted',
description=f'**{member.mention}** is now **permanently muted** reason: **{reason}**.'
)
embed.set_footer(text=f'Muted by {ctx.author}.')
await ctx.send(embed=embed)
basically what a "mute" command does is to create or directly assign a role to a member, the most important part is that the mute role to be correctly configured.
there's also more complex methods of mute command, for example temp mute command which allows you to mute someone for a certain amount of time specified by the mod, but these days is recommended that you use the timeout feature is a lot easier and more efficient. but there you have it, a basic mute command with the appropriate checks.

I cannot add a role to any one with discord.py

so my code looks like this:
#bot.command()
async def admin(ctx, user: discord.Member):
await ctx.send("hellooooooo")
guild = ctx.guild
await guild.create_role(name="role name")
await user.add_roles(guild)
but the role is created but it fails to give the role to the person

What you're doing here is trying to add the role guild to the member. The problem is that guild is not a role at all, but the whole server.
You must add the newly created role, the one that is returned by guild.create_role(name="role name").
Here's how to do it :
#bot.command()
async def create_and_add_role(ctx, user: discord.Member):
guild = ctx.guild
role = await guild.create_role(name="New role")
await user.add_roles(role)
await ctx.send("Role created and added!")

Some code
Something like this should work:
#Bot.command()
#commands.has_permissions(administrator = True)
async def CreateAddRole(ctx, User:discord.Member, RoleName:str):
await ctx.message.delete()
role = await ctx.guild.create_role(name = RoleName)
await User.add_roles(role)
await ctx.send(embed = discord.Embed(title = "NEW ROLE", description = f"{ctx.message.author.mention} created the role {role.mention} and assigned it to {User.mention}", color = discord.Color.green())
Try running the code above, because the embed seems more professional than a simple message.

Im trying to make it where the bot will tell you to specify a member to mute if they dont specify it. How do i do that? I tried to but it doesnt work

Mute code below. If a mod doesnt specify what member to mute, how can the bot tell them that? Thanks!
#bot.command()
#commands.has_permissions(manage_roles=True)
async def mute(ctx, member: discord.Member, reason=None):
if member.id == ctx.author.id:
await ctx.send(f"{ctx.author.mention}, YOU HAVE BEEN STOPPED BY ME YAY, you can't mute yourself!")
return
if discord.Member == None:
await ctx.send(f"{ctx.author.mention}, HEY you nugget, you need to specify who you want to mute!")
return
role = discord.utils.get(ctx.guild.roles, name='muted')
if role in ctx.guild.roles:
await member.add_roles(role)
embed=discord.Embed(title="Muted", description=f"Offender: {member.mention} has been muted until further notice!", color=0x00FFFF)
embed.add_field(name="Reason", value=f'{reason}', inline=True)
embed.add_field(name="Moderator", value=f'{ctx.author.name}', inline=True)
await ctx.send(embed=embed)
else:
await ctx.send(f"{ctx.author.mention}, Make sure your muted role is called `muted` in all lowercase! Then try again.")

Your thought was right, but you need to approach it a little differently.
Take a look at the following code:
#bot.command()
#commands.has_permissions(manage_roles=True)
async def mute(ctx, member: discord.Member, reason=None):
if member.id == ctx.message.author.id:
await ctx.send("You can't mute yourself")
if member:
# Do what you want if the member was given
What we only did is work with if statements.
If you want you can also use return await so the bot will no longer proceed.
You can also build in an error handler for different things. Have a look at the following code:
#mute.error
async def mute_error(ctx, error):
if isinstance(error, commands.MissingRequiredArgument):
await ctx.send("No member given")
You have to put the code under the actual mute command code.

Discord.py ban command

if message.content.upper().startswith('!BAN'):
if "449706643710541824" in [role.id for role in message.author.roles]:
await
I have the base setup so only admins can ban. I want to make the ban command, but I'm not sure how to do it.

Try this:
import discord #Imports the discord module.
from discord.ext import commands #Imports discord extensions.
#The below code verifies the "client".
client = commands.Bot(command_prefix='pb?')
#The below code stores the token.
token = "Your token"
'''
The below code displays if you have any errors publicly. This is useful if you don't want to display them in your output shell.
'''
#client.event
async def on_command_error(ctx, error):
if isinstance(error, commands.MissingRequiredArgument):
await ctx.send('Please pass in all requirements :rolling_eyes:.')
if isinstance(error, commands.MissingPermissions):
await ctx.send("You dont have all the requirements :angry:")
#The below code bans player.
#client.command()
#commands.has_permissions(ban_members = True)
async def ban(ctx, member : discord.Member, *, reason = None):
await member.ban(reason = reason)
#The below code unbans player.
#client.command()
#commands.has_permissions(administrator = True)
async def unban(ctx, *, member):
banned_users = await ctx.guild.bans()
member_name, member_discriminator = member.split("#")
for ban_entry in banned_users:
user = ban_entry.user
if (user.name, user.discriminator) == (member_name, member_discriminator):
await ctx.guild.unban(user)
await ctx.send(f'Unbanned {user.mention}')
return
#The below code runs the bot.
client.run(token)
I hope this helps, good luck on your bot!

My ban command i got for my bot is , obviously dont keep the comment out for the ban part, I just put that there when i didn't know how to lock it to roles
#bans a user with a reason
#client.command()
#commands.has_any_role("Keyblade Master","Foretellers")
async def ban (ctx, member:discord.User=None, reason =None):
if member == None or member == ctx.message.author:
await ctx.channel.send("You cannot ban yourself")
return
if reason == None:
reason = "For being a jerk!"
message = f"You have been banned from {ctx.guild.name} for {reason}"
await member.send(message)
# await ctx.guild.ban(member, reason=reason)
await ctx.channel.send(f"{member} is banned!")

This is the best one
async def ban(ctx, member : discord.Member, reason=None):
"""Bans a user"""
if reason == None:
await ctx.send(f"Woah {ctx.author.mention}, Make sure you provide a reason!")
else:
messageok = f"You have been banned from {ctx.guild.name} for {reason}"
await member.send(messageok)
await member.ban(reason=reason)

I'd recommend to use discord.ext.commands to make commands, it's easier to use. The function to ban is discord.Client.ban(member, delete_message_days = 1). This is an example using discord.ext.commands:
bot = commands.Bot(command_prefix = "!")
#bot.command(pass_context = True)
async def ban(member: discord.Member, days: int = 1):
if "449706643710541824" in [role.id for role in message.author.roles]:
await bot.ban(member, days)
else:
await bot.say("You don't have permission to use this command.")
bot.run("<TOKEN>")

A ban command? It's actually very easy!
#commands.has_permissions(ban_members=True)
#bot.command()
async def ban(ctx, user: discord.Member, *, reason="No reason provided"):
await user.ban(reason=reason)
ban = discord.Embed(title=f":boom: Banned {user.name}!", description=f"Reason: {reason}\nBy: {ctx.author.mention}")
await ctx.message.delete()
await ctx.channel.send(embed=ban)
await user.send(embed=ban)
if you know kick you just need to change the user.kick into a user.ban because user.kick will kick a member so that means user.ban will ban a member.

According to Discord Official Documentation:-
#bot.command(name="ban", help="command to ban user")
#commands.has_permissions(ban_members=True)
async def _ban(ctx, member: discord.Member, *, reason=None):
""" command to ban user. Check !help ban """
try:
await member.ban(reason=reason)
await ctx.message.delete()
await ctx.channel.send(f'{member.name} has been banned from server'
f'Reason: {reason}')
except Exception:
await ctx.channel.send(f"Bot doesn't have enough permission to ban someone. Upgrade the Permissions")
#bot.command(name="unban", help="command to unban user")
#commands.has_permissions(administrator=True)
async def _unban(ctx, *, member_id: int):
""" command to unban user. check !help unban """
await ctx.guild.unban(discord.Object(id=member_id))
await ctx.send(f"Unban {member_id}")

#bot.command()
#commands.has_permissions(ban_members = True)
async def ban(ctx, member : discord.Member, *,reason=None):
if member == None or member == ctx.message.author:
await ctx.channel.send("You cannot ban yourself")
return
if reason == None:
reason = "For being a jerk!"
message = f"You have been banned from {ctx.guild.name} for {reason}"
await member.send(message)
await member.ban(reason=reason)
await ctx.send(f"{member} is banned!")

This is a ban command I use and it works perfectly fine for me. You have full permission to use the whole thing if you'd like.
async def ban(self, ctx, member:discord.Member, *, reason=None):
guild = ctx.guild
author = ctx.message.author
if author.guild_permissions.administrator == False:
embed4=discord.Embed(color=discord.Colour.red(), timestamp=datetime.datetime.utcnow(), title="Missing Permissions!", description="You don't have the required permissions to use this command!")
message1 = await ctx.send(embed=embed4)
sleeper=5
await asyncio.sleep(sleeper)
await message1.delete()
return
if member.guild_permissions.administrator and member != None:
embed=discord.Embed(color=discord.Colour.red(), title="Administrator", description="This user is an administrator and is not allowed to be banned.")
message2 = await ctx.send(embed=embed)
sleeper=5
await asyncio.sleep(sleeper)
await message2.delete()
return
if reason == None:
embed1=discord.Embed(color=discord.Colour.red(), title="Reason Required!", description="You must enter a reason to ban this member.")
message3 = ctx.send(embed=embed1)
sleeper=5
await asyncio.sleep(sleeper)
await message3.delete()
return
else:
guild = ctx.guild
await member.ban()
embed2=discord.Embed(color=discord.Colour.green(), timestamp=datetime.datetime.utcnow(), title="Member Banned", description=f"Banned: {member.mention}\n Moderator: **{author}** \n Reason: **{reason}**")
embed3=discord.Embed(color=discord.Colour.green(), timestamp=datetime.datetime.utcnow(), title=f"You've been banned from **{guild}**!", description=f"Target: {member.mention}\nModerator: **{author.mention}** \n Reason: **{reason}**")
message4 = await ctx.send(embed=embed2)
message5 = await ctx.send("✔ User has been notified.")
sleeper=5
await asyncio.sleep(sleeper)
await message4.delete()
await message5.delete()
await member.send(embed=embed3)