def test__convert_query_fail_not_allowed_fields(app, faker): fields = [] for i in range(3): fields.append(faker.word()) query = { faker.word(): faker.word(), faker.word(): faker.word(), faker.word(): faker.word() } with pytest.raises(app_exceptions.ValidateDataError): Paginator._convert_query(table=pagination, raw_query=query)
async def test__get_count_pages_success(app, database, pagination_data): async with app['db'].acquire() as conn: # type: SAConnection limit = 10 query = {'limit': limit} # paginator = Paginator(conn=conn, table=pagination, query=query) await paginator._calculate() assert paginator.pages_count == ceil(COUNT_DATA / limit) # limit = 123456 query = {'limit': limit} paginator = Paginator(conn=conn, table=pagination, query=query) await paginator._calculate() assert paginator.pages_count == ceil(COUNT_DATA / limit)
async def test_get_page_success(app, database, pagination_data): limit = 14 query = {'limit': limit} async with app['db'].acquire() as conn: # type: SAConnection paginator = Paginator(conn=conn, table=pagination, query=query) await paginator._calculate() # data = await paginator.get_page(page=0) assert paginator == data.paginator assert len(data) == limit elem = data[7] assert elem['id'] == 8 assert elem['sequence'] == f'sequence_7' assert data.has_next() is True assert data.has_prev() is False assert data.get_next_page() == 2 assert data.get_prev_page() == 1 assert data[0]['id'] == 1 # 500 / 14 = 36 count = COUNT_DATA - (paginator._pages_count - 1) * limit data = await paginator.get_page(page=paginator._pages_count + 10) assert data.page == paginator._pages_count assert len(data) == count assert data.has_next() is False assert data.has_prev() is True assert data.get_next_page() == paginator._pages_count assert data.get_prev_page() == paginator._pages_count - 1 assert data[0]['id'] == 491
def user_fans(request, user_id, template=TEMPLATE): # _start_at = datetime.datetime.now() _query_user = User(user_id) _query_user_context = _query_user.read() if request.user.is_authenticated(): _request_user_id = request.user.id _request_user_context = User(_request_user_id).read() _relation = User.get_relation(_request_user_context['user_id'], _query_user_context['user_id']) else: _request_user_id = None _request_user_context = None _relation = None _page_num = request.GET.get('p', 1) _fans_id_list = _query_user.read_fan_user_id_list() _paginator = Paginator(_page_num, 8, len(_fans_id_list)) _fans_list = [] for _u_id in _fans_id_list[_paginator.offset : _paginator.offset + _paginator.count_in_one_page]: try: _f_user = User(_u_id) _f_user_context = _f_user.read() if _request_user_context != None: _f_user_context['relation'] = User.get_relation(_request_user_context['user_id'], _u_id) _f_user_context['latest_like_entity_id_list'] = _f_user.read_latest_like_entity_list() _fans_list.append(_f_user_context) except Exception, e: pass
async def viewblacklist(self, ctx): blacklist = (await self.bot.get_data(ctx.guild.id))[9] if not blacklist: await ctx.send( embed=discord.Embed(description="No one is blacklisted.", colour=self.bot.primary_colour)) return all_pages = [] for chunk in [ blacklist[i:i + 25] for i in range(0, len(blacklist), 25) ]: page = discord.Embed( title="Blacklist", description="\n".join( [f"<@{user}> ({user})" for user in chunk]), colour=self.bot.primary_colour, ) page.set_footer(text="Use the reactions to flip pages.") all_pages.append(page) if len(all_pages) == 1: embed = all_pages[0] embed.set_footer(text=discord.Embed.Empty) await ctx.send(embed=embed) return paginator = Paginator(length=1, entries=all_pages, use_defaults=True, embed=True, timeout=120) await paginator.start(ctx)
def report_list(request): _page_num = int(request.GET.get("p", "1")) _paginator = Paginator(_page_num, 30, Report.objects.count()) _report_context_list = [] for _report in Report.objects.all().order_by( '-created_time')[_paginator.offset:_paginator.offset + _paginator.count_in_one_page]: if isinstance(_report, EntityReport): _report_context_list.append({ 'type': 'entity_report', 'comment': _report.comment, 'entity_id': _report.entity_id, 'reporter_id': _report.reporter_id }) elif isinstance(_report, EntityNoteReport): _report_context_list.append({ 'type': 'entity_note_report', 'comment': _report.comment, 'note_id': _report.note_id, 'reporter_id': _report.reporter_id }) return render_to_response('report/list.html', { 'active_division': 'report', 'report_context_list': _report_context_list, 'paginator': _paginator }, context_instance=RequestContext(request))
def user_tag_entity(request, user_id, tag_hash, template="tag/tag_detail.html"): # _start_at = datetime.datetime.now() # _request_user_id = request.user.id if request.user.is_authenticated() else None if request.user.is_authenticated(): _request_user_id = request.user.id _request_user_like_entity_set = Entity.like_set_of_user(_request_user_id) else: _request_user_id = None _request_user_like_entity_set = list() _user_context = User(user_id).read() _tag_text = Tag.get_tag_text_from_hash(tag_hash) _page_num = request.GET.get('p', 1) _entity_id_list = Tag.find_user_tag_entity(user_id, _tag_text) _paginator = Paginator(_page_num, 24, len(_entity_id_list)) _entities = list() for _entity_id in _entity_id_list[_paginator.offset : _paginator.offset + _paginator.count_in_one_page]: try: _entity_context = Entity(_entity_id).read() _entity_context['is_user_already_like'] = True if _entity_id in _request_user_like_entity_set else False _entities.append(_entity_context) # _entities.append(Entity(_entity_id).read()) except Exception, e: log.error(e.message)
async def sharedservers(self, ctx, *, user_id: int): user = await self.bot.cogs["Communication"].handler("get_user", 1, {"user_id": user_id}) if not user: await ctx.send(embed=discord.Embed(description="No such user was found.", colour=self.bot.error_colour)) return data = await self.bot.cogs["Communication"].handler( "get_user_guilds", self.bot.cluster_count, {"user_id": user_id} ) guilds = [] for chunk in data: guilds.extend(chunk) guilds = [f"{guild['name']} `{guild['id']}`" for guild in guilds] all_pages = [] for chunk in [guilds[i : i + 20] for i in range(0, len(guilds), 20)]: page = discord.Embed(title="Guilds", colour=self.bot.primary_colour) for guild in chunk: if page.description == discord.Embed.Empty: page.description = guild else: page.description += f"\n{guild}" page.set_footer(text="Use the reactions to flip pages.") all_pages.append(page) if len(all_pages) == 1: embed = all_pages[0] embed.set_footer(text=discord.Embed.Empty) await ctx.send(embed=embed) return paginator = Paginator(length=1, entries=all_pages, use_defaults=True, embed=True, timeout=120) await paginator.start(ctx)
async def cmd_ud(self, message): """ Usage: {command_prefix}ud <word> Get the meanings of a word/phrase from urban dictionary. If no word is given, gets a single meaning of a random word. """ word = message.content.replace(f"{self.prefix}ud", '').strip() urban = Urban() responses = urban.fetch(word) if len(responses) == 0: await message.channel.send( f"Sorry {message.author.mention}, couldn't find any results for {word}." ) return embedder = Embedder(message.author.avatar_url) embeds = [ embedder.generate( responses[i]["word"], { "Meaning": responses[i]["meaning"], "Example": responses[i]["example"] }, i + 1, len(responses)) for i in range(len(responses)) ] if len(embeds) == 1: await message.channel.send(content=message.author.mention, embed=embeds[0]) else: base = await message.channel.send( f"{message.author.mention} Fetching results. Please wait. :hourglass_flowing_sand:" ) pager = Paginator(message, base, embeds, self) await pager.run()
async def get(self, request, **kwargs): """查看视频""" user_id = kwargs.get('user_id') prefix = "{}/media/".format(request.app.config.UPLOAD_DOMAIN) q = request.raw_args.get('q') page = int(request.raw_args.get('page', 1)) per_page = int(request.raw_args.get('per_page', 10)) _start = (page - 1) * per_page if q: count_res = await request.app.db.get( "select count(id) as count from video where concat(ifnull(`title`, ''), ',', ifnull(`description`, '')) like %s and video.`user_id` = %s and video.`delete_flag` = 0;", ('%%%s%%' % q, user_id)) count = count_res['count'] res = await request.app.db.query( "select video.`id`, video.`title`, video.`description`, concat(%s, video.`pic`) as pic, concat(%s, video.`path`) as video, video.`create_time`, video.`update_time` from video where concat(ifnull(`title`, ''), ',', ifnull(`description`, '')) like %s and video.`user_id` = %s and video.`delete_flag` = 0 order by id desc limit %s, %s;", (prefix, prefix, '%%%s%%' % q, user_id, _start, per_page)) else: count_res = await request.app.db.get( "select count(id) as count from video where video.`user_id` = %s and video.`delete_flag` = 0;", (user_id, )) count = count_res['count'] res = await request.app.db.query( "select video.`id`, video.`title`, video.`description`, concat(%s, video.`pic`) as pic, concat(%s, video.`path`) as video, video.`create_time`, video.`update_time` from video where video.`user_id` = %s and video.`delete_flag` = 0 order by id desc limit %s, %s;", (prefix, prefix, user_id, _start, per_page)) paginate = Paginator(count, per_page) pages = paginate() return response.json( { 'code': 'Success', 'total': count, 'pages': pages, 'data': res }, dumps=json_dumps)
async def findserver(self, ctx, *, name: str): data = await self.bot.cogs["Communication"].handler( "find_guild", self.bot.cluster_count, {"name": name}) guilds = [] for chunk in data: guilds.extend(chunk) if len(guilds) == 0: await ctx.send( embed=discord.Embed(description="No such guild was found.", colour=self.bot.error_colour)) return all_pages = [] for chunk in [guilds[i:i + 20] for i in range(0, len(guilds), 20)]: page = discord.Embed(title="Guilds", colour=self.bot.primary_colour) for guild in chunk: if page.description == discord.Embed.Empty: page.description = guild else: page.description += f"\n{guild}" page.set_footer(text="Use the reactions to flip pages.") all_pages.append(page) if len(all_pages) == 1: embed = all_pages[0] embed.set_footer(text=discord.Embed.Empty) await ctx.send(embed=embed) return paginator = Paginator(length=1, entries=all_pages, use_defaults=True, embed=True, timeout=120) await paginator.start(ctx)
async def jisho_(self, ctx: BContext, *, keywords: str) -> None: """Get results from Jisho.org, Japanese dictionary""" async with ctx.typing(): data = await self.jisho.lookup(keywords) if not data: await ctx.send("No words found.") return results = [] size = len(data) for i, res in enumerate(data, 1): res = {k: "\n".join(v) or "None" for k, v in res.items()} res["english"] = ", ".join(res["english"].split("\n")) embed = discord.Embed() embed.url = self.jisho_url.format("%20".join(keywords.split())) embed.title = keywords embed.add_field(name="Words", value=res["words"]) embed.add_field(name="Readings", value=res["readings"]) embed.add_field(name="Parts of Speech", value=res["parts_of_speech"]) embed.add_field(name="Meanings", value=res["english"]) embed.set_footer(text="Page {}/{}".format(i, size)) embed.color = discord.Color(0x56D926) results.append(embed) paginator = Paginator(results) await paginator.start(ctx)
async def get(self, request, **kwargs): """查看图片""" prefix = "{}/media/".format(request.app.config.UPLOAD_DOMAIN) q = request.raw_args.get('q') page = int(request.raw_args.get('page', 1)) per_page = int(request.raw_args.get('per_page', 10)) _start = (page - 1) * per_page if q: count_res = await request.app.db.get( "select count(pic.`id`) as count from pic left join user on pic.user_id = user.id where concat(ifnull(`title`, ''), ',', ifnull(`description`, ''), ',', ifnull(user.`nickname`, '')) like %s and pic.`delete_flag` = 0;", ('%%%s%%' % q, )) count = count_res['count'] res = await request.app.db.query( "select pic.`id`, pic.`title`, pic.`description`, concat(%s, pic.`path`) as pic, ifnull(user.`nickname`, '未知') as user, pic.`create_time`, pic.`update_time` from pic left join user on pic.user_id = user.id where concat(ifnull(`title`, ''), ',', ifnull(`description`, ''), ',', ifnull(user.`nickname`, '')) like %s and pic.`delete_flag` = 0 order by id desc limit %s, %s;", (prefix, '%%%s%%' % q, _start, per_page)) else: count_res = await request.app.db.get( "select count(id) as count from pic where pic.`delete_flag` = 0;" ) count = count_res['count'] res = await request.app.db.query( "select pic.`id`, pic.`title`, pic.`description`, concat(%s, pic.`path`) as pic, ifnull(user.nickname, '未知') as user, pic.`create_time`, pic.`update_time` from pic left join user on pic.user_id = user.id where pic.`delete_flag` = 0 order by id desc limit %s, %s;", (prefix, _start, per_page)) paginate = Paginator(count, per_page) pages = paginate() return response.json( { 'code': 'Success', 'total': count, 'pages': pages, 'data': res }, dumps=json_dumps)
async def get(self, request, **kwargs): q = request.raw_args.get('q') page = int(request.raw_args.get('page', 1)) per_page = int(request.raw_args.get('per_page', 10)) _start = (page - 1) * per_page if q: count_res = await request.app.db.get( "select count(id) as count from user where concat(`username`, ',', `nickname`, ',', `phone`, ',', `email`) like %s and delete_flag = 0;", ('%%%s%%' % q)) count = count_res['count'] res = await request.app.db.query( "select `id`, `username`, `nickname`, `gender`, `email`, `phone`, `create_time`, `update_time` from user where concat(`username`, ',', `nickname`, ',', `phone`, ',', `email`) like %s and delete_flag = 0 order by id desc limit %s, %s;", ('%%%s%%' % q, _start, per_page)) else: count_res = await request.app.db.get( "select count(id) as count from user where delete_flag = 0;") count = count_res['count'] res = await request.app.db.query( "select `id`, `username`, `nickname`, `gender`, `email`, `phone`, `create_time`, `update_time` from user where delete_flag = 0 order by id desc limit %s, %s;", (_start, per_page)) paginate = Paginator(count, per_page) pages = paginate() return response.json( { 'code': 'Success', 'total': count, 'pages': pages, 'data': res }, dumps=json_dumps)
async def _star_who(self, ctx, message: MessageID): """Shows who starred a message. The ID can either be the starred message ID or the message ID in the starboard channel. """ query = """ SELECT starrers.author_id FROM starrers INNER JOIN starboard_entries entry ON entry.id = starrers.entry_id WHERE entry.message_id = $1 OR entry.bot_message_id = $1; """ records = await ctx.db.fetch(query, message) if not records: return await ctx.send('No one starred this message or you provided an invalid message ID.') members = [ str(ctx.guild.get_member(r[0])) for r in records if ctx.guild.get_member(r[0]) ] try: base = pluralize(**{'star': len(records)}) if len(records) > len(members): title = f'{base} ({len(records) - len(members)} left server)' else: title = base pages = Paginator(ctx, entries=members, per_page=20, title=title) await pages.interact() except Exception as e: await ctx.send(e)
async def sharedservers(self, ctx, *, user: converters.GlobalUser): data = await self.bot.comm.handler("get_user_guilds", self.bot.cluster_count, {"user_id": user.id}) guilds = [] for chunk in data: guilds.extend(chunk) guilds = [ f"{guild.name} `{guild.id}` ({guild.member_count} members)" for guild in guilds ] all_pages = [] for chunk in [guilds[i:i + 20] for i in range(0, len(guilds), 20)]: page = discord.Embed(title="Servers", colour=self.bot.primary_colour) for guild in chunk: if page.description == discord.Embed.Empty: page.description = guild else: page.description += f"\n{guild}" page.set_footer(text="Use the reactions to flip pages.") all_pages.append(page) if len(all_pages) == 1: embed = all_pages[0] embed.set_footer(text=discord.Embed.Empty) await ctx.send(embed=embed) return paginator = Paginator(length=1, entries=all_pages, use_defaults=True, embed=True, timeout=120) await paginator.start(ctx)
def test__convert_query_success_default(app, faker): _query = {} query = Paginator._convert_query(table=pagination, raw_query=_query) assert query['limit'] == Paginator._DEFAULT_LIMIT assert query['order_by'] == Paginator._DEFAULT_ORDER_BY assert query['sort_by'] == 'id' assert query['page'] == 1 assert query['filters'] == {}
async def test_order_by_success(app, database, pagination_data): query = {'order_by': 'desc', 'limit': COUNT_DATA} async with app['db'].acquire() as conn: # type: SAConnection paginator = Paginator(conn=conn, table=pagination, query=query) page_data = await paginator.get_page() assert paginator._records_count == COUNT_DATA assert len(page_data) == COUNT_DATA assert page_data[0]['id'] == COUNT_DATA
async def send_bot_help(self, cogs): fields = {} for i in cogs: new = self.get_cog(i, cogs[i]) if new: fields.update(new) pag = Paginator( self.context, 'Help', fields, colour=colours['green'], maxf=3 ) await pag.setup()
def book_list(request): # 获取所有的书籍对象 books = models.Book.objects.all() # 这是queryset对象 current_page = request.GET.get('page') paginator = Paginator(request, current_page, books.count(), 10, 7) books = books[paginator.start:paginator.end] return render(request, 'book_list.html', { 'book_list': books, 'paginator': paginator, 'current_page': current_page })
async def viewsnippet(self, ctx, *, name: str = None): if name: name = name.lower() async with self.bot.pool.acquire() as conn: res = await conn.fetchrow( "SELECT name, content FROM snippet WHERE name=$1 AND guild=$2", name, ctx.guild.id, ) if not res: await ctx.send(embed=discord.Embed( description="A snippet with that name was not found.", colour=self.bot.error_colour, )) return embed = discord.Embed(title="Snippet", colour=self.bot.primary_colour) embed.add_field(name="Name", value=res[0], inline=False) embed.add_field(name="Content", value=res[1], inline=False) await ctx.send(embed=embed) return async with self.bot.pool.acquire() as conn: res = await conn.fetch( "SELECT name, content FROM snippet WHERE guild=$1", ctx.guild.id) if not res: await ctx.send(embed=discord.Embed( description="No snippet has been added yet.", colour=self.bot.primary_colour)) return all_pages = [] for chunk in [res[i:i + 10] for i in range(0, len(res), 10)]: page = discord.Embed(title="Snippets", colour=self.bot.primary_colour) for snippet in chunk: page.add_field( name=snippet[0], value=snippet[1][:100] + "..." if len(snippet[1]) > 100 else snippet[1], inline=False, ) page.set_footer(text="Use the reactions to flip pages.") all_pages.append(page) if len(all_pages) == 1: embed = all_pages[0] embed.set_footer(text=discord.Embed.Empty) await ctx.send(embed=embed) return paginator = Paginator(length=1, entries=all_pages, use_defaults=True, embed=True, timeout=120) await paginator.start(ctx)
async def _show_aliases(self, ctx): """Shows all aliases that exist on this server.""" query = """ SELECT alias, command FROM command_aliases WHERE guild_id = $1 ORDER BY alias; """ entries = starmap('`{0}` => `{1}`'.format, await ctx.db.fetch(query, ctx.guild.id)) pages = Paginator(ctx, entries) await pages.interact()
async def test_filter_success(app, database, pagination_data): query = {'sequence': 'sequence_1', 'limit': COUNT_DATA} async with app['db'].acquire() as conn: # type: SAConnection paginator = Paginator(conn=conn, table=pagination, query=query) page_data = await paginator.get_page() assert paginator._records_count == 111 assert len(page_data) == 111 assert 'id' in page_data[0] assert 'sequence' in page_data[0] assert 'some_data' in page_data[0]
async def urban_dictionary(self, ctx, *, term: str = ""): """Searches for a term on urbandictionary.com""" if not term: url = "http://api.urbandictionary.com/v0/random" else: term = uriquote(term) url = f"http://api.urbandictionary.com/v0/define?term={term}" async with self.bot.session.get(url) as resp: data = await resp.json() pages = Paginator(ctx, data['list'], self.ud_callback) await pages.paginate()
def banner_list(request): _page_num = int(request.GET.get("p", "1")) _paginator = Paginator(_page_num, 30, BannerModel.objects.count()) _banner_context_list = Banner.find(offset=_paginator.offset, count=_paginator.count_in_one_page) return render_to_response('banner/list.html', { 'active_division': 'banner', 'banner_context_list': _banner_context_list, 'paginator': _paginator }, context_instance=RequestContext(request))
def tencent_selection(request, template='tencent/selection.html'): _start_at = datetime.now() if request.user.is_authenticated(): _request_user_id = request.user.id else: _request_user_id = None _agent = 'iphone' if 'Android' in request.META['HTTP_USER_AGENT']: _agent = 'android' _page_num = int(request.GET.get('p', 1)) _hdl = NoteSelection.objects.filter(post_time__lt=datetime.now()) _paginator = Paginator(_page_num, 30, _hdl.count()) _hdl = _hdl.order_by('-post_time') _selection_list = [] _entity_id_list = [] for _note_selection in _hdl[_paginator.offset:_paginator.offset + _paginator.count_in_one_page]: _selection_note_id = _note_selection['note_id'] _entity_id = _note_selection['entity_id'] _entity_context = Entity(_entity_id).read() _note_context = Note(_selection_note_id).read() _creator_context = User(_note_context['creator_id']).read() _selection_list.append({ 'entity_context': _entity_context, 'note_context': _note_context, 'creator_context': _creator_context, }) _entity_id_list.append(_entity_id) _duration = datetime.now() - _start_at WebLogTask.delay( entry='tencent', duration=_duration.seconds * 1000000 + _duration.microseconds, page='SELECTION', request=request.REQUEST, ip=get_client_ip(request), log_time=datetime.now(), request_user_id=_request_user_id, appendix={ 'result_entities': _entity_id_list, }, ) return render_to_response(template, { 'agent': _agent, 'selection_list': _selection_list, 'next_page_num': _page_num + 1, }, context_instance=RequestContext(request))
async def rt(self, ctx, *, movie_name: str): """Searches Flixster for a movie's Rotten Tomatoes score and critics consensus if available""" url = self.rt_search_url.format(uriquote(movie_name)) # RT api is slow... async with ctx.channel.typing(): data = await self.json_from_flxurl(url) movielist = [] for movie in data: movielist.append(movie['id']) if not movielist: await ctx.send(f"Couldn't find a movie named `{movie_name}` on Flixster") return pages = Paginator(ctx, movielist, self.rt_output_callback) await pages.paginate()
async def _help(self, ctx, command: str = None): """Shows all commands""" prefix = (await self.bot.get_prefix(ctx.message))[-1] if command: cmd = self.bot.get_command( command.lower()) or self.bot.get_cog(command) if not cmd: return await ctx.send( f"Command or category '{command}' not found.") if isinstance(cmd, commands.Command): em = discord.Embed(color=0xff0000) em.title = cmd.name em.description = cmd.help or "No Description" em.description += "\nUsage: `{}{}`".format( ctx.prefix, _command_signature(cmd)) if cmd.aliases: em.description += "\nAliases: `{}`".format(", ".join( cmd.aliases)) return await ctx.send(embed=em) cmds = self.bot.get_cog_commands(command) em = discord.Embed(color=self.bot.color) em.description = cmd.__doc__ + "\n\n`" if cmd.__doc__ else "No Description\n\n`" em.set_footer( text=f"{prefix}help <cmd> for more info on a command.") for x in cmds: msg = f"{prefix}{x.signature} {x.short_doc}\n" em.description += msg em.description += "`" return await ctx.send(embed=em) else: cogs = self.bot.cogs.keys() pages = [] for x in cogs: if x == "Owner" and ctx.author.id not in ctx.bot.devs: continue cmds = self.bot.get_cog_commands(x) cog = self.bot.get_cog(x) msg = cog.__class__.__name__ + "\n" + cog.__doc__ + "\n\n`" if cog.__doc__ else cog.__class__.__name__ + "\nNo Description\n\n`" for cmd in cmds: if cmd.hidden: continue cmd_msg = f"{prefix}{_command_signature(cmd)} {cmd.short_doc}\n" msg += cmd_msg msg += "`" pages.append(msg) em = discord.Embed(color=0xff0000) em.set_footer( text=f"{prefix}help <cmd> for more information on a command.") paginator = Paginator(ctx, pages=pages, page_count=True, embed=em) await paginator.run()
def note_comment_list(request): _page_num = int(request.GET.get("p", "1")) _comment_count = Note.comment_count() _paginator = Paginator(_page_num, 30, _comment_count) _context_list = [] for _comment in Note.find_comment(offset=_paginator.offset, count=_paginator.count_in_one_page): try: _comment_context = Note(_comment[0]).read_comment(_comment[1]) _comment_context['creator'] = User( _comment_context['creator_id']).read() _context_list.append(_comment_context) except Exception, e: pass
async def _ignores(self, ctx): """Tells you what channels or members are currently ignored on this server.""" query = 'SELECT entity_id FROM plonks WHERE guild_id = $1;' entries = [(ctx.guild.get_channel(entity_id) or ctx.guild.get_member(entity_id) or _DummyEntry(entity_id)).mention for entity_id, in await ctx.db.fetch(query, ctx.guild.id)] if not entries: return await ctx.send('Nothing\'s being ignored in here.') pages = Paginator(ctx, entries, title=f'Currently ignoring...', per_page=20) await pages.interact()