[WIP][Welcome] Add dynamic welcome image generation

.gitignore

@@ -17,7 +17,6 @@ Pipfile.lock
 .vscode/
 *.sublime-project
 *.sublime-workspace
-
 ## Plugin-specific files:
 
 # IntelliJ

.vs/VSWorkspaceState.json

@@ -0,0 +1,9 @@
+{
+  "ExpandedNodes": [
+    "",
+    "\\cogs",
+    "\\cogs\\welcome"
+  ],
+  "SelectedNode": "\\cogs\\welcome\\welcome.py",
+  "PreviewInSolutionExplorer": false
+}

cogs/.vs/VSWorkspaceState.json

@@ -0,0 +1,6 @@
+{
+  "ExpandedNodes": [
+    "\\heist"
+  ],
+  "PreviewInSolutionExplorer": false
+}

cogs/welcome/constants.py

@@ -16,6 +16,8 @@
 KEY_WELCOME_CHANNEL_SETTINGS = "welcomeChannelSettings"
 KEY_POST_FAILED_DM = "postFailedDm"
 KEY_JOINED_USER_IDS = "joinedUserIds"
+KEY_TOGGLE_RANDOM_MSG = "toggleImg"
+WELCOME_IMG_FOLDER = "welcomeImgs"
 
 MAX_MESSAGE_LENGTH = 2000
 MAX_DESCRIPTION_LENGTH = 500
@@ -38,6 +40,7 @@
         KEY_POST_FAILED_DM: False,
     },
     KEY_JOINED_USER_IDS: [],
+    KEY_TOGGLE_RANDOM_MSG: False,
 }
 
 

cogs/welcome/welcome.py

@@ -1,13 +1,16 @@
 """Welcome cog
 Sends welcome DMs to users that join the server.
 """
-
 import asyncio
 import discord
 import logging
 import random
+import aiohttp
+import os
+import io
 
-from redbot.core import Config, checks, commands
+from PIL import Image, ImageChops, ImageOps
+from redbot.core import Config, checks, commands, data_manager
 from redbot.core.bot import Red
 from redbot.core.commands.context import Context
 from redbot.core.utils.chat_formatting import box, info, pagify, warning
@@ -28,8 +31,23 @@ class Welcome(commands.Cog):  # pylint: disable=too-many-instance-attributes
     def __init__(self, bot: Red):
         self.bot = bot
         self.config = Config.get_conf(self, identifier=5842647, force_registration=True)
+
         self.config.register_guild(**DEFAULT_GUILD)
 
