async def unmarkdown(self, ctx, *, message: discord.Message): """Get the raw version of a message. if the message ID isnt in the current channel, provide the message link or the channel_id-message_id.""" p = commands.Paginator(prefix='```md') if len(message.embeds) > 0: p.add_line( utils.escape_markdown(message.embeds[0].description, ignore_links=False)) p.add_line(utils.escape_markdown(message.content, ignore_links=False)) for pa in p.pages: await ctx.send(pa)
async def snippets_command(self, ctx: Kaantext) -> None: """ vs code python snippets """ msg = self.resource_texts['snippets'] p = commands.Paginator(prefix='```json', suffix='```') for line in msg.split('\n'): p.add_line(line) for page in p.pages: await ctx.send(page)
def create_summary(self, user: discord.User, commits): paginator = commands.Paginator(prefix="", suffix="") for line in self.summary_header: paginator.add_line(line.format(user=user.name, total_commits=len(commits))) for commit_id, commit in enumerate(commits): paginator.add_line( self.summary_format.format(commit_id=commit_id + 1, commit_message=commit["message"].split("\n")[0], commit_hash=commit["hash"])) return paginator.pages
async def on_ready(): print("Working boi!") global data global userd global lastping global gamestate global starttime global logz global active global lobby global peochannel global annchannel global guildd lobby = bot.get_channel(822501206848438272) peochannel = bot.get_channel(822512693851193375) annchannel = bot.get_channel(823843532912459786) guildd = bot.get_guild(822497162448732192) #await lobby.send("Who's up for a game?! :smiley:") await annchannel.send("The bot is online!") await bot.change_presence( activity=discord.Game(name="Deception: Murder in Hong Kong", type=1)) try: my_collection = db.main my_collection_t = db.user data = my_collection.find_one() userd = my_collection_t.find_one() gamestate = data['gamestate'] lastping = None logz = commands.Paginator(prefix="", suffix="") except: print("Could not load the data") data = {} data['signedup'] = {} data['players'] = {} data['gamestate'] = 0 gamestate = data['gamestate'] lastping = None data['job'] = {} #stuff userd = {} userd['users'] = {} await annchannel.send("The notif list has been erased!!!") if len(data['signedup']) > 0 and gamestate == 0: starttime = datetime.datetime.now() timeoutloop.start() if data['gamestate'] > 0: msg = await lobby.send( "Terribly sorry for the inconvenience, but it seems like the bot went offline during the game. As a result, the game probably malfunctioned and so I am going to automatically force end it. Contact the admins to do the rest. Again, sorry for the inconvenience." ) ctx = await bot.get_context(msg) await forceend(ctx) dump()
async def _send_command_list(self, full_mapping: set[Command]): """Help function which sends the command list. Factored out for DRYer code.""" categories: dict[str, list[str]] = {} # List of categorized commands. filtered_mapping = { f"`{com.qualified_name}`": com for com in await self.filter_commands(full_mapping) } non_passing = list( set(full_mapping).difference(set(filtered_mapping.values()))) new_message = copy.copy(self.context.message) new_message.guild = None new_ctx = await self.context.bot.get_context(new_message) dm_only = { f"`{com.qualified_name}`¹": com for com in non_passing if await can_run(com, new_ctx) } filtered_mapping.update(dm_only) if not filtered_mapping: await self.get_destination().send( "No help information was found.") return for com_text, com in filtered_mapping.items(): if com.qualified_name in self.context.bot.help.keys(): command_help = self.context.bot.help[ com.qualified_name] # Get command help info. category = command_help.category.lower( ) if command_help.category else "no category" if category not in categories: # Add category if it wasn't encountered before. categories[category] = [] categories[category].append( com_text) # Add command to category. paginator = commands.Paginator(prefix="", suffix="", linesep="") paginator.add_line( f"__**Help Info {self.context.message.author.mention}:**__\n\n" ) for category in sorted(categories.keys()): paginator.add_line(f"**{category.title()}**\n") category_commands = [ f"{com}, " for com in sorted(categories[category]) ] category_commands[ -1] = f"{category_commands[-1][:-2]}\n\n" # Replace ', ' with '\n\n' on last command for com in category_commands: paginator.add_line(self.remove_mentions(com)) end = "1 = In DMs only.\n" if any("¹" in elem for cat in categories.values() for elem in cat) else "" end += f"Use `{self.context.bot.get_bot_prefix()}help <COMMAND>` for more info on individual commands." paginator.add_line(end) for page in paginator.pages: await self.get_destination().send(page)
def paginate_exception(e): if hasattr(e, "original"): exc = e.original else: exc = e tblines = traceback.format_exception(type(exc), exc, exc.__traceback__) paginator = commands.Paginator( prefix=f"**`ERROR:`** {type(e).__name__} - {e}\n```", suffix="```" ) for line in tblines: paginator.add_line(line) return paginator.pages
async def session_start(self, ctx: commands.context): """ Start a new coc session """ if self.session_message != 0: return await ctx.send( "There is an active session right now.\n" "Join by reacting to the pinned message or using `t.coc session join`. Have fun!" ) pager = commands.Paginator( prefix=f"**Hey, {ctx.author.mention} is starting a coc session.\n" f"Use `t.coc session join` or react to this message to join**", suffix="") for member in self.role.members: if member != ctx.author: if member.status != discord.Status.offline: pager.add_line(member.mention + ", ") if not len(pager.pages): return await ctx.send( f"{ctx.author.mention}, Nobody is online to play with <:pepesad:733816214010331197>" ) self.session = True self.last_clash = int(time.time()) self.session_users.append(ctx.author.id) msg = await ctx.send(pager.pages[0]) self.session_message = msg.id await msg.add_reaction("🖐️") try: await msg.pin() except: await ctx.send("Failed to pin message") while self.session_message != 0: await asyncio.sleep(10) if self.last_clash + 1800 < int( time.time()) and self.session_message != 0: await ctx.send( "Clash session has been closed due to inactivity") try: await msg.unpin() except: await ctx.send("Failed to unpin message") self.last_clash = 0 self.session_users = [] self.session_message = 0 self.session = False break
async def on_command_error(self, ctx, exception): channel = await self.fetch_channel(int(config["Config"]["Channel ID"])) await channel.send( f"<@&{self.role}> an unhandled exception has occurred") # by saying this we imply that some errors *are* handled gracefully exc = getattr(exception, 'original', exception) msg = "".join(format_exception(type(exc), exc, exc.__traceback__)) error_paginator = commands.Paginator() for chunk in [msg[i:i + 1800] for i in range(0, len(msg), 1800)]: error_paginator.add_line(chunk) for page in error_paginator.pages: await channel.send(page)
async def list_cogs(ctx): '''Lists all cogs and their status of loading.''' cog_list = commands.Paginator(prefix='', suffix='') cog_list.add_line('**✅ Succesfully loaded:**') for cog in bot.loaded_cogs: cog_list.add_line('- ' + cog) cog_list.add_line('**❌ Not loaded:**') for cog in bot.unloaded_cogs: cog_list.add_line('- ' + cog) for page in cog_list.pages: await ctx.send(page)
def codeblock(contents, syntax="py"): """Returns a list of codeblock text for the given content. Content is broken into items with a character limitation to avoid going above single-message limits. """ paginator = commands.Paginator( prefix='```{}'.format(syntax), max_size=2000) for line in contents.split('\n'): for wrapline in textwrap.wrap(line, width=1990): paginator.add_line(wrapline.rstrip().replace('`', '\u200b`')) return paginator.pages
async def cmdstats(self, ctx): await ctx.message.delete() p = commands.Paginator() counter = self.bot.commands_triggered width = len(max(counter, key=len)) total = sum(counter.values()) fmt = '{0:<{width}}: {1}' p.add_line(fmt.format('Total', total, width=width)) for key, count in counter.most_common(): p.add_line(fmt.format(key, count, width=width)) for page in p.pages: await ctx.send(page, delete_after=20)
async def all(self, ctx): """ Gives the list of all the languages supported by the translator """ async with ctx.channel.typing(): all_languages = googletrans.LANGUAGES pager = commands.Paginator() for key, value in all_languages.items(): pager.add_line(f"{key} - {value.title()}") for pages in pager.pages: await ctx.send(pages)
async def inv(self, ctx, guild: int): """Get all the invites of the server.""" try: guildid = self.bot.get_guild(guild) guildinvs = await guildid.invites() pager = commands.Paginator() for Invite in guildinvs: pager.add_line(Invite.url) for page in pager.pages: await ctx.send(page) except discord.Forbidden: await ctx.send(f"{emotes.warning} Was unable to fetch invites.")
async def paginate(log, destination): """Paginates and sends to a channel""" paginator = commands.Paginator() while log: try: paginator.add_line(log) log = '' except: paginator.add_line(log[:1992]) log = log[1992:] for page in paginator.pages: await destination.send(page)
def _list(self, ctx): """ Displays a list of editable settings. """ paginator = commands.Paginator() for dirpath, dirnames, filenames in self.data_man.walk_json(): for filename in filenames: no_ext = filename.split('.')[0] # remove filename extension paginator.add_line(line='-- \'{0}\''.format(no_ext)) pages = paginator.pages for p in pages: yield from self.bot.say(p)
def __init__(self, **options): options['verify_checks'] = False super().__init__(**options) self.paginator = commands.Paginator(max_size=1985) self.commands_heading = "Commands" self.aliases_heading = "Aliases:" self.no_category = "No Category" self.command_attrs = { 'description': "Provides help for various commands.", 'cooldown': commands.Cooldown(3, 10, commands.BucketType.channel), 'name': 'help' }
async def servers(self, ctx): """Lists servers.""" paginator = commands.Paginator(prefix="```md") for number, guild in enumerate(ctx.bot.guilds, start=1): dot = '\u200B.' backtick = '\u200B`' paginator.add_line( discord.utils.escape_markdown( f'{number}) {guild.name.replace(".", dot).replace("`", backtick)}\n' )) for page in paginator.pages: await ctx.send(page)
async def user_show(self, ctx): """DMs the blacklist. noirscape & Staff & Helpers only.""" paginator = commands.Paginator(prefix='', suffix='') paginator.add_line('___Blacklisted users___') for blacklisted_user in self.blacklisted_users: paginator.add_line('{} (ID: {})'.format( str(await self.bot.get_user_info(blacklisted_user)), blacklisted_user)) for page in paginator.pages: await ctx.author.send(page)
async def servers(self, ctx): """list servers""" if ctx.invoked_subcommand is None: pages = commands.Paginator() for num, guild in enumerate(self.bot.guilds, start=1): pages.add_line(f"{num}. {guild.name} ({guild.id})") pages.add_line(empty=True) for page in pages.pages: await ctx.send(page) await asyncio.sleep(1) await ctx.send( f"Guilds: {len(self.bot.guilds)}\nPages: {len(pages.pages)}")
async def servers(self, ctx): """Lists servers.""" paginator = PaginatorEmbedInterface( self.bot, commands.Paginator(prefix="```md", max_size=500)) for number, guild in enumerate(ctx.bot.guilds, start=1): dot = '\u200B.' backtick = '\u200B`' await paginator.add_line( discord.utils.escape_markdown( f'{number}. {guild.name.replace(".", dot).replace("`", backtick)}\n' )) await paginator.send_to(ctx.channel)
async def send_traceback(ctx: commands.Context, verbosity: int, *exception_info): type_, value, trace = exception_info content = ''.join(traceback.format_exception(type_, value, trace, verbosity)) content = content.replace('``', '`\u200b`').replace(ctx.bot.http.token, '[token omitted]') paginator = commands.Paginator(prefix='```py') for line in content.split('\n'): paginator.add_line(line) menu = Menu(paginator.pages) await menu.start(ctx)
async def pagtest(self, ctx): p = commands.Paginator() for i in range(100): try: p.add_line(line=str(i * i) + "ggggggggggggggggggggggggggggggggggggggggggggg") except: p.close_page() p.add_line(line=str(i * i) + "gdsfdsfdasfdsfdsffdsfsdsdfdfdsfsdfsdsdfsfsfdfs") print(p.pages) await ctx.send(p.pages[0])
async def _eval(self, ctx, *, body: str): """Evaluates a code""" env = { 'bot': ctx.bot, 'ctx': ctx, 'channel': ctx.channel, 'author': ctx.author, 'guild': ctx.guild, 'message': ctx.message, 'guild_dict': ctx.bot.guild_dict } def cleanup_code(content): """Automatically removes code blocks from the code.""" # remove ```py\n``` if content.startswith('```') and content.endswith('```'): return '\n'.join(content.split('\n')[1:-1]) # remove `foo` return content.strip('` \n') env.update(globals()) body = cleanup_code(body) stdout = io.StringIO() to_compile = f'async def func():\n{textwrap.indent(body, " ")}' try: exec(to_compile, env) except Exception as e: return await ctx.send(f'```py\n{e.__class__.__name__}: {e}\n```') func = env['func'] try: with redirect_stdout(stdout): ret = await func() except Exception as e: value = stdout.getvalue() await ctx.send(f'```py\n{value}{traceback.format_exc()}\n```') else: value = stdout.getvalue() try: await ctx.message.add_reaction('\u2705') except: pass if ret is None: if value: paginator = commands.Paginator(prefix='```py') for line in textwrap.wrap(value, 80): paginator.add_line(line.rstrip().replace( '`', '\u200b`')) for p in paginator.pages: await ctx.send(p) else: ctx.bot._last_result = ret await ctx.send(f'```py\n{value}{ret}\n```')
async def _help(self, ctx, *, command: str = None): """Get help on a specified cog or command. Don't put any arguments to get a list of available commands.""" pref = '```\n' postf = f'Get info on a command group, category or just a command with @{self.bot.user.name}#{self.bot.user.discriminator} help <Category>/<Command>/<Command group> or *help <Category>/<Command>/<Command group>' result = '' postfix = '\n```' paginator = commands.Paginator() if not command: li = [cog for cog in self.bot.cogs] for smth in li: if smth != 'Help': s = list(self.bot.cogs[smth].get_commands()) if s: paginator.add_line(f"{s[0].cog_name}:") for c in s: if not c.hidden: paginator.add_line( f' {c.name} - {c.short_doc}') paginator.add_line(postf) for page in paginator.pages: await ctx.send(page) else: if command not in self.bot.all_commands: if command not in self.bot.cogs: cmd = self.bot.get_command( command.replace('*', '').replace(self.bot.user.mention, '')) if cmd: paginator.add_line( f"{ctx.prefix.replace(self.bot.user.mention, f'@{self.bot.user.name}#{self.bot.user.discriminator} ')}{cmd.signature}\n\n {cmd.help}" ) for page in paginator.pages: await ctx.send(page) else: result = 'That command/category/command group does not exist!' await ctx.send(result) else: the_cog = list(command.get_commands()) paginator.add_line(f"{the_cog[0].cog_name}:") for cmd in the_cog: if not cmd.hidden: paginator.add_line(f' {cmd.name} - {cmd.help}') paginator.add_line(postf) for page in paginator.pages: await ctx.send(page) else: cmd = self.bot.get_command( command.replace('*', '').replace(self.bot.user.mention, '')) result += f"{ctx.prefix.replace(self.bot.user.mention, f'@{self.bot.user.name}#{self.bot.user.discriminator} ')}{cmd.signature}\n\nCog: {cmd.cog_name}\n\n {cmd.help}" await ctx.send(f"{pref}{result}{postfix}")
async def cache(self, ctx): """ tell you how many messages the bot have cached if you don't know what is cache then this is not the right command for you """ paginator = commands.Paginator(max_size=1000) lines = list(self.bot.cached_messages) lines.append( f"Total amount of messages cached {len(self.bot.cached_messages)}") for i in lines: i = str(i) paginator.add_line(i) interface = PaginatorInterface(ctx.bot, paginator, owner=ctx.author) await interface.send_to(ctx)
def __call__(self, parser, namespace, values, option_string=None): paginator = commands.Paginator() help_txt = parser.format_help() for line in help_txt.split("\n"): try: paginator.add_line(line) except RuntimeError: for subline in chunkstring(line, paginator.max_size - 10): paginator.add_line(subline) for page in paginator.pages: parser.loop.create_task(parser.ctx.send(page)) raise commands.BadArgument # To exit silently
async def long(self, ctx): p = commands.Paginator(prefix='```css') with open('config/commands.json', 'r') as com: cmds = json.load(com) p.add_line('[List of Custom Commands]') width = len(max(cmds, key=len)) for cmd in sorted(cmds): p.add_line('{0:<{width}}| {1}'.format(cmd, cmds.get(cmd), width=width)) for page in p.pages: await ctx.send(page, delete_after=20) await ctx.message.delete()
async def roles(self, ctx): roles = database.roles.get_all_guild_roles(ctx.guild.id) pages = commands.Paginator() pages.add_line(f'{ctx.guild.name} has the following roles:\n') pages.add_line('/role <role name> | Role assigned') pages.add_line('---------------------|--------------------------') for role in ctx.guild.role_hierarchy: for row in roles: if role.id == row.role_id: pages.add_line(f'{row.alias.ljust(20)} | {role.name}') for page in pages.pages: await ctx.author.send(page) await ctx.message.add_reaction('✉')
def __init__(self, **options): self.sort_commands = options.pop('sort_commands', True) self.commands_heading = options.pop('commands_heading', "Commands") self.dm_help = options.pop('dm_help', False) self.dm_help_threshold = options.pop('dm_help_threshold', 1000) self.aliases_heading = options.pop('aliases_heading', "Aliases:") self.no_category = options.pop('no_category', 'No Category') self.paginator = options.pop('paginator', None) if self.paginator is None: self.paginator = cmd.Paginator(suffix=None, prefix=None) super().__init__(**options)
async def buffered_send(destination, content, max_length=2000): # use to replace await ctx.send(message) if message could potentially be over the Discord limit of 2000 characters # will split message by \n characters and send in chunks up to max_length size if not content: return paginator = commands.Paginator(prefix='', suffix='', max_size=max_length) for line in content.split('\n'): paginator.add_line(line) for page in paginator.pages: await destination.send(page)