From 8e0d8259fbfe1da00459b349b0465594d7162a2f Mon Sep 17 00:00:00 2001 From: Myned Date: Fri, 20 Oct 2017 16:14:24 -0400 Subject: [PATCH] suppress ValueError > isdigit(), reaction order logic --- src/main/cogs/booru.py | 2286 ++++++++++++++++++++-------------------- 1 file changed, 1143 insertions(+), 1143 deletions(-) diff --git a/src/main/cogs/booru.py b/src/main/cogs/booru.py index e99f45b..1c0ac36 100644 --- a/src/main/cogs/booru.py +++ b/src/main/cogs/booru.py @@ -19,27 +19,27 @@ from utils import formatter, scraper class MsG: - def __init__(self, bot): - self.bot = bot - self.color = d.Color(0x1A1A1A) - self.LIMIT = 100 - self.HISTORY_LIMIT = 100 - self.RATE_LIMIT = u.RATE_LIMIT + def __init__(self, bot): + self.bot = bot + self.color = d.Color(0x1A1A1A) + self.LIMIT = 100 + self.HISTORY_LIMIT = 100 + self.RATE_LIMIT = u.RATE_LIMIT self.qualiqueue = asyncio.Queue() - self.qualitifying = False + self.qualitifying = False - self.favorites = u.setdefault('cogs/favorites.pkl', {'tags': set(), 'posts': set()}) - self.blacklists = u.setdefault( - 'cogs/blacklists.pkl', {'global_blacklist': set(), 'guild_blacklist': {}, 'user_blacklist': {}}) - self.aliases = u.setdefault('cogs/aliases.pkl', {}) + self.favorites = u.setdefault('cogs/favorites.pkl', {'tags': set(), 'posts': set()}) + self.blacklists = u.setdefault( + 'cogs/blacklists.pkl', {'global_blacklist': set(), 'guild_blacklist': {}, 'user_blacklist': {}}) + self.aliases = u.setdefault('cogs/aliases.pkl', {}) - if u.tasks['auto_qual']: - for channel in u.tasks['auto_qual']: - temp = self.bot.get_channel(channel) + if u.tasks['auto_qual']: + for channel in u.tasks['auto_qual']: + temp = self.bot.get_channel(channel) self.bot.loop.create_task(self.qualiqueue_for_qualitification(temp)) - print('AUTO-QUALITIFYING : #{}'.format(temp.name)) - self.bot.loop.create_task(self._qualitify()) - self.qualitifying = True + print('AUTO-QUALITIFYING : #{}'.format(temp.name)) + self.bot.loop.create_task(self._qualitify()) + self.qualitifying = True async def get_post(self, channel): post_request = await u.fetch('https://e621.net/post/index.json', json=True) @@ -65,1275 +65,1275 @@ class MsG: await ctx.send('**Already auto-posting in {}.** Type `stop` to stop.'.format(ctx.channel.mention), delete_after=10) await ctx.message.add_reaction('\N{CROSS MARK}') - # Tag search - @commands.command(aliases=['rel'], brief='e621 Search for related tags', description='e621 | NSFW\nReturn related tags for a number of given tags', usage='[related|rel]') - @checks.del_ctx() - async def related(self, ctx, *args): - kwargs = u.get_kwargs(ctx, args) - dest, tags = kwargs['destination'], kwargs['remaining'] - related = [] + # Tag search + @commands.command(aliases=['rel'], brief='e621 Search for related tags', description='e621 | NSFW\nReturn related tags for a number of given tags', usage='[related|rel]') + @checks.del_ctx() + async def related(self, ctx, *args): + kwargs = u.get_kwargs(ctx, args) + dest, tags = kwargs['destination'], kwargs['remaining'] + related = [] - await dest.trigger_typing() + await dest.trigger_typing() - for tag in tags: - tag_request = await u.fetch('https://e621.net/tag/related.json', params={'tags': tag, 'type': 'general'}, json=True) - for rel in tag_request.get(tag, []): - related.append(rel[0]) + for tag in tags: + tag_request = await u.fetch('https://e621.net/tag/related.json', params={'tags': tag, 'type': 'general'}, json=True) + for rel in tag_request.get(tag, []): + related.append(rel[0]) - await dest.send('`{}` **related tags:**\n```\n{}```'.format(tag, formatter.tostring(related))) + await dest.send('`{}` **related tags:**\n```\n{}```'.format(tag, formatter.tostring(related))) - await asyncio.sleep(self.RATE_LIMIT) + await asyncio.sleep(self.RATE_LIMIT) - related.clear() + related.clear() - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - # Tag aliases - @commands.command(name='aliases', aliases=['alias'], brief='e621 Tag aliases', description='e621 | NSFW\nSearch aliases for given tag') - @checks.del_ctx() - async def tag_aliases(self, ctx, *args): - kwargs = u.get_kwargs(ctx, args) - dest, tags = kwargs['destination'], kwargs['remaining'] - aliases = [] - - await dest.trigger_typing() - - for tag in tags: - alias_request = await u.fetch('https://e621.net/tag_alias/index.json', params={'aliased_to': tag, 'approved': 'true'}, json=True) - for dic in alias_request: - aliases.append(dic['name']) - - await dest.send('`{}` **aliases:**\n```\n{}```'.format(tag, formatter.tostring(aliases))) - - await asyncio.sleep(self.RATE_LIMIT) - - aliases.clear() - - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - @commands.command(name='getimage', aliases=['geti', 'gi']) - @checks.del_ctx() - async def get_image(self, ctx, *args): - try: - kwargs = u.get_kwargs(ctx, args) - dest, urls = kwargs['destination'], kwargs['remaining'] - - if not urls: - raise exc.MissingArgument - - for url in urls: - try: - await dest.trigger_typing() - - await dest.send('{}'.format(await scraper.get_image(url))) - - finally: - await asyncio.sleep(self.RATE_LIMIT) - - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - except exc.MissingArgument: - await ctx.send('**Invalid url or file.**', delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - - # Reverse image searches a linked image using the public iqdb - @commands.command(name='reverse', aliases=['rev', 'ris'], brief='e621 Reverse image search', description='e621 | NSFW\nReverse-search an image with given URL') - @checks.del_ctx() - async def reverse_image_search(self, ctx, *args): - try: - kwargs = u.get_kwargs(ctx, args) - dest, urls = kwargs['destination'], kwargs['remaining'] - c = 0 - - if not urls and not ctx.message.attachments: - raise exc.MissingArgument - - for url in urls: - try: - await dest.trigger_typing() - - await dest.send('**Probable match:**\n{}'.format(await scraper.get_post(url))) - - c += 1 - await asyncio.sleep(self.RATE_LIMIT) - - except exc.MatchError as e: - await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) - - for attachment in ctx.message.attachments: - try: - await dest.trigger_typing() - - await dest.send('**Probable match:**\n{}'.format(await scraper.get_post(attachment.url))) - - c += 1 - await asyncio.sleep(self.RATE_LIMIT) - - except exc.MatchError as e: - await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) - - if c: await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - else: - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.MissingArgument: - await ctx.send('**Invalid url or file.**', delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') + # Tag aliases + @commands.command(name='aliases', aliases=['alias'], brief='e621 Tag aliases', description='e621 | NSFW\nSearch aliases for given tag') + @checks.del_ctx() + async def tag_aliases(self, ctx, *args): + kwargs = u.get_kwargs(ctx, args) + dest, tags = kwargs['destination'], kwargs['remaining'] + aliases = [] - @commands.command(name='quality', aliases=['qual', 'qrev', 'qis']) - @checks.del_ctx() - async def quality_reverse_image_search(self, ctx, *args): - try: - kwargs = u.get_kwargs(ctx, args) - dest, urls = kwargs['destination'], kwargs['remaining'] - c = 0 + await dest.trigger_typing() - if not urls and not ctx.message.attachments: - raise exc.MissingArgument + for tag in tags: + alias_request = await u.fetch('https://e621.net/tag_alias/index.json', params={'aliased_to': tag, 'approved': 'true'}, json=True) + for dic in alias_request: + aliases.append(dic['name']) - for url in urls: - try: - await dest.trigger_typing() + await dest.send('`{}` **aliases:**\n```\n{}```'.format(tag, formatter.tostring(aliases))) - post = await scraper.get_post(url) + await asyncio.sleep(self.RATE_LIMIT) - await dest.send('**Probable match:**\n{}'.format(await scraper.get_image(post))) + aliases.clear() - c += 1 - await asyncio.sleep(self.RATE_LIMIT) - - except exc.MatchError as e: - await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) - - for attachment in ctx.message.attachments: - try: - await dest.trigger_typing() - - post = await scraper.get_post(attachment.url) - - await dest.send('**Probable match:**\n{}'.format(await scraper.get_image(post))) - - c += 1 - await asyncio.sleep(self.RATE_LIMIT) - - except exc.MatchError as e: - await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) - - if c: await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - else: - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.MissingArgument: - await ctx.send('**Invalid url or file.**', delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') + @commands.command(name='getimage', aliases=['geti', 'gi']) + @checks.del_ctx() + async def get_image(self, ctx, *args): + try: + kwargs = u.get_kwargs(ctx, args) + dest, urls = kwargs['destination'], kwargs['remaining'] - @commands.command(name='reversify', aliases=['revify', 'risify', 'rify']) - @checks.del_ctx() - async def reversify(self, ctx, *args): - try: - kwargs = u.get_kwargs(ctx, args, limit=self.HISTORY_LIMIT / 5) - dest, remove, limit = kwargs['destination'], kwargs['remove'], kwargs['limit'] - urls = [] - attachments = [] + if not urls: + raise exc.MissingArgument - if not ctx.author.permissions_in(ctx.channel).manage_messages: - dest = ctx.author + for url in urls: + try: + await dest.trigger_typing() - async for message in ctx.channel.history(limit=self.HISTORY_LIMIT * limit): - if len(urls) + len(attachments) >= limit: - break - if message.author.id != self.bot.user.id and re.search('(http[a-z]?:\/\/[^ ]*\.(?:gif|png|jpg|jpeg))', message.content) is not None: - urls.append(message) - await message.add_reaction('\N{HOURGLASS WITH FLOWING SAND}') - elif message.author.id != self.bot.user.id and message.attachments: - attachments.append(message) - await message.add_reaction('\N{HOURGLASS WITH FLOWING SAND}') + await dest.send('{}'.format(await scraper.get_image(url))) - if not urls and not attachments: - raise exc.NotFound + finally: + await asyncio.sleep(self.RATE_LIMIT) - for message in urls: - for match in re.finditer('(http[a-z]?:\/\/[^ ]*\.(?:gif|png|jpg|jpeg))', message.content): - try: - await dest.trigger_typing() + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - await dest.send('**Probable match from** {}**:**\n{}'.format(message.author.display_name, await scraper.get_post(match.group(0)))) - await message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + except exc.MissingArgument: + await ctx.send('**Invalid url or file.**', delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') - await asyncio.sleep(self.RATE_LIMIT) + # Reverse image searches a linked image using the public iqdb + @commands.command(name='reverse', aliases=['rev', 'ris'], brief='e621 Reverse image search', description='e621 | NSFW\nReverse-search an image with given URL') + @checks.del_ctx() + async def reverse_image_search(self, ctx, *args): + try: + kwargs = u.get_kwargs(ctx, args) + dest, urls = kwargs['destination'], kwargs['remaining'] + c = 0 - if remove: - with suppress(err.NotFound): - await message.delete() + if not urls and not ctx.message.attachments: + raise exc.MissingArgument - except exc.MatchError as e: - await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) - await message.add_reaction('\N{CROSS MARK}') + for url in urls: + try: + await dest.trigger_typing() - for message in attachments: - for attachment in message.attachments: - try: - await dest.trigger_typing() + await dest.send('**Probable match:**\n{}'.format(await scraper.get_post(url))) - await dest.send('**Probable match from** {}**:**\n{}'.format(message.author.display_name, await scraper.get_post(attachment.url))) - await message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + c += 1 + await asyncio.sleep(self.RATE_LIMIT) - await asyncio.sleep(self.RATE_LIMIT) + except exc.MatchError as e: + await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) - if remove: - with suppress(err.NotFound): - await message.delete() + for attachment in ctx.message.attachments: + try: + await dest.trigger_typing() - except exc.MatchError as e: - await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) - await message.add_reaction('\N{CROSS MARK}') + await dest.send('**Probable match:**\n{}'.format(await scraper.get_post(attachment.url))) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + c += 1 + await asyncio.sleep(self.RATE_LIMIT) - except exc.NotFound: - await ctx.send('**No matches found.**', delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.BoundsError as e: - await ctx.send('`{}` **invalid limit.** Images limited to 20'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.MatchError as e: + await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) - @commands.command(name='qualitify', aliases=['qualify', 'qrevify', 'qrisify', 'qify']) - @checks.del_ctx() - async def qualitify(self, ctx, *args): - try: - kwargs = u.get_kwargs(ctx, args, limit=self.HISTORY_LIMIT / 5) - dest, remove, limit = kwargs['destination'], kwargs['remove'], kwargs['limit'] - urls = [] - attachments = [] + if c: + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + else: + await ctx.message.add_reaction('\N{CROSS MARK}') - if not ctx.author.permissions_in(ctx.channel).manage_messages: - dest = ctx.author + except exc.MissingArgument: + await ctx.send('**Invalid url or file.**', delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') - async for message in ctx.channel.history(limit=self.HISTORY_LIMIT * limit): - if len(urls) + len(attachments) >= limit: - break - if message.author.id != self.bot.user.id and re.search('(http[a-z]?:\/\/[^ ]*\.(?:gif|png|jpg|jpeg))', message.content) is not None: - urls.append(message) - await message.add_reaction('\N{HOURGLASS WITH FLOWING SAND}') - elif message.author.id != self.bot.user.id and message.attachments: - attachments.append(message) - await message.add_reaction('\N{HOURGLASS WITH FLOWING SAND}') + @commands.command(name='quality', aliases=['qual', 'qrev', 'qis']) + @checks.del_ctx() + async def quality_reverse_image_search(self, ctx, *args): + try: + kwargs = u.get_kwargs(ctx, args) + dest, urls = kwargs['destination'], kwargs['remaining'] + c = 0 - if not urls and not attachments: - raise exc.NotFound + if not urls and not ctx.message.attachments: + raise exc.MissingArgument - for message in urls: - for match in re.finditer('(http[a-z]?:\/\/[^ ]*\.(?:gif|png|jpg|jpeg))', message.content): - try: - await dest.trigger_typing() + for url in urls: + try: + await dest.trigger_typing() - post = await scraper.get_post(match.group(0)) + post = await scraper.get_post(url) - await dest.send('**Probable match from** {}**:**\n{}'.format(message.author.display_name, await scraper.get_image(post))) - await message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + await dest.send('**Probable match:**\n{}'.format(await scraper.get_image(post))) - await asyncio.sleep(self.RATE_LIMIT) + c += 1 + await asyncio.sleep(self.RATE_LIMIT) - if remove: - with suppress(err.NotFound): - await message.delete() + except exc.MatchError as e: + await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) - except exc.MatchError as e: - await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) - await message.add_reaction('\N{CROSS MARK}') + for attachment in ctx.message.attachments: + try: + await dest.trigger_typing() - for message in attachments: - for attachment in message.attachments: - try: - await dest.trigger_typing() + post = await scraper.get_post(attachment.url) - post = await scraper.get_post(attachment.url) + await dest.send('**Probable match:**\n{}'.format(await scraper.get_image(post))) - await dest.send('**Probable match from** {}**:**\n{}'.format(message.author.display_name, await scraper.get_image(post))) - await message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + c += 1 + await asyncio.sleep(self.RATE_LIMIT) - await asyncio.sleep(self.RATE_LIMIT) + except exc.MatchError as e: + await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) - if remove: - with suppress(err.NotFound): - await message.delete() + if c: + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + else: + await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.MatchError as e: - await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) - await message.add_reaction('\N{CROSS MARK}') + except exc.MissingArgument: + await ctx.send('**Invalid url or file.**', delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + @commands.command(name='reversify', aliases=['revify', 'risify', 'rify']) + @checks.del_ctx() + async def reversify(self, ctx, *args): + try: + kwargs = u.get_kwargs(ctx, args, limit=self.HISTORY_LIMIT / 5) + dest, remove, limit = kwargs['destination'], kwargs['remove'], kwargs['limit'] + urls = [] + attachments = [] - except exc.NotFound: - await ctx.send('**No matches found.**', delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.BoundsError as e: - await ctx.send('`{}` **invalid limit.** Images limited to 20'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') + if not ctx.author.permissions_in(ctx.channel).manage_messages: + dest = ctx.author - async def _qualitify(self): - while self.qualitifying: + async for message in ctx.channel.history(limit=self.HISTORY_LIMIT * limit): + if len(urls) + len(attachments) >= limit: + break + if message.author.id != self.bot.user.id and re.search('(http[a-z]?:\/\/[^ ]*\.(?:gif|png|jpg|jpeg))', message.content) is not None: + urls.append(message) + await message.add_reaction('\N{HOURGLASS WITH FLOWING SAND}') + elif message.author.id != self.bot.user.id and message.attachments: + attachments.append(message) + await message.add_reaction('\N{HOURGLASS WITH FLOWING SAND}') + + if not urls and not attachments: + raise exc.NotFound + + for message in urls: + for match in re.finditer('(http[a-z]?:\/\/[^ ]*\.(?:gif|png|jpg|jpeg))', message.content): + try: + await dest.trigger_typing() + + await dest.send('**Probable match from** {}**:**\n{}'.format(message.author.display_name, await scraper.get_post(match.group(0)))) + await message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + + await asyncio.sleep(self.RATE_LIMIT) + + if remove: + with suppress(err.NotFound): + await message.delete() + + except exc.MatchError as e: + await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) + await message.add_reaction('\N{CROSS MARK}') + + for message in attachments: + for attachment in message.attachments: + try: + await dest.trigger_typing() + + await dest.send('**Probable match from** {}**:**\n{}'.format(message.author.display_name, await scraper.get_post(attachment.url))) + await message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + + await asyncio.sleep(self.RATE_LIMIT) + + if remove: + with suppress(err.NotFound): + await message.delete() + + except exc.MatchError as e: + await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) + await message.add_reaction('\N{CROSS MARK}') + + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + + except exc.NotFound: + await ctx.send('**No matches found.**', delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.BoundsError as e: + await ctx.send('`{}` **invalid limit.** Images limited to 20'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + + @commands.command(name='qualitify', aliases=['qualify', 'qrevify', 'qrisify', 'qify']) + @checks.del_ctx() + async def qualitify(self, ctx, *args): + try: + kwargs = u.get_kwargs(ctx, args, limit=self.HISTORY_LIMIT / 5) + dest, remove, limit = kwargs['destination'], kwargs['remove'], kwargs['limit'] + urls = [] + attachments = [] + + if not ctx.author.permissions_in(ctx.channel).manage_messages: + dest = ctx.author + + async for message in ctx.channel.history(limit=self.HISTORY_LIMIT * limit): + if len(urls) + len(attachments) >= limit: + break + if message.author.id != self.bot.user.id and re.search('(http[a-z]?:\/\/[^ ]*\.(?:gif|png|jpg|jpeg))', message.content) is not None: + urls.append(message) + await message.add_reaction('\N{HOURGLASS WITH FLOWING SAND}') + elif message.author.id != self.bot.user.id and message.attachments: + attachments.append(message) + await message.add_reaction('\N{HOURGLASS WITH FLOWING SAND}') + + if not urls and not attachments: + raise exc.NotFound + + for message in urls: + for match in re.finditer('(http[a-z]?:\/\/[^ ]*\.(?:gif|png|jpg|jpeg))', message.content): + try: + await dest.trigger_typing() + + post = await scraper.get_post(match.group(0)) + + await dest.send('**Probable match from** {}**:**\n{}'.format(message.author.display_name, await scraper.get_image(post))) + await message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + + await asyncio.sleep(self.RATE_LIMIT) + + if remove: + with suppress(err.NotFound): + await message.delete() + + except exc.MatchError as e: + await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) + await message.add_reaction('\N{CROSS MARK}') + + for message in attachments: + for attachment in message.attachments: + try: + await dest.trigger_typing() + + post = await scraper.get_post(attachment.url) + + await dest.send('**Probable match from** {}**:**\n{}'.format(message.author.display_name, await scraper.get_image(post))) + await message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + + await asyncio.sleep(self.RATE_LIMIT) + + if remove: + with suppress(err.NotFound): + await message.delete() + + except exc.MatchError as e: + await ctx.send('**No probable match for:** `{}`'.format(e), delete_after=10) + await message.add_reaction('\N{CROSS MARK}') + + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + + except exc.NotFound: + await ctx.send('**No matches found.**', delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.BoundsError as e: + await ctx.send('`{}` **invalid limit.** Images limited to 20'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + + async def _qualitify(self): + while self.qualitifying: message = await self.qualiqueue.get() - for match in re.finditer('(http[a-z]?:\/\/[^ ]*\.(?:gif|png|jpg|jpeg))', message.content): + for match in re.finditer('(http[a-z]?:\/\/[^ ]*\.(?:gif|png|jpg|jpeg))', message.content): + try: + await message.channel.trigger_typing() + + post = await scraper.get_post(match.group(0)) + + await message.channel.send('**Probable match from** {}**:**\n{}'.format(message.author.display_name, await scraper.get_image(post))) + await message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + + await asyncio.sleep(self.RATE_LIMIT) + + with suppress(err.NotFound): + await message.delete() + + except exc.MatchError as e: + await message.channel.send('**No probable match for:** `{}`'.format(e), delete_after=10) + await message.add_reaction('\N{CROSS MARK}') + + for attachment in message.attachments: + try: + await message.channel.trigger_typing() + + post = await scraper.get_post(attachment.url) + + await message.channel.send('**Probable match from** {}**:**\n{}'.format(message.author.display_name, await scraper.get_image(post))) + await message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + + await asyncio.sleep(self.RATE_LIMIT) + + with suppress(err.NotFound): + await message.delete() + + except exc.MatchError as e: + await message.channel.send('**No probable match for:** `{}`'.format(e), delete_after=10) + await message.add_reaction('\N{CROSS MARK}') + + print('STOPPED : qualitifying') + + async def queue_for_qualitification(self, channel): + def check(msg): + if msg.content.lower() == 'stop' and msg.channel is channel and msg.author.guild_permissions.administrator: + raise exc.Abort + elif msg.channel is channel and message.author.id != self.bot.user.id and (re.search('(http[a-z]?:\/\/[^ ]*\.(?:gif|png|jpg|jpeg))', msg.content) is not None or msg.attachments): + return True + return False + try: - await message.channel.trigger_typing() - - post = await scraper.get_post(match.group(0)) - - await message.channel.send('**Probable match from** {}**:**\n{}'.format(message.author.display_name, await scraper.get_image(post))) - await message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - await asyncio.sleep(self.RATE_LIMIT) - - with suppress(err.NotFound): - await message.delete() - - except exc.MatchError as e: - await message.channel.send('**No probable match for:** `{}`'.format(e), delete_after=10) - await message.add_reaction('\N{CROSS MARK}') - - for attachment in message.attachments: - try: - await message.channel.trigger_typing() - - post = await scraper.get_post(attachment.url) - - await message.channel.send('**Probable match from** {}**:**\n{}'.format(message.author.display_name, await scraper.get_image(post))) - await message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - await asyncio.sleep(self.RATE_LIMIT) - - with suppress(err.NotFound): - await message.delete() - - except exc.MatchError as e: - await message.channel.send('**No probable match for:** `{}`'.format(e), delete_after=10) - await message.add_reaction('\N{CROSS MARK}') - - print('STOPPED : qualitifying') - - async def queue_for_qualitification(self, channel): - def check(msg): - if msg.content.lower() == 'stop' and msg.channel is channel and msg.author.guild_permissions.administrator: - raise exc.Abort - elif msg.channel is channel and message.author.id != self.bot.user.id and (re.search('(http[a-z]?:\/\/[^ ]*\.(?:gif|png|jpg|jpeg))', msg.content) is not None or msg.attachments): - return True - return False - - try: - while not self.bot.is_closed(): - message = await self.bot.wait_for('message', check=check) + while not self.bot.is_closed(): + message = await self.bot.wait_for('message', check=check) await self.qualiqueue.put(message) - await message.add_reaction('\N{HOURGLASS WITH FLOWING SAND}') + await message.add_reaction('\N{HOURGLASS WITH FLOWING SAND}') - except exc.Abort: - u.tasks['auto_qual'].remove(channel.id) - u.dump(u.tasks, 'cogs/tasks.pkl') - if not u.tasks['auto_qual']: - self.qualitifying = False - print('STOPPED : qualitifying #{}'.format(channel.name)) - await channel.send('**Stopped queueing messages for qualitification in** {}**.**'.format(channel.mention), delete_after=5) + except exc.Abort: + u.tasks['auto_qual'].remove(channel.id) + u.dump(u.tasks, 'cogs/tasks.pkl') + if not u.tasks['auto_qual']: + self.qualitifying = False + print('STOPPED : qualitifying #{}'.format(channel.name)) + await channel.send('**Stopped queueing messages for qualitification in** {}**.**'.format(channel.mention), delete_after=5) - @commands.command(name='autoqualitify', aliases=['autoqual']) - @commands.has_permissions(manage_channels=True) - async def auto_qualitify(self, ctx): - try: - if ctx.channel.id not in u.tasks['auto_qual']: - u.tasks['auto_qual'].append(ctx.channel.id) - u.dump(u.tasks, 'cogs/tasks.pkl') + @commands.command(name='autoqualitify', aliases=['autoqual']) + @commands.has_permissions(manage_channels=True) + async def auto_qualitify(self, ctx): + try: + if ctx.channel.id not in u.tasks['auto_qual']: + u.tasks['auto_qual'].append(ctx.channel.id) + u.dump(u.tasks, 'cogs/tasks.pkl') self.bot.loop.create_task(self.qualiqueue_for_qualitification(ctx.channel)) - if not self.qualitifying: - self.bot.loop.create_task(self._qualitify()) - self.qualitifying = True + if not self.qualitifying: + self.bot.loop.create_task(self._qualitify()) + self.qualitifying = True - print('AUTO-QUALITIFYING : #{}'.format(ctx.channel.name)) - await ctx.send('**Auto-qualitifying all images in {}.**'.format(ctx.channel.mention), delete_after=5) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - else: - raise exc.Exists + print('AUTO-QUALITIFYING : #{}'.format(ctx.channel.name)) + await ctx.send('**Auto-qualitifying all images in {}.**'.format(ctx.channel.mention), delete_after=5) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + else: + raise exc.Exists - except exc.Exists: - await ctx.send('**Already auto-qualitifying in {}.** Type `stop` to stop.'.format(ctx.channel.mention), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.Exists: + await ctx.send('**Already auto-qualitifying in {}.** Type `stop` to stop.'.format(ctx.channel.mention), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') - def get_favorites(self, ctx, args): - if '-f' in args or '-favs' in args or '-faves' in args or '-favorites' in args: - if self.favorites.get(ctx.author.id, {}).get('tags', set()): - args = ['~{}'.format(tag) for tag in self.favorites[ctx.author.id]['tags']] - else: - raise exc.FavoritesNotFound + def get_favorites(self, ctx, args): + if '-f' in args or '-favs' in args or '-faves' in args or '-favorites' in args: + if self.favorites.get(ctx.author.id, {}).get('tags', set()): + args = ['~{}'.format(tag) for tag in self.favorites[ctx.author.id]['tags']] + else: + raise exc.FavoritesNotFound - return args + return args - async def return_pool(self, ctx, *, booru='e621', query=[]): - def on_message(msg): - if msg.content.lower() == 'cancel' and msg.author is ctx.author and msg.channel is ctx.channel: - raise exc.Abort - with suppress(ValueError): - if int(msg.content) <= len(pools) and int(msg.content) > 0 and msg.author is ctx.author and msg.channel is ctx.channel: - return True - return False + async def return_pool(self, ctx, *, booru='e621', query=[]): + def on_message(msg): + if msg.content.lower() == 'cancel' and msg.author is ctx.author and msg.channel is ctx.channel: + raise exc.Abort + elif msg.content.isdigit(): + if int(msg.content) <= len(pools) and int(msg.content) > 0 and msg.author is ctx.author and msg.channel is ctx.channel: + return True + return False - posts = {} - pool = {} + posts = {} + pool = {} - pools = [] - pool_request = await u.fetch('https://{}.net/pool/index.json'.format(booru), params={'query': ' '.join(query)}, json=True) - if len(pool_request) > 1: - for pool in pool_request: - pools.append(pool['name']) - match = await ctx.send('**Multiple pools found.** Type in the correct match.\n```\n{}```\nor `cancel` to cancel.'.format('\n'.join(['{} {}'.format(c, elem) for c, elem in enumerate(pools, 1)]))) - try: - selection = await self.bot.wait_for('message', check=on_message, timeout=10 * 60) - except exc.Abort: - raise exc.Abort - finally: - await match.delete() - tempool = [pool for pool in pool_request if pool['name'] - == pools[int(selection.content) - 1]][0] - await selection.delete() - pool = {'name': tempool['name'], 'id': tempool['id']} - elif pool_request: - tempool = pool_request[0] - pool = {'name': pool_request[0]['name'], 'id': pool_request[0]['id']} - else: - raise exc.NotFound - - page = 1 - while len(posts) < tempool['post_count']: - posts_request = await u.fetch('https://{}.net/pool/show.json'.format(booru), params={'id': tempool['id'], 'page': page}, json=True) - for post in posts_request['posts']: - posts[post['id']] = {'author': post['author'], 'url': post['file_url']} - page += 1 - - return pool, posts - - # Creates reaction-based paginator for linked pools - @commands.command(name='pool', aliases=['e6pp'], brief='e621 pool paginator', description='e621 | NSFW\nShow pools in a page format', hidden=True) - @checks.del_ctx() - async def pool_paginator(self, ctx, *args): - def on_reaction(reaction, user): - if reaction.emoji == '\N{OCTAGONAL SIGN}' and reaction.message.id == ctx.message.id and (user is ctx.author or user.id == u.config['owner_id']): - raise exc.Abort - elif reaction.emoji == '\N{NUMBER SIGN}\N{COMBINING ENCLOSING KEYCAP}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): - raise exc.GoTo - elif reaction.emoji == '\N{LEFTWARDS BLACK ARROW}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): - raise exc.Left - elif reaction.emoji == '\N{GROWING HEART}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): - raise exc.Save - elif reaction.emoji == '\N{BLACK RIGHTWARDS ARROW}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): - raise exc.Right - return False - - def on_message(msg): - with suppress(ValueError): - if int(msg.content) <= len(posts) and msg.author is ctx.author and msg.channel is ctx.channel: - return True - return False - - try: - kwargs = u.get_kwargs(ctx, args) - dest, query = kwargs['destination'], kwargs['remaining'] - starred = [] - c = 1 - - await dest.trigger_typing() - - pool, posts = await self.return_pool(ctx, booru='e621', query=query) - keys = list(posts.keys()) - values = list(posts.values()) - - embed = d.Embed( - title=values[c - 1]['author'], url='https://e621.net/post/show/{}'.format(keys[c - 1]), color=dest.me.color if isinstance(dest.channel, d.TextChannel) else self.color).set_image(url=values[c - 1]['url']) - embed.set_author(name=pool['name'], - url='https://e621.net/pool/show?id={}'.format(pool['id']), icon_url=ctx.author.avatar_url) - embed.set_footer(text='{} / {}'.format(c, len(posts)), - icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') - - paginator = await dest.send(embed=embed) - - for emoji in ('\N{NUMBER SIGN}\N{COMBINING ENCLOSING KEYCAP}', '\N{LEFTWARDS BLACK ARROW}', '\N{GROWING HEART}', '\N{BLACK RIGHTWARDS ARROW}'): - await paginator.add_reaction(emoji) - await ctx.message.add_reaction('\N{OCTAGONAL SIGN}') - await asyncio.sleep(1) - - while not self.bot.is_closed(): - try: - done, pending = await asyncio.wait([self.bot.wait_for('reaction_add', check=on_reaction, timeout=10 * 60), - self.bot.wait_for('reaction_remove', check=on_reaction, timeout=10 * 60)], return_when=asyncio.FIRST_COMPLETED) - for future in done: - future.result() - - except exc.GoTo: - await paginator.edit(content='**Enter image number...**') - number = await self.bot.wait_for('message', check=on_message, timeout=10 * 60) - - c = int(number.content) - await number.delete() - embed.title = values[c - 1]['author'] - embed.url = 'https://e621.net/post/show/{}'.format(keys[c - 1]) - embed.set_footer(text='{} / {}'.format(c, len(posts)), - icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') - embed.set_image(url=values[c - 1]['url']) - - await paginator.edit(content='\N{HEAVY BLACK HEART}' if values[c - 1]['url'] in starred else None, embed=embed) - - except exc.Left: - if c > 1: - c -= 1 - embed.title = values[c - 1]['author'] - embed.url = 'https://e621.net/post/show/{}'.format(keys[c - 1]) - embed.set_footer(text='{} / {}'.format(c, len(posts)), - icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') - embed.set_image(url=values[c - 1]['url']) - - await paginator.edit(content='\N{HEAVY BLACK HEART}' if values[c - 1]['url'] in starred else None, embed=embed) - else: - await paginator.edit(content='**First image.**') - - except exc.Save: - if values[c - 1]['url'] not in starred: - starred.append(values[c - 1]['url']) - - await paginator.edit(content='\N{HEAVY BLACK HEART}') - else: - starred.remove(values[c - 1]['url']) - - await paginator.edit(content='\N{BROKEN HEART}') - - except exc.Right: - if c < len(keys): - c += 1 - embed.title = values[c - 1]['author'] - embed.url = 'https://e621.net/post/show/{}'.format(keys[c - 1]) - embed.set_footer(text='{} / {}'.format(c, len(posts)), - icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') - embed.set_image(url=values[c - 1]['url']) - - await paginator.edit(content='\N{HEAVY BLACK HEART}' if values[c - 1]['url'] in starred else None, embed=embed) - - except exc.Abort: - try: - await paginator.edit(content='**Exited paginator.**') - - except UnboundLocalError: - await dest.send('**Exited paginator.**') - - finally: - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - except asyncio.TimeoutError: - try: - await paginator.edit(content='**Paginator timed out.**') - - except UnboundLocalError: - await dest.send('**Paginator timed out.**') - - finally: - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - except exc.NotFound: - await ctx.send('**Pool not found.**', delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.Timeout: - await ctx.send('**Request timed out.**') - await ctx.message.add_reaction('\N{CROSS MARK}') - - finally: - for url in starred: - await ctx.author.send('`{} / {}`\n{}'.format(starred.index(url) + 1, len(starred), url)) - if len(starred) > 5: - await asyncio.sleep(self.RATE_LIMIT) - - # Messy code that checks image limit and tags in blacklists - async def check_return_posts(self, ctx, *, booru='e621', tags=[], limit=1, previous={}): - guild = ctx.guild if isinstance( - ctx.guild, d.Guild) else ctx.channel - - blacklist = set() - # Creates temp blacklist based on context - for tag in self.blacklists['global_blacklist']: - blacklist.update(list(self.aliases[tag]) + [tag]) - for tag in self.blacklists['guild_blacklist'].get(guild.id, {}).get(ctx.channel.id, set()): - blacklist.update(list(self.aliases[tag]) + [tag]) - for tag in self.blacklists['user_blacklist'].get(ctx.author.id, set()): - blacklist.update(list(self.aliases[tag]) + [tag]) - # Checks if tags are in local blacklists - if tags: - if (len(tags) > 5 and booru == 'e621') or (len(tags) > 4 and booru == 'e926'): - raise exc.TagBoundsError(formatter.tostring(tags[5:])) - for tag in tags: - if tag == 'swf' or tag == 'webm' or tag in blacklist: - raise exc.TagBlacklisted(tag) - - # Checks for blacklisted tags in endpoint blacklists - try/except is for continuing the parent loop - posts = {} - c = 0 - while len(posts) < limit: - if c == limit * 5 + self.LIMIT: - raise exc.Timeout - request = await u.fetch('https://{}.net/post/index.json'.format(booru), params={'tags': ','.join(['order:random'] + tags), 'limit': int(self.LIMIT * limit)}, json=True) - if len(request) == 0: - raise exc.NotFound(formatter.tostring(tags)) - if len(request) < limit: - limit = len(request) - - for post in request: - if 'swf' in post['file_ext'] or 'webm' in post['file_ext']: - continue - try: - for tag in blacklist: - if tag in post['tags']: - raise exc.Continue - except exc.Continue: - continue - if post['id'] not in posts.keys() and post['id'] not in previous.keys(): - posts[post['id']] = {'author': post['author'], 'url': post['file_url']} - if len(posts) == limit: - break - c += 1 - - return posts - - @commands.command(name='e621p', aliases=['e6p', '6p']) - @checks.del_ctx() - @checks.is_nsfw() - async def e621_paginator(self, ctx, *args): - def on_reaction(reaction, user): - if reaction.emoji == '\N{OCTAGONAL SIGN}' and reaction.message.id == ctx.message.id and (user is ctx.author or user.id == u.config['owner_id']): - raise exc.Abort - elif reaction.emoji == '\N{NUMBER SIGN}\N{COMBINING ENCLOSING KEYCAP}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): - raise exc.GoTo - elif reaction.emoji == '\N{LEFTWARDS BLACK ARROW}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): - raise exc.Left - elif reaction.emoji == '\N{GROWING HEART}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): - raise exc.Save - elif reaction.emoji == '\N{BLACK RIGHTWARDS ARROW}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): - raise exc.Right - return False - - def on_message(msg): - with suppress(ValueError): - if int(msg.content) <= len(posts) and msg.author is ctx.author and msg.channel is ctx.channel: - return True - return False - - try: - kwargs = u.get_kwargs(ctx, args) - dest, tags = kwargs['destination'], kwargs['remaining'] - limit = self.LIMIT / 5 - starred = [] - c = 1 - - tags = self.get_favorites(ctx, tags) - - await ctx.trigger_typing() - - posts = await self.check_return_posts(ctx, booru='e621', tags=tags, limit=limit) - keys = list(posts.keys()) - values = list(posts.values()) - - embed = d.Embed( - title=values[c - 1]['author'], url='https://e621.net/post/show/{}'.format(keys[c - 1]), color=ctx.me.color if isinstance(ctx.channel, d.TextChannel) else self.color).set_image(url=values[c - 1]['url']) - embed.set_author(name=formatter.tostring(tags, random=True), - url='https://e621.net/post?tags={}'.format(','.join(tags)), icon_url=ctx.author.avatar_url) - embed.set_footer(text='{} / {}'.format(c, len(posts)), - icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') - - paginator = await dest.send(embed=embed) - - for emoji in ('\N{NUMBER SIGN}\N{COMBINING ENCLOSING KEYCAP}', '\N{LEFTWARDS BLACK ARROW}', '\N{GROWING HEART}', '\N{BLACK RIGHTWARDS ARROW}'): - await paginator.add_reaction(emoji) - await ctx.message.add_reaction('\N{OCTAGONAL SIGN}') - await asyncio.sleep(1) - - while not self.bot.is_closed(): - try: - done, pending = await asyncio.wait([self.bot.wait_for('reaction_add', check=on_reaction, timeout=10 * 60), - self.bot.wait_for('reaction_remove', check=on_reaction, timeout=10 * 60)], return_when=asyncio.FIRST_COMPLETED) - for future in done: - future.result() - - except exc.GoTo: - await paginator.edit(content='**Enter image number...**') - number = await self.bot.wait_for('message', check=on_message, timeout=10 * 60) - - c = int(number.content) - await number.delete() - embed.title = values[c - 1]['author'] - embed.url = 'https://e621.net/post/show/{}'.format(keys[c - 1]) - embed.set_footer(text='{} / {}'.format(c, len(posts)), - icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') - embed.set_image(url=values[c - 1]['url']) - - await paginator.edit(content='\N{HEAVY BLACK HEART}' if values[c - 1]['url'] in starred else None, embed=embed) - - except exc.Left: - if c > 1: - c -= 1 - embed.title = values[c - 1]['author'] - embed.url = 'https://e621.net/post/show/{}'.format(keys[c - 1]) - embed.set_footer(text='{} / {}'.format(c, len(posts)), - icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') - embed.set_image(url=values[c - 1]['url']) - await paginator.edit(content='\N{HEAVY BLACK HEART}' if values[c - 1]['url'] in starred else None, embed=embed) - else: - await paginator.edit(content='**First image.**') - - except exc.Save: - if values[c - 1]['url'] not in starred: - starred.append(values[c - 1]['url']) - - await paginator.edit(content='\N{HEAVY BLACK HEART}') - else: - starred.remove(values[c - 1]['url']) - - await paginator.edit(content='\N{BROKEN HEART}') - - except exc.Right: - if c % limit == 0: - await dest.trigger_typing() + pools = [] + pool_request = await u.fetch('https://{}.net/pool/index.json'.format(booru), params={'query': ' '.join(query)}, json=True) + if len(pool_request) > 1: + for pool in pool_request: + pools.append(pool['name']) + match = await ctx.send('**Multiple pools found.** Type in the correct match.\n```\n{}```\nor `cancel` to cancel.'.format('\n'.join(['{} {}'.format(c, elem) for c, elem in enumerate(pools, 1)]))) try: - posts.update(await self.check_return_posts(ctx, booru='e621', tags=tags, limit=limit, previous=posts)) + selection = await self.bot.wait_for('message', check=on_message, timeout=10 * 60) + except exc.Abort: + raise exc.Abort + finally: + await match.delete() + tempool = [pool for pool in pool_request if pool['name'] + == pools[int(selection.content) - 1]][0] + await selection.delete() + pool = {'name': tempool['name'], 'id': tempool['id']} + elif pool_request: + tempool = pool_request[0] + pool = {'name': pool_request[0]['name'], 'id': pool_request[0]['id']} + else: + raise exc.NotFound - except exc.NotFound: - await paginator.edit(content='**No more images found.**') + page = 1 + while len(posts) < tempool['post_count']: + posts_request = await u.fetch('https://{}.net/pool/show.json'.format(booru), params={'id': tempool['id'], 'page': page}, json=True) + for post in posts_request['posts']: + posts[post['id']] = {'author': post['author'], 'url': post['file_url']} + page += 1 + return pool, posts + + # Creates reaction-based paginator for linked pools + @commands.command(name='pool', aliases=['e6pp'], brief='e621 pool paginator', description='e621 | NSFW\nShow pools in a page format', hidden=True) + @checks.del_ctx() + async def pool_paginator(self, ctx, *args): + def on_reaction(reaction, user): + if reaction.emoji == '\N{OCTAGONAL SIGN}' and reaction.message.id == ctx.message.id and (user is ctx.author or user.id == u.config['owner_id']): + raise exc.Abort + elif reaction.emoji == '\N{NUMBER SIGN}\N{COMBINING ENCLOSING KEYCAP}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): + raise exc.GoTo + elif reaction.emoji == '\N{LEFTWARDS BLACK ARROW}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): + raise exc.Left + elif reaction.emoji == '\N{GROWING HEART}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): + raise exc.Save + elif reaction.emoji == '\N{BLACK RIGHTWARDS ARROW}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): + raise exc.Right + return False + + def on_message(msg): + if msg.content.isdigit(): + if int(msg.content) <= len(posts) and msg.author is ctx.author and msg.channel is ctx.channel: + return True + return False + + try: + kwargs = u.get_kwargs(ctx, args) + dest, query = kwargs['destination'], kwargs['remaining'] + starred = [] + c = 1 + + await dest.trigger_typing() + + pool, posts = await self.return_pool(ctx, booru='e621', query=query) keys = list(posts.keys()) values = list(posts.values()) - c += 1 - embed.title = values[c - 1]['author'] - embed.url = 'https://e621.net/post/show/{}'.format(keys[c - 1]) - embed.set_footer(text='{} / {}'.format(c, len(posts)), - icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') - embed.set_image(url=values[c - 1]['url']) - await paginator.edit(content='\N{HEAVY BLACK HEART}' if values[c - 1]['url'] in starred else None, embed=embed) + embed = d.Embed( + title=values[c - 1]['author'], url='https://e621.net/post/show/{}'.format(keys[c - 1]), color=dest.me.color if isinstance(dest.channel, d.TextChannel) else self.color) + embed.set_image(url=values[c - 1]['url']) + embed.set_author(name=pool['name'], + url='https://e621.net/pool/show?id={}'.format(pool['id']), icon_url=ctx.author.avatar_url) + embed.set_footer(text='{} / {}'.format(c, len(posts)), + icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') - except exc.Abort: - try: - await paginator.edit(content='**Exited paginator.**') + paginator = await dest.send(embed=embed) - except UnboundLocalError: - await dest.send('**Exited paginator.**') + for emoji in ('\N{NUMBER SIGN}\N{COMBINING ENCLOSING KEYCAP}', '\N{LEFTWARDS BLACK ARROW}', '\N{GROWING HEART}', '\N{BLACK RIGHTWARDS ARROW}'): + await paginator.add_reaction(emoji) + await ctx.message.add_reaction('\N{OCTAGONAL SIGN}') + await asyncio.sleep(1) - finally: + while not self.bot.is_closed(): + try: + done, pending = await asyncio.wait([self.bot.wait_for('reaction_add', check=on_reaction, timeout=10 * 60), + self.bot.wait_for('reaction_remove', check=on_reaction, timeout=10 * 60)], return_when=asyncio.FIRST_COMPLETED) + for future in done: + future.result() + + except exc.GoTo: + await paginator.edit(content='**Enter image number...**') + number = await self.bot.wait_for('message', check=on_message, timeout=10 * 60) + + c = int(number.content) + await number.delete() + embed.title = values[c - 1]['author'] + embed.url = 'https://e621.net/post/show/{}'.format(keys[c - 1]) + embed.set_footer(text='{} / {}'.format(c, len(posts)), + icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') + embed.set_image(url=values[c - 1]['url']) + + await paginator.edit(content='\N{HEAVY BLACK HEART}' if values[c - 1]['url'] in starred else None, embed=embed) + + except exc.Left: + if c > 1: + c -= 1 + embed.title = values[c - 1]['author'] + embed.url = 'https://e621.net/post/show/{}'.format(keys[c - 1]) + embed.set_footer(text='{} / {}'.format(c, len(posts)), + icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') + embed.set_image(url=values[c - 1]['url']) + + await paginator.edit(content='\N{HEAVY BLACK HEART}' if values[c - 1]['url'] in starred else None, embed=embed) + else: + await paginator.edit(content='**First image.**') + + except exc.Save: + if values[c - 1]['url'] not in starred: + starred.append(values[c - 1]['url']) + + await paginator.edit(content='\N{HEAVY BLACK HEART}') + else: + starred.remove(values[c - 1]['url']) + + await paginator.edit(content='\N{BROKEN HEART}') + + except exc.Right: + if c < len(keys): + c += 1 + embed.title = values[c - 1]['author'] + embed.url = 'https://e621.net/post/show/{}'.format(keys[c - 1]) + embed.set_footer(text='{} / {}'.format(c, len(posts)), + icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') + embed.set_image(url=values[c - 1]['url']) + + await paginator.edit(content='\N{HEAVY BLACK HEART}' if values[c - 1]['url'] in starred else None, embed=embed) + + except exc.Abort: + try: + await paginator.edit(content='**Exited paginator.**') + + except UnboundLocalError: + await dest.send('**Exited paginator.**') + except asyncio.TimeoutError: + try: + await paginator.edit(content='**Paginator timed out.**') + + except UnboundLocalError: + await dest.send('**Paginator timed out.**') + except exc.NotFound: + await ctx.send('**Pool not found.**', delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.Timeout: + await ctx.send('**Request timed out.**') + await ctx.message.add_reaction('\N{CROSS MARK}') + + finally: + if starred: + await ctx.message.add_reaction('\N{HOURGLASS WITH FLOWING SAND}') + + for url in starred: + await ctx.author.send('`{} / {}`\n{}'.format(starred.index(url) + 1, len(starred), url)) + if len(starred) > 5: + await asyncio.sleep(self.RATE_LIMIT) + + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + + # Messy code that checks image limit and tags in blacklists + async def check_return_posts(self, ctx, *, booru='e621', tags=[], limit=1, previous={}): + guild = ctx.guild if isinstance( + ctx.guild, d.Guild) else ctx.channel + + blacklist = set() + # Creates temp blacklist based on context + for tag in self.blacklists['global_blacklist']: + blacklist.update(list(self.aliases[tag]) + [tag]) + for tag in self.blacklists['guild_blacklist'].get(guild.id, {}).get(ctx.channel.id, set()): + blacklist.update(list(self.aliases[tag]) + [tag]) + for tag in self.blacklists['user_blacklist'].get(ctx.author.id, set()): + blacklist.update(list(self.aliases[tag]) + [tag]) + # Checks if tags are in local blacklists + if tags: + if (len(tags) > 5 and booru == 'e621') or (len(tags) > 4 and booru == 'e926'): + raise exc.TagBoundsError(formatter.tostring(tags[5:])) + for tag in tags: + if tag == 'swf' or tag == 'webm' or tag in blacklist: + raise exc.TagBlacklisted(tag) + + # Checks for blacklisted tags in endpoint blacklists - try/except is for continuing the parent loop + posts = {} + c = 0 + while len(posts) < limit: + if c == limit * 5 + self.LIMIT: + raise exc.Timeout + request = await u.fetch('https://{}.net/post/index.json'.format(booru), params={'tags': ','.join(['order:random'] + tags), 'limit': int(self.LIMIT * limit)}, json=True) + if len(request) == 0: + raise exc.NotFound(formatter.tostring(tags)) + if len(request) < limit: + limit = len(request) + + for post in request: + if 'swf' in post['file_ext'] or 'webm' in post['file_ext']: + continue + try: + for tag in blacklist: + if tag in post['tags']: + raise exc.Continue + except exc.Continue: + continue + if post['id'] not in posts.keys() and post['id'] not in previous.keys(): + posts[post['id']] = {'author': post['author'], 'url': post['file_url']} + if len(posts) == limit: + break + c += 1 + + return posts + + @commands.command(name='e621p', aliases=['e6p', '6p']) + @checks.del_ctx() + @checks.is_nsfw() + async def e621_paginator(self, ctx, *args): + def on_reaction(reaction, user): + if reaction.emoji == '\N{OCTAGONAL SIGN}' and reaction.message.id == ctx.message.id and (user is ctx.author or user.id == u.config['owner_id']): + raise exc.Abort + elif reaction.emoji == '\N{NUMBER SIGN}\N{COMBINING ENCLOSING KEYCAP}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): + raise exc.GoTo + elif reaction.emoji == '\N{LEFTWARDS BLACK ARROW}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): + raise exc.Left + elif reaction.emoji == '\N{GROWING HEART}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): + raise exc.Save + elif reaction.emoji == '\N{BLACK RIGHTWARDS ARROW}' and reaction.message.id == paginator.id and (user is ctx.author or user.id == u.config['owner_id']): + raise exc.Right + return False + + def on_message(msg): + if msg.content.isdigit(): + if int(msg.content) <= len(posts) and msg.author is ctx.author and msg.channel is ctx.channel: + return True + return False + + try: + kwargs = u.get_kwargs(ctx, args) + dest, tags = kwargs['destination'], kwargs['remaining'] + limit = self.LIMIT / 5 + starred = [] + c = 1 + + tags = self.get_favorites(ctx, tags) + + await ctx.trigger_typing() + + posts = await self.check_return_posts(ctx, booru='e621', tags=tags, limit=limit) + keys = list(posts.keys()) + values = list(posts.values()) + + embed = d.Embed( + title=values[c - 1]['author'], url='https://e621.net/post/show/{}'.format(keys[c - 1]), color=ctx.me.color if isinstance(ctx.channel, d.TextChannel) else self.color) + embed.set_image(url=values[c - 1]['url']) + embed.set_author(name=formatter.tostring(tags, random=True), + url='https://e621.net/post?tags={}'.format(','.join(tags)), icon_url=ctx.author.avatar_url) + embed.set_footer(text='{} / {}'.format(c, len(posts)), + icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') + + paginator = await dest.send(embed=embed) + + for emoji in ('\N{NUMBER SIGN}\N{COMBINING ENCLOSING KEYCAP}', '\N{LEFTWARDS BLACK ARROW}', '\N{GROWING HEART}', '\N{BLACK RIGHTWARDS ARROW}'): + await paginator.add_reaction(emoji) + await ctx.message.add_reaction('\N{OCTAGONAL SIGN}') + await asyncio.sleep(1) + + while not self.bot.is_closed(): + try: + done, pending = await asyncio.wait([self.bot.wait_for('reaction_add', check=on_reaction, timeout=10 * 60), + self.bot.wait_for('reaction_remove', check=on_reaction, timeout=10 * 60)], return_when=asyncio.FIRST_COMPLETED) + for future in done: + future.result() + + except exc.GoTo: + await paginator.edit(content='**Enter image number...**') + number = await self.bot.wait_for('message', check=on_message, timeout=10 * 60) + + c = int(number.content) + await number.delete() + embed.title = values[c - 1]['author'] + embed.url = 'https://e621.net/post/show/{}'.format(keys[c - 1]) + embed.set_footer(text='{} / {}'.format(c, len(posts)), + icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') + embed.set_image(url=values[c - 1]['url']) + + await paginator.edit(content='\N{HEAVY BLACK HEART}' if values[c - 1]['url'] in starred else None, embed=embed) + + except exc.Left: + if c > 1: + c -= 1 + embed.title = values[c - 1]['author'] + embed.url = 'https://e621.net/post/show/{}'.format(keys[c - 1]) + embed.set_footer(text='{} / {}'.format(c, len(posts)), + icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') + embed.set_image(url=values[c - 1]['url']) + await paginator.edit(content='\N{HEAVY BLACK HEART}' if values[c - 1]['url'] in starred else None, embed=embed) + else: + await paginator.edit(content='**First image.**') + + except exc.Save: + if values[c - 1]['url'] not in starred: + starred.append(values[c - 1]['url']) + + await paginator.edit(content='\N{HEAVY BLACK HEART}') + else: + starred.remove(values[c - 1]['url']) + + await paginator.edit(content='\N{BROKEN HEART}') + + except exc.Right: + if c % limit == 0: + await dest.trigger_typing() + try: + posts.update(await self.check_return_posts(ctx, booru='e621', tags=tags, limit=limit, previous=posts)) + + except exc.NotFound: + await paginator.edit(content='**No more images found.**') + + keys = list(posts.keys()) + values = list(posts.values()) + + c += 1 + embed.title = values[c - 1]['author'] + embed.url = 'https://e621.net/post/show/{}'.format(keys[c - 1]) + embed.set_footer(text='{} / {}'.format(c, len(posts)), + icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') + embed.set_image(url=values[c - 1]['url']) + await paginator.edit(content='\N{HEAVY BLACK HEART}' if values[c - 1]['url'] in starred else None, embed=embed) + + except exc.Abort: + try: + await paginator.edit(content='**Exited paginator.**') + + except UnboundLocalError: + await dest.send('**Exited paginator.**') + except asyncio.TimeoutError: + try: + await paginator.edit(content='**Paginator timed out.**') + + except UnboundLocalError: + await dest.send('**Paginator timed out.**') + except exc.NotFound as e: + await ctx.send('`{}` **not found.**'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.TagBlacklisted as e: + await ctx.send('\N{NO ENTRY SIGN} `{}` **blacklisted.**'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{NO ENTRY SIGN}') + except exc.TagBoundsError as e: + await ctx.send('`{}` **out of bounds.** Tags limited to 5, currently.'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.FavoritesNotFound: + await ctx.send('**You have no favorite tags.**', delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.Timeout: + await ctx.send('**Request timed out.**') + await ctx.message.add_reaction('\N{CROSS MARK}') + + finally: + if starred: + await ctx.message.add_reaction('\N{HOURGLASS WITH FLOWING SAND}') + + for url in starred: + await ctx.author.send('`{} / {}`\n{}'.format(starred.index(url) + 1, len(starred), url)) + if len(starred) > 5: + await asyncio.sleep(self.RATE_LIMIT) + + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + + @e621_paginator.error + async def e621_paginator_error(self, ctx, error): + if isinstance(error, errext.CheckFailure): + await ctx.send('\N{NO ENTRY} {} **is not an NSFW channel.**'.format(ctx.channel.mention), delete_after=10) + return await ctx.message.add_reaction('\N{NO ENTRY}') + + # Searches for and returns images from e621.net given tags when not blacklisted + @commands.group(aliases=['e6', '6'], brief='e621 | NSFW', description='e621 | NSFW\nTag-based search for e621.net\n\nYou can only search 5 tags and 6 images at once for now.\ne6 [tags...] ([# of images])') + @checks.del_ctx() + @checks.is_nsfw() + async def e621(self, ctx, *args): + try: + kwargs = u.get_kwargs(ctx, args, limit=3) + dest, args, limit = kwargs['destination'], kwargs['remaining'], kwargs['limit'] + + tags = self.get_favorites(ctx, args) + + await dest.trigger_typing() + + posts = await self.check_return_posts(ctx, booru='e621', tags=tags, limit=limit) + + for ident, post in posts.items(): + embed = d.Embed(title=post['author'], url='https://e621.net/post/show/{}'.format(ident), + color=ctx.me.color if isinstance(ctx.channel, d.TextChannel) else self.color).set_image(url=post['url']) + embed.set_author(name=formatter.tostring(tags, random=True), + url='https://e621.net/post?tags={}'.format(','.join(tags)), icon_url=ctx.author.avatar_url) + embed.set_footer( + text=str(ident), icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') + + await dest.send(embed=embed) + + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + + except exc.TagBlacklisted as e: + await ctx.send('`{}` **blacklisted.**'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.BoundsError as e: + await ctx.send('`{}` **out of bounds.** Images limited to 3.'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.TagBoundsError as e: + await ctx.send('`{}` **out of bounds.** Tags limited to 5.'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.NotFound as e: + await ctx.send('`{}` **not found.**'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.FavoritesNotFound: + await ctx.send('**You have no favorite tags.**', delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.Timeout: + await ctx.send('**Request timed out.**') + await ctx.message.add_reaction('\N{CROSS MARK}') + + # tools.command_dict.setdefault(str(ctx.author.id), {}).update( + # {'command': ctx.command, 'args': ctx.args}) + + @e621.error + async def e621_error(self, ctx, error): + if isinstance(error, errext.CheckFailure): + await ctx.send('\N{NO ENTRY} {} **is not an NSFW channel.**'.format(ctx.channel.mention), delete_after=10) + return await ctx.message.add_reaction('\N{NO ENTRY}') + + # Searches for and returns images from e926.net given tags when not blacklisted + @commands.command(aliases=['e9', '9'], brief='e926 | SFW', description='e926 | SFW\nTag-based search for e926.net\n\nYou can only search 5 tags and 6 images at once for now.\ne9 [tags...] ([# of images])') + @checks.del_ctx() + async def e926(self, ctx, *args): + try: + kwargs = u.get_kwargs(ctx, args, limit=3) + dest, args, limit = kwargs['destination'], kwargs['remaining'], kwargs['limit'] + + tags = self.get_favorites(ctx, args) + + await dest.trigger_typing() + + posts = await self.check_return_posts(ctx, booru='e926', tags=tags, limit=limit) + + for ident, post in posts.items(): + embed = d.Embed(title=post['author'], url='https://e926.net/post/show/{}'.format(ident), + color=ctx.me.color if isinstance(ctx.channel, d.TextChannel) else self.color).set_image(url=post['url']) + embed.set_author(name=formatter.tostring(tags, random=True), + url='https://e621.net/post?tags={}'.format(','.join(tags)), icon_url=ctx.author.avatar_url) + embed.set_footer( + text=str(ident), icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') + + await dest.send(embed=embed) + + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + + except exc.TagBlacklisted as e: + await ctx.send('`{}` **blacklisted.**'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.BoundsError as e: + await ctx.send('`{}` **out of bounds.** Images limited to 3.'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.TagBoundsError as e: + await ctx.send('`{}` **out of bounds.** Tags limited to 5.'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.NotFound as e: + await ctx.send('`{}` **not found.**'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.FavoritesNotFound: + await ctx.send('**You have no favorite tags.**', delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.Timeout: + await ctx.send('**Request timed out.**') + await ctx.message.add_reaction('\N{CROSS MARK}') + + @commands.group(aliases=['fave', 'fav', 'f']) + @checks.del_ctx() + async def favorite(self, ctx): + if ctx.invoked_subcommand is None: + await ctx.send('**Use a flag to manage favorites.**\n*Type* `{}help fav` *for more info.*'.format(ctx.prefix), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + + @favorite.error + async def favorite_error(self, ctx, error): + pass + + @favorite.group(name='get', aliases=['g']) + async def _get_favorite(self, ctx): + pass + + @_get_favorite.command(name='tags', aliases=['t']) + async def __get_favorite_tags(self, ctx, *args): + dest = u.get_kwargs(ctx, args)['destination'] + + await dest.send('\N{WHITE MEDIUM STAR} {}**\'s favorite tags:**\n```\n{}```'.format(ctx.author.mention, formatter.tostring(self.favorites.get(ctx.author.id, {}).get('tags', set()))), delete_after=10) await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - except asyncio.TimeoutError: - try: - await paginator.edit(content='**Paginator timed out.**') - except UnboundLocalError: - await dest.send('**Paginator timed out.**') + @_get_favorite.command(name='posts', aliases=['p']) + async def __get_favorite_posts(self, ctx): + pass - finally: + @favorite.group(name='add', aliases=['a']) + async def _add_favorite(self, ctx): + pass + + @_add_favorite.command(name='tags', aliases=['t']) + async def __add_favorite_tags(self, ctx, *args): + try: + kwargs = u.get_kwargs(ctx, args) + dest, tags = kwargs['destination'], kwargs['remaining'] + + for tag in tags: + if tag in self.blacklists['user_blacklist'].get(ctx.author.id, set()): + raise exc.TagBlacklisted(tag) + if len(self.favorites[ctx.author.id]['tags']) + len(tags) > 5: + raise exc.BoundsError + + self.favorites.setdefault(ctx.author.id, {}).setdefault('tags', set()).update(tags) + u.dump(self.favorites, 'cogs/favorites.pkl') + + await dest.send('{} **added to their favorites:**\n```\n{}```'.format(ctx.author.mention, formatter.tostring(tags)), delete_after=5) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + + except exc.BoundsError: + await ctx.send('**Favorites list currently limited to:** `5`', delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + except exc.TagBlacklisted as e: + await ctx.send('\N{NO ENTRY SIGN} `{}` **blacklisted.**', delete_after=10) + await ctx.message.add_reaction('\N{NO ENTRY SIGN}') + + @_add_favorite.command(name='posts', aliases=['p']) + async def __add_favorite_posts(self, ctx, *posts): + pass + + @favorite.group(name='remove', aliases=['r']) + async def _remove_favorite(self, ctx): + pass + + @_remove_favorite.command(name='tags', aliases=['t']) + async def __remove_favorite_tags(self, ctx, *args): + try: + kwargs = u.get_kwargs(ctx, args) + dest, tags = kwargs['destination'], kwargs['remaining'] + + for tag in tags: + try: + self.favorites[ctx.author.id].get('tags', set()).remove(tag) + + except KeyError: + raise exc.TagError(tag) + + u.dump(self.favorites, 'cogs/favorites.pkl') + + await dest.send('{} **removed from their favorites:**\n```\n{}```'.format(ctx.author.mention, formatter.tostring(tags)), delete_after=5) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + + except exc.TagError as e: + await ctx.send('`{}` **not in favorites.**'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') + + @_remove_favorite.command(name='posts', aliases=['p']) + async def __remove_favorite_posts(self, ctx): + pass + + @favorite.group(name='clear', aliases=['c']) + async def _clear_favorite(self, ctx): + pass + + @_clear_favorite.command(name='tags', aliases=['t']) + async def __clear_favorite_tags(self, ctx, *args): + dest = u.get_kwargs(ctx, args)['destination'] + + with suppress(KeyError): + del self.favorites[ctx.author.id] + u.dump(self.favorites, 'cogs/favorites.pkl') + + await dest.send('{}**\'s favorites cleared.**'.format(ctx.author.mention), delete_after=5) await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - except exc.NotFound as e: - await ctx.send('`{}` **not found.**'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.TagBlacklisted as e: - await ctx.send('\N{NO ENTRY SIGN} `{}` **blacklisted.**'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{NO ENTRY SIGN}') - except exc.TagBoundsError as e: - await ctx.send('`{}` **out of bounds.** Tags limited to 5, currently.'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.FavoritesNotFound: - await ctx.send('**You have no favorite tags.**', delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.Timeout: - await ctx.send('**Request timed out.**') - await ctx.message.add_reaction('\N{CROSS MARK}') - finally: - for url in starred: - await ctx.author.send('`{} / {}`\n{}'.format(starred.index(url) + 1, len(starred), url)) - if len(starred) > 5: - await asyncio.sleep(self.RATE_LIMIT) + @_clear_favorite.command(name='posts', aliases=['p']) + async def __clear_favorite_posts(self, ctx): + pass - @e621_paginator.error - async def e621_paginator_error(self, ctx, error): - if isinstance(error, errext.CheckFailure): - await ctx.send('\N{NO ENTRY} {} **is not an NSFW channel.**'.format(ctx.channel.mention), delete_after=10) - return await ctx.message.add_reaction('\N{NO ENTRY}') + # Umbrella command structure to manage global, channel, and user blacklists + @commands.group(aliases=['bl', 'b'], brief='Manage blacklists', description='Blacklist base command for managing blacklists\n\n`bl get [blacklist]` to show a blacklist\n`bl set [blacklist] [tags]` to replace a blacklist\n`bl clear [blacklist]` to clear a blacklist\n`bl add [blacklist] [tags]` to add tags to a blacklist\n`bl remove [blacklist] [tags]` to remove tags from a blacklist', usage='[flag] [blacklist] ([tags])') + @checks.del_ctx() + async def blacklist(self, ctx): + if ctx.invoked_subcommand is None: + await ctx.send('**Use a flag to manage blacklists.**\n*Type* `{}help bl` *for more info.*'.format(ctx.prefix), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') - # Searches for and returns images from e621.net given tags when not blacklisted - @commands.group(aliases=['e6', '6'], brief='e621 | NSFW', description='e621 | NSFW\nTag-based search for e621.net\n\nYou can only search 5 tags and 6 images at once for now.\ne6 [tags...] ([# of images])') - @checks.del_ctx() - @checks.is_nsfw() - async def e621(self, ctx, *args): - try: - kwargs = u.get_kwargs(ctx, args, limit=3) - dest, args, limit = kwargs['destination'], kwargs['remaining'], kwargs['limit'] + # @blacklist.error + # async def blacklist_error(self, ctx, error): + # if isinstance(error, KeyError): + # return await ctx.send('**Blacklist does not exist.**', delete_after=10) - tags = self.get_favorites(ctx, args) + @blacklist.group(name='get', aliases=['g']) + async def _get_blacklist(self, ctx): + if ctx.invoked_subcommand is None: + await ctx.send('**Invalid blacklist.**', delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') - await dest.trigger_typing() + @_get_blacklist.command(name='global', aliases=['gl', 'g']) + async def __get_global_blacklist(self, ctx, *args): + dest = u.get_kwargs(ctx, args)['destination'] - posts = await self.check_return_posts(ctx, booru='e621', tags=tags, limit=limit) + await dest.send('\N{NO ENTRY SIGN} **Global blacklist:**\n```\n{}```'.format(formatter.tostring(self.blacklists['global_blacklist']))) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - for ident, post in posts.items(): - embed = d.Embed(title=post['author'], url='https://e621.net/post/show/{}'.format(ident), - color=ctx.me.color if isinstance(ctx.channel, d.TextChannel) else self.color).set_image(url=post['url']) - embed.set_author(name=formatter.tostring(tags, random=True), - url='https://e621.net/post?tags={}'.format(','.join(tags)), icon_url=ctx.author.avatar_url) - embed.set_footer( - text=str(ident), icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') + @_get_blacklist.command(name='channel', aliases=['ch', 'c']) + async def __get_channel_blacklist(self, ctx, *args): + dest = u.get_kwargs(ctx, args)['destination'] - await dest.send(embed=embed) + guild = ctx.guild if isinstance( + ctx.guild, d.Guild) else ctx.channel - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + await dest.send('\N{NO ENTRY SIGN} {} **blacklist:**\n```\n{}```'.format(ctx.channel.mention, formatter.tostring(self.blacklists['guild_blacklist'].get(guild.id, {}).get(ctx.channel.id, set())))) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - except exc.TagBlacklisted as e: - await ctx.send('`{}` **blacklisted.**'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.BoundsError as e: - await ctx.send('`{}` **out of bounds.** Images limited to 3.'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.TagBoundsError as e: - await ctx.send('`{}` **out of bounds.** Tags limited to 5.'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.NotFound as e: - await ctx.send('`{}` **not found.**'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.FavoritesNotFound: - await ctx.send('**You have no favorite tags.**', delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.Timeout: - await ctx.send('**Request timed out.**') - await ctx.message.add_reaction('\N{CROSS MARK}') + @_get_blacklist.command(name='me', aliases=['m']) + async def __get_user_blacklist(self, ctx, *args): + dest = u.get_kwargs(ctx, args)['destination'] - # tools.command_dict.setdefault(str(ctx.author.id), {}).update( - # {'command': ctx.command, 'args': ctx.args}) + await dest.send('\N{NO ENTRY SIGN} {}**\'s blacklist:**\n```\n{}```'.format(ctx.author.mention, formatter.tostring(self.blacklists['user_blacklist'].get(ctx.author.id, set()))), delete_after=10) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - @e621.error - async def e621_error(self, ctx, error): - if isinstance(error, errext.CheckFailure): - await ctx.send('\N{NO ENTRY} {} **is not an NSFW channel.**'.format(ctx.channel.mention), delete_after=10) - return await ctx.message.add_reaction('\N{NO ENTRY}') + @_get_blacklist.command(name='here', aliases=['h']) + async def __get_here_blacklists(self, ctx, *args): + dest = u.get_kwargs(ctx, args)['destination'] - # Searches for and returns images from e926.net given tags when not blacklisted - @commands.command(aliases=['e9', '9'], brief='e926 | SFW', description='e926 | SFW\nTag-based search for e926.net\n\nYou can only search 5 tags and 6 images at once for now.\ne9 [tags...] ([# of images])') - @checks.del_ctx() - async def e926(self, ctx, *args): - try: - kwargs = u.get_kwargs(ctx, args, limit=3) - dest, args, limit = kwargs['destination'], kwargs['remaining'], kwargs['limit'] + guild = ctx.guild if isinstance( + ctx.guild, d.Guild) else ctx.channel - tags = self.get_favorites(ctx, args) + await dest.send('\N{NO ENTRY SIGN} **__Blacklisted:__**\n\n**Global:**\n```\n{}```\n**{}:**\n```\n{}```'.format(formatter.tostring(self.blacklists['global_blacklist']), ctx.channel.mention, formatter.tostring(self.blacklists['guild_blacklist'].get(guild.id, {}).get(ctx.channel.id, set())))) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - await dest.trigger_typing() + @_get_blacklist.group(name='all', aliases=['a']) + async def __get_all_blacklists(self, ctx): + if ctx.invoked_subcommand is None: + await ctx.send('**Invalid blacklist.**') + await ctx.message.add_reaction('\N{CROSS MARK}') - posts = await self.check_return_posts(ctx, booru='e926', tags=tags, limit=limit) + @__get_all_blacklists.command(name='guild', aliases=['g']) + @commands.has_permissions(manage_channels=True) + async def ___get_all_guild_blacklists(self, ctx, *args): + dest = u.get_kwargs(ctx, args)['destination'] - for ident, post in posts.items(): - embed = d.Embed(title=post['author'], url='https://e926.net/post/show/{}'.format(ident), - color=ctx.me.color if isinstance(ctx.channel, d.TextChannel) else self.color).set_image(url=post['url']) - embed.set_author(name=formatter.tostring(tags, random=True), - url='https://e621.net/post?tags={}'.format(','.join(tags)), icon_url=ctx.author.avatar_url) - embed.set_footer( - text=str(ident), icon_url='http://lh6.ggpht.com/d3pNZNFCcJM8snBsRSdKUhR9AVBnJMcYYrR92RRDBOzCrxZMhuTeoGOQSmSEn7DAPQ=w300') + guild = ctx.guild if isinstance( + ctx.guild, d.Guild) else ctx.channel - await dest.send(embed=embed) + await dest.send('\N{NO ENTRY SIGN} **__{} blacklists:__**\n\n{}'.format(guild.name, formatter.dict_tostring(self.blacklists['guild_blacklist'].get(guild.id, {})))) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + @__get_all_blacklists.command(name='user', aliases=['u', 'member', 'm']) + @commands.is_owner() + async def ___get_all_user_blacklists(self, ctx, *args): + dest = u.get_kwargs(ctx, args)['destination'] - except exc.TagBlacklisted as e: - await ctx.send('`{}` **blacklisted.**'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.BoundsError as e: - await ctx.send('`{}` **out of bounds.** Images limited to 3.'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.TagBoundsError as e: - await ctx.send('`{}` **out of bounds.** Tags limited to 5.'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.NotFound as e: - await ctx.send('`{}` **not found.**'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.FavoritesNotFound: - await ctx.send('**You have no favorite tags.**', delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.Timeout: - await ctx.send('**Request timed out.**') - await ctx.message.add_reaction('\N{CROSS MARK}') + await dest.send('\N{NO ENTRY SIGN} **__User blacklists:__**\n\n{}'.format(formatter.dict_tostring(self.blacklists['user_blacklist']))) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - @commands.group(aliases=['fave', 'fav', 'f']) - @checks.del_ctx() - async def favorite(self, ctx): - if ctx.invoked_subcommand is None: - await ctx.send('**Use a flag to manage favorites.**\n*Type* `{}help fav` *for more info.*'.format(ctx.prefix), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') + @blacklist.group(name='add', aliases=['a']) + async def _add_tags(self, ctx): + if ctx.invoked_subcommand is None: + await ctx.send('**Invalid blacklist.**', delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') - @favorite.error - async def favorite_error(self, ctx, error): - pass + @_add_tags.command(name='global', aliases=['gl', 'g']) + @commands.is_owner() + async def __add_global_tags(self, ctx, *args): + kwargs = u.get_kwargs(ctx, args) + dest, tags = kwargs['destination'], kwargs['remaining'] - @favorite.group(name='get', aliases=['g']) - async def _get_favorite(self, ctx): - pass + await dest.trigger_typing() - @_get_favorite.command(name='tags', aliases=['t']) - async def __get_favorite_tags(self, ctx, *args): - dest = u.get_kwargs(ctx, args)['destination'] + self.blacklists['global_blacklist'].update(tags) + for tag in tags: + alias_request = await u.fetch('https://e621.net/tag_alias/index.json', params={'aliased_to': tag, 'approved': 'true'}, json=True) + if alias_request: + for dic in alias_request: + self.aliases.setdefault(tag, set()).add(dic['name']) + else: + self.aliases.setdefault(tag, set()) + u.dump(self.blacklists, 'cogs/blacklists.pkl') + u.dump(self.aliases, 'cogs/aliases.pkl') - await dest.send('\N{WHITE MEDIUM STAR} {}**\'s favorite tags:**\n```\n{}```'.format(ctx.author.mention, formatter.tostring(self.favorites.get(ctx.author.id, {}).get('tags', set()))), delete_after=10) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + await dest.send('**Added to global blacklist:**\n```\n{}```'.format(formatter.tostring(tags)), delete_after=5) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - @_get_favorite.command(name='posts', aliases=['p']) - async def __get_favorite_posts(self, ctx): - pass + @_add_tags.command(name='channel', aliases=['ch', 'c']) + @commands.has_permissions(manage_channels=True) + async def __add_channel_tags(self, ctx, *args): + kwargs = u.get_kwargs(ctx, args) + dest, tags = kwargs['destination'], kwargs['remaining'] - @favorite.group(name='add', aliases=['a']) - async def _add_favorite(self, ctx): - pass + guild = ctx.guild if isinstance( + ctx.guild, d.Guild) else ctx.channel - @_add_favorite.command(name='tags', aliases=['t']) - async def __add_favorite_tags(self, ctx, *args): - try: - kwargs = u.get_kwargs(ctx, args) - dest, tags = kwargs['destination'], kwargs['remaining'] + await dest.trigger_typing() - for tag in tags: - if tag in self.blacklists['user_blacklist'].get(ctx.author.id, set()): - raise exc.TagBlacklisted(tag) - if len(self.favorites[ctx.author.id]['tags']) + len(tags) > 5: - raise exc.BoundsError + self.blacklists['guild_blacklist'].setdefault( + guild.id, {}).setdefault(ctx.channel.id, set()).update(tags) + for tag in tags: + alias_request = await u.fetch('https://e621.net/tag_alias/index.json', params={'aliased_to': tag, 'approved': 'true'}, json=True) + if alias_request: + for dic in alias_request: + self.aliases.setdefault(tag, set()).add(dic['name']) + else: + self.aliases.setdefault(tag, set()) + u.dump(self.blacklists, 'cogs/blacklists.pkl') + u.dump(self.aliases, 'cogs/aliases.pkl') - self.favorites.setdefault(ctx.author.id, {}).setdefault('tags', set()).update(tags) - u.dump(self.favorites, 'cogs/favorites.pkl') + await dest.send('**Added to** {} **blacklist:**\n```\n{}```'.format(ctx.channel.mention, formatter.tostring(tags)), delete_after=5) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - await dest.send('{} **added to their favorites:**\n```\n{}```'.format(ctx.author.mention, formatter.tostring(tags)), delete_after=5) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + @_add_tags.command(name='me', aliases=['m']) + async def __add_user_tags(self, ctx, *args): + kwargs = u.get_kwargs(ctx, args) + dest, tags = kwargs['destination'], kwargs['remaining'] - except exc.BoundsError: - await ctx.send('**Favorites list currently limited to:** `5`', delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - except exc.TagBlacklisted as e: - await ctx.send('\N{NO ENTRY SIGN} `{}` **blacklisted.**', delete_after=10) - await ctx.message.add_reaction('\N{NO ENTRY SIGN}') + await dest.trigger_typing() - @_add_favorite.command(name='posts', aliases=['p']) - async def __add_favorite_posts(self, ctx, *posts): - pass + self.blacklists['user_blacklist'].setdefault(ctx.author.id, set()).update(tags) + for tag in tags: + alias_request = await u.fetch('https://e621.net/tag_alias/index.json', params={'aliased_to': tag, 'approved': 'true'}, json=True) + if alias_request: + for dic in alias_request: + self.aliases.setdefault(tag, set()).add(dic['name']) + else: + self.aliases.setdefault(tag, set()) + u.dump(self.blacklists, 'cogs/blacklists.pkl') + u.dump(self.aliases, 'cogs/aliases.pkl') - @favorite.group(name='remove', aliases=['r']) - async def _remove_favorite(self, ctx): - pass + await dest.send('{} **added to their blacklist:**\n```\n{}```'.format(ctx.author.mention, formatter.tostring(tags)), delete_after=5) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - @_remove_favorite.command(name='tags', aliases=['t']) - async def __remove_favorite_tags(self, ctx, *args): - try: - kwargs = u.get_kwargs(ctx, args) - dest, tags = kwargs['destination'], kwargs['remaining'] + @blacklist.group(name='remove', aliases=['rm', 'r']) + async def _remove_tags(self, ctx): + if ctx.invoked_subcommand is None: + await ctx.send('**Invalid blacklist.**', delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') - for tag in tags: + @_remove_tags.command(name='global', aliases=['gl', 'g']) + @commands.is_owner() + async def __remove_global_tags(self, ctx, *args): try: - self.favorites[ctx.author.id].get('tags', set()).remove(tag) + kwargs = u.get_kwargs(ctx, args) + dest, tags = kwargs['destination'], kwargs['remaining'] - except KeyError: - raise exc.TagError(tag) + for tag in tags: + try: + self.blacklists['global_blacklist'].remove(tag) - u.dump(self.favorites, 'cogs/favorites.pkl') + except KeyError: + raise exc.TagError(tag) - await dest.send('{} **removed from their favorites:**\n```\n{}```'.format(ctx.author.mention, formatter.tostring(tags)), delete_after=5) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + u.dump(self.blacklists, 'cogs/blacklists.pkl') - except exc.TagError as e: - await ctx.send('`{}` **not in favorites.**'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') + await dest.send('**Removed from global blacklist:**\n```\n{}```'.format(formatter.tostring(tags)), delete_after=5) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - @_remove_favorite.command(name='posts', aliases=['p']) - async def __remove_favorite_posts(self, ctx): - pass + except exc.TagError as e: + await ctx.send('`{}` **not in blacklist.**'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') - @favorite.group(name='clear', aliases=['c']) - async def _clear_favorite(self, ctx): - pass - - @_clear_favorite.command(name='tags', aliases=['t']) - async def __clear_favorite_tags(self, ctx, *args): - dest = u.get_kwargs(ctx, args)['destination'] - - with suppress(KeyError): - del self.favorites[ctx.author.id] - u.dump(self.favorites, 'cogs/favorites.pkl') - - await dest.send('{}**\'s favorites cleared.**'.format(ctx.author.mention), delete_after=5) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - @_clear_favorite.command(name='posts', aliases=['p']) - async def __clear_favorite_posts(self, ctx): - pass - - # Umbrella command structure to manage global, channel, and user blacklists - @commands.group(aliases=['bl', 'b'], brief='Manage blacklists', description='Blacklist base command for managing blacklists\n\n`bl get [blacklist]` to show a blacklist\n`bl set [blacklist] [tags]` to replace a blacklist\n`bl clear [blacklist]` to clear a blacklist\n`bl add [blacklist] [tags]` to add tags to a blacklist\n`bl remove [blacklist] [tags]` to remove tags from a blacklist', usage='[flag] [blacklist] ([tags])') - @checks.del_ctx() - async def blacklist(self, ctx): - if ctx.invoked_subcommand is None: - await ctx.send('**Use a flag to manage blacklists.**\n*Type* `{}help bl` *for more info.*'.format(ctx.prefix), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - - # @blacklist.error - # async def blacklist_error(self, ctx, error): - # if isinstance(error, KeyError): - # return await ctx.send('**Blacklist does not exist.**', delete_after=10) - - @blacklist.group(name='get', aliases=['g']) - async def _get_blacklist(self, ctx): - if ctx.invoked_subcommand is None: - await ctx.send('**Invalid blacklist.**', delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - - @_get_blacklist.command(name='global', aliases=['gl', 'g']) - async def __get_global_blacklist(self, ctx, *args): - dest = u.get_kwargs(ctx, args)['destination'] - - await dest.send('\N{NO ENTRY SIGN} **Global blacklist:**\n```\n{}```'.format(formatter.tostring(self.blacklists['global_blacklist']))) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - @_get_blacklist.command(name='channel', aliases=['ch', 'c']) - async def __get_channel_blacklist(self, ctx, *args): - dest = u.get_kwargs(ctx, args)['destination'] - - guild = ctx.guild if isinstance( - ctx.guild, d.Guild) else ctx.channel - - await dest.send('\N{NO ENTRY SIGN} {} **blacklist:**\n```\n{}```'.format(ctx.channel.mention, formatter.tostring(self.blacklists['guild_blacklist'].get(guild.id, {}).get(ctx.channel.id, set())))) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - @_get_blacklist.command(name='me', aliases=['m']) - async def __get_user_blacklist(self, ctx, *args): - dest = u.get_kwargs(ctx, args)['destination'] - - await dest.send('\N{NO ENTRY SIGN} {}**\'s blacklist:**\n```\n{}```'.format(ctx.author.mention, formatter.tostring(self.blacklists['user_blacklist'].get(ctx.author.id, set()))), delete_after=10) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - @_get_blacklist.command(name='here', aliases=['h']) - async def __get_here_blacklists(self, ctx, *args): - dest = u.get_kwargs(ctx, args)['destination'] - - guild = ctx.guild if isinstance( - ctx.guild, d.Guild) else ctx.channel - - await dest.send('\N{NO ENTRY SIGN} **__Blacklisted:__**\n\n**Global:**\n```\n{}```\n**{}:**\n```\n{}```'.format(formatter.tostring(self.blacklists['global_blacklist']), ctx.channel.mention, formatter.tostring(self.blacklists['guild_blacklist'].get(guild.id, {}).get(ctx.channel.id, set())))) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - @_get_blacklist.group(name='all', aliases=['a']) - async def __get_all_blacklists(self, ctx): - if ctx.invoked_subcommand is None: - await ctx.send('**Invalid blacklist.**') - await ctx.message.add_reaction('\N{CROSS MARK}') - - @__get_all_blacklists.command(name='guild', aliases=['g']) - @commands.has_permissions(manage_channels=True) - async def ___get_all_guild_blacklists(self, ctx, *args): - dest = u.get_kwargs(ctx, args)['destination'] - - guild = ctx.guild if isinstance( - ctx.guild, d.Guild) else ctx.channel - - await dest.send('\N{NO ENTRY SIGN} **__{} blacklists:__**\n\n{}'.format(guild.name, formatter.dict_tostring(self.blacklists['guild_blacklist'].get(guild.id, {})))) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - @__get_all_blacklists.command(name='user', aliases=['u', 'member', 'm']) - @commands.is_owner() - async def ___get_all_user_blacklists(self, ctx, *args): - dest = u.get_kwargs(ctx, args)['destination'] - - await dest.send('\N{NO ENTRY SIGN} **__User blacklists:__**\n\n{}'.format(formatter.dict_tostring(self.blacklists['user_blacklist']))) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - @blacklist.group(name='add', aliases=['a']) - async def _add_tags(self, ctx): - if ctx.invoked_subcommand is None: - await ctx.send('**Invalid blacklist.**', delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - - @_add_tags.command(name='global', aliases=['gl', 'g']) - @commands.is_owner() - async def __add_global_tags(self, ctx, *args): - kwargs = u.get_kwargs(ctx, args) - dest, tags = kwargs['destination'], kwargs['remaining'] - - await dest.trigger_typing() - - self.blacklists['global_blacklist'].update(tags) - for tag in tags: - alias_request = await u.fetch('https://e621.net/tag_alias/index.json', params={'aliased_to': tag, 'approved': 'true'}, json=True) - if alias_request: - for dic in alias_request: - self.aliases.setdefault(tag, set()).add(dic['name']) - else: - self.aliases.setdefault(tag, set()) - u.dump(self.blacklists, 'cogs/blacklists.pkl') - u.dump(self.aliases, 'cogs/aliases.pkl') - - await dest.send('**Added to global blacklist:**\n```\n{}```'.format(formatter.tostring(tags)), delete_after=5) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - @_add_tags.command(name='channel', aliases=['ch', 'c']) - @commands.has_permissions(manage_channels=True) - async def __add_channel_tags(self, ctx, *args): - kwargs = u.get_kwargs(ctx, args) - dest, tags = kwargs['destination'], kwargs['remaining'] - - guild = ctx.guild if isinstance( - ctx.guild, d.Guild) else ctx.channel - - await dest.trigger_typing() - - self.blacklists['guild_blacklist'].setdefault( - guild.id, {}).setdefault(ctx.channel.id, set()).update(tags) - for tag in tags: - alias_request = await u.fetch('https://e621.net/tag_alias/index.json', params={'aliased_to': tag, 'approved': 'true'}, json=True) - if alias_request: - for dic in alias_request: - self.aliases.setdefault(tag, set()).add(dic['name']) - else: - self.aliases.setdefault(tag, set()) - u.dump(self.blacklists, 'cogs/blacklists.pkl') - u.dump(self.aliases, 'cogs/aliases.pkl') - - await dest.send('**Added to** {} **blacklist:**\n```\n{}```'.format(ctx.channel.mention, formatter.tostring(tags)), delete_after=5) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - @_add_tags.command(name='me', aliases=['m']) - async def __add_user_tags(self, ctx, *args): - kwargs = u.get_kwargs(ctx, args) - dest, tags = kwargs['destination'], kwargs['remaining'] - - await dest.trigger_typing() - - self.blacklists['user_blacklist'].setdefault(ctx.author.id, set()).update(tags) - for tag in tags: - alias_request = await u.fetch('https://e621.net/tag_alias/index.json', params={'aliased_to': tag, 'approved': 'true'}, json=True) - if alias_request: - for dic in alias_request: - self.aliases.setdefault(tag, set()).add(dic['name']) - else: - self.aliases.setdefault(tag, set()) - u.dump(self.blacklists, 'cogs/blacklists.pkl') - u.dump(self.aliases, 'cogs/aliases.pkl') - - await dest.send('{} **added to their blacklist:**\n```\n{}```'.format(ctx.author.mention, formatter.tostring(tags)), delete_after=5) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - @blacklist.group(name='remove', aliases=['rm', 'r']) - async def _remove_tags(self, ctx): - if ctx.invoked_subcommand is None: - await ctx.send('**Invalid blacklist.**', delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') - - @_remove_tags.command(name='global', aliases=['gl', 'g']) - @commands.is_owner() - async def __remove_global_tags(self, ctx, *args): - try: - kwargs = u.get_kwargs(ctx, args) - dest, tags = kwargs['destination'], kwargs['remaining'] - - for tag in tags: + @_remove_tags.command(name='channel', aliases=['ch', 'c']) + @commands.has_permissions(manage_channels=True) + async def __remove_channel_tags(self, ctx, *args): try: - self.blacklists['global_blacklist'].remove(tag) + kwargs = u.get_kwargs(ctx, args) + dest, tags = kwargs['destination'], kwargs['remaining'] - except KeyError: - raise exc.TagError(tag) + guild = ctx.guild if isinstance( + ctx.guild, d.Guild) else ctx.channel - u.dump(self.blacklists, 'cogs/blacklists.pkl') + for tag in tags: + try: + self.blacklists['guild_blacklist'][guild.id][ctx.channel.id].remove(tag) - await dest.send('**Removed from global blacklist:**\n```\n{}```'.format(formatter.tostring(tags)), delete_after=5) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + except KeyError: + raise exc.TagError(tag) - except exc.TagError as e: - await ctx.send('`{}` **not in blacklist.**'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') + u.dump(self.blacklists, 'cogs/blacklists.pkl') - @_remove_tags.command(name='channel', aliases=['ch', 'c']) - @commands.has_permissions(manage_channels=True) - async def __remove_channel_tags(self, ctx, *args): - try: - kwargs = u.get_kwargs(ctx, args) - dest, tags = kwargs['destination'], kwargs['remaining'] + await dest.send('**Removed from** {} **blacklist:**\n```\n{}```'.format(ctx.channel.mention, formatter.tostring(tags), delete_after=5)) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - guild = ctx.guild if isinstance( - ctx.guild, d.Guild) else ctx.channel + except exc.TagError as e: + await ctx.send('`{}` **not in blacklist.**'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') - for tag in tags: + @_remove_tags.command(name='me', aliases=['m']) + async def __remove_user_tags(self, ctx, *args): try: - self.blacklists['guild_blacklist'][guild.id][ctx.channel.id].remove(tag) + kwargs = u.get_kwargs(ctx, args) + dest, tags = kwargs['destination'], kwargs['remaining'] - except KeyError: - raise exc.TagError(tag) + for tag in tags: + try: + self.blacklists['user_blacklist'][ctx.author.id].remove(tag) - u.dump(self.blacklists, 'cogs/blacklists.pkl') + except KeyError: + raise exc.TagError(tag) - await dest.send('**Removed from** {} **blacklist:**\n```\n{}```'.format(ctx.channel.mention, formatter.tostring(tags), delete_after=5)) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + u.dump(self.blacklists, 'cogs/blacklists.pkl') - except exc.TagError as e: - await ctx.send('`{}` **not in blacklist.**'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') + await dest.send('{} **removed from their blacklist:**\n```\n{}```'.format(ctx.author.mention, formatter.tostring(tags)), delete_after=5) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - @_remove_tags.command(name='me', aliases=['m']) - async def __remove_user_tags(self, ctx, *args): - try: - kwargs = u.get_kwargs(ctx, args) - dest, tags = kwargs['destination'], kwargs['remaining'] + except exc.TagError as e: + await ctx.send('`{}` **not in blacklist.**'.format(e), delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') - for tag in tags: - try: - self.blacklists['user_blacklist'][ctx.author.id].remove(tag) + @blacklist.group(name='clear', aliases=['cl', 'c']) + async def _clear_blacklist(self, ctx): + if ctx.invoked_subcommand is None: + await ctx.send('**Invalid blacklist.**', delete_after=10) + await ctx.message.add_reaction('\N{CROSS MARK}') - except KeyError: - raise exc.TagError(tag) + @_clear_blacklist.command(name='global', aliases=['gl', 'g']) + @commands.is_owner() + async def __clear_global_blacklist(self, ctx, *args): + dest = u.get_kwargs(ctx, args)['destination'] - u.dump(self.blacklists, 'cogs/blacklists.pkl') + self.blacklists['global_blacklist'].clear() + u.dump(self.blacklists, 'cogs/blacklists.pkl') - await dest.send('{} **removed from their blacklist:**\n```\n{}```'.format(ctx.author.mention, formatter.tostring(tags)), delete_after=5) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + await dest.send('**Global blacklist cleared.**', delete_after=5) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - except exc.TagError as e: - await ctx.send('`{}` **not in blacklist.**'.format(e), delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') + @_clear_blacklist.command(name='channel', aliases=['ch', 'c']) + @commands.has_permissions(manage_channels=True) + async def __clear_channel_blacklist(self, ctx, *args): + dest = u.get_kwargs(ctx, args)['destination'] - @blacklist.group(name='clear', aliases=['cl', 'c']) - async def _clear_blacklist(self, ctx): - if ctx.invoked_subcommand is None: - await ctx.send('**Invalid blacklist.**', delete_after=10) - await ctx.message.add_reaction('\N{CROSS MARK}') + guild = ctx.guild if isinstance( + ctx.guild, d.Guild) else ctx.channel - @_clear_blacklist.command(name='global', aliases=['gl', 'g']) - @commands.is_owner() - async def __clear_global_blacklist(self, ctx, *args): - dest = u.get_kwargs(ctx, args)['destination'] + with suppress(KeyError): + del self.blacklists['guild_blacklist'][guild.id][ctx.channel.id] + u.dump(self.blacklists, 'cogs/blacklists.pkl') - self.blacklists['global_blacklist'].clear() - u.dump(self.blacklists, 'cogs/blacklists.pkl') + await dest.send('{} **blacklist cleared.**'.format(ctx.channel.mention), delete_after=5) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - await dest.send('**Global blacklist cleared.**', delete_after=5) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + @_clear_blacklist.command(name='me', aliases=['m']) + async def __clear_user_blacklist(self, ctx, *args): + dest = u.get_kwargs(ctx, args)['destination'] - @_clear_blacklist.command(name='channel', aliases=['ch', 'c']) - @commands.has_permissions(manage_channels=True) - async def __clear_channel_blacklist(self, ctx, *args): - dest = u.get_kwargs(ctx, args)['destination'] + with suppress(KeyError): + del self.blacklists['user_blacklist'][ctx.author.id] + u.dump(self.blacklists, 'cogs/blacklists.pkl') - guild = ctx.guild if isinstance( - ctx.guild, d.Guild) else ctx.channel - - with suppress(KeyError): - del self.blacklists['guild_blacklist'][guild.id][ctx.channel.id] - u.dump(self.blacklists, 'cogs/blacklists.pkl') - - await dest.send('{} **blacklist cleared.**'.format(ctx.channel.mention), delete_after=5) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') - - @_clear_blacklist.command(name='me', aliases=['m']) - async def __clear_user_blacklist(self, ctx, *args): - dest = u.get_kwargs(ctx, args)['destination'] - - with suppress(KeyError): - del self.blacklists['user_blacklist'][ctx.author.id] - u.dump(self.blacklists, 'cogs/blacklists.pkl') - - await dest.send('{}**\'s blacklist cleared.**'.format(ctx.author.mention), delete_after=5) - await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}') + await dest.send('{}**\'s blacklist cleared.**'.format(ctx.author.mention), delete_after=5) + await ctx.message.add_reaction('\N{WHITE HEAVY CHECK MARK}')