+        self.dataDir = data_manager.cog_data_path(cog_instance=self)
+        self.imgDir = self.dataDir / WELCOME_IMG_FOLDER
+        self.bundled_assets = data_manager.bundled_data_path(self)
+
+        # create folder to hold welcome images
+        try:
+            os.makedirs(self.imgDir, exist_ok=True)
+        except OSError as error:
+            LOGGER.error(
+                "Could not create folder for images!",
+                exc_info=True,
+            )
+            raise OSError("Could not create folder for images!")
+
     async def getRandomMessage(self, guild: discord.Guild, pool: Optional[GreetingPools] = None):
         """Gets a random message from a greeting pool.
 
@@ -149,6 +167,7 @@ async def sendWelcomeMessageChannel(self, newUser: discord.Member):
         isSet = await self.config.guild(guild).get_attr(KEY_WELCOME_CHANNEL_ENABLED)()
         # if channel isn't set
         if not isSet:
+            print("not set")
             return
         channel = discord.utils.get(guild.channels, id=channelID)
 
@@ -161,7 +180,12 @@ async def sendWelcomeMessageChannel(self, newUser: discord.Member):
         message = rawMessage.replace("{USER}", newUser.mention)
 
         try:
-            await channel.send(message)
+            img = await self.generateRandWelcomeImg(newUser, newUser.guild)
+            if await self.config.guild(guild).get_attr(KEY_TOGGLE_RANDOM_MSG)():
+                await channel.send(message, file=discord.File(img, filename="generated.png"))
+            else:
+                await channel.send(message)
+            img.close()
         except (discord.Forbidden, discord.HTTPException) as errorMsg:
             LOGGER.error(
                 "Could not send message, please make sure the bot "
@@ -318,6 +342,71 @@ async def logServerLeave(self, leaveUser: discord.Member):
                     leaveUser.id,
                 )
 
+    async def generateRandWelcomeImg(self, user, guild):
+        """create an image for the specific player using their avatar and an image from the random image pool, then returns it"""
+        base = Image.open(
+            self.imgDir
+            / str(guild.id)
+            / random.choice(os.listdir(os.path.join(self.imgDir, str(guild.id))))
+        )
+        mask = Image.open(os.path.join(data_manager.bundled_data_path(self), "MASK.png"))
+        borderOverlay = Image.open(
+            os.path.join(data_manager.bundled_data_path(self), "BORDER.png")
+        )
+        borderOverlayMask = Image.open(
+            os.path.join(data_manager.bundled_data_path(self), "BORDER_mask.png")
+        )
+        # get avatar from User
+        avatar: bytes
+        session = aiohttp.ClientSession()
+        # a header to successfully download user avatars for use
+        usedHeader = {"User-agent": "Mozilla/5.0"}
+
+        try:
+            async with session.get(str(user.avatar.url), headers=usedHeader) as webp:
+                avatar = await webp.read()
+        except aiohttp.ClientResponseError:
+            pass
+
+        with Image.open(io.BytesIO(avatar)) as retrievedAvatar:
+            if not retrievedAvatar:
+                base.close()
+                mask.close()
+                borderOverlay.close()
+                borderOverlayMask.close()
+                return
+            else:
+                retrievedAvatar = retrievedAvatar.resize((325, 325), 1)
+                base.paste(borderOverlay, (434, 0), borderOverlayMask)
+                base.paste(retrievedAvatar, (434, 0), mask)
+                generated = io.BytesIO()
+                base.save(generated, format="png")
+                generated.seek(0)
+                base.close()
+                mask.close()
+                borderOverlay.close()
+                borderOverlayMask.close()
+                return generated
+
+    async def ensureCurrentServerHasImgCache(self, channel):
+        """
+        Check if there is a folder in the image cache for the associated server. If one doesn't exist, creates it.
+        """
+        idStr = str(channel.guild.id)
+        fp = os.path.join(self.imgDir, idStr)
+        if os.path.exists(fp):
+            return
+
+        try:
+            os.makedirs(fp, exist_ok=True)
+            await channel.send("No image cache folder found for this server! Created one")
+
+        except OSError as info:
+            LOGGER.info(
+                "No folder for given server ID found. Created folder for server: %s" % idStr,
+                exc_info=True,
+            )
+
     ####################
     # MESSAGE COMMANDS #
     ####################
@@ -470,6 +559,24 @@ async def greetings(self, ctx: Context):
         - `returning`: pool of greetings that are sent to returning users
         """
 
+    # [p]welcomeset greetings toggleimg
+    @greetings.command(name="toggleimg")
+    async def toggleImg(self, ctx: Context):
+        """Toggle the random image on and off"""
+        await self.ensureCurrentServerHasImgCache(ctx.channel)
+        toggleImgConfig = self.config.guild(ctx.guild).get_attr(KEY_TOGGLE_RANDOM_MSG)
+        randomImageEnabled = await toggleImgConfig()
+
+        if randomImageEnabled:
+            await toggleImgConfig.set(False)
+        else:
+            if len(os.listdir(os.path.join(self.imgDir, str(ctx.guild.id)))) < 1:
+                await ctx.send("Add at least one image before turning the randomiser on")
+                return
+            await toggleImgConfig.set(True)
+
+        await ctx.send(f"Sending randomised welcome image: {await toggleImgConfig()}")
+
     # [p]welcomeset greetings add
     @greetings.command(name="add")
     async def greetAdd(self, ctx: Context, name: str, pool: Optional[str] = None):
@@ -537,6 +644,104 @@ def check(message: discord.Message):
         await self.config.guild(ctx.guild).get_attr(key).set(greetings)
         return
 
