async def on_message(self, message): self.bot.deleted_message_cache[message.id] = message if message.content == "<@!787927476177076234>" and not message.author.bot: message_ = await message.channel.send( "Hii there why u ping me smh oh i mean hii my prefix is `ovo ` " ) self.bot._message_cache[message.id] = message_ if message.content.startswith(";;") and not message.author.bot: lists = [] msg = message.content.replace(" ", "") emojis = msg.split(";;") for i in emojis: if i == "": continue e = finder(i, self.bot.emojis, key=lambda i: i.name, lazy=False) if e == []: continue e = e[0] if e is None or emojis == []: continue if e.is_usable() != False: lists.append(str(e)) if lists != []: try: message_ = await message.channel.send("".join(lists)) self.bot._message_cache[message.id] = message_ except: pass
async def javadocs(self, ctx, query: str = None): e = discord.Embed(colour=discord.Color.blurple()) e.set_author(name=f'Query made by: {ctx.author}', icon_url=ctx.author.avatar_url) if not query: e.description = '[JavaDocs](https://www.chattriggers.com/javadocs/)' return await ctx.send(embed=e) e.title = f'Results for: `{query}`' e.description = '' for kotlin_class in self.bot._cache: print([kotlin_class] + [method for method in kotlin_class.methods]) results = finder(query, [kotlin_class] + [method for method in kotlin_class.methods]) for obj in results: if isinstance(obj, KotlinClass): e.description += f'[`{obj.clean_name}`]({obj.url})\n' elif isinstance(obj, KotlinMethod): e.description += f'[`{obj.kotlin_class.clean_name}.{obj.name}{obj.parameters}`]({obj.url})\n' if not e.description: e.description = 'None Found!' await ctx.send(embed=e)
async def emoji(self, ctx, *, search: str = None): lists = [] paginator = WrappedPaginator(max_size=500, prefix="", suffix="") if search != None: emojis = finder(search, self.bot.emojis, key=lambda i: i.name, lazy=False) if emojis == []: return await ctx.send("no emoji found") for i in emojis: if i.animated == True: lists.append(f"{str(i)} `<a:{i.name}:{i.id}>`") else: lists.append(f"{str(i)} `<:{i.name}:{i.id}>`") paginator.add_line("\n".join(lists)) interface = PaginatorInterface(ctx.bot, paginator, owner=ctx.author) return await interface.send_to(ctx) for i in self.bot.emojis: if i.animated == True: lists.append(f"{str(i)} `<a:{i.name}:{i.id}>`") else: lists.append(f"{str(i)} `<:{i.name}:{i.id}>`") paginator.add_line("\n".join(lists)) interface = PaginatorInterface(ctx.bot, paginator, owner=ctx.author) await interface.send_to(ctx)
async def do_docs(self, ctx, key, obj): page_types = { "python": "https://docs.python.org/3", "nextcord": "https://docs.nextcord.dev/en/stable", "nextcord_latest": "https://docs.nextcord.dev/en/latest", "menus": "https://menus.docs.nextcord.dev/en/latest", "ipc": "https://ipc.docs.nextcord.dev/en/latest", "dpy": "https://discordpy.readthedocs.io/en/stable", "dpy2": "https://discordpy.readthedocs.io/en/latest", "pycord": "https://docs.pycord.dev/en/master", "edpy": "https://enhanced-dpy.readthedocs.io/en/latest", "disnake": "https://disnake.readthedocs.io/en/latest", } if obj is None: await ctx.send(page_types[key]) return if not hasattr(self, "_docs_cache"): await ctx.trigger_typing() await self.build_docs_lookup_table(page_types) obj = re.sub(r"^(?:discord\.(?:ext\.)?)?(?:commands\.)?(.+)", r"\1", obj) obj = re.sub(r"^(?:nextcord\.(?:ext\.)?)?(?:commands\.)?(.+)", r"\1", obj) if key.startswith("master"): # point the abc.Messageable types properly: q = obj.lower() for name in dir(discord.abc.Messageable): if name[0] == "_": continue if q == name: obj = f"abc.Messageable.{name}" break cache = list(self._docs_cache[key].items()) matches = fuzzy.finder(obj, cache, key=lambda t: t[0], lazy=False)[:8] # type: ignore e = discord.Embed(colour=discord.Colour.blurple()) if len(matches) == 0: return await ctx.send("Could not find anything. Sorry.") e.description = "\n".join(f"[`{key}`]({url})" for key, url in matches) ref = ctx.message.reference refer = None if ref and isinstance(ref.resolved, discord.Message): refer = ref.resolved.to_reference() await ctx.send(embed=e, reference=refer)
async def emojis(self, ctx, search=None): emojis = [] if search: result = finder(text=search, collection=self.bot.emojis, key=lambda emoji: emoji.name, lazy=False) if result == []: return await ctx.send("Nothing found for your query.") for emoji in result: emojis.append(f"{str(emoji)} `{emoji.name}`") paginator = WrappedPaginator(prefix='', suffix='', max_size=500) else: for emoji in self.bot.emojis: emojis.append(f"{str(emoji)} `{emoji.name}`") paginator = WrappedPaginator(prefix='', suffix='', max_size=1000) paginator.add_line('\n'.join(emojis)) interface = PaginatorInterface(ctx.bot, paginator, owner=ctx.author) await interface.send_to(ctx)
async def uhh_rtfm_pls(self, ctx, key, obj): page_types = { 'latest': 'https://discordpy.readthedocs.io/en/latest', 'python': 'https://docs.python.org/3', 'asyncpg': "https://magicstack.github.io/asyncpg/current/", "zaneapi": "https://docs.zaneapi.com/en/latest/", "aiohttp": "https://docs.aiohttp.org/en/stable/" } if obj is None: await ctx.send(page_types[key]) return if not hasattr(self.bot, "_rtfm_cache"): await ctx.trigger_typing() await self.build_rtfm_lookup_table(page_types) obj = re.sub(r'^(?:discord\.(?:ext\.)?)?(?:commands\.)?(.+)', r'\1', obj) if key.startswith('latest'): # point the abc.Messageable types properly: q = obj.lower() for name in dir(discord.abc.Messageable): if name[0] == '_': continue if q == name: obj = f'abc.Messageable.{name}' break cache = list(self.bot._rtfm_cache[key].items()) def transform(tup): return tup[0] matches = fuzzy.finder(obj, cache, key=lambda t: t[0], lazy=False)[:10] e = discord.Embed(colour=0x00ff6a) if len(matches) == 0: return await ctx.send("Can't find anything") # paginator = commands.Paginator(prefix="", suffix="", max_size=1980) # for i,v in matches: # paginator.add_line(f'[{i}]({v})') # interface = PaginatorEmbedInterface(ctx.bot, paginator, owner=ctx.author) # await interface.send_to(ctx) e.description = '\n'.join(f'[{key}]({url})' for key, url in matches) await ctx.send(embed=e, reference=ctx.replied_reference)
async def do_rtfm(self, ctx: Context, key: str, obj: Optional[str]) -> None: page_types = { "discord.py": "https://discordpy.readthedocs.io/en/latest", "discord.py-master": "https://discordpy.readthedocs.io/en/master", "python": "https://docs.python.org/3", "python-jp": "https://docs.python.org/ja/3", "asyncpg": "https://magicstack.github.io/asyncpg/current", "aiohttp": "https://docs.aiohttp.org/en/stable", "hondana": "https://hondana.readthedocs.io/en/stable", "hondana-m": "https://hondana.readthedocs.io/en/latest", } if obj is None: await ctx.send(page_types[key]) return if not hasattr(self, "_rtfm_cache"): await ctx.trigger_typing() await self.build_rtfm_lookup_table(page_types) obj = re.sub(r"^(?:discord\.(?:ext\.)?)?(?:commands\.)?(.+)", r"\1", obj) if key.startswith("discord."): # point the abc.Messageable types properly: q = obj.lower() for name in dir(discord.abc.Messageable): if name[0] == "_": continue if q == name: obj = f"abc.Messageable.{name}" break cache = list(self._rtfm_cache[key].items()) matches = fuzzy.finder(obj, cache, key=lambda t: t[0], lazy=False) e = discord.Embed(colour=self.bot.colour) if not matches: await ctx.send("Could not find anything. Sorry.") return e.title = f"RTFM for __**`{key}`**__: {obj}" e.description = "\n".join(f"[`{key}`]({url})" for key, url in matches[:8]) # type: ignore e.set_footer(text=f"{len(matches)} possible results.") # type: ignore await ctx.send(embed=e)
async def mappings(self, ctx, query: str): e = discord.Embed(colour=discord.Color.blurple()) e.set_author(name=f'Query made by: {ctx.author}', icon_url=ctx.author.avatar_url) if not query: e.description = '[JavaDocs](https://www.chattriggers.com/javadocs/)' return await ctx.send(embed=e) e.title = f'Results for: `{query}`' e.description = '' counter = 0 for mc_class in self.bot.mapping_viewer.mappings: results = finder(query, [mc_class] + [method for method in mc_class.methods] + [method for method in mc_class.fields]) if counter > 5: break for obj in results: if counter > 5: break if isinstance(obj, MCObfuscatedClass): e.description += f'`{obj.package.replace("/", ".")}{obj.name}`\n' counter += 1 elif isinstance(obj, MCObfuscatedMethod): e.description += f'`{obj.mc_class.package.replace("/", ".")}' \ f'{obj.mc_class.name}.{obj.obfuscated_name}() | ' \ f'{obj.mc_class.package.replace("/", ".")}' \ f'{obj.mc_class.name}.{obj.deobfuscated_name}()`\n' counter += 1 elif isinstance(obj, MCObfuscatedField): e.description += f'`{obj.mc_class.package.replace("/", ".")}' \ f'{obj.mc_class.name}.{obj.obfuscated_name} | ' \ f'{obj.mc_class.package.replace("/", ".")}' \ f'{obj.mc_class.name}.{obj.deobfuscated_name}`\n' counter += 1 if not e.description: e.description = 'None Found!' await ctx.send(embed=e)
async def on_message(self, message): not_owner = not await self.bot.is_owner(message.author) if not_owner or message.author.bot: return matches = self.match.findall(message.content) if not matches: return emoji = [] for match in matches: e = finder(match, self.bot.emojis, key=lambda emoji: emoji.name, lazy=False) if e == []: continue e = e[0] if e is None: return if e.is_usable() != False: emoji.append(str(e)) await message.channel.send(" ".join(emoji))
async def do_rtfm(self, ctx: commands.Context, query: Optional[str], key: str) -> None: pages = { 'latest': 'https://discordpy.readthedocs.io/en/latest', 'python': 'https://docs.python.org/3' } if not query: return await ctx.send(pages[key]) if not hasattr(self, '_rtfm_cache'): await ctx.trigger_typing() await self.build_rtfm(pages) query = re.sub(r'^(?:discord\.(?:ext\.)?)?(?:commands\.)?(.+)', r'\1', query) if key.startswith('latest'): obj = query.lower() for name in dir(discord.abc.Messageable): if name[0] == '_': continue if obj == name: query = f'abc.Messageable.{name}' break cache = list(self._rtfm_cache[key].items()) matches = fuzzy.finder(query, cache, key=lambda item: item[0], lazy=False)[:8] if len(matches) == 0: return await ctx.send('Nada encontrado, você digitou corretamente?' ) content = '\n'.join(f'[`{key}`]({url})' for key, url in matches) await ctx.send(content)
async def on_command_error(self, ctx, error): global match if hasattr(ctx.command, 'on_error'): return cog = ctx.cog if cog and cog._get_overridden_method(cog.cog_command_error) is not None: return ignored = () error = getattr(error, 'original', error) if isinstance(error, ignored): return if isinstance(error, commands.CommandNotFound): failed_command = re.match(rf"^({ctx.prefix})\s*(.*)", ctx.message.content, flags=re.IGNORECASE).group(2) matches = finder(failed_command, self.bot.command_list, lazy=False) if not matches: return match = None for command in matches: cmd = self.bot.get_command(command) if not await cmd.can_run(ctx): return match = command break return await qembed(ctx, f"No command called `{ctx.invoked_with}` found. Did you mean `{match}`?") elif isinstance(error, commands.CheckFailure): return await qembed( ctx, f'You do not have the correct permissions for `{ctx.invoked_with}`') if isinstance(error, discord.Forbidden): return await qembed( ctx, f'I do not have the correct permissions for `{ctx.command}`') elif isinstance(error, commands.CommandOnCooldown): retry_after = humanize.precisedelta(error.retry_after, minimum_unit='seconds') return await qembed(ctx, f"This command is on cooldown.\nTry again in {retry_after}") elif isinstance(error, commands.NoPrivateMessage): try: e = discord.Embed(description=f'`{ctx.command}` can not be used in Private Messages.',color=self.bot.embed_color) return await ctx.author.send(embed=e) except discord.HTTPException: pass elif isinstance(error, commands.MissingRequiredArgument): return await qembed(ctx, f'{error}') elif isinstance(error, commands.DisabledCommand): return await qembed(ctx, f'`{ctx.command}` has been disabled.') elif isinstance(error, commands.BadArgument): print(f'Ignoring exception in command {ctx.invoked_with}:'file=sys.stderr) traceback.print_exception(type(error), error, error.__traceback__, file=sys.stderr) formatted = traceback.format_exception(type(error), error, error.__traceback__) await ctx.send(f"Something has gone wrong while executing `{ctx.invoked_with}`:\n" f"```py\n{''.join(formatted)}\n```")
async def on_command_error(self, ctx, error): if isinstance(error, Maintenance): return await ctx.send(embed=ctx.embed(title='⚠️ Maintenence mode is active.')) if isinstance(error, Blacklisted): reason = self.bot.blacklist.get(ctx.author.id, "No reason, you probably did something dumb.") return await ctx.author.send(embed=ctx.embed(title='⚠️ You are blacklisted.', description=f'**Blacklisted For:** {reason}' f'\n\nYou can join the support server [here]({self.bot.support_invite}) if you feel this is a mistake.')) command = ctx.invoked_with # This prevents any commands with local handlers being handled here in on_command_error. global match if hasattr(ctx.command, 'on_error'): return # This prevents any cogs with an overwritten cog_command_error being handled here. cog = ctx.cog if cog and cog._get_overridden_method(cog.cog_command_error) is not None: return # ignored = (commands.CommandNotFound,) # if you want to not send error messages ignored = () # Allows us to check for original exceptions raised and sent to CommandInvokeError. # If nothing is found. We keep the exception passed to on_command_error. error = getattr(error, 'original', error) # Anything in ignored will return and prevent anything happening. if isinstance(error, ignored): return if isinstance(error, commands.CommandNotFound): failed_command = re.match(rf"^({ctx.prefix})\s*(.*)", ctx.message.content, flags=re.IGNORECASE).group(2) matches = finder(failed_command, self.bot.command_list, lazy=False) if not matches: return match = None for command in matches: cmd = self.bot.get_command(command) if not await cmd.can_run(ctx): return match = command break return await ctx.send(embed=ctx.embed( description=f"No command called `{failed_command}` found. Did you mean `{match}`?" )) if isinstance(error, commands.CheckFailure): return await ctx.send(embed=ctx.embed( description=f'You do not have the correct permissions for `{command}`' )) if isinstance(error, discord.Forbidden): return await ctx.send(embed=ctx.embed( description=f'I do not have the correct permissions for `{command}`' )) if isinstance(error, commands.CommandOnCooldown): retry = humanize.precisedelta(error.retry_after, minimum_unit='seconds') return await ctx.send(embed=ctx.embed( description=f"{command} is on cooldown.\nTry again in {retry}" )) if isinstance(error, commands.NoPrivateMessage): try: return await ctx.author.send(embed=ctx.embed(description=f"{ctx.invoked_with} cannot be used in DM's")) except discord.HTTPException: pass if isinstance(error, commands.MissingRequiredArgument): errors = str(error).split(" ", maxsplit=1) return await ctx.send(embed=ctx.embed( description=f'`{errors[0]}` {errors[1]}\n' f'You can view the help for this command with `{ctx.clean_prefix}help` `{command}`' )) if isinstance(error, commands.DisabledCommand): return await ctx.send(embed=ctx.embed(description=f'`{command}` has been disabled.')) if isinstance(error, commands.BadArgument): return await ctx.send(embed=ctx.embed(title=str(error), description=f'You provided a bad argument to `{command}`! View `{ctx.clean_prefix}help {command}` for more info on how to use this command.')) print('Ignoring exception in command {}:'.format(ctx.command), file=sys.stderr) traceback.print_exception(type(error), error, error.__traceback__, file=sys.stderr) formatted = traceback.format_exception(type(error), error, error.__traceback__) pretty_traceback = "".join( prettify_exceptions.DefaultFormatter().format_exception(type(error), error, error.__traceback__) ) log_channel = await self.bot.fetch_channel(817433615473311744) webhook = await log_channel.webhooks() msg = ( f"Command: {ctx.invoked_with}\n" f"Full content: {ctx.escape(ctx.message.content)}\n" f"Guild: {ctx.guild.name} ({ctx.guild.id})\n" f"Channel: {ctx.channel.name} ({ctx.channel.id})\n" f"User: {ctx.author.name} ({ctx.author.id})\n" f"Jump URL: {ctx.message.jump_url}" ) embed = ctx.embed(title='AN ERROR OCCURED', url=await ctx.mystbin(pretty_traceback) + '.py', description=f"```yaml\n{msg}```") await webhook[0].send(f"```py\n{''.join(formatted)}```", embed=embed) error = "".join(formatted) if len(error) > 1700: error = await ctx.mystbin(str(error)) + ".py" await ctx.send( f"Something has gone wrong while executing `{command}`. You should not be seeing this, I have contacted my developer with information about this error.\n" f"```py\n{error}\n```")
async def on_command_error(self, ctx, error): # This prevents any commands with local handlers being handled here in on_command_error. global match if hasattr(ctx.command, 'on_error'): return # This prevents any cogs with an overwritten cog_command_error being handled here. cog = ctx.cog if cog and cog._get_overridden_method( cog.cog_command_error) is not None: return # ignored = (commands.CommandNotFound,) # if you want to not send error messages ignored = () # Allows us to check for original exceptions raised and sent to CommandInvokeError. # If nothing is found. We keep the exception passed to on_command_error. error = getattr(error, 'original', error) # Anything in ignored will return and prevent anything happening. if isinstance(error, ignored): return if isinstance(error, commands.CommandNotFound): failed_command = re.match(rf"^({ctx.prefix})\s*(.*)", ctx.message.content, flags=re.IGNORECASE).group(2) matches = finder(failed_command, self.bot.command_list, lazy=False) if not matches: return match = None for command in matches: cmd = self.bot.get_command(command) if not await cmd.can_run(ctx): return match = command break return await qembed( ctx, f"No command called `{ctx.invoked_with}` found. Did you mean `{match}`?" ) elif isinstance(error, commands.CheckFailure): return await qembed( ctx, f'You do not have the correct permissions for `{ctx.invoked_with}`' ) if isinstance(error, discord.Forbidden): return await qembed( ctx, f'I do not have the correct permissions for `{ctx.command}`') elif isinstance(error, commands.CommandOnCooldown): return await qembed( ctx, f"This command is on cooldown.\nTry again in {humanize.precisedelta(error.retry_after, minimum_unit='seconds')}" ) elif isinstance(error, commands.NoPrivateMessage): try: e = discord.Embed( description= f'`{ctx.command}` can not be used in Private Messages.', color=self.bot.embed_color) return await ctx.author.send(embed=e) except discord.HTTPException: pass elif isinstance(error, commands.MissingRequiredArgument): return await qembed( ctx, f'{error}\n' f'You can view the help for this command with `{ctx.prefix}help {ctx.invoked_with}`' ) elif isinstance(error, commands.DisabledCommand): return await qembed(ctx, f'`{ctx.command}` has been disabled.') # For this error example we check to see where it came from... elif isinstance(error, commands.BadArgument): if ctx.command.qualified_name == 'tag list': # Check if the command being invoked is 'tag list' return await qembed( ctx, 'I could not find that member. Please try again.') else: # All other Errors not returned come here. And we can just print the default TraceBack. print('Ignoring exception in command {}:'.format(ctx.command), file=sys.stderr) traceback.print_exception(type(error), error, error.__traceback__, file=sys.stderr) formatted = traceback.format_exception(type(error), error, error.__traceback__) await ctx.send( f"Something has gone wrong while executing `{ctx.invoked_with}`:\n" f"```py\n{''.join(formatted)}\n```")
async def on_command_error(self, ctx, error): command = ctx.invoked_with # This prevents any commands with local handlers being handled here in on_command_error. global match if hasattr(ctx.command, 'on_error'): return # This prevents any cogs with an overwritten cog_command_error being handled here. cog = ctx.cog if cog and cog._get_overridden_method( cog.cog_command_error) is not None: return # ignored = (commands.CommandNotFound,) # if you want to not send error messages ignored = () # Allows us to check for original exceptions raised and sent to CommandInvokeError. # If nothing is found. We keep the exception passed to on_command_error. error = getattr(error, 'original', error) # Anything in ignored will return and prevent anything happening. if isinstance(error, ignored): return if isinstance(error, commands.CommandNotFound): failed_command = re.match(rf"^({ctx.prefix})\s*(.*)", ctx.message.content, flags=re.IGNORECASE).group(2) matches = finder(failed_command, self.bot.command_list, lazy=False) if not matches: return match = None for command in matches: cmd = self.bot.get_command(command) if not await cmd.can_run(ctx): return match = command break return await ctx.send(embed=ctx.embed( description= f"No command called `{command}` found. Did you mean `{match}`?" )) if isinstance(error, commands.CheckFailure): return await ctx.send(embed=ctx.embed( description= f'You do not have the correct permissions for `{command}`')) if isinstance(error, discord.Forbidden): return await ctx.send(embed=ctx.embed( description= f'I do not have the correct permissions for `{command}`')) if isinstance(error, commands.CommandOnCooldown): retry = humanize.precisedelta(error.retry_after, minimum_unit='seconds') return await ctx.send(embed=ctx.embed( description=f"{command} is on cooldown.\nTry again in {retry}") ) if isinstance(error, commands.NoPrivateMessage): try: return await ctx.author.send(embed=ctx.embed( description=f"{ctx.invoked_with} cannot be used in DM's")) except discord.HTTPException: pass if isinstance(error, commands.MissingRequiredArgument): errors = str(error).split(" ", maxsplit=1) return await ctx.send(embed=ctx.embed( description=f'`{errors[0]}` {errors[1]}\n' f'You can view the help for this command with `{ctx.prefix}help` `{command}`' )) if isinstance(error, commands.DisabledCommand): return await ctx.send(embed=ctx.embed( description=f'`{command}` has been disabled.')) print('Ignoring exception in command {}:'.format(ctx.command), file=sys.stderr) traceback.print_exception(type(error), error, error.__traceback__, file=sys.stderr) formatted = traceback.format_exception(type(error), error, error.__traceback__) await ctx.send( f"Something has gone wrong while executing `{command}`:\n" f"```py\n{''.join(formatted)}\n```")