async def slap(self, ctx, person):
"""Slap yourself or someone."""
async with self.session.get(
"https://nekos.life/api/v2/img/slap") as resp:
slap = await resp.json()
url = slap["url"]
color_random = [
int(x * 255) for x in colorsys.hsv_to_rgb(random.random(), 1, 1)
]
embed = discord.Embed(colour=discord.Color.from_rgb(*color_random))
embed.set_image(url=url)
embed.set_footer(
text="Powered by nekos.life",
icon_url="https://nekos.life/static/icons/favicon-194x194.png")
try:
person = await (commands.MemberConverter()).convert(
ctx=ctx, argument=person
) # Reimplementation of NekoBot/Kawaii Bot slap function. May change it in the near future.
except commands.BadArgument:
pass
if isinstance(person, discord.Member) and person.id == ctx.author.id:
embed.title = (f"*{ctx.author.name} slapped themself.*")
else:
if isinstance(person, discord.Member):
name = person.name
else:
name = person[:30]
embed.title = (f"*{ctx.author.name} slapped {name}*")
await ctx.send(embed=embed)
async def resolveMember(ctx, stringToResolve):
mc = commands.MemberConverter()
stringToResolve = stringToResolve.strip()
if isSnowflake(stringToResolve):
#gave an number that may be an ID
member = ctx.guild.get_member(
int(stringToResolve
)) #if stringToResolve is not a valid snowflake, mem=None
elif '@' in stringToResolve:
#mentioned a user
try:
member = await mc.convert(ctx, stringToResolve)
except Exception:
member = None
else:
try:
memList = await ctx.guild.query_members(query=stringToResolve)
except Exception:
memList = []
if len(memList) == 0:
member = None
elif len(memList) == 1:
member = memList[0]
else:
return memList
return member
def __init__(self, bot):
self.bot = bot
self.m_converter = commands.MemberConverter()
self.times = dict()
self.session = aiohttp.ClientSession()
## self.client = bot.api_c
self.sched = {}
async def gudgitters(self, ctx):
try:
converter = commands.MemberConverter()
res = cf_common.user_db.get_gudgitters()
res.sort(key=lambda r: r[1], reverse=True)
style = table.Style('{:>} {:<}')
t = table.Table(style)
t += table.Header('#', 'Name')
t += table.Line()
index = 0
for user_id, score in res:
try: # in case the person has left the server
member = await converter.convert(ctx, user_id)
name = member.nick if member.nick else member.name
handle_display = f'{name} ({score})'
t += table.Data(index, handle_display)
index = index + 1
except Exception as e:
print(e)
msg = '```\n' + str(t) + '\n```'
except Exception as e:
print(e)
msg = 'showhandles error!'
await ctx.send(msg)
async def addRole(self, ctx, role: discord.Role, *userList):
empty = True
added = 0
had = 0
notFound = 0
for user in userList:
try:
member = commands.MemberConverter(ctx, user).convert()
if member in ctx.message.server.members:
if role not in member.roles:
await self.bot.add_roles(member, role)
added += 1
else:
had += 1
empty = False
except:
if notFound == 0:
await self.bot.say("Couldn't find:")
await self.bot.say(user)
notFound += 1
if empty:
message = ":x: Nobody was given the role {0}".format(role.mention)
else:
message = ":white_check_mark: {0} role given to everyone that was found from list".format(
role.mention)
if notFound > 0:
message += ". {0} user(s) were not found".format(notFound)
if had > 0:
message += ". {0} user(s) already had the role".format(had)
if added > 0:
message += ". {0} user(s) had the role added to them".format(added)
await self.bot.say(message)
async def OnShowMissingPlayers(self, ctx):
"""Shows who is not in the matchmaking queue"""
print('Showing missing players')
if (botSettings.guild is None):
raise InvalidGuild()
missingMembers = []
for channel in botSettings.guild.voice_channels:
missingMembers.extend(
matchService.GetNotInQueue(channel.voice_states))
if (len(missingMembers) == 0):
await SendMessage(ctx,
description='Nobody is missing from queue.',
color=discord.Color.blue())
return
field = {}
field['name'] = 'Players not in queue'
field['value'] = ''
field['inline'] = False
converter = commands.MemberConverter()
for memberID in missingMembers:
try:
member = await converter.convert(ctx, str(memberID))
field['value'] += '{0.mention}\n'.format(member)
except commands.errors.MemberNotFound:
field['value'] += '{0}\n'.format(memberID)
await SendMessage(ctx, fields=[field], color=discord.Color.blue())
def resolve_target(self, ctx, target):
if target == 'channel':
target = ctx.message.channel, self.ignored.channels
elif target == 'server':
return ctx.message.server, self.ignored.servers
# Try converting to a channel
try:
channel = commands.ChannelConverter(ctx, target).convert()
except commands.BadArgument:
pass
else:
return channel, self.ignored.channels
# Try converting to a user
try:
user = commands.MemberConverter(ctx, target).convert()
except commands.BadArgument:
pass
else:
server_id = ctx.message.server.id
r_conf = self.ignored.users.get(server_id, None)
if r_conf is None:
self.ignored.users[server_id] = []
return user, self.ignored.users[server_id]
# Convert to a server, let it raise commands.errors.BadArgument if we still can't make sense of the target
server = utils.ServerConverter(ctx, target).convert()
return server, self.ignored.servers
async def kill(self, ctx, *, who):
if who == 'yourself':
# Aww mean D:
await self.bot.say(
'Committing sudoku...\nhttp://i.imgur.com/emefsOg.jpg')
self.bot.do_restart = False
self.bot.shutdown()
return
if not ctx.message.channel.permissions_for(
ctx.message.server.me).kick_members:
await self.bot.say('My power is not over 9000, sorry.')
return
try:
member = commands.MemberConverter(ctx, who).convert()
except commands.BadArgument:
await self.bot.say('Member not found.')
else:
if member.id == self.bot.owner.id:
await self.bot.say('Cannot kill the bot owner.')
elif member.id == ctx.message.server.owner.id:
await self.bot.say('Cannot kill the server owner.')
else:
await self.bot.say('http://i.imgur.com/k3n09s9.png')
await self.bot.kick(member)
def get_member(ctx: commands.Context, user: str) -> discord.Member:
"""
Return the :cls:`discord.Member` for a given input identifying a user (ID, mention, name, etc.).
The user must be a member of a visible server. The current server (as determined by context)
is prioritised in searching.
This function is intended to be robust for various types of inputs that may be input by
a user to a bot command:
* Simple ID: '123456789012345678'
* Mentions:
* No nickname: '<@123456789012345678>'
* User has nickname: '<@!123456789012345678>'
* Variations on mentions altered by user:
* '@123456789012345678'
* '@!123456789012345678'
* '!123456789012345678'
* Search by user name and discriminator:
* JaneDoe#0921
* JaneDoe
:return:
:raises discord.InvalidArgument: user not found
"""
# try our own extractor as it handles more weird input cases
# if fail assume it's a name lookup
try:
s_user_id = extract_user_id(user)
except discord.InvalidArgument:
s_user_id = user
member_converter = commands.MemberConverter(ctx, s_user_id)
return member_converter.convert()
async def is_valid_user(ctx, user_name):
converter = commands.MemberConverter()
try:
await converter.convert(ctx, user_name)
return True
except Exception:
return False
async def convert(self, ctx: commands.Context, argument: str):
# In this example we have made a custom converter.
# This checks if an input is convertible to a
# `discord.Member` or `discord.TextChannel` instance from the
# input the user has given us using the pre-existing converters
# that the library provides.
member_converter = commands.MemberConverter()
try:
# Try and convert to a Member instance.
# If this fails, then an exception is raised.
# Otherwise, we just return the converted member value.
member = await member_converter.convert(ctx, argument)
except commands.MemberNotFound:
pass
else:
return member
# Do the same for TextChannel...
textchannel_converter = commands.TextChannelConverter()
try:
channel = await textchannel_converter.convert(ctx, argument)
except commands.ChannelNotFound:
pass
else:
return channel
# If the value could not be converted we can raise an error
# so our error handlers can deal with it in one place.
# The error has to be CommandError derived, so BadArgument works fine here.
raise commands.BadArgument(
f'No Member or TextChannel could be converted from "{argument}"')
async def _sub_adminlist(self, ctx, *, trainer=None):
"""**Usage**: `!sub adminlist/alist <member>`
Receive a list of all current subscriptions the provided member has"""
message = ctx.message
channel = message.channel
author = message.author
if not trainer:
response_msg = "Please provide a trainer name or id"
response = await channel.send(response_msg)
return await utils.sleep_and_cleanup([message, response], 10)
if trainer.isdigit():
trainerid = trainer
else:
converter = commands.MemberConverter()
try:
trainer_member = await converter.convert(ctx, trainer)
trainerid = trainer_member.id
except:
response_msg = f"Could not process trainer with name: {trainer}"
await channel.send(response_msg)
return await utils.sleep_and_cleanup([message, response_msg],
10)
try:
results = (SubscriptionTable.select(
SubscriptionTable.type, SubscriptionTable.target).join(
TrainerTable,
on=(SubscriptionTable.trainer == TrainerTable.snowflake
)).where(SubscriptionTable.trainer == trainerid).where(
TrainerTable.guild == ctx.guild.id).where(
SubscriptionTable.guild_id == ctx.guild.id))
results = results.execute()
subscription_msg = ''
types = set([s.type for s in results])
subscriptions = {
t: [s.target for s in results if s.type == t]
for t in types
}
for sub in subscriptions:
subscription_msg += '**{category}**:\n\t{subs}\n\n'.format(
category=sub.title(), subs='\n\t'.join(subscriptions[sub]))
if len(subscription_msg) > 0:
listmsg = "Listing subscriptions for user: {id}\n".format(
id=trainer)
listmsg += 'Current subscriptions are:\n\n{subscriptions}'.format(
subscriptions=subscription_msg)
await message.add_reaction(self.success_react)
await author.send(listmsg)
else:
none_msg = await channel.send(
f"No subscriptions found for user: {trainer}")
await message.add_reaction(self.success_react)
return await utils.sleep_and_cleanup([none_msg], 10)
except:
response_msg = f"Encountered an error while looking up subscriptions for trainer with name: {trainer}"
await channel.send(response_msg)
return await utils.sleep_and_cleanup([response_msg, message], 10)
async def clean(ctx, arg):
await check_admin(ctx)
def check_member(ctx, arg):
return ctx.author == arg
try:
# Se si vuole cancellare oltre 5000 messaggi no
if int(arg) > 5000:
if ctx.message.author.id != int(creator_id):
await ctx.channel.send(get_string(ctx, 'canc_errore'))
return
except:
try:
# Se e' un membro cancella messaggi suoi
converter = commands.MemberConverter()
member = await converter.convert(ctx, arg)
await ctx.channel.purge(
check=lambda ctx: check_member(ctx, member))
except errors.MemberNotFound:
# Altrimenti cancella il numero indicato
await ctx.channel.purge(limit=int(arg))
m = await ctx.channel.send(
f'{get_string(ctx, "costo")} {ra.randint(10, 200)}$')
await m.add_reaction('🧹')
await asyncio.sleep(4)
await m.delete()
def __init__(self, client):
self.client = client
self.tournament = Tournament()
self.queue = Tournament.get_tournaments(client)
self.attr = ['name', 'time', 'prize', 'host', 'roles', 'note']
self.channels = Channel(client)
self.roles = Role(client)
self.checklist = None
self.modifiers = [{
'name': 'RequiredRole',
'value': commands.RoleConverter()
}, {
'name': 'MaxParticipants',
'value': int
}, 'SpectatorsAllowed', {
'name': 'PrizeType',
'value': ModifierUtils.convert_to_prize_type
}, {
'name': 'AutoGiveCoins',
'value': int
}, {
'name': 'AssistingTO',
'value': commands.MemberConverter()
}]
asyncio.create_task(self.update_reminders())
print(self.__class__.__name__ + " cog initialized!")
async def _checkin(self, ctx, *, member):
converter = commands.MemberConverter()
try:
member = await converter.convert(ctx, member)
except:
member = None
result = (EventTable.select(
EventTable.role).where((EventTable.active == True)
& (EventTable.guild_id == member.guild.id)))
roles = [r.role for r in result]
if len(roles) < 1:
await ctx.message.add_reaction(self.failed_react)
return await ctx.send("There is no active event.", delete_after=10)
if len(roles) > 1:
await ctx.message.add_reaction(self.failed_react)
return await ctx.send(
"There are too many active events, please contact an admin.",
delete_after=10)
try:
role = role = discord.utils.get(ctx.guild.roles, id=roles[0])
await member.add_roles(*[role])
await asyncio.sleep(0.1)
if role not in member.roles:
await ctx.message.add_reaction(self.failed_react)
return await ctx.send(
f"Failed to give event role to {member.display_name}.",
delete_after=10)
except discord.Forbidden:
await ctx.message.add_reaction(self.failed_react)
return await ctx.send(
f"Failed to give event role to to {member.display_name} because you do not have permission",
delete_after=10)
await ctx.message.add_reaction(self.success_react)
async def anoint_command(context):
# NOTE: the bot must have the highest permission or this function will break
author = context.message.author
message = context.message.content
perm = False
for role in author.roles:
if role.name == CONFIG['role']:
perm = True
pleb_role = role
break
args = message.split(' ')
if perm and len(args) == 2:
try:
converter = commands.MemberConverter()
member = await converter.convert(context, args[1])
async def make_pleb():
await member.add_roles(pleb_role)
message = message.replace('!', '') # for some reason user @ themselves adds !
counsel.try_vote_act(message, make_pleb, 'anoint')
await counsel.query(message, author, 'anoint', context.message.channel)
except:
print('invalid user')
else:
print('invalid anoint"{}"'.format(message))
def __init__(self, bot):
global curr_tour, _API
_API = environ.get('CHALLONGE_API')
self.bot = bot
self.converter = commands.MemberConverter()
self.draw_offers = {}
async def convert(self, ctx: Context, argument: str = None):
try:
member_converter = commands.MemberConverter()
member = await member_converter.convert(ctx, argument)
image = member.avatar.replace(format="png",
static_format="png",
size=1024)
return str(image)
except Exception:
try:
url = await emoji_to_url(argument)
if re.match(regex_url, url):
image = str(url)
return image
if re.match(regex_url, argument):
image = argument
return image
if re.match(emoji_regex, argument):
emoji_converter = commands.EmojiConverter()
emoji = await emoji_converter.convert(ctx, argument)
image = emoji.url_as(format="png",
static_format="png",
size=1024)
return image
except Exception:
return None
raise commands.MemberNotFound(argument)
async def ban(self, ctx, member: commands.MemberConverter(), *, reason=None):
embed = discord.Embed(title=f'You Have Been Banned From {ctx.guild}',
description=f'Reason for Ban: {reason}', colour=discord.Colour.from_rgb(67, 181, 129))
embed.set_footer(icon_url=str(self.bot.user.avatar_url),
text=f'WillCaninoBot Alpha • {datetime.date.today()}')
await member.send(embed=embed)
await member.kick(reason=reason)
async def _format_leaderboard_message(ctx, highest_balances):
converter = commands.MemberConverter()
send_back = ''
for idx, poop_balance in enumerate(highest_balances):
member = await converter.convert(ctx, f'<@!{poop_balance.id}>')
send_back += f'{idx + 1}. {member.name}\t{poop_balance.balance} :poop:\n'
return send_back
async def profile(ctx, member= None):
mc = commands.MemberConverter()
if member is None:
mem = ctx.guild.get_member(ctx.author.id)
elif '@' in member:
mem = await mc.convert(ctx, member)
embed = profileEmbed(mem)
await ctx.send(embed=embed)
async def rigSet(ctx, arg: str):
if not ctx.message.author.id in cmdsettings:
cmdsettings[ctx.message.author.id] = {}
foundUser = commands.MemberConverter(ctx, arg).convert()
cmdsettings[ctx.message.author.id]['rig'] = str(foundUser)
await bot.say('Rigged to {}'.format(str(foundUser)))
async def givexp(self, ctx, amount: int, receiver=commands.MemberConverter()):
if not isinstance(receiver, discord.Member):
receiver = ctx.author
user = await self.session.run_sync(UserXP.get_or_create, receiver.id, ctx.guild.id)
user.xp += amount
await self.session.commit()
await ctx.send(f"{ctx.author.mention} You have succesfully given {amount:,} XP "
f"to {'yourself' if receiver == ctx.author else receiver.mention}!")
async def kick(self, ctx, player: str, reason=''):
"""Kicks a player from the current ladder.
Automatically updates the ranking.
The player can rejoin the ladder by signing up again but this resets their ranking and record completely.
Example: .1v1kick @Player"""
# 1. Check if user has admin role
if not await hasAdminRights(ctx, bot):
return
# Tries to convert input to member object
try:
converter = commands.MemberConverter()
player = await converter.convert(ctx, player)
except:
# If it can't bec converted, try different stuff
if len(player) > 10:
# Tries to read the input as Discord ID, assuming the player left the server
db.kickPlayer(int(player))
await updateRankingMessage(ctx.guild)
await ctx.send(f"Player was removed from the 1v1 ladder!")
return
else:
# Interprets the input as ranking number
playerInfo = db.getPlayerByRank(player)
if playerInfo is None:
await ctx.send(f"There's no player at #{player}.")
return
try:
player = await converter.convert(ctx, playerInfo.discordID)
except:
# If player isn't in server anymore, deletes them from the database
db.kickPlayer(int(playerInfo.discordID))
await updateRankingMessage(ctx.guild)
await ctx.send(
f"Player at rank #{player} was removed from the 1v1 ladder!"
)
return
# 2. Check if target is part of the ladder
if not db.isLadderPlayer(player):
await ctx.send("Player isn't participating in the 1v1 ladder!")
return
# 3. Remove ladder role and delete player from ladder database, update ranking
await kickPlayer(ctx, player, ctx.author.name, reason)
# 4. Display success message
kickMessage = f"{player.name} was kicked from the ladder."
if not reason == '':
kickMessage += f" Reason: '{reason}'"
await ctx.send(kickMessage)
async def convert(self, ctx, argument):
converter = commands.MemberConverter()
member = await converter.convert(ctx, argument)
permissions = ctx.channel.permissions_for(member)
if permissions.manage_messages:
raise utils.MemberIsStaff("That member is a staff member...")
else:
return member
async def _dm_generic(ctx, *, online_only):
'''
See ``dm``.
'''
if ctx.channel.id not in BOT_DM_CHANNELS:
raise ChannelPermissionMissing()
# split argument string into roles and message
args = ctx.message.content.partition(ctx.invoked_with + " ")[2]
recipient_part, _, message = args.partition("--")
recipient_part = recipient_part.strip()
message = message.lstrip()
if (len(message) == 0):
raise commands.BadArgument()
# extract roles and Members and collect recipients
recipients = set()
for recipient in recipient_part.split(" "):
if recipient == "":
continue
try:
conv = commands.RoleConverter()
recipient = await conv.convert(ctx, recipient)
recipients |= set(recipient.members)
except commands.BadArgument:
#This gets triggered when there is no Role for the string 'recipients'
member_converter = commands.MemberConverter()
recipient = await member_converter.convert(ctx, recipient)
recipients.add(recipient)
sent = 0
offline = 0
blocked = 0
for member in recipients:
if online_only and member.status == discord.Status.offline:
offline += 1
continue
try:
await member.send(message)
sent += 1
except discord.errors.Forbidden:
blocked += 1
await ctx.send(f"{member.mention} did not receive the message "
f"(bot was blocked).")
message = (f"Message sending complete.\n"
f"> Sent to a total of {sent} people\n")
if offline > 0 or blocked > 0:
message += (f"> {offline+blocked} people did not receive a message\n"
f"> - {offline} offline\n"
f"> - {blocked} blocked")
await ctx.send(message)
async def osu_converter(self, ctx: commands.Context, arg: str):
converter = commands.MemberConverter()
try:
user = await converter.convert(ctx, arg)
data = await self.bot.redis.get("osu:{}".format(user.id))
if data is None:
raise ValueError("Missing data")
data = int(data)
return data
except:
return arg
async def memeviolation_command(context):
sender = context.message.author
msg = context.message.content
args = msg.split(' ')
args.pop(0)
async def post_help():
m = """```
1: Madding Too Fast
2: Louding Too Fast
3: Background Stuff
4: Unfunny
5: Unironic XD
6: Rapid Head Expansion
7: Global Elite Syndrome
8: Spoilers
9: Unidentified Sucking Noises
0: Other: *MSG
Example Usage:
.memeviolation @targetsName 1
.memeviolation @targetsName 2345
.memeviolation @targetsName 0 *MSG```
"""
await context.message.channel.send(m)
if len(args) >= 2:
target = args.pop(0)
code = args.pop(0)
try:
code = int(code)
code = list(str(code))
code = [int(v) for v in code]
converter = commands.MemberConverter()
target = await converter.convert(context, target)
except ValueError:
await post_help()
return
async def send_mv():
PENALTY = 15
other_text = ' '.join(args)
mv = MemeViolation(code, sender, other_text=other_text)
img = mv.generate()
with BytesIO() as img_bin:
img.save(img_bin, 'PNG')
img_bin.seek(0)
await context.message.channel.send(":rotating_light: MEME VIOLATION :rotating_light:\nIssued to -> {}! penalized {}{}".format(target.mention, CONFIG['curr-symbol'], PENALTY),
file=discord.File(fp=img_bin, filename='mv.png'))
await curr_man.do_transaction(target.id, -PENALTY)
counsel.try_vote_act(msg, send_mv, 'memeviolation')
await counsel.query(msg, sender, 'memeviolation', context.message.channel)
else:
await post_help()
async def visualizza_mutati(ctx):
await check_admin(ctx)
msg = ''
if not set(silenziati):
msg = get_string(ctx, 'ness_silenziato')
else:
converter = commands.MemberConverter()
for user in set(silenziati):
member = await converter.convert(ctx, f'<@!{user}>')
msg += f'> {member.display_name}\n'
await ctx.channel.send(msg)
async def kick(self, ctx, *members: commands.MemberConverter()):
numberKicked = 0
for member in members:
try:
await member.kick()
numberKicked += 1
except:
pass
await ctx.send(embed=self.bot.generateEmbed(
f'Kicked {numberKicked} members.', '🥾'))