+    # [p]welcomeset greetings image
+    @greetings.group(name="image")
+    async def image(self, ctx: Context):
+        """Base command for the image command group"""
+        pass
+
+    # [p]welcomeset greetings image template
+    @image.command(name="template")
+    async def imageTemplate(self, ctx: Context):
+        await ctx.send(
+            "Here is the welcome image template so you can make your own! For best results please render the image at 72dpi, 1193 x 671. The bot will try to make it conform automatically but mileage may vary.",
+            file=discord.File(
+                os.path.join(data_manager.bundled_data_path(self), "welcome_template.png")
+            ),
+        )
+
+    # [p]welcomeset greetings image add
+    @image.command(name="add")
+    async def imgAdd(self, ctx: Context, name: str):
+        """adds the attached image to the pool of random based images used to generate custom welcome images. Attaches only the first image attached.
+
+
+        Additionally automatically makes the sent image conform to the dimensions and dpi that's been tested for: 72dpi, 1193x671. Mileage may vary
+
+        """
+        await self.ensureCurrentServerHasImgCache(ctx.channel)
+        file_name = f"{name}.png"
+        fp = os.path.join(self.imgDir, str(ctx.channel.guild.id), file_name)
+
+        if os.path.exists(fp):
+            await ctx.reply(
+                "This name is already in use! For ease of management, please use another name."
+            )
+            return
+
+        image = None
+        if len(ctx.message.attachments) == 1:
+            image = ctx.message.attachments[0]
+
+        else:
+            await ctx.reply(
+                "You need to attach exactly 1 image in the message that uses this command"
+            )
+            return
+
+        await image.save(fp)
+
+        # Performing necessary checks to ensure that this base can produce a good generated image
+        temp = Image.open(fp)
+        temp_resize = temp.resize((1193, 671), 2)
+        temp_resize.save(fp, dpi=(72, 72))
+
+        # alert user that their image has been added
+        await ctx.reply("Image added to this server's image cache")
+
+    # [p]welcomeset greetings image remove
+    @image.command(name="remove")
+    async def imgRemove(self, ctx: Context, img_name: str):
+        """Removes the specified image from the pool"""
+        await self.ensureCurrentServerHasImgCache(ctx.channel)
+        file_name = f"{img_name}.png"
+        try:
+            os.remove(os.path.join(self.imgDir, str(ctx.channel.guild.id), file_name))
+        except:
+            await ctx.reply("The named image doesn't exist")
+            return
+
+        if len(os.listdir(os.path.join(self.imgDir, str(ctx.channel.guild.id)))) == 0:
+            self.config.guild(ctx.guild).get_attr(KEY_TOGGLE_RANDOM_MSG).set(False)
+            await ctx.reply("Last image deleted. Image randomiser turned off.")
+
+        await ctx.reply("Image sucessfully removed")
+
+    # [p]welcomeset greetings image view
+    @image.command(name="view")
+    async def showImg(self, ctx: Context, img_name: str):
+        """Show the named image from the image pool if it exists"""
+        await self.ensureCurrentServerHasImgCache(ctx.channel)
+        file_name = f"{img_name}.png"
+        try:
+            await ctx.send(
+                img_name + ":",
+                file=discord.File(os.path.join(self.imgDir, str(ctx.channel.guild.id), file_name)),
+            )
+        except:
+            await ctx.reply("The named image doesn't exist")
+
+    # [p]welcomeset greetings image list
+    @image.command(name="list")
+    async def listImg(self, ctx: Context):
+        """Display a list of all the images in this server's image cache"""
+        await self.ensureCurrentServerHasImgCache(ctx.channel)
+        listOfImages = "\n".join(os.listdir(os.path.join(self.imgDir, str(ctx.channel.guild.id))))
+        if len(listOfImages) == 0:
+            await ctx.reply("No images added yet.")
+            return
+        await ctx.reply(listOfImages.replace(".png", ""))
+
     # [p]welcomeset greetings channelset
     @greetings.group(name="channelset", aliases=["channelconfig", "chconfig", "chset"])
     async def greetChannelConfig(self, ctx: Context):