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.', '🥾'))