Await bot.add_cog

* [RSS] Fix for media_plaintext tag (#263)

* [Wolfram] Allow very long answers

* [DiscordExperiments] Add new activities and update names (#268)

* [DiscordExperiments] Add missing activities

* [DiscordExperiments] update Letter Tile name to Letter League

* [DiscordExperiments] update Doodle Crew to Sketch Heads

Doodle Crew is obsolete

* fix(rss): message longer than 2000 in listtags (#265)

* Add reward feature for shot birbs (#262)

* Add reward feature for shot birbs

Adds the option to set a reward range(min-max) of currency to be given out on a successfully shot birb. Properly handles whether bank is global or not as well

* make it so they can specify 0 as the minimum

users can specify 0 as the minimum reward range

Co-authored-by: Karlo Prikratki <karlo@karloprikratki.com>
Co-authored-by: Julien Mauroy <61093863+Predeactor@users.noreply.github.com>
Co-authored-by: Alex <58824393+vertyco@users.noreply.github.com>

antiphoneclapper/__init__.py

@@ -1,7 +0,0 @@
-from .antiphoneclapper import AntiPhoneClapper
-
-__red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
-
-
-async def setup(bot):
-    bot.add_cog(AntiPhoneClapper(bot))

antiphoneclapper/antiphoneclapper.py

@@ -1,118 +0,0 @@
-from PIL import Image
-from io import BytesIO
-import aiohttp
-import discord
-import logging
-
-from redbot.core import commands, checks, Config
-
-
-log = logging.getLogger("red.aikaterna.antiphoneclapper")
-
-
-class AntiPhoneClapper(commands.Cog):
-    """This cog deletes bad GIFs that will crash phone clients."""
-
-    async def red_delete_data_for_user(self, **kwargs):
-        """ Nothing to delete """
-        return
-
-    def __init__(self, bot):
-        self.bot = bot
-        self.session = aiohttp.ClientSession()
-        self.config = Config.get_conf(self, 2719371001, force_registration=True)
-
-        default_guild = {"watching": []}
-
-        self.config.register_guild(**default_guild)
-
-    @commands.group()
-    @checks.mod_or_permissions(administrator=True)
-    @commands.guild_only()
-    async def nogif(self, ctx):
-        """Configuration options."""
-        pass
-
-    @nogif.command()
-    async def watch(self, ctx, channel: discord.TextChannel):
-        """
-        Add a channel to watch. 
-        Gif attachments that break mobile clients will be removed in these channels.
-        """
-        channel_list = await self.config.guild(ctx.guild).watching()
-        if channel.id not in channel_list:
-            channel_list.append(channel.id)
-        await self.config.guild(ctx.guild).watching.set(channel_list)
-        await ctx.send(f"{self.bot.get_channel(channel.id).mention} will have bad gifs removed.")
-
-    @nogif.command()
-    async def watchlist(self, ctx):
-        """List the channels being watched."""
-        channel_list = await self.config.guild(ctx.guild).watching()
-        msg = "Bad gifs will be removed in:\n"
-        for channel in channel_list:
-            channel_obj = self.bot.get_channel(channel)
-            if channel_obj is None:  # Catch deleted/unexisting channels
-                continue
-            msg += f"{channel_obj.mention}\n"
-        await ctx.send(msg)
-
-    @nogif.command()
-    async def unwatch(self, ctx, channel: discord.TextChannel):
-        """Remove a channel from the watch list."""
-        channel_list = await self.config.guild(ctx.guild).watching()
-        if channel.id in channel_list:
-            channel_list.remove(channel.id)
-        else:
-            return await ctx.send("Channel is not being watched.")
-        await self.config.guild(ctx.guild).watching.set(channel_list)
-        await ctx.send(f"{self.bot.get_channel(channel.id).mention} will not have bad gifs removed.")
-
-    def is_phone_clapper(self, im):
-        limit = im.size
-        tile_sizes = []
-        for frame in range(im.n_frames):
-            im.seek(frame)
-            tile_sizes.append(im.tile[0][1][2:])
-        return any([x[0] > limit[0] or x[1] > limit[1] for x in tile_sizes])
-
-    @commands.Cog.listener()
-    async def on_message(self, m):
-        if not m.attachments:
-            return
-        if isinstance(m.channel, discord.abc.PrivateChannel):
-            return
-        if m.author.bot:
-            return
-        watch_channel_list = await self.config.guild(m.guild).watching()
-        if not watch_channel_list:
-            return
-        if m.channel.id not in watch_channel_list:
-            return
-        for att in m.attachments:
-            if not att.filename.endswith(".gif") or att.size > 200000:
-                continue
-
-            async with self.session.get(att.url) as resp:
-                data = await resp.content.read()
-                f = BytesIO(data)
-                try:
-                    img = Image.open(f)
-                    phone_clapper = self.is_phone_clapper(img)
-                except Image.DecompressionBombError:
-                    phone_clapper = True
-
-            if phone_clapper:
-                try:
-                    await m.delete()
-                    await m.channel.send(f"{m.author.mention} just tried to send a phone-killing GIF and I removed it.")
-                    return
-                except discord.errors.Forbidden:
-                    await m.channel.send(f"Don't send GIFs that do that, {m.author.mention}")
-                    log.debug(f"Failed to delete message ({m.id}) that contained phone killing gif")
-                    return
-            else:
-                return
-
-    def cog_unload(self):
-        self.bot.loop.create_task(self.session.close())

antiphoneclapper/info.json

@@ -1,12 +0,0 @@
-{
-    "author": ["sitryk", "aikaterna"],
-    "description": "Deletes messages with malformed GIFs.",
-    "install_msg": "Thanks for installing, have fun.",
-    "permissions" : ["manage_messages"],
-    "requirements": ["pillow"],
-    "hidden": true,
-    "disabled": true,
-    "short": "Deletes messages with malformed GIFs.",
-    "type": "COG",
-    "end_user_data_statement": "This cog does not persistently store data or metadata about users."
-}

away/__init__.py

@@ -12,5 +12,5 @@ __red_end_user_data_statement__ = (
 )
 
 
-def setup(bot):
-    bot.add_cog(Away(bot))
+async def setup(bot):
+    await bot.add_cog(Away(bot))

away/away.py

@@ -1,7 +1,6 @@
 import discord
 from redbot.core import Config, commands, checks
 from typing import Optional, Literal
-import datetime
 import re
 
 IMAGE_LINKS = re.compile(r"(http[s]?:\/\/[^\"\']*\.(?:png|jpg|jpeg|gif|png))")
@@ -37,7 +36,7 @@ class Away(commands.Cog):
     def _draw_play(self, song):
         song_start_time = song.start
         total_time = song.duration
-        current_time = datetime.datetime.utcnow()
+        current_time = discord.utils.utcnow()
         elapsed_time = current_time - song_start_time
         sections = 12
         loc_time = round((elapsed_time / total_time) * sections)  # 10 sections
@@ -60,7 +59,7 @@ class Away(commands.Cog):
         """
             Makes the embed reply
         """
-        avatar = author.avatar_url_as()  # This will return default avatar if no avatar is present
+        avatar = author.display_avatar  # This will return default avatar if no avatar is present
         color = author.color
         if message:
             link = IMAGE_LINKS.search(message)
@@ -226,7 +225,7 @@ class Away(commands.Cog):
         return False
 
     @commands.Cog.listener()
-    async def on_message(self, message: discord.Message):
+    async def on_message_without_command(self, message: discord.Message):
         guild = message.guild
         if not guild or not message.mentions or message.author.bot:
             return
@@ -667,7 +666,7 @@ class Away(commands.Cog):
 
         if ctx.channel.permissions_for(ctx.me).embed_links:
             em = discord.Embed(description=msg[:2048], color=author.color)
-            em.set_author(name=f"{author.display_name}'s away settings", icon_url=author.avatar_url)
+            em.set_author(name=f"{author.display_name}'s away settings", icon_url=author.avatar.url)
             await ctx.send(embed=em)
         else:
             await ctx.send(f"{author.display_name} away settings\n" + msg)

blurplefy/__init__.py

@@ -3,5 +3,5 @@ from .blurplefy import Blurplefy
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(Blurplefy(bot))
+async def setup(bot):
+    await bot.add_cog(Blurplefy(bot))

blurplefy/blurplefy.py

@@ -85,14 +85,14 @@ class Blurplefy(commands.Cog):
         await ctx.send("{}, starting blurple image analysis.".format(ctx.message.author.mention))
         link = ctx.message.attachments
         if user is None and not link:
-            picture = ctx.author.avatar_url
+            picture = ctx.author.avatar.url
         else:
             if not user:
                 if len(link) != 0:
                     for image in link:
                         picture = image.url
             else:
-                picture = user.avatar_url
+                picture = user.avatar.url
         try:
             async with self.session.request("GET", str(picture)) as r:
                 response = await r.read()
@@ -109,7 +109,7 @@ class Blurplefy(commands.Cog):
         await ctx.send("{}, starting blurple image analysis.".format(ctx.message.author.mention))
         link = ctx.message.attachments
         if user is None and not link:
-            picture = ctx.author.avatar_url
+            picture = ctx.author.avatar.url
             role_check = True
         elif not user:
             if len(link) != 0:
@@ -117,7 +117,7 @@ class Blurplefy(commands.Cog):
                     picture = image.url
                     role_check = False
         else:
-            picture = user.avatar_url
+            picture = user.avatar.url
             role_check = False
 
         try:
@@ -180,7 +180,7 @@ class Blurplefy(commands.Cog):
             blurple_role_obj = discord.utils.get(ctx.guild.roles, id=blurple_role_id)
             if (
                 blurplenesspercentage > 75
-                and picture == ctx.author.avatar_url
+                and picture == ctx.author.avatar.url
                 and blurple_role_obj not in ctx.author.roles
                 and percentblurple > 5
             ):
@@ -190,7 +190,7 @@ class Blurplefy(commands.Cog):
                     )
                 )
                 await ctx.author.add_roles(blurple_role_obj)
-            elif picture == ctx.author.avatar_url and blurple_role_obj not in ctx.author.roles:
+            elif picture == ctx.author.avatar.url and blurple_role_obj not in ctx.author.roles:
                 await ctx.send(
                     "{}, your profile pic does not have enough blurple (over 75% in total and over 5% blurple), therefore you are not eligible for the role {}.".format(
                         ctx.message.author.display_name, blurple_role_obj.name
@@ -206,14 +206,14 @@ class Blurplefy(commands.Cog):
         await ctx.send("{}, starting blurple image analysis.".format(ctx.message.author.mention))
         link = ctx.message.attachments
         if user is None and not link:
-            picture = ctx.author.avatar_url
+            picture = ctx.author.avatar.url
         else:
             if not user:
                 if len(link) != 0:
                     for image in link:
                         picture = image.url
             else:
-                picture = user.avatar_url
+                picture = user.avatar.url
         try:
             async with self.session.request("GET", str(picture)) as r:
                 response = await r.read()
@@ -380,12 +380,14 @@ class Blurplefy(commands.Cog):
     @commands.command()
     async def countdown(self, ctx):
         """Countdown to Discord's 7th Anniversary."""
-        embed = discord.Embed(name="", colour=0x7289DA)
-        timeleft = datetime.datetime(2021, 5, 13) + datetime.timedelta(hours=7) - datetime.datetime.utcnow()
-        embed.set_author(name="Time left until Discord's 6th Anniversary")
+        embed = discord.Embed()
+        embed.description="\N{ZERO WIDTH SPACE}"
+        embed.colour=0x7289DA
+        timeleft = datetime.datetime(2021, 5, 13, tzinfo=datetime.timezone.utc) + datetime.timedelta(hours=7) - discord.utils.utcnow()
+        embed.set_author(name="Time left until Discord's 7th Anniversary")
         if int(timeleft.total_seconds()) < 0:
-            timeleft = datetime.datetime(2022, 5, 13) + datetime.timedelta(hours=7) - datetime.datetime.utcnow()
-            embed.set_author(name="Time left until Discord's 6th Anniversary")
+            timeleft = datetime.datetime(2022, 5, 13, tzinfo=datetime.timezone.utc) + datetime.timedelta(hours=7) - discord.utils.utcnow()
+            embed.set_author(name="Time left until Discord's 7th Anniversary")
         embed.add_field(
             name="Countdown to midnight, May 13, California time (UTC-7):",
             value=("{}".format(self._dynamic_time(int(timeleft.total_seconds())))),

cah/__init__.py

@@ -3,5 +3,5 @@ from .cah import CardsAgainstHumanity
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(CardsAgainstHumanity(bot))
+async def setup(bot):
+    await bot.add_cog(CardsAgainstHumanity(bot))

cah/cah.py

@@ -374,7 +374,11 @@ class CardsAgainstHumanity(commands.Cog):
                     member["Task"] = None
         # Set running to false
         game["Running"] = False
-        self.games.remove(game)
+        try:
+            self.games.remove(game)
+        except ValueError:
+            # game was in progress but players left, leaving the open game with less than 3 people
+            pass
         return False
 
     async def typing(self, game, typeTime=5):
@@ -702,7 +706,7 @@ class CardsAgainstHumanity(commands.Cog):
         await self.sendToUser(user, msg)
 
     async def drawCard(self, game):
-        with open(str(bundled_data_path(self)) + "/deck.json", "r") as deck_file:
+        with open(str(bundled_data_path(self)) + "/deck.json", "r", encoding='utf-8') as deck_file:
             deck = json.load(deck_file)
         # Draws a random unused card and shuffles the deck if needed
         totalDiscard = len(game["Discard"])
@@ -752,7 +756,7 @@ class CardsAgainstHumanity(commands.Cog):
                     i += 1
 
     async def drawBCard(self, game):
-        with open(str(bundled_data_path(self)) + "/deck.json", "r") as deck_file:
+        with open(str(bundled_data_path(self)) + "/deck.json", "r", encoding='utf-8') as deck_file:
             deck = json.load(deck_file)
         # Draws a random black card
         totalDiscard = len(game["BDiscard"])
@@ -890,7 +894,11 @@ class CardsAgainstHumanity(commands.Cog):
         if message == None:
             msg = "Ooookay, you say *nothing...*"
             return await self.sendToUser(ctx.author, msg)
+        long_message = False
         msg = f"*{ctx.author.name}* says: {message}"
+        if len(msg) > 1999:
+            msg = msg[:1990] + " [...]"
+            long_message = True
         for member in userGame["Members"]:
             if member["IsBot"]:
                 continue
@@ -901,7 +909,10 @@ class CardsAgainstHumanity(commands.Cog):
             else:
                 # Update member's time
                 member["Time"] = int(time.time())
-        await self.sendToUser(ctx.author, "Message sent!")
+        msg = "Message sent!"
+        if long_message:
+            msg += " Your message was cut short to keep it under the 2000 character limit."
+        await self.sendToUser(ctx.author, msg)
 
     @commands.command()
     async def lay(self, ctx, *, card=None):
@@ -1069,7 +1080,7 @@ class CardsAgainstHumanity(commands.Cog):
         """Starts a new Cards Against Humanity game."""
         try:
             embed = discord.Embed(color=discord.Color.green())
-            embed.set_author(name="**Setting up the game...**")
+            embed.set_author(name="Setting up the game...")
             await ctx.author.send(embed=embed)
         except discord.errors.Forbidden:
             return await ctx.send("You must allow Direct Messages from the bot for this game to work.")

chatchart/__init__.py

@@ -3,5 +3,5 @@ from .chatchart import Chatchart
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(Chatchart(bot))
+async def setup(bot):
+    await bot.add_cog(Chatchart(bot))

dadjokes/__init__.py

@@ -3,5 +3,5 @@ from .dadjokes import DadJokes
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(DadJokes(bot))
+async def setup(bot):
+    await bot.add_cog(DadJokes(bot))

dictionary/__init__.py

@@ -3,5 +3,5 @@ from .dictionary import Dictionary
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(Dictionary(bot))
+async def setup(bot):
+    await bot.add_cog(Dictionary(bot))

discordexperiments/__init__.py

@@ -3,5 +3,5 @@ from .discordexperiments import DiscordExperiments
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(DiscordExperiments(bot))
+async def setup(bot):
+    await bot.add_cog(DiscordExperiments(bot))

discordexperiments/discordexperiments.py

@@ -90,24 +90,24 @@ class DiscordExperiments(commands.Cog):
 
     @commands.cooldown(1, 10, discord.ext.commands.BucketType.guild)
     @commands.command()
-    async def doodlecrew(self, ctx, invite_max_age_in_seconds=86400):
+    async def sketchheads(self, ctx, invite_max_age_in_seconds=86400):
         """
-        Create a Doodle Crew voice channel invite.
+        Create a Sketch Heads voice channel invite.
 
         Use `0` for `invite_max_age_in_seconds` if you want the invite to be permanent.
         """
-        app_name = "the Doodle Crew game"
-        await self._create_invite(ctx, 878067389634314250, invite_max_age_in_seconds, app_name)
+        app_name = "the Sketch Heads game"
+        await self._create_invite(ctx, 902271654783242291, invite_max_age_in_seconds, app_name)
 
     @commands.cooldown(1, 10, discord.ext.commands.BucketType.guild)
     @commands.command()
-    async def lettertile(self, ctx, invite_max_age_in_seconds=86400):
+    async def letterleague(self, ctx, invite_max_age_in_seconds=86400):
         """
-        Create a Letter Tile voice channel invite.
+        Create a Letter League voice channel invite.
 
         Use `0` for `invite_max_age_in_seconds` if you want the invite to be permanent.
         """
-        app_name = "the Letter Tile game"
+        app_name = "the Letter League game"
         await self._create_invite(ctx, 879863686565621790, invite_max_age_in_seconds, app_name)
 
     @commands.cooldown(1, 10, discord.ext.commands.BucketType.guild)
@@ -142,3 +142,33 @@ class DiscordExperiments(commands.Cog):
         """
         app_name = "Checkers in the Park"
         await self._create_invite(ctx, 832013003968348200, invite_max_age_in_seconds, app_name)
+
+    @commands.cooldown(1, 10, discord.ext.commands.BucketType.guild)
+    @commands.command()
+    async def blazing8s(self, ctx, invite_max_age_in_seconds=86400):
+        """
+        Create a Blazing 8s voice channel invite.
+        Use `0` for `invite_max_age_in_seconds` if you want the invite to be permanent.
+        """
+        app_name = "Blazing 8s"
+        await self._create_invite(ctx, 832025144389533716, invite_max_age_in_seconds, app_name)
+
+    @commands.cooldown(1, 10, discord.ext.commands.BucketType.guild)
+    @commands.command()
+    async def puttparty(self, ctx, invite_max_age_in_seconds=86400):
+        """
+        Create a Putt Party voice channel invite.
+        Use `0` for `invite_max_age_in_seconds` if you want the invite to be permanent.
+        """
+        app_name = "Putt Party"
+        await self._create_invite(ctx, 945737671223947305, invite_max_age_in_seconds, app_name)
+
+    @commands.cooldown(1, 10, discord.ext.commands.BucketType.guild)
+    @commands.command()
+    async def landio(self, ctx, invite_max_age_in_seconds=86400):
+        """
+        Create a Land-io voice channel invite.
+        Use `0` for `invite_max_age_in_seconds` if you want the invite to be permanent.
+        """
+        app_name = "Land-io"
+        await self._create_invite(ctx, 903769130790969345, invite_max_age_in_seconds, app_name)

dungeon/__init__.py

@@ -1,9 +0,0 @@
-from .dungeon import Dungeon
-
-__red_end_user_data_statement__ = (
-    "This cog does not persistently store end user data. " "This cog does store discord IDs as needed for operation. "
-)
-
-
-def setup(bot):
-    bot.add_cog(Dungeon(bot))

dungeon/dungeon.py

@@ -1,535 +0,0 @@
-import datetime
-from typing import Literal
-
-import discord
-import logging
-from redbot.core import Config, commands, checks, modlog
-from redbot.core.utils.chat_formatting import box, pagify
-
-
-log = logging.getLogger("red.aikaterna.dungeon")
-
-
-class Dungeon(commands.Cog):
-    """Auto-quarantine suspicious users."""
-
-    async def red_delete_data_for_user(
-        self, *, requester: Literal["discord", "owner", "user", "user_strict"], user_id: int,
-    ):
-        if requester == "discord":
-            # user is deleted, just comply
-
-            data = await self.config.all_guilds()
-            for guild_id, guild_data in data.items():
-                if user_id in guild_data.get("bypass", []):
-                    bypass = guild_data.get("bypass", [])
-                    bypass = set(bypass)
-                    bypass.discard(user_id)
-                    await self.config.guild_from_id(guild_id).bypass.set(list(bypass))
-
-    def __init__(self, bot):
-        self.bot = bot
-        self.config = Config.get_conf(self, 2700081001, force_registration=True)
-
-        default_guild = {
-            "announce_channel": None,
-            "auto_ban": False,
-            "auto_ban_message": None,
-            "auto_blacklist": False,
-            "bypass": [],
-            "dm_message": None,
-            "dm_toggle": False,
-            "dungeon_channel": None,
-            "dungeon_role": None,
-            "join_days": 7,
-            "mod_log": False,
-            "profile_toggle": False,
-            "toggle": False,
-            "user_role": None,
-            "user_role_toggle": False,
-        }
-
-        self.config.register_guild(**default_guild)
-
-    @checks.mod_or_permissions(administrator=True)
-    @commands.command()
-    async def banish(self, ctx, user: discord.Member):
-        """Strip a user of their roles, apply the dungeon role, and blacklist them.
-		If the blacklist toggle is off, the user will not be blacklisted from the bot."""
-        data = await self.config.guild(ctx.guild).all()
-        blacklist = data["auto_blacklist"]
-        dungeon_role_id = data["dungeon_role"]
-        dungeon_role_obj = discord.utils.get(ctx.guild.roles, id=dungeon_role_id)
-
-        if blacklist:
-            # if you are reading this to learn, DON'T do this, there will be a real way
-            # to interact with bot-owned data without touching config directly at some
-            # point in the future after Red 3.2
-            async with self.bot._config.blacklist() as blacklist_list:
-                if user.id not in blacklist_list:
-                    blacklist_list.append(user.id)
-
-        if not dungeon_role_obj:
-            return await ctx.send("No dungeon role set.")
-
-        #Managed roles CANNOT be removed by the bot.
-        remaining_roles = [r for r in user.roles if r.managed]
-        try:
-            await user.edit(roles=remaining_roles, reason=f"Removing all roles, {ctx.message.author} is banishing user")
-        except discord.Forbidden:
-            return await ctx.send(
-                "I need permission to manage roles or the role hierarchy might not allow me to do this. I need a role higher than the person you're trying to banish."
-            )
-
-        await user.add_roles(dungeon_role_obj, reason=f"Adding dungeon role, {ctx.message.author} is banishing user")
-
-        if blacklist:
-            blacklist_msg = ", blacklisted from the bot,"
-        else:
-            blacklist_msg = ""
-        msg = f"{user} has been sent to the dungeon{blacklist_msg} and has had all previous roles stripped."
-        await ctx.send(msg)
-
-    @commands.group(autohelp=True)
-    @commands.guild_only()
-    @checks.admin_or_permissions(manage_guild=True)
-    async def dungeon(self, ctx):
-        """Main dungeon commands."""
-        pass
-
-    @dungeon.command()
-    async def announce(self, ctx, channel: discord.TextChannel):
-        """Sets the announcement channel for users moved to the dungeon."""
-        await self.config.guild(ctx.guild).announce_channel.set(channel.id)
-        announce_channel_id = await self.config.guild(ctx.guild).announce_channel()
-        await ctx.send(f"User announcement channel set to: {self.bot.get_channel(announce_channel_id).mention}.")
-
-    @dungeon.command()
-    async def autoban(self, ctx):
-        """Toggle auto-banning users instead of sending them to the dungeon."""
-        auto_ban = await self.config.guild(ctx.guild).auto_ban()
-        await self.config.guild(ctx.guild).auto_ban.set(not auto_ban)
-        await ctx.send(f"Auto-ban instead of sending to the dungeon: {not auto_ban}.")
-
-    @dungeon.command()
-    async def banmessage(self, ctx, *, ban_message=None):
-        """Set the message to send on an autoban. If message is left blank, no message will be sent."""
-        auto_ban = await self.config.guild(ctx.guild).auto_ban()
-        if not ban_message:
-            await self.config.guild(ctx.guild).auto_ban_message.set(None)
-            return await ctx.send("Auto-ban message removed. No message will be sent on an auto-ban.")
-        await self.config.guild(ctx.guild).auto_ban_message.set(str(ban_message))
-        await self.config.guild(ctx.guild).auto_ban.set(True)
-        await ctx.send(f"Auto-ban has been turned on.\nMessage to send on ban:\n{ban_message}")
-
-    @dungeon.command()
-    async def blacklist(self, ctx):
-        """Toggle auto-blacklisting for the bot for users moved to the dungeon."""
-        auto_blacklist = await self.config.guild(ctx.guild).auto_blacklist()
-        await self.config.guild(ctx.guild).auto_blacklist.set(not auto_blacklist)
-        await ctx.send(f"Auto-blacklisting dungeon users from the bot: {not auto_blacklist}.")
-
-    @dungeon.command()
-    @commands.cooldown(1, 5, discord.ext.commands.BucketType.guild)
-    async def bypass(self, ctx, user_id: int):
-        """Add a user ID to the bypass list - user will be able to join without restrictions."""
-        if not 17 <= len(str(user_id)) >= 18:
-            return await ctx.send("This doesn't look like a Discord user id.")
-        bypass_ids = await self.config.guild(ctx.guild).bypass()
-        if user_id in bypass_ids:
-            return await ctx.send(f"**{user_id}** is already in the list of bypassed users.")
-        bypass_ids.append(user_id)
-        await self.config.guild(ctx.guild).bypass.set(bypass_ids)
-        bypassed_user = await self.bot.fetch_user(user_id)
-        await ctx.send(
-            f"**{bypassed_user}** ({user_id}) has been added to the bypass list. The next time they attempt to join this server, they will bypass any Dungeon restrictions."
-        )
-
-    @dungeon.command()
-    @commands.cooldown(1, 5, discord.ext.commands.BucketType.guild)
-    async def bypasslist(self, ctx):
-        """Show the current bypass list."""
-        bypass_ids = await self.config.guild(ctx.guild).bypass()
-        msg = "[Bypassed IDs]\n"
-        if not bypass_ids:
-            msg += "None."
-        for id in bypass_ids:
-            msg += f"{id}\n"
-        for page in pagify(msg, delims=["\n"], page_length=1000):
-            await ctx.send(box(msg, lang="ini"))
-
-    @dungeon.command()
-    async def channel(self, ctx, channel: discord.TextChannel):
-        """Sets the text channel to use for the dungeon."""
-        await self.config.guild(ctx.guild).dungeon_channel.set(channel.id)
-        dungeon_channel_id = await self.config.guild(ctx.guild).dungeon_channel()
-        await ctx.send(f"Dungeon channel set to: {self.bot.get_channel(dungeon_channel_id).name}.")
-
-    @dungeon.command()
-    async def dm(self, ctx, *, dm_message=None):
-        """Set the message to send on successful verification.
-        A blank message will turn off the DM setting."""
-        if not dm_message:
-            await self.config.guild(ctx.guild).dm_toggle.set(False)
-            await self.config.guild(ctx.guild).dm_message.set(None)
-            return await ctx.send("DM message on verification turned off.")
-        await self.config.guild(ctx.guild).dm_message.set(str(dm_message))
-        await self.config.guild(ctx.guild).dm_toggle.set(True)
-        await ctx.send(f"DM message on verification turned on.\nMessage to send:\n{dm_message}")
-
-    @dungeon.command()
-    async def joindays(self, ctx, days: int):
-        """Set how old an account needs to be a trusted user."""
-        await self.config.guild(ctx.guild).join_days.set(days)
-        await ctx.send(
-            f"Users must have accounts older than {days} day(s) to be awarded the member role instead of the dungeon role on join."
-        )
-
-    @dungeon.command()
-    async def modlog(self, ctx):
-        """Toggle using the Red mod-log for auto-bans.
-        The mod-log has to be configured to display bans for this to work."""
-        mod_log = await self.config.guild(ctx.guild).mod_log()
-        await self.config.guild(ctx.guild).mod_log.set(not mod_log)
-        await ctx.send(f"Mod-log entry on auto-ban: {not mod_log}.")
-
-    @dungeon.command()
-    async def role(self, ctx, role_name: discord.Role):
-        """Sets the role to use for the dungeon."""
-        await self.config.guild(ctx.guild).dungeon_role.set(role_name.id)
-        dungeon_role_id = await self.config.guild(ctx.guild).dungeon_role()
-        dungeon_role_obj = discord.utils.get(ctx.guild.roles, id=dungeon_role_id)
-        await ctx.send(f"Dungeon role set to: {dungeon_role_obj.name}.")
-
-    @dungeon.command()
-    async def toggle(self, ctx):
-        """Toggle the dungeon on or off."""
-        dungeon_enabled = await self.config.guild(ctx.guild).toggle()
-        await self.config.guild(ctx.guild).toggle.set(not dungeon_enabled)
-        await ctx.send(f"Dungeon enabled: {not dungeon_enabled}.")
-
-    @dungeon.command()
-    async def profiletoggle(self, ctx):
-        """Toggles flagging accounts that have a default profile pic.
-        Accounts that are over the join days threshold will still be flagged if they have a default profile pic."""
-        profile_toggle = await self.config.guild(ctx.guild).profile_toggle()
-        await self.config.guild(ctx.guild).profile_toggle.set(not profile_toggle)
-        await ctx.send(f"Default profile pic flagging: {not profile_toggle}.")
-
-    @dungeon.command()
-    async def userrole(self, ctx, *, role_name: discord.Role = None):
-        """Sets the role to give to new users that are not sent to the dungeon."""
-        if not role_name:
-            await self.config.guild(ctx.guild).user_role.set(None)
-            return await ctx.send("Member role cleared.")
-        await self.config.guild(ctx.guild).user_role.set(role_name.id)
-        user_role_id = await self.config.guild(ctx.guild).user_role()
-        user_role_obj = discord.utils.get(ctx.guild.roles, id=user_role_id)
-        await ctx.send(f"Member role set to: {user_role_obj.name}.")
-
-    @dungeon.command()
-    async def usertoggle(self, ctx):
-        """Toggle the user role on or off."""
-        user_role_toggle = await self.config.guild(ctx.guild).user_role_toggle()
-        await self.config.guild(ctx.guild).user_role_toggle.set(not user_role_toggle)
-        await ctx.send(f"New user dungeon role enabled: {not user_role_toggle}.")
-
-    @dungeon.command()
-    async def verify(self, ctx, user: discord.Member):
-        """Verify a user: remove the dungeon role and add initial user role."""
-        data = await self.config.guild(ctx.guild).all()
-        announce_channel = data["announce_channel"]
-        blacklist = data["auto_blacklist"]
-        dungeon_role_id = data["dungeon_role"]
-        dungeon_role_obj = discord.utils.get(ctx.guild.roles, id=dungeon_role_id)
-        user_role_id = data["user_role"]
-        user_role_obj = discord.utils.get(ctx.guild.roles, id=user_role_id)
-        dm_toggle = data["dm_toggle"]
-        dm_message = data["dm_message"]
-
-        if blacklist:
-            # if you are reading this to learn, DON'T do this, there will be a real way
-            # to interact with bot-owned data without touching config directly at some
-            # point in the future after Red 3.2
-            async with self.bot._config.blacklist() as blacklist_list:
-                if user.id in blacklist_list:
-                    blacklist_list.remove(user.id)
-
-        role_check = False
-        for role in user.roles:
-            if not dungeon_role_obj:
-                return await ctx.send("No dungeon role set.")
-            if role == dungeon_role_obj:
-                role_check = True
-                try:
-                    await user.remove_roles(
-                        dungeon_role_obj, reason=f"Removing dungeon role, verified by {ctx.message.author}.",
-                    )
-                    if not user_role_obj:
-                        return await ctx.send("Dungeon role removed, but no member role is set so I can't award one.")
-                    await user.add_roles(user_role_obj, reason="Adding member role.")
-                except discord.Forbidden:
-                    return await ctx.send(
-                        "I need permissions to manage roles or the role hierarchy might not allow me to do this."
-                    )
-
-        if not role_check:
-            return await ctx.send("User is not in the dungeon.")
-
-        if blacklist:
-            blacklist_msg = " and the bot blacklist"
-        else:
-            blacklist_msg = ""
-        msg = f"{user} has been removed from the dungeon{blacklist_msg} and now has the initial user role."
-        await ctx.send(msg)
-
-        if dm_toggle:
-            try:
-                await user.send(dm_message)
-            except discord.Forbidden:
-                await ctx.send(f"I couldn't DM {user} to let them know they've been verified, they've blocked me.")
-
-    @dungeon.command()
-    async def autosetup(self, ctx):
-        """Automatically set up the dungeon channel and role to apply to suspicious users.
-        You must deny the default role (@ everyone) from viewing or typing in other channels in your server manually.
-        """
-        try:
-            overwrites = {ctx.guild.default_role: discord.PermissionOverwrite(send_messages=False, read_messages=False)}
-
-            dungeon_role = await ctx.guild.create_role(name="Dungeon")
-
-            dungeon_category = await ctx.guild.create_category("Dungeon", overwrites=overwrites)
-            await dungeon_category.set_permissions(
-                dungeon_role, read_messages=True, send_messages=False, read_message_history=True
-            )
-
-            dungeon_channel = await ctx.guild.create_text_channel("Silenced", category=dungeon_category)
-            await dungeon_channel.set_permissions(
-                dungeon_role, read_messages=True, send_messages=False, read_message_history=True
-            )
-            await dungeon_channel.set_permissions(
-                ctx.guild.me, read_messages=True, send_messages=True, read_message_history=True
-            )
-            await dungeon_channel.send("Please wait while an admin verifies your account.")
-
-            await self.config.guild(ctx.guild).dungeon_channel.set(dungeon_channel.id)
-            await self.config.guild(ctx.guild).dungeon_role.set(dungeon_role.id)
-            await self.config.guild(ctx.guild).announce_channel.set(ctx.channel.id)
-            toggle = await self.config.guild(ctx.guild).toggle()
-            if not toggle:
-                await ctx.invoke(self.usertoggle)
-            await ctx.send(
-                f"Done.\nDungeon channel created: {dungeon_channel.mention}\nDungeon role created: {dungeon_role.name}\n\nPlease set these items manually:\n- The announce channel for reporting new users that are moved to the dungeon ({ctx.prefix}dungeon announce)\n- The role you wish to award regular members when they join the server ({ctx.prefix}dungeon userrole)\n- The toggle for enabling the regular user role awarding ({ctx.prefix}dungeon usertoggle)"
-            )
-
-        except discord.Forbidden:
-            await ctx.send("I need permissions to manage channels and manage roles.")
-
-    @dungeon.command()
-    async def settings(self, ctx):
-        """Show the current settings."""
-        data = await self.config.guild(ctx.guild).all()
-
-        try:
-            drole = discord.utils.get(ctx.guild.roles, id=data["dungeon_role"]).name
-        except AttributeError:
-            drole = None
-        try:
-            urole = discord.utils.get(ctx.guild.roles, id=data["user_role"]).name
-        except AttributeError:
-            urole = None
-        try:
-            achannel = self.bot.get_channel(data["announce_channel"]).name
-        except AttributeError:
-            achannel = None
-        try:
-            dchannel = self.bot.get_channel(data["dungeon_channel"]).name
-        except AttributeError:
-            dchannel = None
-        dungeon_enabled = data["toggle"]
-        user_role_enabled = data["user_role_toggle"]
-        join_days = data["join_days"]
-        auto_blacklist = data["auto_blacklist"]
-        profile_toggle = data["profile_toggle"]
-        dm_toggle = data["dm_toggle"]
-        auto_ban = data["auto_ban"]
-        ban_msg = data["auto_ban_message"]
-        mod_log = data["mod_log"]
-
-        if ban_msg:
-            ban_msg = "True"
-
-        msg = (
-            "```ini\n----Dungeon Settings----\n"
-            f"Dungeon Enabled:  [{dungeon_enabled}]\n"
-            f"Dungeon Role:     [{drole}]\n"
-            f"Dungeon Channel:  [{dchannel}]\n"
-            f"Announce Channel: [{achannel}]\n"
-            f"Autorole Enabled: [{user_role_enabled}]\n"
-            f"Autorole Role:    [{urole}]\n"
-            f"Auto-blacklist:   [{auto_blacklist}]\n"
-            f"Default PFP Flag: [{profile_toggle}]\n"
-            f"Day Threshold:    [{str(join_days)}]\n"
-            f"Msg on Verify:    [{dm_toggle}]\n"
-            f"Auto-ban:         [{auto_ban}]\n"
-            f"Ban Message:      [{ban_msg}]\n"
-            f"Mod-log on Ban:   [{mod_log}]\n```"
-        )
-
-        embed = discord.Embed(colour=ctx.guild.me.top_role.colour, description=msg)
-        return await ctx.send(embed=embed)
-
-    @commands.Cog.listener()
-    async def on_member_join(self, member):
-        default_avatar = False
-        toggle = await self.config.guild(member.guild).toggle()
-        if not toggle:
-            return
-        if member.avatar_url == member.default_avatar_url:
-            default_avatar = True
-        try:
-            join_date = datetime.datetime.strptime(str(member.created_at), "%Y-%m-%d %H:%M:%S.%f")
-        except ValueError:
-            member_created_at = f"{str(member.created_at)}.0"
-            join_date = datetime.datetime.strptime(member_created_at, "%Y-%m-%d %H:%M:%S.%f")
-        now = datetime.datetime.now(datetime.timezone.utc).replace(tzinfo=None)
-        since_join = now - join_date
-        join_days = await self.config.guild(member.guild).join_days()
-        profile_toggle = await self.config.guild(member.guild).profile_toggle()
-        announce_channel = await self.config.guild(member.guild).announce_channel()
-        channel_object = self.bot.get_channel(announce_channel)
-        auto_ban = await self.config.guild(member.guild).auto_ban()
-        auto_ban_msg = await self.config.guild(member.guild).auto_ban_message()
-        mod_log = await self.config.guild(member.guild).mod_log()
-        bypassed_ids = await self.config.guild(member.guild).bypass()
-
-        if member.id in bypassed_ids:
-            bypassed_ids.remove(member.id)
-            await self.config.guild(member.guild).bypass.set(bypassed_ids)
-            user_role_id = await self.config.guild(member.guild).user_role()
-            user_role_obj = discord.utils.get(member.guild.roles, id=user_role_id)
-            try:
-                await member.add_roles(
-                    user_role_obj, reason="User has bypassed Dungeon checks. Assigning member role.",
-                )
-            except discord.Forbidden:
-                pass
-            except AttributeError:
-                pass
-            bypass_msg = f"**{member}** ({member.id}) was in the bypass list for **{member.guild.name}** ({member.guild.id}). They were allowed to join without Dungeon checks and I have assigned them the Member role specified in the settings, if any."
-            if announce_channel:
-                await channel_object.send(bypass_msg)
-            else:
-                log.debug(f"dungeon.py: {bypass_msg}")
-            return
-
-        if (since_join.days < join_days) or (profile_toggle and default_avatar):
-            banned = False
-            blacklist = await self.config.guild(member.guild).auto_blacklist()
-            dungeon_role_id = await self.config.guild(member.guild).dungeon_role()
-            dungeon_role_obj = discord.utils.get(member.guild.roles, id=dungeon_role_id)
-            perm_msg = f"dungeon.py: Unable to auto-ban user, permissions needed and no announce channel set. Guild: {member.guild.id}"
-
-            if auto_ban:
-                banned = True
-                if auto_ban_msg:
-                    try:
-                        await member.send(auto_ban_msg)
-                    except discord.Forbidden:
-                        if announce_channel:
-                            await channel_object.send(
-                                f"I couldn't DM {member} ({member.id}) to let them know they've been banned, they've blocked me."
-                            )
-                        else:
-                            log.debug(perm_msg)
-                            return
-                try:
-                    await member.guild.ban(member, reason="Dungeon auto-ban", delete_message_days=0)
-                except discord.Forbidden:
-                    if announce_channel:
-                        return await channel_object.send(
-                            f"I tried to auto-ban someone ({member}, {member.id}) but I don't have ban permissions."
-                        )
-                    else:
-                        log.debug(perm_msg)
-                        return
-
-                if not mod_log:
-                    if announce_channel:
-                        msg = f"Auto-banned new user: \n**{member}** ({member.id})\n{self._dynamic_time(int(since_join.total_seconds()))} old account"
-                        return await channel_object.send(msg)
-                    else:
-                        log.debug(perm_msg)
-                        return
-                else:
-                    try:
-                        await modlog.create_case(
-                            self.bot, member.guild, now, "ban", member, member.guild.me, until=None, channel=None,
-                        )
-                    except RuntimeError:
-                        log.error(
-                            f"dungeon.py error while autobanning user and attempting to create modlog entry in guild: {member.guild.id}",
-                            exc_info=True,
-                        )
-
-            if blacklist:
-                # if you are reading this to learn, DON'T do this, there will be a real way
-                # to interact with bot-owned data without touching config directly at some
-                # point in the future after Red 3.2
-                async with self.bot._config.blacklist() as blacklist_list:
-                    if member.id not in blacklist_list:
-                        blacklist_list.append(member.id)
-            if banned:
-                return
-            try:
-                if since_join.days < join_days:
-                    reason = "Adding dungeon role, new account."
-                else:
-                    reason = "Adding dungeon role, default profile pic."
-                await member.add_roles(dungeon_role_obj, reason=reason)
-            except discord.Forbidden:
-                if announce_channel:
-                    return await channel_object.send(
-                        "Someone suspicious joined but something went wrong. I need permissions to manage channels and manage roles."
-                    )
-                else:
-                    log.info(
-                        f"dungeon.py: I need permissions to manage channels and manage roles in {member.guild.name} ({member.guild.id})."
-                    )
-                    return
-
-            msg = f"Auto-banished new user: \n**{member}** ({member.id})\n{self._dynamic_time(int(since_join.total_seconds()))} old account"
-            if default_avatar:
-                msg += ", no profile picture set"
-            await channel_object.send(msg)
-        else:
-            user_role_toggle = await self.config.guild(member.guild).user_role_toggle()
-            if not user_role_toggle:
-                return
-            user_role_id = await self.config.guild(member.guild).user_role()
-            user_role_obj = discord.utils.get(member.guild.roles, id=user_role_id)
-            try:
-                await member.add_roles(user_role_obj, reason="Adding member role to new user.")
-            except discord.Forbidden:
-                pass
-            except AttributeError:
-                pass
-
-    @staticmethod
-    def _dynamic_time(time):
-        m, s = divmod(time, 60)
-        h, m = divmod(m, 60)
-        d, h = divmod(h, 24)
-
-        if d > 0:
-            msg = "{0}d {1}h"
-        elif d == 0 and h > 0:
-            msg = "{1}h {2}m"
-        elif d == 0 and h == 0 and m > 0:
-            msg = "{2}m {3}s"
-        elif d == 0 and h == 0 and m == 0 and s > 0:
-            msg = "{3}s"
-        else:
-            msg = ""
-        return msg.format(d, h, m, s)

dungeon/info.json

@@ -1,12 +0,0 @@
-{
-    "author": ["aikaterna"],
-    "description": "Provides additional raid protection for servers utilizing a welcome/rules join channel.",
-    "install_msg": "This cog is hidden as Twentysix's Defender does a much better job at this sort of thing. If you insist on using this, know that it is EOL and will not be supported. Please read the additional instructions at: <https://github.com/aikaterna/aikaterna-cogs/blob/v3/dungeon_readme.md>",
-    "permissions" : ["ban_members", "manage_channels", "manage_roles"],
-    "short": "Specialized raid protection.",
-    "tags": ["dungeon", "autoban"],
-    "type": "COG",
-    "hidden": true,
-    "disabled": true,
-    "end_user_data_statement": "This cog does not persistently store end user data. This cog does store discord IDs as needed for operation. "
-}

dungeon_readme.md

@@ -1,46 +0,0 @@
-
-The dungeon cog was written for a specific type of server setup and may or may not work for your needs. This cog stops text and voice channel raiders by restricting new accounts to a read-only channel on-join when set up appropriately.
-
-The ideal guild setup for this cog would be one set up with an autorole so that new users are given a role on-join that sends them to a “verify” or “agreement” or “welcome” channel - usually to agree to rules and receive a new Member role, removing the initial autorole and granting them access to the rest of the server. The everyone role is generally denied from viewing or speaking in any channels and channel access is generally granted through the Member role or other roles after the normal server verification process.
-
-
-What this cog can do if the above guild restrictions are in place:
-
-- A new user joins the server.
-- The cog determines whether the user is new (under a settable threshold of days)
-- If the user is new, the dungeon role would be added to them instead of the autorole, restricting them to the dungeon channel where they can only see and not speak. 
-- If autoban is on, they will be banned instead of sent to the dungeon.
-- If the setting is on to do so, the bot will blacklist the user from using the bot.
-- A message is sent to the announce channel with the dungeoned user’s name, id, account age, and whether they have a default profile pic.
-- Admins can verify someone in the dungeon by using a command. This will remove the dungeon role, add the initial autorole, and then un-blacklist the user from using the bot.
-
-If a user is over the new user days threshold:
-
-- A new user joins the server.
-- They are given the autorole.
-- They proceed as normal through the server’s verification/role awarding/welcome channels.
-
-How to set it up:
-
-Turn off your current autorole system, if you have one. This cog will only interact with roles used in this cog like the dungeon role and the user role (autorole).
-Remember to deny the Dungeon role from viewing any channel that’s viewable by @ everyone.
-
-Use [p]dungeon autosetup
-    This sets up the dungeon/silenced channel in it’s own category.
-
-Use [p]dungeon announce #channel
-    This sets up the channel to announce dungeoned users.
-
-Use [p]dungeon userrole rolename
-    This sets up the autorole to award if the new user is not a new account.
-
-Use [p]dungeon blacklist
-    This toggles the auto-blacklist on. Dungeoned users will be blacklisted from using the bot.
-
-If a user needs to be verified, use [p]dungeon verify id/username. This will remove the dungeon role from them and apply the initial autorole so they can proceed through the server’s verification or welcome process. If a custom message should be sent to the user when they are verified, use [p]dungeon dm message to set a message. The command with no message will turn the DM feature off.
-
-A user can be stripped of all their roles with [p]banish. This will apply the dungeon role to them and if the blacklist toggle is on, blacklist them from using the bot.
-
-Autobanning can be done instead of sending the user to the dungeon channel. It will use the days and profile picture parameters to choose who to auto-ban. Turn autoban on with [p]dungeon autoban and set a message to DM the user: [p]dungeon banmessage. If [p]dungeon modlog is used, it will create a mod log entry if the bot is set up to report bans with the built-in Mod cog instead of reporting to the announce channel.
-
-Current settings can be seen with [p]dungeon settings.

embedpeek/__init__.py

@@ -3,5 +3,5 @@ from .embedpeek import EmbedPeek
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(EmbedPeek(bot))
+async def setup(bot):
+    await bot.add_cog(EmbedPeek(bot))

hunting/__init__.py

@@ -11,4 +11,4 @@ __red_end_user_data_statement__ = (
 
 
 async def setup(bot):
-    bot.add_cog(Hunting(bot))
+    await bot.add_cog(Hunting(bot))

hunting/hunting.py

@@ -7,13 +7,14 @@ import time
 from typing import Literal
 
 import discord
-from redbot.core import Config, checks, commands
+from redbot.core import Config, checks, commands, bank
+from redbot.core.errors import BalanceTooHigh
 from redbot.core.utils.chat_formatting import (bold, box, humanize_list,
                                                humanize_number, pagify)
 from redbot.core.utils.menus import DEFAULT_CONTROLS, menu
 from redbot.core.utils.predicates import MessagePredicate
 
-__version__ = "3.1.6"
+__version__ = "3.1.7"
 
 
 class Hunting(commands.Cog):
@@ -46,10 +47,15 @@ class Hunting(commands.Cog):
             "channels": [],
             "bang_time": False,
             "bang_words": True,
+            "reward_range": [],
+        }
+        default_global = {
+            "reward_range": [],  # For bots with global banks
         }
         default_user = {"score": {}, "total": 0}
         self.config.register_user(**default_user)
         self.config.register_guild(**default_guild)
+        self.config.register_guild(**default_global)
 
     @commands.guild_only()
     @commands.group()
@@ -76,6 +82,17 @@ class Hunting(commands.Cog):
             msg += f"[Hunting mode]:               {hunting_mode}\n"
             msg += f"[Bang response time message]: {reaction_time}\n"
 
+            if await bank.is_global():
+                reward = await self.config.reward_range()
+                if reward:
+                    reward = f"{reward[0]} - {reward[1]}"
+                msg += f"[Hunting reward range]:       {reward if reward else 'None'}\n"
+            else:
+                reward = guild_data['reward_range']
+                if reward:
+                    reward = f"{reward[0]} - {reward[1]}"
+                msg += f"[Hunting reward range]:       {reward if reward else 'None'}\n"
+
             for page in pagify(msg, delims=["\n"]):
                 await ctx.send(box(page, lang="ini"))
 
@@ -156,6 +173,36 @@ class Hunting(commands.Cog):
         toggle_text = "Use the reaction" if toggle else "Type 'bang'"
         await ctx.send(f"{toggle_text} to react to the bang message when it appears.\n")
 
+    @checks.mod_or_permissions(manage_guild=True)
+    @hunting.command()
+    async def reward(self, ctx, min_reward: int = None, max_reward: int = None):
+        """
+        Set a credit reward range for successfully shooting a bird
+
+        Leave the options blank to disable bang rewards
+        """
+        bank_is_global = await bank.is_global()
+        if ctx.author.id not in self.bot.owner_ids and bank_is_global:
+            return await ctx.send("Bank is global, only bot owner can set a reward range.")
+        if not min_reward or not max_reward:
+            if min_reward != 0 and not max_reward:  # Maybe they want users to sometimes not get rewarded
+                if bank_is_global:
+                    await self.config.reward_range.set([])
+                else:
+                    await self.config.guild(ctx.guild).reward_range.set([])
+                msg = "Reward range reset to default(None)."
+                return await ctx.send(msg)
+        if min_reward > max_reward:
+            return await ctx.send("Your minimum reward is greater than your max reward...")
+        reward_range = [min_reward, max_reward]
+        currency_name = await bank.get_currency_name(ctx.guild)
+        if bank_is_global:
+            await self.config.reward_range.set(reward_range)
+        else:
+            await self.config.guild(ctx.guild).reward_range.set(reward_range)
+        msg = f"Users can now get {min_reward} to {max_reward} {currency_name} for shooting a bird."
+        await ctx.send(msg)
+
     @checks.mod_or_permissions(manage_guild=True)
     @hunting.command()
     async def next(self, ctx):
@@ -376,13 +423,34 @@ class Hunting(commands.Cog):
 
         if random.randrange(0, 17) > 1:
             await self._add_score(guild, author, animal)
-            msg = f"{author.display_name} shot a {animal}{bangtime}!"
+            reward = await self.maybe_send_reward(guild, author)
+            if reward:
+                cur_name = await bank.get_currency_name(guild)
+                msg = f"{author.display_name} shot a {animal}{bangtime} and earned {reward} {cur_name}!"
+            else:
+                msg = f"{author.display_name} shot a {animal}{bangtime}!"
         else:
             msg = f"{author.display_name} missed the shot and the {animal} got away!"
 
         self.in_game.remove(channel.id)
         await channel.send(bold(msg))
 
+    async def maybe_send_reward(self, guild, author) -> int:
+        max_bal = await bank.get_max_balance(guild)
+        user_bal = await bank.get_balance(author)
+        if await bank.is_global():
+            range_to_give = await self.config.reward_range()
+        else:
+            range_to_give = await self.config.guild(guild).reward_range()
+        to_give = random.choice(range(range_to_give[0], range_to_give[1] + 1))
+        if to_give + user_bal > max_bal:
+            to_give = max_bal - user_bal
+        try:
+            await bank.deposit_credits(author, to_give)
+        except BalanceTooHigh as e:  # This shouldn't throw since we already compare to max bal
+            await bank.set_balance(author, e.max_balance)
+        return to_give
+
     @commands.Cog.listener()
     async def on_message(self, message):
         if not message.guild:

icyparser/__init__.py

@@ -3,5 +3,5 @@ from .icyparser import IcyParser
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(IcyParser(bot))
+async def setup(bot):
+    await bot.add_cog(IcyParser(bot))

inspirobot/__init__.py

@@ -3,5 +3,5 @@ from .inspirobot import Inspirobot
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(Inspirobot(bot))
+async def setup(bot):
+    await bot.add_cog(Inspirobot(bot))

invites/__init__.py

@@ -3,5 +3,5 @@ from .invites import Invites
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(Invites(bot))
+async def setup(bot):
+    await bot.add_cog(Invites(bot))

invites/invites.py

@@ -42,7 +42,7 @@ class Invites(commands.Cog):
     @invites.command()
     async def show(self, ctx: commands.Context, invite_code_or_url: str = None):
         """Show the stats for an invite, or show all invites."""
-        if not ctx.me.permissions_in(ctx.channel).administrator:
+        if not ctx.channel.permissions_for(ctx.guild.me).administrator:
             return await self._send_embed(ctx, PERM_MSG)
 
         if not invite_code_or_url:
@@ -57,7 +57,7 @@ class Invites(commands.Cog):
     @invites.command()
     async def leaderboard(self, ctx: commands.Context, list_all_invites: bool = False):
         """List pinned invites or all invites in a leaderboard style."""
-        if not ctx.me.permissions_in(ctx.channel).administrator:
+        if not ctx.channel.permissions_for(ctx.guild.me).administrator:
             return await self._send_embed(ctx, PERM_MSG)
 
         if not list_all_invites:
@@ -96,7 +96,7 @@ class Invites(commands.Cog):
     @invites.command()
     async def pin(self, ctx: commands.Context, invite_code_or_url: str):
         """Pin an invite to the leaderboard."""
-        if not ctx.me.permissions_in(ctx.channel).administrator:
+        if not ctx.channel.permissions_for(ctx.guild.me).administrator:
             return await self._send_embed(ctx, PERM_MSG)
 
         invite_code = await self._find_invite_code(invite_code_or_url)

latex/__init__.py

@@ -2,5 +2,6 @@ from .latex import Latex
 
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
-def setup(bot):
-  bot.add_cog(Latex(bot))
+
+async def setup(bot):
+    await bot.add_cog(Latex(bot))

luigipoker/__init__.py

@@ -3,5 +3,5 @@ from .luigipoker import LuigiPoker
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(LuigiPoker(bot))
+async def setup(bot):
+    await bot.add_cog(LuigiPoker(bot))

massunban/__init__.py

@@ -3,5 +3,5 @@ from .massunban import MassUnban
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(MassUnban(bot))
+async def setup(bot):
+    await bot.add_cog(MassUnban(bot))

noflippedtables/__init__.py

@@ -3,5 +3,5 @@ from .noflippedtables import NoFlippedTables
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(NoFlippedTables(bot))
+async def setup(bot):
+    await bot.add_cog(NoFlippedTables(bot))

nolinks/__init__.py

@@ -1,7 +0,0 @@
-from .nolinks import NoLinks
-
-__red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
-
-
-def setup(bot):
-    bot.add_cog(NoLinks(bot))

nolinks/info.json

@@ -1,12 +0,0 @@
-{
-    "author": ["aikaterna"],
-    "description": "Removes all links in specified channels, with the ability to whitelist roles.",
-    "install_msg": "Consider using TrustyJAID's retrigger or Twentysix's Defender instead of this cog as they are better suited for this sort of moderation. Thanks for installing. Use `[p]nolinks` to get started.",
-    "permissions" : ["manage_messages"],
-    "short": "No links allowed.",
-    "hidden": true,
-    "disabled": true,
-    "tags": ["links", "automod"],
-    "type": "COG",
-    "end_user_data_statement": "This cog does not persistently store data or metadata about users."
-}

nolinks/nolinks.py

@@ -1,151 +0,0 @@
-import discord
-import re
-from redbot.core import Config, commands, checks
-
-LINKS = re.compile(
-    "(\|\|)?(([\w]+:)?\/\/)?(([\d\w]|%[a-fA-f\d]{2,2})+(:([\d\w]|%[a-fA-f\d]{2,2})+)?@)?([\d\w][-\d\w]{0,253}[\d\w]\.)+[\w]{2,63}(:[\d]+)?(\/([-+_~.\d\w]|%[a-fA-f\d]{2,2})*)*(\?(&?([-+_~.\d\w]|%[a-fA-f\d]{2,2})=?)*)?(#([-+_~.\d\w]|%[a-fA-f\d]{2,2})*)?(\|\|)?"
-)
-
-
-class NoLinks(commands.Cog):
-    """A heavy-handed hammer for anything that looks like a link."""
-
-    async def red_delete_data_for_user(self, **kwargs):
-        """ Nothing to delete """
-        return
-
-    def __init__(self, bot):
-        self.bot = bot
-        self.config = Config.get_conf(self, 2740131001, force_registration=True)
-
-        default_guild = {"report_channel": None, "role": [], "watching": []}
-
-        self.config.register_guild(**default_guild)
-
-    @commands.group()
-    @checks.mod_or_permissions(administrator=True)
-    @commands.guild_only()
-    async def nolinks(self, ctx):
-        """Configuration options."""
-        pass
-
-    @nolinks.command()
-    async def channel(self, ctx, channel: discord.TextChannel = None):
-        """Set the message transfer channel. Leave the channel blank to turn it off."""
-        if not channel:
-            await self.config.guild(ctx.guild).report_channel.clear()
-            return await ctx.send("Message transfer channel turned off.")
-        await self.config.guild(ctx.guild).report_channel.set(channel.id)
-        await ctx.send(f"Message transfer channel set to: {channel.mention}.")
-
-    @nolinks.command()
-    async def rolelist(self, ctx):
-        """List whitelisted roles."""
-        role_list = await self.config.guild(ctx.guild).role()
-        role_msg = "Whitelisted Roles:\n"
-        for role in role_list:
-            role_obj = discord.utils.get(ctx.guild.roles, id=role)
-            role_msg += f"{role_obj.name}\n"
-        await ctx.send(role_msg)
-
-    @nolinks.command()
-    async def removerole(self, ctx, *, role_name: discord.Role):
-        """Remove a whitelisted role."""
-        role_list = await self.config.guild(ctx.guild).role()
-        if role_name.id in role_list:
-            role_list.remove(role_name.id)
-        else:
-            return await ctx.send("Role not in whitelist.")
-        await self.config.guild(ctx.guild).role.set(role_list)
-        role_obj = discord.utils.get(ctx.guild.roles, id=role_name.id)
-        await ctx.send(f"{role_obj.name} removed from the link whitelist.")
-
-    @nolinks.command()
-    async def role(self, ctx, *, role_name: discord.Role):
-        """Add a whitelisted role."""
-        role_list = await self.config.guild(ctx.guild).role()
-        if role_name.id not in role_list:
-            role_list.append(role_name.id)
-        await self.config.guild(ctx.guild).role.set(role_list)
-        role_obj = discord.utils.get(ctx.guild.roles, id=role_name.id)
-        await ctx.send(f"{role_obj.name} appended to the role whitelist.")
-
-    @nolinks.command()
-    async def watch(self, ctx, channel: discord.TextChannel):
-        """Add a channel to watch. Links will be removed in these channels."""
-        channel_list = await self.config.guild(ctx.guild).watching()
-        if channel.id not in channel_list:
-            channel_list.append(channel.id)
-        await self.config.guild(ctx.guild).watching.set(channel_list)
-        await ctx.send(f"{self.bot.get_channel(channel.id).mention} will have links removed.")
-
-    @nolinks.command()
-    async def watchlist(self, ctx):
-        """List the channels being watched."""
-        channel_list = await self.config.guild(ctx.guild).watching()
-        msg = "Links will be removed in:\n"
-        if not channel_list:
-            msg += "No channels."
-        else:
-            remove_list = []
-            for channel in channel_list:
-                channel_obj = self.bot.get_channel(channel)
-                if not channel_obj:
-                    remove_list.append(channel)
-                else:
-                    msg += f"{channel_obj.mention}\n"
-            if remove_list:
-                new_list = [x for x in channel_list if x not in remove_list]
-                await self.config.guild(ctx.guild).watching.set(new_list)
-                if len(remove_list) == len(channel_list):
-                    msg += "No channels."
-        await ctx.send(msg)
-
-    @nolinks.command()
-    async def unwatch(self, ctx, channel: discord.TextChannel):
-        """Remove a channel from the watch list."""
-        channel_list = await self.config.guild(ctx.guild).watching()
-        if channel.id in channel_list:
-            channel_list.remove(channel.id)
-        else:
-            return await ctx.send("Channel is not being watched.")
-        await self.config.guild(ctx.guild).watching.set(channel_list)
-        await ctx.send(f"{self.bot.get_channel(channel.id).mention} will not have links removed.")
-
-    @commands.Cog.listener()
-    async def on_message(self, message):
-        if isinstance(message.channel, discord.abc.PrivateChannel):
-            return
-        if message.author.bot:
-            return
-        data = await self.config.guild(message.guild).all()
-        watch_channel_list = data["watching"]
-        if not watch_channel_list:
-            return
-        if message.channel.id not in watch_channel_list:
-            return
-        allowed_roles = []
-        for role in data["role"]:
-            whitelist_role = discord.utils.get(message.author.roles, id=role)
-            if whitelist_role:
-                allowed_roles.append(whitelist_role)
-        message_channel = self.bot.get_channel(data["report_channel"])
-        if not allowed_roles:
-            try:
-                sentence = message.content.split()
-                for word in sentence:
-                    if self._match_url(word):
-                        msg = "**Message Removed in** {} ({})\n".format(message.channel.mention, message.channel.id)
-                        msg += "**Message sent by**: {} ({})\n".format(message.author.name, message.author.id)
-                        msg += "**Message content**:\n{}".format(message.content)
-                        if message_channel:
-                            await message_channel.send(msg)
-                        await message.delete()
-            except Exception as e:
-                if message_channel:
-                    await message_channel.send(e)
-                pass
-
-    @staticmethod
-    def _match_url(url):
-        return LINKS.match(url)

otherbot/__init__.py

@@ -1,11 +1,11 @@
 from .otherbot import Otherbot
 
 __red_end_user_data_statement__ = (
-    "This cog does not persistently store end user data. " "This cog does store discord IDs as needed for operation. "
+    "This cog does not persistently store end user data. This cog does store discord IDs as needed for operation."
 )
 
 
 async def setup(bot):
-    cog = Otherbot(bot)
-    await cog.generate_cache()
-    bot.add_cog(cog)
+    n = Otherbot(bot)
+    await n.generate_cache()
+    await bot.add_cog(n)

otherbot/otherbot.py

@@ -4,7 +4,6 @@ import discord
 from redbot.core.bot import Red
 from redbot.core import commands, checks, Config
 
-from datetime import datetime
 
 DEFAULT_OFFLINE_EMOJI = "\N{LARGE RED CIRCLE}"
 DEFAULT_ONLINE_EMOJI = "\N{WHITE HEAVY CHECK MARK}"
@@ -12,7 +11,7 @@ DEFAULT_ONLINE_EMOJI = "\N{WHITE HEAVY CHECK MARK}"
 
 class Otherbot(commands.Cog):
     __author__ = ["aikaterna", "Predä 。#1001"]
-    __version__ = "0.10"
+    __version__ = "0.11"
 
     async def red_delete_data_for_user(
         self, *, requester: Literal["discord", "owner", "user", "user_strict"], user_id: int,
@@ -126,7 +125,8 @@ class Otherbot(commands.Cog):
                     else:
                         msg += f"**{name}**: {guild_data[attr]}\n"
                 em.description = msg
-                em.set_thumbnail(url=guild.icon_url)
+                if guild.icon:
+                    em.set_thumbnail(url=guild.icon.url)
                 await ctx.send(embed=em)
             else:
                 msg = "```\n"
@@ -346,7 +346,7 @@ class Otherbot(commands.Cog):
         await self.generate_cache()
 
     @commands.Cog.listener()
-    async def on_member_update(self, before: discord.Member, after: discord.Member):
+    async def on_presence_update(self, before: discord.Member, after: discord.Member):
         if after.guild is None or not after.bot:
             return
 
@@ -368,19 +368,16 @@ class Otherbot(commands.Cog):
                     em = discord.Embed(
                         color=0x8B0000,
                         description=f"{after.mention} is offline. {data['offline_emoji']}",
-                        timestamp=datetime.utcnow(),
+                        timestamp=discord.utils.utcnow(),
                     )
                     if not data["ping"]:
                         await channel.send(embed=em)
                     else:
-                        if discord.version_info.minor < 4:
-                            await channel.send(f"<@&{data['ping']}>", embed=em)
-                        else:
-                            await channel.send(
-                                f"<@&{data['ping']}>",
-                                embed=em,
-                                allowed_mentions=discord.AllowedMentions(roles=True),
-                            )
+                        await channel.send(
+                            f"<@&{data['ping']}>",
+                            embed=em,
+                            allowed_mentions=discord.AllowedMentions(roles=True),
+                        )
                 else:
                     if not data["ping"]:
                         await channel.send(f"{after.mention} is offline. {data['offline_emoji']}")
@@ -401,19 +398,16 @@ class Otherbot(commands.Cog):
                     em = discord.Embed(
                         color=0x008800,
                         description=f"{after.mention} is back online. {data['online_emoji']}",
-                        timestamp=datetime.utcnow(),
+                        timestamp=discord.utils.utcnow(),
                     )
                     if not data["ping"]:
                         await channel.send(embed=em)
                     else:
-                        if discord.version_info.minor < 4:
-                            await channel.send(f"<@&{data['ping']}>", embed=em)
-                        else:
-                            await channel.send(
-                                f"<@&{data['ping']}>",
-                                embed=em,
-                                allowed_mentions=discord.AllowedMentions(roles=True),
-                            )
+                        await channel.send(
+                            f"<@&{data['ping']}>",
+                            embed=em,
+                            allowed_mentions=discord.AllowedMentions(roles=True),
+                        )
                 else:
                     if not data["ping"]:
                         await channel.send(

partycrash/__init__.py

@@ -3,5 +3,5 @@ from .partycrash import PartyCrash
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(PartyCrash(bot))
+async def setup(bot):
+    await bot.add_cog(PartyCrash(bot))

pingtime/__init__.py

@@ -3,5 +3,5 @@ from .pingtime import Pingtime
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(Pingtime(bot))
+async def setup(bot):
+    await bot.add_cog(Pingtime(bot))

pressf/__init__.py

@@ -3,5 +3,5 @@ from .pressf import PressF
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(PressF(bot))
+async def setup(bot):
+    await bot.add_cog(PressF(bot))

pupper/__init__.py

@@ -4,4 +4,4 @@ __red_end_user_data_statement__ = "This cog does not persistently store data or
 
 
 async def setup(bot):
-    bot.add_cog(Pupper(bot))
+    await bot.add_cog(Pupper(bot))

quiz/__init__.py

@@ -3,5 +3,5 @@ from .quiz import Quiz
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(Quiz(bot))
+async def setup(bot):
+    await bot.add_cog(Quiz(bot))

region/__init__.py

@@ -1,7 +0,0 @@
-from .region import Region
-
-__red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
-
-
-def setup(bot):
-    bot.add_cog(Region())

region/info.json

@@ -1,10 +0,0 @@
-{
-    "author" : ["aikaterna"],
-    "short" : "Change the Discord server's region.",
-    "description" : "Change the Discord server's region with a command.",
-    "install_msg" : "This cog is not needed any more because voice servers are determined upon joining the channel, instead of server-based voice regions. Thanks for installing.",
-    "tags" : ["voice region", "region"],
-    "hidden": true,
-    "disabled" : true,
-    "end_user_data_statement": "This cog does not persistently store data or metadata about users."
-}

region/region.py

@@ -1,51 +0,0 @@
-import discord
-from redbot.core import checks, commands
-from redbot.core.utils.chat_formatting import humanize_list
-
-
-class Region(commands.Cog):
-    """Change the guild voice region."""
-
-    async def red_delete_data_for_user(self, **kwargs):
-        """ Nothing to delete """
-        return
-
-    @checks.mod_or_permissions(administrator=True)
-    @commands.cooldown(1, 60, discord.ext.commands.BucketType.guild)
-    @commands.command()
-    async def region(self, ctx, *, region: str):
-        """Set the current guild's voice region."""
-        regions = [
-            "japan",
-            "singapore",
-            "eu-central",
-            "europe",
-            "india",
-            "us-central",
-            "london",
-            "eu-west",
-            "amsterdam",
-            "brazil",
-            "dubai",
-            "us-west",
-            "hongkong",
-            "us-south",
-            "southafrica",
-            "us-east",
-            "sydney",
-            "frankfurt",
-            "russia",
-        ]
-        region = region.replace(" ", "-")
-        if region not in regions:
-            ctx.command.reset_cooldown(ctx)
-            return await ctx.send(
-                f"`{region}` was not found in the list of Discord voice regions. Valid regions are: {humanize_list(regions)}."
-            )
-        try:
-            await ctx.guild.edit(region=region)
-        except discord.errors.Forbidden:
-            return await ctx.send("I don't have permissions to edit this guild's settings.")
-        except discord.errors.HTTPException:
-            return await ctx.send(f"Error: An invalid server region was passed: `{region}`")
-        await ctx.send(f"The voice server region for `{ctx.guild.name}` has been changed to `{region}`.")

rndstatus/__init__.py

@@ -3,5 +3,5 @@ from .rndstatus import RndStatus
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(RndStatus(bot))
+async def setup(bot):
+    await bot.add_cog(RndStatus(bot))

rss/__init__.py

@@ -7,5 +7,5 @@ __red_end_user_data_statement__ = "This cog does not persistently store data or
 
 async def setup(bot: commands.Bot):
     n = RSS(bot)
-    bot.add_cog(n)
+    await bot.add_cog(n)
     n.initialize()

rss/rss.py

@@ -29,7 +29,7 @@ IPV4_RE = re.compile("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}")
 IPV6_RE = re.compile("([a-f0-9:]+:+)+[a-f0-9]+")
 
 
-__version__ = "1.8.0"
+__version__ = "1.8.1"
 
 
 class RSS(commands.Cog):
@@ -218,7 +218,6 @@ class RSS(commands.Cog):
                             name = f"media_plaintext{str(enclosure_content_counter).zfill(2)}"
                             rss_object[name] = image_url
                             rss_object["is_special"].append(name)
-                            tags_list.append(tag) if tag not in tags_list else tags_list
                         except KeyError:
                             pass
 
@@ -1049,7 +1048,8 @@ class RSS(commands.Cog):
         msg += "\n\n\t[X] = html | [\\] = dictionary | [-] = list | [ ] = plain text"
         msg += "\n\t[*] = specially-generated tag, may not be present in every post"
 
-        await ctx.send(box(msg, lang="ini"))
+        for msg_part in pagify(msg, delims=["\n\t", "\n\n"]):
+            await ctx.send(box(msg_part, lang="ini"))
 
     @checks.is_owner()
     @rss.group(name="parse")
@@ -1463,7 +1463,7 @@ class RSS(commands.Cog):
                 return
 
             embed_toggle = rss_feed["embed"]
-            red_embed_settings = await self.bot.embed_requested(channel, None)
+            red_embed_settings = await self.bot.embed_requested(channel)
             embed_permissions = channel.permissions_for(channel.guild.me).embed_links
 
             rss_limit = rss_feed.get("limit", 0)

seen/__init__.py

@@ -9,4 +9,4 @@ __red_end_user_data_statement__ = (
 async def setup(bot):
     cog = Seen(bot)
     await cog.initialize()
-    bot.add_cog(cog)
+    await bot.add_cog(cog)

seen/seen.py

@@ -117,7 +117,7 @@ class Seen(commands.Cog):
             elif output[2] > 1:
                 ts += "{} minutes ago".format(output[2])
         em = discord.Embed(colour=discord.Color.green())
-        avatar = author.avatar_url or author.default_avatar_url
+        avatar = author.display_avatar
         em.set_author(name="{} was seen {}".format(author.display_name, ts), icon_url=avatar)
         await ctx.send(embed=em)
 

snacktime/__init__.py

@@ -4,4 +4,4 @@ __red_end_user_data_statement__ = "This cog does not persistently store data or
 
 
 async def setup(bot):
-    bot.add_cog(Snacktime(bot))
+    await bot.add_cog(Snacktime(bot))

timezone/__init__.py

@@ -12,5 +12,5 @@ __red_end_user_data_statement__ = (
 )
 
 
-def setup(bot):
-    bot.add_cog(Timezone(bot))
+async def setup(bot):
+    await bot.add_cog(Timezone(bot))

tools/__init__.py

@@ -3,5 +3,5 @@ from .tools import Tools
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(Tools(bot))
+async def setup(bot):
+    await bot.add_cog(Tools(bot))

tools/tools.py

@@ -24,7 +24,7 @@ class Tools(commands.Cog):
     """Mod and Admin tools."""
 
     async def red_delete_data_for_user(self, **kwargs):
-        """ Nothing to delete """
+        """Nothing to delete"""
         return
 
     def __init__(self, bot):
@@ -47,9 +47,7 @@ class Tools(commands.Cog):
 
     @access.command()
     async def compare(self, ctx, user: discord.Member, guild: int = None):
-        """Compare channel access with [user]."""
-        if user is None:
-            return
+        """Compare channel access with another user."""
         if guild is None:
             guild = ctx.guild
         else:
@@ -67,42 +65,35 @@ class Tools(commands.Cog):
         user_text_channels = [c for c in tcs if c.permissions_for(user).read_messages is True]
         user_voice_channels = [c for c in vcs if c.permissions_for(user).connect is True]
 
-        author_only_t = set(author_text_channels) - set(
-            user_text_channels
-        )  # text channels only the author has access to
-        author_only_v = set(author_voice_channels) - set(
-            user_voice_channels
-        )  # voice channels only the author has access to
+        # text channels only the author has access to
+        author_only_t = set(author_text_channels) - set(user_text_channels)
+        # voice channels only the author has access to
+        author_only_v = set(author_voice_channels) - set(user_voice_channels)
 
-        user_only_t = set(user_text_channels) - set(author_text_channels)  # text channels only the user has access to
-        user_only_v = set(user_voice_channels) - set(
-            author_voice_channels
-        )  # voice channels only the user has access to
+        # text channels only the user has access to
+        user_only_t = set(user_text_channels) - set(author_text_channels)
+        # voice channels only the user has access to
+        user_only_v = set(user_voice_channels) - set(author_voice_channels)
 
-        common_t = list(
-            set([c for c in tcs]) - author_only_t - user_only_t
-        )  # text channels that author and user have in common
-        common_v = list(
-            set([c for c in vcs]) - author_only_v - user_only_v
-        )  # voice channels that author and user have in common
+        # text channels that author and user have in common
+        common_t = list(set([c for c in tcs]) - author_only_t - user_only_t)
+        # voice channels that author and user have in common
+        common_v = list(set([c for c in vcs]) - author_only_v - user_only_v)
 
-        msg = "```ini\n"
-        msg += "{} [TEXT CHANNELS IN COMMON]:\n\n{}\n\n".format(len(common_t), ", ".join([c.name for c in common_t]))
-        msg += "{} [TEXT CHANNELS {} HAS EXCLUSIVE ACCESS TO]:\n\n{}\n\n".format(
-            len(user_only_t), user.name.upper(), ", ".join([c.name for c in user_only_t])
-        )
-        msg += "{} [TEXT CHANNELS YOU HAVE EXCLUSIVE ACCESS TO]:\n\n{}\n\n\n".format(
-            len(author_only_t), ", ".join([c.name for c in author_only_t])
-        )
-        msg += "{} [VOICE CHANNELS IN COMMON]:\n\n{}\n\n".format(len(common_v), ", ".join([c.name for c in common_v]))
-        msg += "{} [VOICE CHANNELS {} HAS EXCLUSIVE ACCESS TO]:\n\n{}\n\n".format(
-            len(user_only_v), user.name.upper(), ", ".join([c.name for c in user_only_v])
-        )
-        msg += "{} [VOICE CHANNELS YOU HAVE EXCLUSIVE ACCESS TO]:\n\n{}\n\n".format(
-            len(author_only_v), ", ".join([c.name for c in author_only_v])
-        )
-        msg += "```"
-        for page in cf.pagify(msg, delims=["\n"], shorten_by=16):
+        text_common_access = ", ".join([c.name for c in common_t])
+        text_user_exclusive_access = ", ".join([c.name for c in user_only_t])
+        text_author_exclusive_access = ", ".join([c.name for c in author_only_t])
+        voice_common_access = ", ".join([c.name for c in common_v])
+        voice_user_exclusive_access = ", ".join([c.name for c in user_only_v])
+        voice_author_exclusive_access = ", ".join([c.name for c in author_only_v])
+
+        msg = f"{len(common_t)} [TEXT CHANNELS IN COMMON]:\n\n{text_common_access}\n\n"
+        msg += f"{len(user_only_t)} [TEXT CHANNELS {user.name.upper()} HAS EXCLUSIVE ACCESS TO]:\n\n{text_user_exclusive_access}\n\n"
+        msg += f"{len(author_only_t)} [TEXT CHANNELS YOU HAVE EXCLUSIVE ACCESS TO]:\n\n{text_author_exclusive_access}\n\n\n"
+        msg += f"{len(common_v)} [VOICE CHANNELS IN COMMON]:\n\n{voice_common_access}\n\n"
+        msg += f"{len(user_only_v)} [VOICE CHANNELS {user.name.upper()} HAS EXCLUSIVE ACCESS TO]:\n\n{voice_user_exclusive_access}\n\n"
+        msg += f"{len(author_only_v)} [VOICE CHANNELS YOU HAVE EXCLUSIVE ACCESS TO]:\n\n{voice_author_exclusive_access}\n\n"
+        for page in cf.pagify(cf.box(msg, lang="ini"), delims=["\n"], shorten_by=16):
             await ctx.send(page)
 
     @access.command()
@@ -122,13 +113,11 @@ class Tools(commands.Cog):
             return await ctx.send("User is not in that guild or I do not have access to that guild.")
 
         prefix = "You have" if user.id == ctx.author.id else user.name + " has"
-        msg = "```ini\n[{} access to {} out of {} text channels]\n\n".format(
-            prefix, len(can_access), len(text_channels)
-        )
-
-        msg += "[ACCESS]:\n{}\n\n".format(", ".join(can_access))
-        msg += "[NO ACCESS]:\n{}\n```".format(", ".join(list(set(text_channels) - set(can_access))))
-        for page in cf.pagify(msg, delims=["\n"], shorten_by=16):
+        no_access = ", ".join(list(set(text_channels) - set(can_access)))
+        msg = f"\n[{prefix} access to {len(can_access)} out of {len(text_channels)} text channels]\n\n"
+        msg += f"[ACCESS]:\n{', '.join(can_access)}\n\n"
+        msg += f"[NO ACCESS]:\n{no_access}"
+        for page in cf.pagify(cf.box(msg, lang="ini"), delims=["\n"], shorten_by=16):
             await ctx.send(page)
 
     @access.command()
@@ -148,13 +137,11 @@ class Tools(commands.Cog):
             return await ctx.send("User is not in that guild or I do not have access to that guild.")
 
         prefix = "You have" if user.id == ctx.author.id else user.name + " has"
-        msg = "```ini\n[{} access to {} out of {} voice channels]\n\n".format(
-            prefix, len(can_access), len(voice_channels)
-        )
-
-        msg += "[ACCESS]:\n{}\n\n".format(", ".join(can_access))
-        msg += "[NO ACCESS]:\n{}\n```".format(", ".join(list(set(voice_channels) - set(can_access))))
-        for page in cf.pagify(msg, delims=["\n"], shorten_by=16):
+        no_access = ", ".join(list(set(voice_channels) - set(can_access)))
+        msg = f"\n[{prefix} access to {len(can_access)} out of {len(voice_channels)} voice channels]\n\n"
+        msg += f"[ACCESS]:\n{', '.join(can_access)}\n\n"
+        msg += f"[NO ACCESS]:\n{no_access}"
+        for page in cf.pagify(cf.box(msg, lang="ini"), delims=["\n"], shorten_by=16):
             await ctx.send(page)
 
     @commands.guild_only()
@@ -178,20 +165,27 @@ class Tools(commands.Cog):
                 msg += f"`{user_obj.user.id} - {user_name}`\n"
 
         banlist = sorted(msg)
-        embed_list = []
-        for page in cf.pagify(msg, shorten_by=1400):
-            embed = discord.Embed(
-                description="**Total bans:** {}\n\n{}".format(bancount, page),
-                colour=await ctx.embed_colour(),
-            )
-            embed_list.append(embed)
-        await menu(ctx, embed_list, DEFAULT_CONTROLS)
+        if ctx.channel.permissions_for(ctx.guild.me).embed_links:
+            embed_list = []
+            for page in cf.pagify(msg, shorten_by=1400):
+                embed = discord.Embed(
+                    description=f"**Total bans:** {bancount}\n\n{page}",
+                    colour=await ctx.embed_colour(),
+                )
+                embed_list.append(embed)
+            await menu(ctx, embed_list, DEFAULT_CONTROLS)
+        else:
+            text_list = []
+            for page in cf.pagify(msg, shorten_by=1400):
+                text = f"**Total bans:** {bancount}\n{page}"
+                text_list.append(text)
+            await menu(ctx, text_list, DEFAULT_CONTROLS)
 
     @commands.guild_only()
     @commands.command()
     async def cid(self, ctx):
-        """Shows the channel ID."""
-        await ctx.send("**#{0.name} ID:** {0.id}".format(ctx.channel))
+        """Shows the channel id for the current channel."""
+        await ctx.send(f"**#{ctx.channel.name} ID:** {ctx.channel.id}")
 
     @commands.guild_only()
     @commands.command()
@@ -213,32 +207,41 @@ class Tools(commands.Cog):
             discord.TextChannel: "Text Channel",
             discord.VoiceChannel: "Voice Channel",
             discord.CategoryChannel: "Category",
+            discord.StageChannel: "Stage Channel",
+            discord.Thread: "Thread",
         }
 
-        load = "```\nLoading channel info...```"
-        waiting = await ctx.send(load)
-
         with sps(Exception):
             caller = inspect.currentframe().f_back.f_code.co_name.strip()
 
-        data = "```ini\n"
+        data = ""
         if caller == "invoke" or channel.guild != ctx.guild:
-            data += "[Server]:     {}\n".format(channel.guild.name)
-        data += "[Name]:       {}\n".format(cf.escape(str(channel)))
-        data += "[ID]:         {}\n".format(channel.id)
-        data += "[Private]:    {}\n".format(yesno[isinstance(channel, discord.abc.PrivateChannel)])
-        if isinstance(channel, discord.TextChannel) and channel.topic != "":
-            data += "[Topic]:      {}\n".format(channel.topic)
-        data += "[Position]:   {}\n".format(channel.position)
-        data += "[Created]:    {}\n".format(self._dynamic_time(channel.created_at))
-        data += "[Type]:       {}\n".format(typemap[type(channel)])
+            data += f"[Server]:          {channel.guild.name}\n"
+        data += f"[Name]:            {cf.escape(str(channel))}\n"
+        data += f"[ID]:              {channel.id}\n"
+        data += f"[Private]:         {yesno[isinstance(channel, discord.abc.PrivateChannel)]}\n"
+        if isinstance(channel, discord.TextChannel) and channel.topic != None:
+            data += f"[Topic]:           {channel.topic}\n"
+        try:
+            data += f"[Position]:        {channel.position}\n"
+        except AttributeError:
+            # this is a thread
+            data += f"[Parent Channel]:  {channel.parent.name} ({channel.parent.id})\n"
+            data += f"[Parent Position]: {channel.parent.position}\n"
+        try:
+            data += f"[Created]:         {self._dynamic_time(channel.created_at)}\n"
+        except AttributeError:
+            # this is a thread
+            data += f"[Updated]:         {self._dynamic_time(channel.archive_timestamp)}\n"
+        data += f"[Type]:            {typemap[type(channel)]}\n"
+        if isinstance(channel, discord.TextChannel) and channel.is_news():
+            data += f"[News Channel]:    {yesno[channel.is_news()]}\n"
         if isinstance(channel, discord.VoiceChannel):
-            data += "[Users]:      {}\n".format(len(channel.members))
-            data += "[User limit]: {}\n".format(channel.user_limit)
-            data += "[Bitrate]:    {}kbps\n".format(int(channel.bitrate / 1000))
-        data += "```"
-        await asyncio.sleep(1)
-        await waiting.edit(content=data)
+            data += f"[Users]:           {len(channel.members)}\n"
+            data += f"[User limit]:      {channel.user_limit}\n"
+            data += f"[Bitrate]:         {int(channel.bitrate / 1000)}kbps\n"
+
+        await ctx.send(cf.box(data, lang="ini"))
 
     @commands.guild_only()
     @commands.command()
@@ -250,22 +253,20 @@ class Tools(commands.Cog):
     @commands.command()
     async def einfo(self, ctx, emoji: discord.Emoji):
         """Emoji information."""
-        e = emoji
+        yesno = {True: "Yes", False: "No"}
+        header = f"{str(emoji)}\n"
         m = (
-            f"{str(e)}\n"
-            f"```ini\n"
-            f"[NAME]:       {e.name}\n"
-            f"[GUILD]:      {e.guild}\n"
-            f"[URL]:        {e.url}\n"
-            f"[ANIMATED]:   {e.animated}"
-            "```"
+            f"[Name]:       {emoji.name}\n"
+            f"[Guild]:      {emoji.guild}\n"
+            f"[URL]:        {emoji.url}\n"
+            f"[Animated]:   {yesno[emoji.animated]}"
         )
-        await ctx.send(m)
+        await ctx.send(header + cf.box(m, lang="ini"))
 
     @commands.guild_only()
     @commands.command()
     @checks.mod_or_permissions(manage_guild=True)
-    async def inrole(self, ctx, *, rolename):
+    async def inrole(self, ctx, *, rolename: str):
         """Check members in the role specified."""
         guild = ctx.guild
         await ctx.trigger_typing()
@@ -286,7 +287,7 @@ class Tools(commands.Cog):
             if len(roles) == 1:
                 role = roles[0]
             elif len(roles) < 1:
-                await ctx.send("No roles were found.")
+                await ctx.send(f"No roles containing `{rolename}` were found.")
                 return
             else:
                 msg = (
@@ -320,41 +321,46 @@ class Tools(commands.Cog):
                 else:
                     role = roles[response - 1]
 
-        awaiter = await ctx.send(
-            embed=discord.Embed(description="Getting member names...", colour=await ctx.embed_colour())
-        )
-        await asyncio.sleep(1.5)  # taking time to retrieve the names
         users_in_role = "\n".join(sorted(m.display_name for m in guild.members if role in m.roles))
         if len(users_in_role) == 0:
-            embed = discord.Embed(
-                description=cf.bold(f"0 users found in the {role.name} role."),
-                colour=await ctx.embed_colour(),
-            )
-            await awaiter.edit(embed=embed)
-            return
-        try:
-            await awaiter.delete()
-        except discord.NotFound:
-            pass
+            if ctx.channel.permissions_for(ctx.guild.me).embed_links:
+                embed = discord.Embed(
+                    description=cf.bold(f"0 users found in the {role.name} role."),
+                    colour=await ctx.embed_colour(),
+                )
+                return await ctx.send(embed=embed)
+            else:
+                return await ctx.send(cf.bold(f"0 users found in the {role.name} role."))
+
         embed_list = []
-        for page in cf.pagify(users_in_role, delims=["\n"], page_length=200):
-            embed = discord.Embed(
-                description=cf.bold("{1} users found in the {0} role.\n").format(
-                    role.name, len([m for m in guild.members if role in m.roles])
-                ),
-                colour=await ctx.embed_colour(),
-            )
-            embed.add_field(name="Users", value=page)
-            embed_list.append(embed)
-        final_embed_list = []
-        for i, embed in enumerate(embed_list):
-            embed.set_footer(text=f"Page {i + 1}/{len(embed_list)}")
-            final_embed_list.append(embed)
-        if len(embed_list) == 1:
-            close_control = {"\N{CROSS MARK}": close_menu}
-            await menu(ctx, final_embed_list, close_control)
+        role_len = len([m for m in guild.members if role in m.roles])
+        if ctx.channel.permissions_for(ctx.guild.me).embed_links:
+            for page in cf.pagify(users_in_role, delims=["\n"], page_length=200):
+                embed = discord.Embed(
+                    description=cf.bold(f"{role_len} users found in the {role.name} role.\n"),
+                    colour=await ctx.embed_colour(),
+                )
+                embed.add_field(name="Users", value=page)
+                embed_list.append(embed)
+            final_embed_list = []
+            for i, embed in enumerate(embed_list):
+                embed.set_footer(text=f"Page {i + 1}/{len(embed_list)}")
+                final_embed_list.append(embed)
+            if len(embed_list) == 1:
+                close_control = {"\N{CROSS MARK}": close_menu}
+                await menu(ctx, final_embed_list, close_control)
+            else:
+                await menu(ctx, final_embed_list, DEFAULT_CONTROLS)
         else:
-            await menu(ctx, final_embed_list, DEFAULT_CONTROLS)
+            for page in cf.pagify(users_in_role, delims=["\n"], page_length=200):
+                msg = f"**{role_len} users found in the {role.name} role.**\n"
+                msg += page
+                embed_list.append(msg)
+            if len(embed_list) == 1:
+                close_control = {"\N{CROSS MARK}": close_menu}
+                await menu(ctx, embed_list, close_control)
+            else:
+                await menu(ctx, embed_list, DEFAULT_CONTROLS)
 
     @commands.guild_only()
     @commands.command()
@@ -376,18 +382,15 @@ class Tools(commands.Cog):
             )
             await ctx.send(embed=embed)
         else:
-            await ctx.send(f"{user.display_name} joined this guild on {joined_on}.")
+            await ctx.send(f"**{user.display_name}** joined this guild on **{joined_on}**.")
 
     @commands.command(name="listguilds", aliases=["listservers", "guildlist", "serverlist"])
     @checks.mod_or_permissions()
     async def listguilds(self, ctx):
         """List the guilds|servers the bot is in."""
-        asciidoc = lambda m: "```asciidoc\n{}\n```".format(m)
         guilds = sorted(self.bot.guilds, key=lambda g: -g.member_count)
-        header = ("```\n" "The bot is in the following {} server{}:\n" "```").format(
-            len(guilds), "s" if len(guilds) > 1 else ""
-        )
-
+        plural = "s" if len(guilds) > 1 else ""
+        header = f"The bot is in the following {len(guilds)} server{plural}:\n"
         max_zpadding = max([len(str(g.member_count)) for g in guilds])
         form = "{gid} :: {mems:0{zpadding}} :: {name}"
         all_forms = [
@@ -396,13 +399,13 @@ class Tools(commands.Cog):
         ]
         final = "\n".join(all_forms)
 
-        await ctx.send(header)
+        await ctx.send(cf.box(header))
         page_list = []
         for page in cf.pagify(final, delims=["\n"], page_length=1000):
-            page_list.append(asciidoc(page))
+            page_list.append(cf.box(page, lang="asciidoc"))
 
         if len(page_list) == 1:
-            return await ctx.send(asciidoc(page))
+            return await ctx.send(cf.box(page, lang="asciidoc"))
         await menu(ctx, page_list, DEFAULT_CONTROLS)
 
     @commands.guild_only()
@@ -412,38 +415,40 @@ class Tools(commands.Cog):
         """
         List the channels of the current server
         """
-        asciidoc = lambda m: "```asciidoc\n{}\n```".format(m)
-        channels = ctx.guild.channels
         top_channels, category_channels = self.sort_channels(ctx.guild.channels)
 
-        topChannels_formed = "\n".join(self.channels_format(top_channels))
+        top_channels_formed = "\n".join(self.channels_format(top_channels))
         categories_formed = "\n\n".join([self.category_format(tup) for tup in category_channels])
 
-        await ctx.send(f"{ctx.guild.name} has {len(channels)} channel{'s' if len(channels) > 1 else ''}.")
+        await ctx.send(
+            f"{ctx.guild.name} has {len(ctx.guild.channels)} channel{'s' if len(ctx.guild.channels) > 1 else ''}."
+        )
 
-        for page in cf.pagify(topChannels_formed, delims=["\n"], shorten_by=16):
-            await ctx.send(asciidoc(page))
+        for page in cf.pagify(top_channels_formed, delims=["\n"], shorten_by=16):
+            await ctx.send(cf.box(page, lang="asciidoc"))
 
         for page in cf.pagify(categories_formed, delims=["\n\n"], shorten_by=16):
-            await ctx.send(asciidoc(page))
+            await ctx.send(cf.box(page, lang="asciidoc"))
 
     @commands.guild_only()
     @commands.command()
     @checks.mod_or_permissions(manage_guild=True)
-    async def newusers(self, ctx, count: int = 5, fm: str = "py"):
-        """Lists the newest 5 members."""
-        guild = ctx.guild
+    async def newusers(self, ctx, count: int = 5, text_format: str = "py"):
+        """
+        Lists the newest 5 members.
+
+        `text_format` is the markdown language to use. Defaults to `py`.
+        """
         count = max(min(count, 25), 5)
-        members = sorted(guild.members, key=lambda m: m.joined_at, reverse=True)[:count]
+        members = sorted(ctx.guild.members, key=lambda m: m.joined_at, reverse=True)[:count]
 
-        head1 = "{} newest members".format(count)
-        header = "{:>33}\n{}\n\n".format(head1, "-" * 57)
+        header = f"{count} newest members"
+        disp = "{:>33}\n{}\n\n".format(header, "-" * 57)
 
-        user_body = (
-            " {mem} ({memid})\n" " {spcs}Joined Guild:    {sp1}{join}\n" " {spcs}Account Created: {sp2}{created}\n\n"
-        )
+        user_body = " {mem} ({memid})\n"
+        user_body += " {spcs}Joined Guild:    {sp1}{join}\n"
+        user_body += " {spcs}Account Created: {sp2}{created}\n\n"
 
-        disp = header
         spcs = [" " * (len(m.name) // 2) for m in members]
         smspc = min(spcs, key=lambda it: len(it))
 
@@ -473,7 +478,7 @@ class Tools(commands.Cog):
             )
 
         for page in cf.pagify(disp, delims=["\n\n"]):
-            await ctx.send(cf.box(page, lang=fm))
+            await ctx.send(cf.box(page, lang=text_format))
 
     @commands.guild_only()
     @commands.command()
@@ -488,10 +493,10 @@ class Tools(commands.Cog):
         perms_we_dont = ""
         for x in sorted(perms):
             if "True" in str(x):
-                perms_we_have += "+\t{0}\n".format(str(x).split("'")[1])
+                perms_we_have += "+ {0}\n".format(str(x).split("'")[1])
             else:
-                perms_we_dont += "-\t{0}\n".format(str(x).split("'")[1])
-        await ctx.send(cf.box("{0}{1}".format(perms_we_have, perms_we_dont), lang="diff"))
+                perms_we_dont += "- {0}\n".format(str(x).split("'")[1])
+        await ctx.send(cf.box(f"{perms_we_have}{perms_we_dont}", lang="diff"))
 
     @commands.guild_only()
     @commands.command()
@@ -501,9 +506,9 @@ class Tools(commands.Cog):
         if rolename is discord.Role:
             role = rolename
         else:
-            role = self._role_from_string(ctx.guild, rolename)
+            role = self.role_from_string(ctx.guild, rolename)
         if role is None:
-            await ctx.send(embed=discord.Embed(description="Cannot find role.", colour=await ctx.embed_colour()))
+            await ctx.send(f"Cannot find role: `{rolename}`")
             return
         await ctx.send(f"**{rolename} ID:** {role.id}")
 
@@ -511,8 +516,6 @@ class Tools(commands.Cog):
     @commands.command()
     async def rinfo(self, ctx, *, rolename: discord.Role):
         """Shows role info."""
-        channel = ctx.channel
-        guild = ctx.guild
         await ctx.trigger_typing()
 
         try:
@@ -521,16 +524,18 @@ class Tools(commands.Cog):
             pass
 
         if not isinstance(rolename, discord.Role):
-            role = self._role_from_string(guild, rolename, guild.roles)
+            role = self.role_from_string(ctx.guild, rolename, ctx.guild.roles)
         else:
             role = rolename
         if role is None:
             await ctx.send("That role cannot be found.")
             return
-        if role is not None:
-            perms = iter(role.permissions)
-            perms_we_have = ""
-            perms_we_dont = ""
+
+        perms = iter(role.permissions)
+        perms_we_have = ""
+        perms_we_dont = ""
+
+        if ctx.channel.permissions_for(ctx.guild.me).embed_links:
             for x in sorted(perms):
                 if "True" in str(x):
                     perms_we_have += "{0}\n".format(str(x).split("'")[1])
@@ -540,52 +545,42 @@ class Tools(commands.Cog):
                 perms_we_have = "None"
             if perms_we_dont == "":
                 perms_we_dont = "None"
-            msg = discord.Embed(description="Gathering role stats...", colour=role.color)
-            if role.color is None:
-                role.color = discord.Colour(value=0x000000)
-            loadingmsg = await ctx.send(embed=msg)
-            em = discord.Embed(colour=role.colour)
+            role_color = role.color if role.color else discord.Colour(value=0x000000)
+            em = discord.Embed(colour=role_color)
             if caller == "invoke":
                 em.add_field(name="Server", value=role.guild.name)
             em.add_field(name="Role Name", value=role.name)
             em.add_field(name="Created", value=self._dynamic_time(role.created_at))
-            em.add_field(name="Users in Role", value=len([m for m in guild.members if role in m.roles]))
+            em.add_field(name="Users in Role", value=len([m for m in ctx.guild.members if role in m.roles]))
             em.add_field(name="ID", value=role.id)
             em.add_field(name="Color", value=role.color)
             em.add_field(name="Position", value=role.position)
-            em.add_field(name="Valid Permissions", value="{}".format(perms_we_have))
-            em.add_field(name="Invalid Permissions", value="{}".format(perms_we_dont))
-            em.set_thumbnail(url=role.guild.icon_url)
-        try:
-            await loadingmsg.edit(embed=em)
-        except discord.HTTPException:
-            permss = "```diff\n"
-            role = self._role_from_string(guild, rolename, guild.roles)
+            em.add_field(name="Valid Permissions", value=perms_we_have)
+            em.add_field(name="Invalid Permissions", value=perms_we_dont)
+            if role.guild.icon:
+                em.set_thumbnail(url=role.guild.icon.url)
+            await ctx.send(embed=em)
+        else:
+            role = self.role_from_string(ctx.guild, rolename, ctx.guild.roles)
             if role is None:
                 await ctx.send("That role cannot be found.")
                 return
-            if role is not None:
-                perms = iter(role.permissions)
-                perms_we_have2 = ""
-                perms_we_dont2 = ""
-                for x in sorted(perms):
-                    if "True" in str(x):
-                        perms_we_have2 += "+{0}\n".format(str(x).split("'")[1])
-                    else:
-                        perms_we_dont2 += "-{0}\n".format(str(x).split("'")[1])
-            await ctx.send(
-                "{}Name: {}\nCreated: {}\nUsers in Role : {}\nId : {}\nColor : {}\nPosition : {}\nValid Perms : \n{}\nInvalid Perms : \n{}```".format(
-                    permss,
-                    role.name,
-                    self._dynamic_time(role.created_at),
-                    len([m for m in guild.members if role in m.roles]),
-                    role.id,
-                    role.color,
-                    role.position,
-                    perms_we_have2,
-                    perms_we_dont2,
-                )
-            )
+
+            for x in sorted(perms):
+                if "True" in str(x):
+                    perms_we_have += "+ {0}\n".format(str(x).split("'")[1])
+                else:
+                    perms_we_dont += "- {0}\n".format(str(x).split("'")[1])
+            msg = ""
+            msg += f"Name: {role.name}\n"
+            msg += f"Created: {self._dynamic_time(role.created_at)}\n"
+            msg += f"Users in Role : {len([m for m in role.guild.members if role in m.roles])}\n"
+            msg += f"ID: {role.id}\n"
+            msg += f"Color: {role.color}\n"
+            msg += f"Position: {role.position}\n"
+            msg += f"Valid Perms: \n{perms_we_have}\n"
+            msg += f"Invalid Perms: \n{perms_we_dont}"
+            await ctx.send(cf.box(msg, lang="diff"))
 
     @commands.guild_only()
     @commands.command(aliases=["listroles"])
@@ -598,25 +593,28 @@ class Tools(commands.Cog):
             form.format(rpos=r.position, zpadding=max_zpadding, rid=r.id, rment=r.mention, rcolor=r.color)
             for r in ctx.guild.roles
         ]
-
         rolelist = sorted(rolelist, reverse=True)
         rolelist = "\n".join(rolelist)
         embed_list = []
-        for page in cf.pagify(rolelist, shorten_by=1400):
-            embed = discord.Embed(
-                description=f"**Total roles:** {len(ctx.guild.roles)}\n\n{page}",
-                colour=await ctx.embed_colour(),
-            )
-            embed_list.append(embed)
+        if ctx.channel.permissions_for(ctx.guild.me).embed_links:
+            for page in cf.pagify(rolelist, shorten_by=1400):
+                embed = discord.Embed(
+                    description=f"**Total roles:** {len(ctx.guild.roles)}\n\n{page}",
+                    colour=await ctx.embed_colour(),
+                )
+                embed_list.append(embed)
+        else:
+            for page in cf.pagify(rolelist, shorten_by=1400):
+                msg = f"**Total roles:** {len(ctx.guild.roles)}\n{page}"
+                embed_list.append(msg)
+
         await menu(ctx, embed_list, DEFAULT_CONTROLS)
 
     @commands.command(hidden=True)
     async def sharedservers(self, ctx, user: discord.Member = None):
         """Shows shared server info. Defaults to author."""
-        author = ctx.author
-        guild = ctx.guild
         if not user:
-            user = author
+            user = ctx.author
 
         mutual_guilds = user.mutual_guilds
         data = f"[Guilds]:     {len(mutual_guilds)} shared\n"
@@ -624,13 +622,13 @@ class Tools(commands.Cog):
         data += f"[In Guilds]:  {cf.humanize_list(shared_servers, style='unit')}"
 
         for page in cf.pagify(data, ["\n"], page_length=1800):
-            await ctx.send(f"```ini\n{data}```")
+            await ctx.send(cf.box(data, lang="ini"))
 
     @commands.guild_only()
     @commands.command()
     async def sid(self, ctx):
-        """Show the server ID."""
-        await ctx.send("**{0.name} ID:** {0.id}".format(ctx.guild))
+        """Show the server id."""
+        await ctx.send(f"**{ctx.guild.name} ID:** {ctx.guild.id}")
 
     @commands.guild_only()
     @commands.command(aliases=["ginfo"])
@@ -648,22 +646,49 @@ class Tools(commands.Cog):
         text_channels = [x for x in guild.channels if isinstance(x, discord.TextChannel)]
         voice_channels = [x for x in guild.channels if isinstance(x, discord.VoiceChannel)]
 
-        load = "```\nLoading guild info...```"
-        waiting = await ctx.send(load)
+        data = f"[Name]:     {guild.name}\n"
+        data += f"[ID]:       {guild.id}\n"
+        data += f"[Owner]:    {guild.owner}\n"
+        data += f"[Users]:    {online}/{total_users}\n"
+        data += f"[Text]:     {len(text_channels)} channels\n"
+        data += f"[Voice]:    {len(voice_channels)} channels\n"
+        data += f"[Emojis]:   {len(guild.emojis)}\n"
+        data += f"[Stickers]: {len(guild.stickers)}\n"
+        data += f"[Roles]:    {len(guild.roles)}\n"
+        data += f"[Created]:  {self._dynamic_time(guild.created_at)}\n"
 
-        data = "```ini\n"
-        data += "[Name]:     {}\n".format(guild.name)
-        data += "[ID]:       {}\n".format(guild.id)
-        data += "[Region]:   {}\n".format(guild.region)
-        data += "[Owner]:    {}\n".format(guild.owner)
-        data += "[Users]:    {}/{}\n".format(online, total_users)
-        data += "[Text]:     {} channels\n".format(len(text_channels))
-        data += "[Voice]:    {} channels\n".format(len(voice_channels))
-        data += "[Emojis]:   {}\n".format(len(guild.emojis))
-        data += "[Roles]:    {} \n".format(len(guild.roles))
-        data += "[Created]:  {}\n```".format(self._dynamic_time(guild.created_at))
-        await asyncio.sleep(1)
-        await waiting.edit(content=data)
+        await ctx.send(cf.box(data, lang="ini"))
+
+    @commands.guild_only()
+    @commands.command(aliases=["stickerinfo"])
+    async def stinfo(self, ctx, message_link: str = None):
+        """
+        Sticker information.
+
+        Attach a sticker to the command message or provide a link to a message with a sticker.
+        """
+        if message_link:
+            message = await self.message_from_message_link(ctx, message_link)
+        else:
+            message = ctx.message
+
+        if isinstance(message, str):
+            return await ctx.send(message)
+
+        stickers = message.stickers
+        for sticker_item in stickers:
+            sticker = await sticker_item.fetch()
+
+            msg = f"[Name]:        {sticker.name}\n"
+            msg += f"[Guild]:       {sticker.guild if sticker.guild != None else 'Guild name is unavailable'}\n"
+            msg += f"[ID]:          {sticker.id}\n"
+            msg += f"[URL]:         {str(sticker.url)}\n"
+            msg += f"[Format]:      {sticker.format.file_extension if sticker.format.file_extension else 'lottie'}\n"
+            if sticker.description:
+                msg += f"[Description]: {sticker.description}\n"
+            msg += f"[Created]:     {self._dynamic_time(sticker.created_at)}\n"
+
+            await ctx.send(cf.box(msg, lang="ini"))
 
     @commands.guild_only()
     @commands.command()
@@ -688,6 +713,40 @@ class Tools(commands.Cog):
         else:
             await menu(ctx, pages, DEFAULT_CONTROLS)
 
+    @commands.guild_only()
+    @commands.command()
+    async def uimages(self, ctx, user: discord.Member = None, embed=False):
+        """
+        Shows user image urls. Defaults to author.
+
+        `embed` is a True/False value for whether to display the info in an embed.
+        """
+        if user is None:
+            user = ctx.author
+
+        fetch_user = await self.bot.fetch_user(user.id)
+
+        if not embed or not ctx.channel.permissions_for(ctx.guild.me).embed_links:
+            data = f"[Name]:              {cf.escape(str(user))}\n"
+            data += f"[Avatar URL]:        {user.avatar if user.avatar is not None else user.default_avatar}\n"
+            if user.guild_avatar:
+                data += f"[Server Avatar URL]: {user.guild_avatar}\n"
+            if fetch_user.banner:
+                data += f"[Banner URL]:        {fetch_user.banner}\n"
+
+            await ctx.send(cf.box(data, lang="ini"))
+        else:
+            embed = discord.Embed(
+                description=f"**{cf.escape(str(user))}**",
+                colour=await ctx.embed_colour(),
+            )
+            if user.guild_avatar:
+                embed.add_field(name="Server Avatar", value=user.guild_avatar, inline=False)
+            embed.set_thumbnail(url=user.avatar if user.avatar is not None else user.default_avatar)
+            if fetch_user.banner:
+                embed.set_image(url=fetch_user.banner)
+            await ctx.send(embed=embed)
+
     @commands.guild_only()
     @commands.command()
     async def uinfo(self, ctx, user: discord.Member = None):
@@ -704,47 +763,42 @@ class Tools(commands.Cog):
                 roles[0].name,
             ] + [f"{r.name:>{len(r.name)+17}}" for r in roles[1:]]
         except IndexError:
-            # if there are no roles then roles[0] will raise the IndexError here
             _roles = ["None"]
 
         seen = str(len(set([member.guild.name for member in self.bot.get_all_members() if member.id == user.id])))
 
-        load = "```\nLoading user info...```"
-        waiting = await ctx.send(load)
-
-        data = "```ini\n"
-        data += "[Name]:          {}\n".format(cf.escape(str(user)))
-        data += "[ID]:            {}\n".format(user.id)
-        data += "[Status]:        {}\n".format(user.status)
-        data += "[Servers]:       {} shared\n".format(seen)
+        data = f"[Name]:          {cf.escape(str(user))}\n"
+        data += f"[ID]:            {user.id}\n"
+        data += f"[Status]:        {user.status}\n"
+        data += f"[Servers]:       {seen} shared\n"
         if actplay := discord.utils.get(user.activities, type=discord.ActivityType.playing):
-            data += "[Playing]:       {}\n".format(cf.escape(str(actplay.name)))
+            data += f"[Playing]:       {cf.escape(str(actplay.name))}\n"
         if actlisten := discord.utils.get(user.activities, type=discord.ActivityType.listening):
             if isinstance(actlisten, discord.Spotify):
-                _form = "{} - {}".format(actlisten.artist, actlisten.title)
+                _form = f"{actlisten.artist} - {actlisten.title}"
             else:
                 _form = actlisten.name
-            data += "[Listening]:     {}\n".format(cf.escape(_form))
+            data += f"[Listening]:     {cf.escape(_form)}\n"
         if actwatch := discord.utils.get(user.activities, type=discord.ActivityType.watching):
-            data += "[Watching]:      {}\n".format(cf.escape(str(actwatch.name)))
+            data += f"[Watching]:      {cf.escape(str(actwatch.name))}\n"
         if actstream := discord.utils.get(user.activities, type=discord.ActivityType.streaming):
-            data += "[Streaming]: [{}]({})\n".format(cf.escape(str(actstream.name)), cf.escape(actstream.url))
+            data += f"[Streaming]: [{cf.escape(str(actstream.name))}]({cf.escape(actstream.url)})\n"
         if actcustom := discord.utils.get(user.activities, type=discord.ActivityType.custom):
             if actcustom.name is not None:
-                data += "[Custom status]: {}\n".format(cf.escape(str(actcustom.name)))
+                data += f"[Custom Status]: {cf.escape(str(actcustom.name))}\n"
         passed = (ctx.message.created_at - user.created_at).days
-        data += "[Created]:       {}\n".format(self._dynamic_time(user.created_at))
+        data += f"[Created]:       {self._dynamic_time(user.created_at)}\n"
         joined_at = self.fetch_joined_at(user, ctx.guild)
         if caller != "invoke":
-            data += "[Joined]:        {}\n".format(self._dynamic_time(joined_at))
-            data += "[Roles]:         {}\n".format("\n".join(_roles))
+            role_list = "\n".join(_roles)
+            data += f"[Joined]:        {self._dynamic_time(joined_at)}\n"
+            data += f"[Roles]:         {role_list}\n"
             if len(_roles) > 1:
                 data += "\n"
-            data += "[In Voice]:      {}\n".format(user.voice.channel if user.voice is not None else None)
-            data += "[AFK]:           {}\n".format(user.voice.afk if user.voice is not None else False)
-        data += "```"
-        await asyncio.sleep(1)
-        await waiting.edit(content=data)
+            data += f"[In Voice]:      {user.voice.channel if user.voice is not None else None}\n"
+            data += f"[AFK]:           {user.voice.afk if user.voice is not None else False}\n"
+
+        await ctx.send(cf.box(data, lang="ini"))
 
     @commands.guild_only()
     @commands.command()
@@ -779,6 +833,8 @@ class Tools(commands.Cog):
             await ctx.invoke(self.sinfo, id)
         elif isinstance(it_is, discord.abc.GuildChannel):
             await ctx.invoke(self.chinfo, id)
+        elif isinstance(it_is, discord.Thread):
+            await ctx.invoke(self.chinfo, id)
         elif isinstance(it_is, (discord.User, discord.Member)):
             await ctx.invoke(self.uinfo, it_is)
         elif isinstance(it_is, discord.Role):
@@ -789,32 +845,7 @@ class Tools(commands.Cog):
             await ctx.send("I could not find anything for this ID.")
 
     @staticmethod
-    def _dynamic_time(time):
-        try:
-            date_join = datetime.datetime.strptime(str(time), "%Y-%m-%d %H:%M:%S.%f")
-        except ValueError:
-            time = f"{str(time)}.0"
-            date_join = datetime.datetime.strptime(str(time), "%Y-%m-%d %H:%M:%S.%f")
-        date_now = datetime.datetime.now(datetime.timezone.utc)
-        date_now = date_now.replace(tzinfo=None)
-        since_join = date_now - date_join
-
-        mins, secs = divmod(int(since_join.total_seconds()), 60)
-        hrs, mins = divmod(mins, 60)
-        days, hrs = divmod(hrs, 24)
-        mths, wks, days = Tools._count_months(days)
-        yrs, mths = divmod(mths, 12)
-
-        m = f"{yrs}y {mths}mth {wks}w {days}d {hrs}h {mins}m {secs}s"
-        m2 = [x for x in m.split() if x[0] != "0"]
-        s = " ".join(m2[:2])
-        if s:
-            return f"{s} ago"
-        else:
-            return ""
-
-    @staticmethod
-    def _count_months(days):
+    def count_months(days):
         lens = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
         cy = itertools.cycle(lens)
         months = 0
@@ -832,10 +863,107 @@ class Tools(commands.Cog):
         weeks, days = divmod(m_temp, 7)
         return months, weeks, days
 
-    def fetch_joined_at(self, user, guild):
+    def category_format(self, cat_chan_tuple: tuple):
+        cat = cat_chan_tuple[0]
+        chs = cat_chan_tuple[1]
+
+        chfs = self.channels_format(chs)
+        if chfs != []:
+            ch_forms = ["\t" + f for f in chfs]
+            return "\n".join([f"{cat.name} :: {cat.id}"] + ch_forms)
+        else:
+            return "\n".join([f"{cat.name} :: {cat.id}"] + ["\tNo Channels"])
+
+    @staticmethod
+    def channels_format(channels: list):
+        if channels == []:
+            return []
+
+        channel_form = "{name} :: {ctype} :: {cid}"
+
+        def type_name(channel):
+            return channel.__class__.__name__[:-7]
+
+        name_justify = max([len(c.name[:24]) for c in channels])
+        type_justify = max([len(type_name(c)) for c in channels])
+
+        return [
+            channel_form.format(
+                name=c.name[:24].ljust(name_justify),
+                ctype=type_name(c).ljust(type_justify),
+                cid=c.id,
+            )
+            for c in channels
+        ]
+
+    def _dynamic_time(self, time):
+        try:
+            date_join = datetime.datetime.strptime(str(time), "%Y-%m-%d %H:%M:%S.%f%z")
+        except ValueError:
+            time = f"{str(time)}.0"
+            date_join = datetime.datetime.strptime(str(time), "%Y-%m-%d %H:%M:%S.%f%z")
+        date_now = discord.utils.utcnow()
+        since_join = date_now - date_join
+
+        mins, secs = divmod(int(since_join.total_seconds()), 60)
+        hrs, mins = divmod(mins, 60)
+        days, hrs = divmod(hrs, 24)
+        mths, wks, days = self.count_months(days)
+        yrs, mths = divmod(mths, 12)
+
+        m = f"{yrs}y {mths}mth {wks}w {days}d {hrs}h {mins}m {secs}s"
+        m2 = [x for x in m.split() if x[0] != "0"]
+        s = " ".join(m2[:2])
+        if s:
+            return f"{s} ago"
+        else:
+            return ""
+
+    @staticmethod
+    def fetch_joined_at(user, guild):
         return user.joined_at
 
-    def _role_from_string(self, guild, rolename, roles=None):
+    async def message_from_message_link(self, ctx: commands.Context, message_link: str):
+        bad_link_msg = "That doesn't look like a message link, I can't reach that message, "
+        bad_link_msg += "or you didn't attach a sticker to the command message."
+        no_guild_msg = "You aren't in that guild."
+        no_channel_msg = "You can't view that channel."
+        no_message_msg = "That message wasn't found."
+        no_sticker_msg = "There are no stickers attached to that message."
+
+        if not "discord.com/channels/" in message_link:
+            return bad_link_msg
+        ids = message_link.split("/")
+        if len(ids) != 7:
+            return bad_link_msg
+
+        guild = self.bot.get_guild(int(ids[4]))
+        if not guild:
+            return bad_link_msg
+
+        channel = guild.get_channel_or_thread(int(ids[5]))
+        if not channel:
+            channel = self.bot.get_channel(int(ids[5]))
+        if not channel:
+            return bad_link_msg
+
+        if ctx.author not in guild.members:
+            return no_guild_msg
+        if not channel.permissions_for(ctx.author).read_messages:
+            return no_channel_msg
+
+        try:
+            message = await channel.fetch_message(int(ids[6]))
+        except discord.errors.NotFound:
+            return no_message_msg
+
+        if not message.stickers:
+            return no_sticker_msg
+
+        return message
+
+    @staticmethod
+    def role_from_string(guild, rolename, roles=None):
         if roles is None:
             roles = guild.roles
         role = discord.utils.find(lambda r: r.name.lower() == str(rolename).lower(), roles)
@@ -861,36 +989,3 @@ class Tools(commands.Cog):
             key=lambda t: t[0].position,
         )
         return channels, category_channels
-
-    def channels_format(self, channels: list):
-        if channels == []:
-            return []
-
-        channel_form = "{name} :: {ctype} :: {cid}"
-
-        def type_name(channel):
-            return channel.__class__.__name__[:-7]
-
-        name_justify = max([len(c.name[:24]) for c in channels])
-        type_justify = max([len(type_name(c)) for c in channels])
-
-        return [
-            channel_form.format(
-                name=c.name[:24].ljust(name_justify),
-                ctype=type_name(c).ljust(type_justify),
-                cid=c.id,
-            )
-            for c in channels
-        ]
-
-    def category_format(self, cat_chan_tuple: tuple):
-
-        cat = cat_chan_tuple[0]
-        chs = cat_chan_tuple[1]
-
-        chfs = self.channels_format(chs)
-        if chfs != []:
-            ch_forms = ["\t" + f for f in chfs]
-            return "\n".join([f"{cat.name} :: {cat.id}"] + ch_forms)
-        else:
-            return "\n".join([f"{cat.name} :: {cat.id}"] + ["\tNo Channels"])

trackdecoder/__init__.py

@@ -3,5 +3,5 @@ from .trackdecoder import TrackDecoder
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(TrackDecoder(bot))
+async def setup(bot):
+    await bot.add_cog(TrackDecoder(bot))

trickortreat/__init__.py

@@ -10,5 +10,5 @@ __red_end_user_data_statement__ = (
 )
 
 
-def setup(bot):
-    bot.add_cog(TrickOrTreat(bot))
+async def setup(bot):
+    await bot.add_cog(TrickOrTreat(bot))

ttt/__init__.py

@@ -2,5 +2,5 @@ from .ttt import TTT
 
 __red_end_user_data_statement__ = "This cog does store temporarily (in memory) data about users, which is cleared after the game is done."
 
-def setup(bot):
-    bot.add_cog(TTT(bot))
+async def setup(bot):
+    await bot.add_cog(TTT(bot))

urlfetch/__init__.py

@@ -3,5 +3,5 @@ from .urlfetch import UrlFetch
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(UrlFetch(bot))
+async def setup(bot):
+    await bot.add_cog(UrlFetch(bot))

voicelogs/__init__.py

@@ -2,5 +2,5 @@ from .voicelogs import VoiceLogs
 
 
 async def setup(bot):
-    cog = VoiceLogs(bot)
-    bot.add_cog(cog)
+    n = VoiceLogs(bot)
+    await bot.add_cog(n)

warcraftlogs/__init__.py

@@ -1,19 +0,0 @@
-from redbot.core.bot import Red
-from .core import WarcraftLogs
-
-__red_end_user_data_statement__ = (
-    "This cog stores data provided by users "
-    "for the express purpose of redisplaying. "
-    "It does not store user data which was not "
-    "provided through a command. "
-    "Users may remove their own content "
-    "without making a data removal request. "
-    "This cog does not support data requests, "
-    "but will respect deletion requests."
-)
-
-
-async def setup(bot: Red) -> None:
-    cog = WarcraftLogs(bot)
-    await cog._create_client()
-    bot.add_cog(cog)

warcraftlogs/calls.py

@@ -1,74 +0,0 @@
-# Most of the source of this file can be found at: https://github.com/Kowlin/GraphQL-WoWLogs/blob/master/wowlogs/calls.py
-
-class Queries:
-
-    get_last_encounter = """
-    query ($char_realm: String!, $char_name: String!, $char_server: String!) {
-  rateLimitData {
-    limitPerHour
-    pointsSpentThisHour
-    pointsResetIn
-  }
-  characterData {
-    character(name: $char_name, serverSlug: $char_realm, serverRegion: $char_server) {
-      name
-      id
-      classID
-      recentReports(limit: 1) {
-        data {
-          fights(killType: Kills) {
-            encounterID
-            name
-            endTime
-          }
-        }
-      }
-    }
-  }
-}
-"""
-
-    get_overview = """
-    query ($char_realm: String!, $char_name: String!, $char_server: String!, $zone_id: Int!) {
-  rateLimitData {
-    limitPerHour
-    pointsSpentThisHour
-    pointsResetIn
-  }
-  characterData {
-    character(name: $char_name, serverSlug: $char_realm, serverRegion: $char_server) {
-      name
-      id
-      zoneRankings(zoneID: $zone_id)
-      }
-    }
-  }
-"""
-
-    get_gear = """
-    query($char_realm: String!, $char_name: String!, $char_server: String!, $encounter: Int!) {
-  rateLimitData {
-    limitPerHour
-    pointsSpentThisHour
-    pointsResetIn
-  }
-  characterData {
-    character(name: $char_name, serverSlug: $char_realm, serverRegion: $char_server) {
-      name
-      id
-      classID
-      encounterRankings(includeCombatantInfo: true, byBracket: true, encounterID: $encounter)
-    }
-  }
-}
-"""
-
-    check_bearer = """
-    query {
-  rateLimitData {
-    limitPerHour
-    pointsSpentThisHour
-    pointsResetIn
-  }
-}
-"""

warcraftlogs/core.py

@@ -1,612 +0,0 @@
-# Most of the source of this file for the actual API mechanics can be found at: 
-# https://github.com/Kowlin/GraphQL-WoWLogs/blob/master/wowlogs/core.py
-
-import discord
-import io
-import logging
-import math
-
-from redbot.core import checks, commands, Config
-from redbot.core.bot import Red
-from redbot.core.data_manager import bundled_data_path
-from redbot.core.utils.chat_formatting import box
-
-from beautifultable import ALIGN_LEFT, BeautifulTable
-from datetime import datetime
-from PIL import ImageFont, ImageDraw, Image
-from typing import Literal, Mapping, Optional
-
-from .enchantid import ENCHANT_ID
-from .encounterid import ZONES_BY_ID, ZONES_BY_SHORT_NAME
-from .http import WoWLogsClient, generate_bearer
-
-
-log = logging.getLogger("red.aikaterna.warcraftlogs")
-
-WCL_URL = "https://classic.warcraftlogs.com/reports/{}"
-
-
-class WarcraftLogs(commands.Cog):
-    """Retrieve World of Warcraft Classic character information from WarcraftLogs."""
-
-    def __init__(self, bot):
-        self.bot: Red = bot
-        self.config = Config.get_conf(self, identifier=2713931002, force_registration=True)
-        self.http: WoWLogsClient = None
-        self.path = bundled_data_path(self)
-
-        self.config.register_global(bearer_timestamp=0)
-
-        default_user = {
-            "charname": None,
-            "realm": None,
-            "region": None,
-        }
-
-        self.config.register_user(**default_user)
-
-    async def _create_client(self) -> None:
-        self.http = WoWLogsClient(bearer=await self._get_bearer())
-        bearer_status = await self.http.check_bearer()
-        if bearer_status is False:
-            await generate_bearer(self.bot, self.config)
-            await self.http.recreate_session(await self._get_bearer())
-
-    async def _get_bearer(self) -> str:
-        api_tokens = await self.bot.get_shared_api_tokens("warcraftlogs")
-        bearer = api_tokens.get("bearer", "")
-
-        bearer_timestamp = await self.config.bearer_timestamp()
-        timestamp_now = int(datetime.utcnow().timestamp())
-
-        if timestamp_now > bearer_timestamp:
-            log.info("Bearer token has expired. Generating one")
-            bearer = await generate_bearer(self.bot, self.config)
-        elif not bearer:
-            log.info("Bearer token doesn't exist. Generating one")
-            bearer = await generate_bearer(self.bot, self.config)
-
-        if bearer is None:
-            return
-        return bearer
-
-    def cog_unload(self) -> None:
-        self.bot.loop.create_task(self.http.session.close())
-
-    async def red_get_data_for_user(self, **kwargs):
-        return {}
-
-    async def red_delete_data_for_user(
-        self, *, requester: Literal["discord", "owner", "user", "user_strict"], user_id: int
-    ):
-        await self.config.user_from_id(user_id).clear()
-
-    @commands.bot_has_permissions(embed_links=True)
-    @commands.command()
-    async def getgear(self, ctx, name: str = None, realm: str = None, *, region: str = None):
-        """
-        Fetch a character's gear.
-
-        Examples:
-        [p]getgear Username Atiesh US
-        [p]getgear Username Nethergarde Keep EU
-
-        This is provided from the last log entry for a user that includes gear data.
-        Not every log has gear data.
-        Enchants can be shown - if the log provides them.
-        """
-        userdata = await self.config.user(ctx.author).all()
-
-        if not name:
-            name = userdata["charname"]
-            if not name:
-                return await ctx.send("Please specify a character name with this command.")
-        if not realm:
-            realm = userdata["realm"]
-            if not realm:
-                return await ctx.send("Please specify a realm name with this command.")
-        if not region:
-            region = userdata["region"]
-            if not region:
-                return await ctx.send("Please specify a region name with this command.")
-
-        if len(region.split(" ")) > 1:
-            presplit = region.split(" ")
-            realm = f"{realm}-{presplit[0]}"
-            region = presplit[1]
-
-        name = name.title()
-        realm = realm.title()
-        region = region.upper()
-
-        # Get the user's last raid encounters
-        encounters = await self.http.get_last_encounter(name, realm, region)
-
-        if encounters is False:
-            # the user wasn't found on the API.
-            return await ctx.send(f"{name} wasn't found on the API.")
-
-        error = encounters.get("error", None)
-        if error:
-            return await ctx.send(f"WCL API Error: {error}")
-
-        if encounters is None:
-            return await ctx.send("The bearer token was invalidated for some reason.")
-
-        char_data = await self.http.get_gear(name, realm, region, encounters["latest"])
-        if not char_data:
-            return await ctx.send("Check your API token and make sure you have added it to the bot correctly.")
-        gear = None
-
-        if char_data is None:
-            # Assuming bearer has been invalidated.
-            await self._create_client()
-
-        if len(char_data["encounterRankings"]["ranks"]) != 0:
-            # Ensure this is the encounter that has gear listed. IF its not, we're moving on with the other encounters.
-            sorted_by_time = sorted(char_data["encounterRankings"]["ranks"], key=lambda k: k['report']['startTime'], reverse=True) 
-            gear = sorted_by_time[0]["gear"]
-        else:
-            encounters["ids"].remove(encounters["latest"])
-            for encounter in encounters["ids"]:
-                char_data = await self.http.get_gear(name, realm, region, encounter)
-                if len(char_data["encounterRankings"]["ranks"]) != 0:
-                    sorted_by_time = sorted(char_data["encounterRankings"]["ranks"], key=lambda k: k['report']['startTime'], reverse=True) 
-                    gear = sorted_by_time[0]["gear"]
-                    break
-
-        if gear is None:
-            return await ctx.send(f"No gear for {name} found in the last report.")
-
-        item_list = []
-        item_ilevel = 0
-        item_count = 0
-        for item in gear:
-            if item["id"] == 0:
-                continue
-            # item can be {'name': 'Unknown Item', 'quality': 'common', 'id': None, 'icon': 'inv_axe_02.jpg'} here
-            rarity = self._get_rarity(item)
-            item_ilevel_entry = item.get("itemLevel", None)
-            if item_ilevel_entry:
-                if int(item["itemLevel"]) > 5:
-                    item_ilevel += int(item["itemLevel"])
-                    item_count += 1
-            item_list.append(f"{rarity} [{item['name']}](https://classic.wowhead.com/item={item['id']})")
-            perm_enchant_id = item.get("permanentEnchant", None)
-            temp_enchant_id = item.get("temporaryEnchant", None)
-            perm_enchant_text = ENCHANT_ID.get(perm_enchant_id, None)
-            temp_enchant_text = ENCHANT_ID.get(temp_enchant_id, None)
-
-            if perm_enchant_id:
-                if temp_enchant_id:
-                    symbol = "├"
-                else:
-                    symbol = "└"
-                if perm_enchant_text:
-                    item_list.append(f"`{symbol}──` {perm_enchant_text}")
-            if temp_enchant_id:
-                if temp_enchant_text:
-                    item_list.append(f"`└──` {temp_enchant_text}")
-
-        if item_ilevel > 0:
-            avg_ilevel = "{:g}".format(item_ilevel / item_count)
-        else:
-            avg_ilevel = "Unknown (not present in log data from the API)"
-
-        # embed
-        embed = discord.Embed()
-        title = f"{name.title()} - {realm.title()} ({region.upper()})"
-        guild_name = sorted_by_time[0]["guild"].get("name", None)
-        if guild_name:
-            title += f"\n{guild_name}"
-        embed.title = title
-        embed.description = "\n".join(item_list)
-
-        # embed footer
-        ilvl = f"Average Item Level: {avg_ilevel}\n"
-        encounter_spec = sorted_by_time[0].get("spec", None)
-        spec = f"Encounter spec: {encounter_spec}\n"
-        gear_data = f'Gear data pulled from {WCL_URL.format(sorted_by_time[0]["report"]["code"])}\n'
-        log = f'Log Date/Time: {self._time_convert(sorted_by_time[0]["startTime"])} UTC'
-        embed.set_footer(text=f"{spec}{ilvl}{gear_data}{log}")
-
-        await ctx.send(embed=embed)
-
-    @commands.bot_has_permissions(embed_links=True)
-    @commands.command()
-    async def getrank(self, ctx, name: str = None, realm: str = None, region: str = None, zone: str = None):
-        """
-        Character rank overview.
-
-        If the realm name is two words, use a hyphen to connect the words.
-
-        Examples:
-        [p]getrank Username Atiesh US
-        [p]getrank Username Nethergarde-Keep EU
-
-        Specific Zones:
-        [p]getrank Username Atiesh US BWL
-        [p]getrank Username Nethergarde-Keep EU AQ20
-
-        Zone name must be formatted like:
-        Naxx, AQ40, AQ20, ZG, BWL, Ony, MC
-
-        - Only Phase 6 World Buff metrics will be displayed
-        """
-        # someone has their data saved so they are just trying 
-        # to look up a zone for themselves
-        if name:
-            if name.upper() in ZONES_BY_SHORT_NAME:
-                zone = name
-                name = None
-                realm = None
-                region = None
-
-        # look up any saved info
-        userdata = await self.config.user(ctx.author).all()
-        if not name:
-            name = userdata["charname"]
-            if not name:
-                return await ctx.send("Please specify a character name with this command.")
-        if not realm:
-            realm = userdata["realm"]
-            if not realm:
-                return await ctx.send("Please specify a realm name with this command.")
-        if not region:
-            region = userdata["region"]
-            if not region:
-                return await ctx.send("Please specify a region name with this command.")
-
-        region = region.upper()
-        if region not in ["US", "EU"]:
-            msg = "Realm names that have a space (like 'Nethergarde Keep') must be written with a hyphen, "
-            msg += "upper or lower case: `nethergarde-keep` or `Nethergarde-Keep`."
-            return await ctx.send(msg)
-
-        name = name.title()
-        realm = realm.title()
-
-        # fetch zone name and zone id from user input
-        zone_id = None
-        if zone:
-            if zone.upper() in ZONES_BY_SHORT_NAME:
-                zone_id = ZONES_BY_SHORT_NAME[zone.upper()][1]
-                zone_id_to_name = ZONES_BY_SHORT_NAME[zone.upper()][0]
-
-        if zone_id == None:
-            # return first raid that actually has parse info in phase 6
-            # as no specific zone was requested
-            zone_ids = list(ZONES_BY_ID.keys())
-            zone_ids.reverse()
-            for zone_number in zone_ids:
-                data = await self.http.get_overview(name, realm, region, zone_number)
-                error = data.get("error", None)
-                if error:
-                    return await ctx.send(f"WCL API Error: {error}")
-                if (data is False) or (not data["data"]["characterData"]["character"]):
-                    return await ctx.send(f"{name} wasn't found on the API.")
-                char_data = data["data"]["characterData"]["character"]["zoneRankings"]
-                data_test = char_data.get("bestPerformanceAverage", None)
-                if data_test != None:
-                    break
-        else:
-            # try getting a specific zone's worth of info for this character
-            data = await self.http.get_overview(name, realm, region, zone_id)
-            error = data.get("error", None)
-            if error:
-                return await ctx.send(f"WCL API Error: {error}")
-            if (data is False) or (not data["data"]["characterData"]["character"]):
-                return await ctx.send(f"{name} wasn't found on the API.")
-
-        # embed and data setup
-        zws = "\N{ZERO WIDTH SPACE}"
-        space = "\N{SPACE}"
-
-        try:
-            char_data = data["data"]["characterData"]["character"]["zoneRankings"]
-        except (KeyError, TypeError):
-            msg = "Something went terribly wrong while trying to access the zone rankings for this character."
-            return await ctx.send(msg)
-
-        zone_name = await self._zone_name_from_id(char_data["zone"])
-        zone_name = f"⫷ {zone_name} ⫸".center(40, " ")
-
-        embed = discord.Embed()
-        embed.title = f"{name.title()} - {realm.title()} ({region.upper()})"
-
-        # perf averages
-        embed.add_field(name=zws, value=box(zone_name, lang="fix"), inline=False)  ###
-
-        perf_avg = char_data.get("bestPerformanceAverage", None)
-        if perf_avg:
-            pf_avg = "{:.1f}".format(char_data["bestPerformanceAverage"])
-            pf_avg = self._get_color(float(pf_avg))
-            embed.add_field(name="Best Perf. Avg", value=pf_avg, inline=True)
-        else:
-            if zone_id:
-                return await ctx.send(f"Nothing found for {zone_id_to_name.title()} for this player for phase 6.")
-            else:
-                return await ctx.send("Nothing at all found for this player for phase 6.")
-
-        md_avg = "{:.1f}".format(char_data["medianPerformanceAverage"])
-        md_avg = self._get_color(float(md_avg))
-        embed.add_field(name="Median Perf. Avg", value=md_avg, inline=True)
-
-        # perf avg filler space
-        embed.add_field(name=zws, value=zws, inline=True)
-
-        # table setup
-        table = BeautifulTable(default_alignment=ALIGN_LEFT, maxwidth=500)
-        table.set_style(BeautifulTable.STYLE_COMPACT)
-        table.columns.header = [
-            "Name",
-            "Best %",
-            "Spec",
-            "DPS",
-            "Kills",
-            "Fastest",
-            "Med %",
-            "AS Pts",
-            "AS Rank",
-        ]
-
-        # add rankings per encounter to table
-        rankings = sorted(char_data["rankings"], key=lambda k: k["encounter"]["id"])
-        for encounter in rankings:
-            all_stars = encounter["allStars"]
-            enc_details = encounter["encounter"]
-            best_amt = "{:.1f}".format(encounter["bestAmount"]) if encounter["bestAmount"] != 0 else "-"
-            median_pct = "{:.1f}".format(encounter["medianPercent"]) if encounter["medianPercent"] else "-"
-            rank_pct = "{:.1f}".format(encounter["rankPercent"]) if encounter["medianPercent"] else "-"
-            fastest_kill_tup = self._dynamic_time(encounter["fastestKill"] / 1000)
-
-            if fastest_kill_tup == (0, 0):
-                fastest_kill = "-"
-            else:
-                if len(str(fastest_kill_tup[1])) == 1:
-                    seconds = f"0{fastest_kill_tup[1]}"
-                else:
-                    seconds = fastest_kill_tup[1]
-                fastest_kill = f"{fastest_kill_tup[0]}:{seconds}"
-
-            table.rows.append(
-                (
-                    enc_details.get("name", None),
-                    rank_pct,
-                    encounter["spec"],
-                    best_amt,
-                    encounter["totalKills"],
-                    fastest_kill,
-                    median_pct,
-                    all_stars.get("points", None) if all_stars else "-",
-                    all_stars.get("rank", None) if all_stars else "-",
-                )
-            )
-
-        # all stars
-        all_stars = char_data["allStars"]
-        section_name = f"⫷ Expansion All Stars ⫸".center(40, " ")
-        embed.add_field(name=zws, value=box(section_name, lang="Prolog"), inline=False)
-        for item in all_stars:
-            msg = f"**{item['spec']}**\n"
-            rank_percent = "{:.1f}".format(item["rankPercent"])
-            msg += f"Points:\n`{item['points']}`\n"
-            msg += f"Rank:\n`{item['rank']}`\n"
-            msg += f"{self._get_color(float(rank_percent), '%')}\n"
-            embed.add_field(name=zws, value=msg, inline=True)
-
-        # all stars filler space
-        if not len(all_stars) % 3 == 0:
-            nearest_multiple = 3 * math.ceil(len(all_stars) / 3)
-        else:
-            nearest_multiple = len(all_stars)
-        bonus_empty_fields = nearest_multiple - len(all_stars)
-        if bonus_empty_fields > 0:
-            for _ in range(bonus_empty_fields):
-                embed.add_field(name=zws, value=zws, inline=True)
-
-        # table time
-        table_image = await self._make_table_image(str(table))
-        image_file = discord.File(fp=table_image, filename="table_image.png")
-        embed.set_image(url=f"attachment://{image_file.filename}")
-
-        await ctx.send(file=image_file, embed=embed)
-
-    @commands.command()
-    async def wclcharname(self, ctx, charname: str):
-        """Set your character's name."""
-        await self.config.user(ctx.author).charname.set(charname)
-        await ctx.send(f"Your character name was set to {charname.title()}.")
-
-    @commands.command()
-    async def wclrealm(self, ctx, *, realm: str):
-        """Set your realm."""
-        realmname = realm.replace(" ", "-")
-        await self.config.user(ctx.author).realm.set(realmname)
-        await ctx.send(f"Your realm was set to {realm.title()}.")
-
-    @commands.command()
-    async def wclregion(self, ctx, region: str):
-        """Set your region."""
-        valid_regions = ["EU", "US"]
-        if region.upper() not in valid_regions:
-            return await ctx.send("Valid regions are: {humanize_list(valid_regions)}")
-        await self.config.user(ctx.author).region.set(region)
-        await ctx.send(f"Your realm's region was set to {region.upper()}.")
-
-    @commands.command()
-    async def wclsettings(self, ctx, user: discord.User = None):
-        """Show your current settings."""
-        if not user:
-            user = ctx.author
-        userinfo = await self.config.user(user).all()
-        msg = f"[Settings for {user.display_name}]\n"
-        charname = userinfo["charname"].title() if userinfo["charname"] else "None"
-        realmname = userinfo["realm"].title().replace("-", " ") if userinfo["realm"] else "None"
-        regionname = userinfo["region"].upper() if userinfo["region"] else "None"
-        msg += f"Character: {charname}\nRealm: {realmname}\nRegion: {regionname}\n\n"
-
-        msg += f"[Bot Permissions Needed]\n"
-        if ctx.message.guild.me.guild_permissions.embed_links:
-            msg += "[X] Embed Links permissions\n"
-        else:
-            msg += "[ ] I need Embed Links permissions\n"
-
-        await ctx.send(box(msg, lang="ini"))
-
-    @commands.command()
-    @checks.is_owner()
-    async def wclapikey(self, ctx):
-        """Instructions for setting the api key."""
-        msg = "Set your API key by adding it to Red's API key storage.\n"
-        msg += "Get a key from <https://classic.warcraftlogs.com> by signing up for an account, then visit your settings.\n"
-        msg += "At the bottom is a section called Web API. Click on the blue link that says `manage your V2 clients here`.\n"
-        msg += "Do NOT sign up for a v1 API key, it will not work with this cog.\n"
-        msg += "Click on Create Client. Be ready to write down your information somewhere, you cannot retrive the secret after this.\n"
-        msg += "Enter a name (whatever you want), `https://localhost` for the redirect URL, and leave the Public Client box unchecked.\n"
-        msg += f"Use `{ctx.prefix}set api warcraftlogs client_id,client-id-goes-here client_secret,client-secret-goes-here` to set your key.\n"
-        await ctx.send(msg)
-
-    @commands.command(hidden=True)
-    @checks.is_owner()
-    async def wclrank(self, ctx):
-        """[Depreciated] Fetch ranking info about a player."""
-        msg = "This cog has changed significantly from the last update.\n"
-        msg += f"Use `{ctx.prefix}help WarcraftLogs` to see all commands.\n"
-        msg += f"Use `{ctx.prefix}wclapikey` to see instructions on how to get the new API key.\n"
-        await ctx.send(msg)
-
-    @commands.command(hidden=True)
-    @commands.guild_only()
-    async def wclgear(self, ctx):
-        """[Depreciated] Fetch gear info about a player."""
-        msg = "This cog has changed significantly from the last update.\n"
-        msg += f"Use `{ctx.prefix}help WarcraftLogs` to see all commands.\n"
-        msg += f"Use `{ctx.prefix}wclapikey` to see instructions on how to get the new API key.\n"
-        await ctx.send(msg)
-
-    async def _make_table_image(self, table):
-        image_path = str(self.path / "blank.png")
-        image = Image.open(image_path)
-        draw = ImageDraw.Draw(image)
-        font = ImageFont.truetype(str(self.path / "Cousine-Regular.ttf"), 20)
-
-        x = 20
-        y = 0
-
-        text_lines = table.split("\n")
-        for text_line in text_lines:
-            y += 25
-            draw.text((x, y), text_line, font=font, fill=(255, 255, 255, 255))
-
-        image_object = io.BytesIO()
-        image.save(image_object, format="PNG")
-        image_object.seek(0)
-        return image_object
-
-    @staticmethod
-    def _dynamic_time(time_elapsed):
-        m, s = divmod(int(time_elapsed), 60)
-        return m, s
-
-    @staticmethod
-    def _get_rarity(item):
-        rarity = item["quality"]
-        if rarity == "common":
-            return "⬜"
-        elif rarity == "uncommon":
-            return "🟩"
-        elif rarity == "rare":
-            return "🟦"
-        elif rarity == "epic":
-            return "🟪"
-        else:
-            return "🔳"
-
-    @staticmethod
-    def _time_convert(time):
-        time = str(time)[0:10]
-        value = datetime.fromtimestamp(int(time)).strftime("%Y-%m-%d %H:%M:%S")
-        return value
-
-    @staticmethod
-    async def _zone_name_from_id(zoneID: int):
-        for zone_id, zone_name in ZONES_BY_ID.items():
-            if zoneID == zone_id:
-                return zone_name
-
-    def _get_color(self, number: float, bonus=""):
-        if number >= 95:
-            # legendary
-            out = self._orange(number, bonus)
-        elif 94 >= number > 75:
-            # epic
-            out = self._red(number, bonus)
-        elif 75 >= number > 50:
-            # rare
-            out = self._blue(number, bonus)
-        elif 50 >= number > 25:
-            # common
-            out = self._green(number, bonus)
-        elif 25 >= number >= 0:
-            # trash
-            out = self._grey(number, bonus)
-        else:
-            # someone fucked up somewhere
-            out = box(number)
-        return out
-
-    @staticmethod
-    def _red(number, bonus):
-        output_center = f"{str(number)}{bonus}".center(8, " ")
-        text = f" [  {output_center}  ]"
-        new_number = f"{box(text, lang='css')}"
-        return new_number
-
-    @staticmethod
-    def _orange(number, bonus):
-        output_center = f"{str(number)}{bonus}".center(8, " ")
-        text = f" [  {output_center}  ]"
-        new_number = f"{box(text, lang='fix')}"
-        return new_number
-
-    @staticmethod
-    def _green(number, bonus):
-        output_center = f"{str(number)}{bonus}".center(8, " ")
-        text = f" [  {output_center}  ]"
-        new_number = f"{box(text, lang='py')}"
-        return new_number
-
-    @staticmethod
-    def _blue(number, bonus):
-        output_center = f"{str(number)}{bonus}".center(8, " ")
-        text = f" [  {output_center}  ]"
-        new_number = f"{box(text, lang='ini')}"
-        return new_number
-
-    @staticmethod
-    def _grey(number, bonus):
-        output_center = f"{str(number)}{bonus}".center(8, " ")
-        text = f" [  {output_center}  ]"
-        new_number = f"{box(text, lang='bf')}"
-        return new_number
-
-    @commands.Cog.listener()
-    async def on_red_api_tokens_update(self, service_name: str, api_tokens: Mapping[str, str]):
-        """Lifted shamelessly from GHC. Thanks Kowlin for this and everything else you did on this cog."""
-        if service_name != "warcraftlogs":
-            return
-        await self.http.recreate_session(await self._get_token(api_tokens))
-
-    async def _get_token(self, api_tokens: Optional[Mapping[str, str]] = None) -> str:
-        """Get WCL bearer token."""
-        if api_tokens is None:
-            api_tokens = await self.bot.get_shared_api_tokens("warcraftlogs")
-
-        bearer = api_tokens.get("bearer", None)
-        if not bearer:
-            log.info("No valid token found, trying to create one.")
-            await generate_bearer(self.bot, self.config)
-            return await self._get_bearer()
-        else:
-            return bearer

warcraftlogs/data/LICENSE.txt

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2010-2012 Google Corporation
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

warcraftlogs/data/NOTICE.txt

@@ -1,7 +0,0 @@
-Cousine-Regular.ttf
-
-Cousine was designed by Steve Matteson as an innovative, refreshing sans serif design that is metrically compatible with Courier New™. 
-Cousine offers improved on-screen readability characteristics and the pan-European WGL character set and solves the needs of developers looking for width-compatible
-fonts to address document portability across platforms.
-
-Digitized data copyright (c) 2010-2012 Google Corporation.

warcraftlogs/encounterid.py

@@ -1,91 +0,0 @@
-ENCOUNTER_ID = {
-    610: "Razorgore the Untamed",
-    611: "Vaelastrasz the Corrupt",
-    612: "Broodlord Lashlayer",
-    613: "Firemaw",
-    614: "Ebonroc",
-    615: "Flamegor",
-    616: "Chromaggus",
-    617: "Nefarian",
-    663: "Lucifron",
-    664: "Magmadar",
-    665: "Gehennas",
-    666: "Garr",
-    667: "Shazzrah",
-    668: "Baron Geddon",
-    669: "Sulfuron Harbinger",
-    670: "Golemagg the Incinerator",
-    671: "Majordomo Executus",
-    672: "Ragnaros",
-    709: "The Prophet Skeram",
-    710: "Silithid Royalty",
-    711: "Battleguard Sartura",
-    712: "Fankriss the Unyielding",
-    713: "Viscidus",
-    714: "Princess Huhuran",
-    715: "Twin Emperors",
-    716: "Ouro",
-    717: "C'thun",
-    718: "Kurinnaxx",
-    719: "General Rajaxx",
-    720: "Moam",
-    721: "Buru the Gorger",
-    722: "Ayamiss the Hunter",
-    723: "Ossirian the Unscarred",
-    784: "High Priest Venoxis",
-    785: "High Priestess Jeklik",
-    786: "High Priestess Mar'li",
-    787: "Bloodlord Mandokir",
-    788: "Edge of Madness",
-    789: "High Priest Thekal",
-    790: "Gahz'ranka",
-    791: "High Priestess Arlokk",
-    792: "Jin'do the Hexxer",
-    793: "Hakkar",
-    1084: "Onyxia",
-    1107: "Anub'Rekhan",
-    1108: "Gluth",
-    1109: "Gothik the Harvester",
-    1110: "Grand Widow Faerlina",
-    1111: "Grobbulus",
-    1112: "Heigan the Unclean",
-    1113: "Instructor Razuvious",
-    1114: "Kel'Thuzad",
-    1115: "Loatheb",
-    1116: "Maexxna",
-    1117: "Noth the Plaguebringer",
-    1118: "Patchwerk",
-    1119: "Sapphiron",
-    1120: "Thaddius",
-    1121: "The Four Horsemen",
-}
-
-ENCOUNTER_ZONES = {
-    "Molten Core": [663, 664, 665, 666, 667, 668, 669, 670, 671, 672],
-    "Onyxia": [1084],
-    "Blackwing Lair": [610, 611, 612, 613, 614, 615, 616, 617],
-    "Zul'Gurub": [784, 785, 786, 787, 788, 789, 790, 791, 792, 793],
-    "Ahn'Qiraj Ruins": [718, 719, 720, 721, 722, 723],
-    "Ahn'Qiraj Temple": [709, 710, 711, 712, 713, 714, 715, 716, 717],
-    "Naxxramas": [1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121],
-}
-
-ZONES_BY_ID = {
-    1000: "Molten Core",
-    1001: "Onyxia",
-    1002: "Blackwing Lair",
-    1003: "Zul'Gurub",
-    1004: "Ahn'Qiraj Ruins",
-    1005: "Ahn'Qiraj Temple",
-    1006: "Naxxramas",
-}
-
-ZONES_BY_SHORT_NAME = {
-    "MC": ["Molten Core", 1000],
-    "ONY": ["Onyxia", 1001],
-    "BWL": ["Blackwing Lair", 1002],
-    "ZG": ["Zul'Gurub", 1003],
-    "AQ20": ["Ahn'Qiraj Ruins", 1004],
-    "AQ40": ["Ahn'Qiraj Temple", 1005],
-    "NAXX": ["Naxxramas", 1006],
-}

warcraftlogs/http.py

@@ -1,176 +0,0 @@
-# Most of this code is copied from https://github.com/Kowlin/Sentinel/blob/master/githubcards/http.py
-# Most of the source of this file can be found at: https://github.com/Kowlin/GraphQL-WoWLogs/blob/master/wowlogs/http.py
-
-from enum import unique
-import aiohttp
-import logging
-
-from redbot.core.bot import Red
-from redbot.core.config import Config
-
-from datetime import datetime
-
-from .calls import Queries
-
-log = logging.getLogger("red.aikaterna.warcraftlogs.http")
-baseurl = "https://classic.warcraftlogs.com"
-graphql_url = baseurl + "/api/v2/client"
-
-
-async def generate_bearer(bot: Red, config: Config) -> str:
-    """Generate the Bearer token used in GraphQL queries
-
-    Bot and Config are imported here from the main class,
-    due the need to save data to both of them."""
-    tokens = await bot.get_shared_api_tokens("warcraftlogs")
-
-    client_id = tokens.get("client_id", "")
-    client_secret = tokens.get("client_secret", "")
-    if not client_id:
-        log.error("Generate bearer: No valid client ID set")
-        return None
-    elif not client_secret:
-        log.error("Generate bearer: No valid client secret set")
-        return None
-    else:
-        headers = {"User-Agent": "Red-DiscordBot/WarcraftLogsCog"}
-        async with aiohttp.ClientSession(
-            headers=headers, auth=aiohttp.BasicAuth(login=client_id, password=client_secret)
-        ) as session:
-            form = aiohttp.FormData()
-            form.add_field("grant_type", "client_credentials")
-            request = await session.post(f"{baseurl}/oauth/token", data=form)
-            json = await request.json()
-            if json.get("error", ""):
-                log.error("There is an error generating the bearer key, probably a misconfigured client id and secret.")
-                log.error(f"{json['error']}: {json['error_description']}")
-                return None
-
-            timestamp_now = int(datetime.utcnow().timestamp())  # Round the timestamp down to a full number
-            bearer_timestamp = (
-                timestamp_now + json["expires_in"] - 120
-            )  # Reduce the timestamp by 2 min to be on the safe side of possible errors
-            await config.bearer_timestamp.set(bearer_timestamp)
-
-            log.info("Bearer token created")
-            await bot.set_shared_api_tokens("warcraftlogs", bearer=json["access_token"])
-            return json["access_token"]
-
-
-class WoWLogsClient:
-    """This is where the magic happens."""
-
-    def __init__(self, bearer: str) -> None:
-        self.session: aiohttp.ClientSession
-        self._bearer: str
-        self._create_session(bearer)
-
-    def _create_session(self, bearer: str) -> None:
-        headers = {
-            "Authorization": f"Bearer {bearer}",
-            "Content-Type": "application/json",
-            # Not strictly required to set an user agent, yet still respectful.
-            "User-Agent": "Red-DiscordBot/WarcraftLogsCog",
-        }
-        self._bearer = bearer
-        self.session = aiohttp.ClientSession(headers=headers)
-
-    async def recreate_session(self, bearer: str) -> None:
-        await self.session.close()
-        self._create_session(bearer)
-
-    async def check_bearer(self):
-        async with self.session.post(graphql_url, json={"query": Queries.check_bearer}) as call:
-            try:
-                await call.json()
-            except aiohttp.ContentTypeError:
-                log.error("Bearer token has been invalidated")
-                return False
-            return True
-
-    async def get_overview(self, char_name: str, char_realm: str, char_server: str, zone_id: int):
-        async with self.session.post(
-            graphql_url,
-            json={
-                "query": Queries.get_overview,
-                "variables": {
-                    "char_name": char_name,
-                    "char_realm": char_realm,
-                    "char_server": char_server,
-                    "zone_id": zone_id,
-                },
-            },
-        ) as call:
-            try:
-                json = await call.json()
-            except aiohttp.ContentTypeError:
-                log.error("Bearer token has been invalidated")
-                return None
-
-            error = json.get("error", None)
-            if error:
-                log.error(f"Error: {error}")
-
-            return json
-
-    async def get_last_encounter(self, char_name: str, char_realm: str, char_server: str):
-        async with self.session.post(
-            graphql_url,
-            json={
-                "query": Queries.get_last_encounter,
-                "variables": {"char_name": char_name, "char_realm": char_realm, "char_server": char_server},
-            },
-        ) as call:
-            try:
-                json = await call.json()
-            except aiohttp.ContentTypeError:
-                log.error("Bearer token has been invalidated")
-                return None
-
-            error = json.get("error", None)
-            if error:
-                log.error(f"Error: {error}")
-                return json
-
-            if json["data"]["characterData"]["character"] is None:
-                return False
-
-            data = json["data"]["characterData"]["character"]["recentReports"]["data"]
-            unique_encouters = {"ids": [], "latest": 0, "latest_time": 0}
-            for fight in data[0]["fights"]:
-                if fight["encounterID"] not in unique_encouters["ids"]:
-                    unique_encouters["ids"].append(int(fight["encounterID"]))
-                if fight["endTime"] > unique_encouters["latest_time"]:
-                    unique_encouters["latest"] = fight["encounterID"]
-                    unique_encouters["latest_time"] = fight["endTime"]
-            return unique_encouters
-
-    async def get_gear(self, char_name: str, char_realm: str, char_server: str, encounter_id: int):
-        async with self.session.post(
-            graphql_url,
-            json={
-                "query": Queries.get_gear,
-                "variables": {
-                    "char_name": char_name,
-                    "char_realm": char_realm,
-                    "char_server": char_server,
-                    "encounter": encounter_id,
-                },
-            },
-        ) as call:
-            try:
-                json = await call.json()
-            except aiohttp.ContentTypeError:
-                log.error("Bearer token has been invalidated")
-                return None
-
-            error = json.get("error", None)
-            if error:
-                log.error(f"Error: {error}")
-                return json
-
-            if json["data"]["characterData"]["character"] is None:
-                return False
-
-            data = json["data"]["characterData"]["character"]
-            return data

warcraftlogs/info.json

@@ -1,13 +0,0 @@
-{
-    "author": ["aikaterna", "Kowlin"],
-    "description": "Check WarcraftLogs for data on players of World of Warcraft Classic.",
-    "install_msg": "Check out [p]help WarcraftLogs and set your WCL API key, available by signing into a WarcraftLogs account on their site and visiting the bottom of your settings page.\nThe bot needs Embed Links permissions before the relevant commands will be available for use in this cog.\nThis cog also comes with a font that is included in the bundled data, under the Apache 2.0 License, which can also be found in that bundled data directory.",
-    "short": "WarcraftLogs data for World of Warcraft Classic players.",
-    "hidden": true,
-    "disabled": true,
-    "tags": ["warcraft"],
-    "permissions": ["embed_links"],
-    "requirements": ["pillow", "beautifultable"],
-    "type": "COG",
-    "end_user_data_statement": "This cog stores data provided by users for the express purpose of redisplaying. It does not store user data which was not provided through a command. Users may remove their own content without making a data removal request. This cog does not support data requests, but will respect deletion requests."
-}

wolfram/__init__.py

@@ -3,5 +3,5 @@ from .wolfram import Wolfram
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(Wolfram(bot))
+async def setup(bot):
+    await bot.add_cog(Wolfram(bot))

wolfram/wolfram.py

@@ -6,13 +6,14 @@ import urllib.parse
 
 from redbot.core import Config, commands, checks
 from redbot.core.utils.chat_formatting import box, pagify
+from redbot.core.utils.menus import menu, DEFAULT_CONTROLS
 
 
 class Wolfram(commands.Cog):
     """Ask Wolfram Alpha any question."""
 
     async def red_delete_data_for_user(self, **kwargs):
-        """ Nothing to delete """
+        """Nothing to delete."""
         return
 
     def __init__(self, bot):
@@ -50,7 +51,13 @@ class Wolfram(commands.Cog):
             if "Current geoip location" in message:
                 message = "There is as yet insufficient data for a meaningful answer."
 
-        await ctx.send(box(message))
+        if len(message) > 1990:
+            menu_pages = []
+            for page in pagify(message, delims=[" | ", "\n"], page_length=1990):
+                menu_pages.append(box(page))
+            await menu(ctx, menu_pages, DEFAULT_CONTROLS)
+        else:
+            await ctx.send(box(message))
 
     @commands.command(name="wolframimage")
     async def _image(self, ctx, *arguments: str):

youtube/__init__.py

@@ -3,5 +3,5 @@ from .youtube import YouTube
 __red_end_user_data_statement__ = "This cog does not persistently store data or metadata about users."
 
 
-def setup(bot):
-    bot.add_cog(YouTube(bot))
+async def setup(bot):
+    await bot.add_cog(YouTube(bot))