add quote.py to repo/not loaded

api.py

@@ -6,6 +6,7 @@ from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 import util
 
+
 class ValidSendMsgRequest(BaseModel):
     """
     - **guild**: optional, guild id in case multiple channels match (normally first result would be used)
@@ -17,14 +18,15 @@ class ValidSendMsgRequest(BaseModel):
     channel: str
     message: str
 
+
 class API:
     """API [FastAPI Instance] for Havoc"""
+
     def __init__(self, discord_bot):
         api_app = FastAPI(title="Havoc API")
         self.bot = discord_bot
         self.api_app = api_app
 
-
         @api_app.get("/{any:path}")
         def block_get():
             raise HTTPException(status_code=403, detail="Invalid request")
@@ -38,12 +40,14 @@ class API:
                 message=data.message,
             )
             return {
-                'result': "presumed_success",
+                "result": "presumed_success",
             }
 
 
 def __init__():
     import util
+
     importlib.reload(util)
 
+
 __init__()

cogs/karma.py

@@ -1,330 +0,0 @@
-import sys
-from os import path
-sys.path.append( path.dirname( path.dirname( path.abspath(__file__) ) ) )
-import constants
-import traceback
-import time
-import importlib
-import logging
-from typing import Optional
-import discord
-import regex
-from regex import Pattern
-from aiohttp import ClientSession, ClientTimeout
-from discord.ext import bridge, commands, tasks
-from disc_havoc import Havoc
-
-class Util:
-    """Karma Utility"""
-    def __init__(self, bot: Havoc):
-        self.bot: Havoc = bot
-        self.api_key: str = constants.PRV_API_KEY
-        self.karma_endpoints_base_url: str = "https://api.codey.lol/karma/"
-        self.karma_retrieval_url: str = f"{self.karma_endpoints_base_url}get"
-        self.karma_update_url: str = f"{self.karma_endpoints_base_url}modify"
-        self.karma_top_10_url: str = f"{self.karma_endpoints_base_url}top"                
-        self.timers: dict = {} # discord uid : timestamp, used for rate limiting
-        self.karma_cooldown: int = 15 # 15 seconds between karma updates        
-
-    async def get_karma(self, keyword: str) -> int:
-        """
-        Get Karma for Keyword
-        
-        Args:
-            keyword (str)
-        Returns:
-            int
-        """
-        try:
-            async with ClientSession() as session:
-                async with await session.post(self.karma_retrieval_url,
-                                        json={'keyword': keyword},
-                                        headers={
-                                            'content-type': 'application/json; charset=utf-8',
-                                            'X-Authd-With': f'Bearer {constants.KARMA_API_KEY}',
-                                            }, timeout=ClientTimeout(connect=3, sock_read=5)) as request:
-                    resp = await request.json()
-                    return resp.get('count')
-        except Exception as e:
-            traceback.print_exc()
-            return False
-            
-    async def get_top(self, n: int = 10) -> Optional[dict]:
-        """
-        Get top (n=10) Karma
-        
-        Args:
-            n (int): Number of top results to return, default 10
-        Returns:
-            Optional[dict] 
-        """
-        try:
-            async with ClientSession() as session:
-                async with await session.post(self.karma_top_10_url,
-                                        json = {
-                                            'n': n,
-                                        },
-                                        headers={
-                                            'content-type': 'application/json; charset=utf-8',
-                                            'X-Authd-With': f'Bearer {constants.KARMA_API_KEY}'
-                                        }, timeout=ClientTimeout(connect=3, sock_read=5)) as request:
-                    resp: dict = await request.json()
-                    return resp
-        except:
-            traceback.print_exc()
-            return None
-
-    async def get_top_embed(self, n:int = 10) -> Optional[discord.Embed]:
-        """
-        Get Top Karma Embed
-        
-        Args:
-            n (int): Number of top results to return, default 10
-        Returns:
-            Optional[discord.Embed] 
-        """
-        top: Optional[dict] = await self.get_top(n)
-        if not top:
-            return None
-        top_formatted: str = ""
-        for x, item in enumerate(top):
-            top_formatted += f"{x+1}. **{discord.utils.escape_markdown(item[0])}**: *{item[1]}*\n"
-        top_formatted = top_formatted.strip()
-        embed: discord.Embed = discord.Embed(title=f"Top {n} Karma",
-                            description=top_formatted,
-                            colour=0xff00ff)
-        return embed
-
-    async def update_karma(self, display: str, _id: int, keyword: str, flag: int) -> bool:
-        """
-        Update Karma for Keyword
-        Args:
-
-            display (str): Display name of the user who requested the update
-            _id (int): Discord UID of the user who requested the update
-            keyword (str): Keyword to update
-            flag (int)
-        Returns:
-            bool
-        """
-        if not flag in [0, 1]:
-            return False
-        
-        reqObj: dict = {
-            'granter': f"Discord: {display} ({_id})",
-            'keyword': keyword,
-            'flag': flag,
-        }
-
-        try:
-            async with ClientSession() as session:
-                async with await session.post(self.karma_update_url,
-                                        json=reqObj,
-                                        headers={
-                                            'content-type': 'application/json; charset=utf-8',
-                                            'X-Authd-With': f'Bearer {self.api_key}',
-                                        },
-                                        timeout=ClientTimeout(connect=3, sock_read=5)) as request:
-                    result = await request.json()
-                    return result.get('success', False)
-        except:
-            traceback.print_exc()
-            return False
-
-        
-    async def check_cooldown(self, user_id: int) -> bool:
-        """
-        Check if member has met cooldown period prior to adjusting karma
-        
-        Args:
-            user_id (int): The Discord UID to check
-        Returns:
-            bool
-        """
-        if not user_id in self.timers:
-            return True
-        now = int(time.time())
-        if (now - self.timers[user_id]) < self.karma_cooldown:
-            return False
-        return True
-            
-    
-
-class Karma(commands.Cog):
-    """Karma Cog for Havoc"""
-    def __init__(self, bot: Havoc):
-        importlib.reload(constants)
-        self.bot: Havoc = bot
-        self.util = Util(self.bot)
-        # self.karma_regex = regex.compile(r'(\w+)(\+\+|\-\-)')
-        self.karma_regex: Pattern = regex.compile(r'(\b\w+(?:\s+\w+)*)(\+\+($|\s)|\-\-($|\s))')
-        self.mention_regex: Pattern = regex.compile(r'(<@([0-9]{17,20})>)(\+\+|\-\-)')
-        self.mention_regex_no_flag: Pattern = regex.compile(r'(<@([0-9]{17,20})>+)')
-        self.karma_chanid: int = 1307065684785893406
-        self.karma_msgid: int = 1325442184572567686
-
-        # asyncio.get_event_loop().create_task(self.bot.get_channel(self.karma_chanid).send("."))
-
-        try:
-            self.update_karma_chan.start()
-        except Exception as e:
-            pass
-
-
-    @tasks.loop(seconds=30, reconnect=True)
-    async def update_karma_chan(self) -> None:
-        """Update the Karma Chan Leaderboard"""
-        try:
-            top_embed = await self.util.get_top_embed(n=25)
-            channel = self.bot.get_channel(self.karma_chanid)
-            if not isinstance(channel, discord.TextChannel):
-                return
-            message_to_edit = await channel.fetch_message(self.karma_msgid)
-            await message_to_edit.edit(embed=top_embed,
-                                    content="## This message will automatically update periodically.")
-        except:
-            traceback.print_exc()
-
-
-    @commands.Cog.listener()
-    async def on_message(self, message: discord.Message) -> None:
-        """
-        Message hook, to monitor for ++/--
-        Also monitors for messages to #karma to autodelete, only Havoc may post in #karma!
-        """
-        if not self.bot.user: # No valid client instance
-            return
-        if not isinstance(message.channel, discord.TextChannel):
-            return
-        if message.channel.id == self.karma_chanid and not message.author.id == self.bot.user.id:
-            """Message to #karma not by Havoc, delete it"""
-            await message.delete(reason="Messages to #karma are not allowed")
-            removal_embed: discord.Embed = discord.Embed(
-                title="Message Deleted",
-                description=f"Your message to **#{message.channel.name}** has been automatically deleted.\n**Reason**: Messages to this channel by users is not allowed."
-            )
-            await message.author.send(embed=removal_embed)
-
-
-        if message.author.id == self.bot.user.id: # Bots own message
-            return
-        if not message.guild:
-            return
-        if not message.guild.id in [1145182936002482196, 1228740575235149855]: # Not a valid guild for cmd
-            return
-        
-        message_content: str = message.content.strip()
-        mentions: list = regex.findall(self.mention_regex, message_content)
-        
-        for mention in mentions:
-            try:
-                logging.debug("Mention: %s", mention)
-                mentioned_uid: int = int(mention[1])
-                friendly_flag: int = int(mention[2])
-                guild: Optional[discord.Guild] = self.bot.get_guild(message.guild.id)
-                if not guild:
-                    return
-                guild_member: Optional[discord.Member] = guild.get_member(mentioned_uid)
-                if not guild_member:
-                    return
-                display: str = guild_member.display_name
-                message_content = message_content.replace(mention[0], display)
-                logging.debug("New message: %s", message_content)
-            except:
-                traceback.print_exc()
-
-        message_content = discord.utils.escape_markdown(message_content)
-
-        karma_regex: list[str] = regex.findall(self.karma_regex, message_content.strip())
-        if not karma_regex:  # Not a request to adjust karma
-            return
-        
-        flooding: bool = not await self.util.check_cooldown(message.author.id)
-        exempt_uids: list[int] = [1172340700663255091, 992437729927376996] 
-        if flooding and not message.author.id in exempt_uids:
-            return await message.add_reaction(emoji="❗")
-        
-        processed_keywords_lc: list[str] = []
-
-        logging.debug("Matched: %s", karma_regex)
-        
-        for matched_keyword in karma_regex:
-            if not isinstance(matched_keyword, tuple):
-                continue
-            if len(matched_keyword) == 4:
-                (keyword, friendly_flag, _, __) = matched_keyword
-            else:
-                (keyword, friendly_flag) = matched_keyword 
-            now: int = int(time.time())
-
-            flag: int = None
-            match friendly_flag:
-                case "++":
-                    flag = 0
-                case "--":
-                    flag = 1
-                case _:
-                    logging.info("Unknown flag %s", flag)
-                    continue
-
-            if keyword.lower() in processed_keywords_lc:
-                continue
-            
-            processed_keywords_lc.append(keyword.lower())
-
-            self.util.timers[message.author.id] = now
-
-            updated: bool = await self.util.update_karma(message.author.display_name,
-                                                         message.author.id, keyword, flag)
-            if updated:
-                return await message.add_reaction(emoji="👍")
-
-    @bridge.bridge_command()
-    async def karma(self, ctx, *, keyword: str | None = None) -> None:
-        """With no arguments, top 10 karma is provided; a keyword can also be provided to lookup."""
-        try:
-            if not keyword:
-                top_10_embed: Optional[discord.Embed] = await self.util.get_top_embed()
-                if not top_10_embed:
-                    return
-                return await ctx.respond(embed=top_10_embed)
-            
-            keyword = discord.utils.escape_markdown(keyword)
-            
-            mentions: list[str] = regex.findall(self.mention_regex_no_flag, keyword)
-
-            for mention in mentions:
-                try:
-                    mentioned_uid = int(mention[1])
-                    guild: Optional[discord.Guild] = self.bot.get_guild(ctx.guild.id)
-                    if not guild:
-                        return
-                    guild_member: Optional[discord.Member] = guild.get_member(mentioned_uid)
-                    if not guild_member:
-                        return
-                    display = guild_member.display_name
-                    keyword = keyword.replace(mention[0], display)
-                except:
-                    traceback.print_exc()
-                    continue
-
-            score: int = await self.util.get_karma(keyword)
-            description: str = f"**{keyword}** has a karma of *{score}*"
-            embed: discord.Embed = discord.Embed(title=f"Karma for {keyword}",
-                                                 description=description)
-            return await ctx.respond(embed=embed)
-        except Exception as e:
-            await ctx.respond(f"Error: {str(e)}")
-            traceback.print_exc()
-    
-    def cog_unload(self) -> None:
-        try:
-            self.update_karma_chan.cancel()
-        except:
-            """Safe to ignore"""
-            pass
-        
-                             
-def setup(bot) -> None:
-    """Run on Cog Load"""
-    bot.add_cog(Karma(bot))

cogs/lovehate.py

@@ -5,8 +5,10 @@ from discord.ext import bridge, commands
 from util.lovehate_db import DB
 from disc_havoc import Havoc
 
+
 class LoveHate(commands.Cog):
     """LoveHate Cog for Havoc"""
+
     def __init__(self, bot: Havoc) -> None:
         self.bot: Havoc = bot
         self.db = DB(self.bot)
@@ -21,26 +23,20 @@ class LoveHate(commands.Cog):
             str
         """
         if len(items) > 1:
-            return ', '.join(items[:-1]) + ' and ' + items[-1]
+            return ", ".join(items[:-1]) + " and " + items[-1]
-        return items[0] if items else ''        
+        return items[0] if items else ""
-
 
     @bridge.bridge_command()
     async def loves(self, ctx, user: Optional[str] = None) -> None:
         """
         If keyword isn't provided, returns the things YOU love; specify a user to find what THEY love.
-        
-        Args:
-            ctx (Any)
-            user (Optional[str])
-        Returns:
-            None 
         """
         try:
             if not user:
                 display_name = ctx.author.display_name
-                loves: Union[list[tuple], bool] = await self.db.get_lovehates(user=display_name,
+                loves: Union[list[tuple], bool] = await self.db.get_lovehates(
-                                                                              loves=True)
+                    user=display_name, loves=True
+                )
                 if not loves:
                     return await ctx.respond("You don't seem to love anything...")
 
@@ -68,12 +64,6 @@ class LoveHate(commands.Cog):
     async def wholoves(self, ctx, *, thing: Optional[str] = None) -> None:
         """
         Check who loves <thing>
-        
-        Args:
-            ctx (Any)
-            thing (Optional[str])
-        Returns:
-            None
         """
         try:
             if not thing:
@@ -82,7 +72,7 @@ class LoveHate(commands.Cog):
                 _thing = thing
             if discord.utils.raw_mentions(_thing):
                 # There are mentions
-                thing_id: int = discord.utils.raw_mentions(_thing)[0] # First mention
+                thing_id: int = discord.utils.raw_mentions(_thing)[0]  # First mention
                 guild: Optional[discord.Guild] = self.bot.get_guild(ctx.guild.id)
                 if not guild:
                     return
@@ -95,8 +85,9 @@ class LoveHate(commands.Cog):
             if not _thing:
                 return
 
-            who_loves: Union[list, bool] = await self.db.get_wholovehates(thing=_thing,
+            who_loves: Union[list, bool] = await self.db.get_wholovehates(
-                                                    loves=True)
+                thing=_thing, loves=True
+            )
             if not isinstance(who_loves, list):
                 return await ctx.respond(f"I couldn't find anyone who loves {thing}...")
 
@@ -118,12 +109,6 @@ class LoveHate(commands.Cog):
     async def whohates(self, ctx, *, thing: Optional[str] = None) -> None:
         """
         Check who hates <thing>
-        
-        Args:
-            ctx (Any)
-            thing (Optional[str])
-        Returns:
-            None
         """
         try:
             if not thing:
@@ -135,14 +120,15 @@ class LoveHate(commands.Cog):
                 guild: Optional[discord.Guild] = self.bot.get_guild(ctx.guild.id)
                 if not guild:
                     return
-                thing_id: int = discord.utils.raw_mentions(_thing)[0] # First mention
+                thing_id: int = discord.utils.raw_mentions(_thing)[0]  # First mention
                 thing_member: Optional[discord.Member] = guild.get_member(thing_id)
                 if not thing_member:
                     return
                 _thing = thing_member.display_name
 
-            who_hates: Union[list[tuple], bool] = await self.db.get_wholovehates(thing=_thing,
+            who_hates: Union[list[tuple], bool] = await self.db.get_wholovehates(
-                                                    hates=True)
+                thing=_thing, hates=True
+            )
             if not who_hates:
                 return await ctx.respond(f"I couldn't find anyone who hates {thing}...")
 
@@ -162,21 +148,13 @@ class LoveHate(commands.Cog):
             traceback.print_exc()
             return await ctx.respond(f"Error: {str(e)}")
 
-
     @bridge.bridge_command()
     async def dontcare(self, ctx, thing: str) -> None:
         """
         Make me forget your opinion on <thing>
-        
-        Args:
-            ctx (Any)
-            thing (str)
-        Returns:
-            None
         """
         try:
-            stop_caring: str = await self.db.update(ctx.author.display_name,
+            stop_caring: str = await self.db.update(ctx.author.display_name, thing, 0)
-                                               thing, 0)
             return await ctx.respond(stop_caring)
         except Exception as e:
             await ctx.respond(f"Error: {str(e)}")
@@ -186,18 +164,13 @@ class LoveHate(commands.Cog):
     async def hates(self, ctx, user: Optional[str] = None) -> None:
         """
         If keyword isn't provided, returns the things YOU hate; specify a user to find what THEY hate.
-        
-        Args:
-            ctx (Any)
-            user (Optional[str])
-        Returns:
-            None 
         """
         try:
             if not user:
                 display_name = ctx.author.display_name
-                hates: Union[list[tuple], bool] = await self.db.get_lovehates(user=display_name,
+                hates: Union[list[tuple], bool] = await self.db.get_lovehates(
-                                                                 hates=True)
+                    user=display_name, hates=True
+                )
                 if not hates:
                     return await ctx.respond("You don't seem to hate anything...")
             else:
@@ -218,21 +191,15 @@ class LoveHate(commands.Cog):
             await ctx.respond(f"Error: {str(e)}")
             traceback.print_exc()
 
-    @bridge.bridge_command(aliases=['sarcastichate'])
+    @bridge.bridge_command(aliases=["sarcastichate"])
     async def love(self, ctx, *, thing: str) -> None:
         """
         Love <thing>
-        
-        Args:
-            ctx (Any)
-            thing (str)
-        Returns:
-            None
         """
         try:
             if discord.utils.raw_mentions(thing):
                 # There are mentions
-                thing_id: int = discord.utils.raw_mentions(thing)[0] # First mention
+                thing_id: int = discord.utils.raw_mentions(thing)[0]  # First mention
                 guild: Optional[discord.Guild] = self.bot.get_guild(ctx.guild)
                 if not guild:
                     return
@@ -241,28 +208,21 @@ class LoveHate(commands.Cog):
                     return
                 thing = thing_member.display_name
 
-            love: str = await self.db.update(ctx.author.display_name,
+            love: str = await self.db.update(ctx.author.display_name, thing, 1)
-                                               thing, 1)
             return await ctx.respond(love)
         except Exception as e:
             await ctx.respond(f"Error: {str(e)}")
             traceback.print_exc()
 
-    @bridge.bridge_command(aliases=['sarcasticlove'])
+    @bridge.bridge_command(aliases=["sarcasticlove"])
     async def hate(self, ctx, *, thing: str) -> None:
         """
         Hate <thing>
-        
-        Args:
-            ctx (Any)
-            thing (str)
-        Returns:
-            None
         """
         try:
             if discord.utils.raw_mentions(thing):
                 # There are mentions
-                thing_id: int = discord.utils.raw_mentions(thing)[0] # First mention
+                thing_id: int = discord.utils.raw_mentions(thing)[0]  # First mention
                 guild: Optional[discord.Guild] = self.bot.get_guild(ctx.guild.id)
                 if not guild:
                     return
@@ -270,8 +230,7 @@ class LoveHate(commands.Cog):
                 if not thing_member:
                     return
                 thing = thing_member.display_name
-            hate: str = await self.db.update(ctx.author.display_name,
+            hate: str = await self.db.update(ctx.author.display_name, thing, -1)
-                                               thing, -1)
             return await ctx.respond(hate)
         except Exception as e:
             await ctx.respond(f"Error: {str(e)}")

cogs/meme.py

@@ -4,10 +4,9 @@ import json
 import io
 import asyncio
 import random
-from typing import (LiteralString,
+from PIL import Image, UnidentifiedImageError
-                    Optional, 
+import imagehash
-                    Any,
+from typing import LiteralString, Optional, Any, Union
-                    Union)
 import aiosqlite as sqlite3
 import logging
 import textwrap
@@ -17,6 +16,7 @@ import discord
 from disc_havoc import Havoc
 from aiohttp import ClientSession
 from discord.ext import bridge, commands, tasks
+from util.discord_helpers import log_to_playground
 from util.jesusmemes import JesusMemeGenerator
 import scrapers.reddit_scrape as memeg
 import scrapers.explosm_scrape as explosmg
@@ -35,68 +35,91 @@ BOT_CHANIDS = []
 TODO: Cleanup new meme leaderboard stuff
 """
 
+
 class Helper:
     """Meme Helper"""
+
     def load_meme_choices(self) -> None:
         """Load Available Meme Templates from JSON File"""
         global meme_choices
 
-        memes_file: str|LiteralString = os.path.join(os.path.dirname(__file__), "memes.json")
+        memes_file: str | LiteralString = os.path.join(
-        with open(memes_file, 'r', encoding='utf-8') as f:
+            os.path.dirname(__file__), "memes.json"
+        )
+        with open(memes_file, "r", encoding="utf-8") as f:
             meme_choices = json.loads(f.read())
 
+
 class MemeView(discord.ui.View):
     """Meme Selection discord.ui.View"""
+
     helper = Helper()
     helper.load_meme_choices()
+
     @discord.ui.select(
-        placeholder = "Choose a Meme!",
+        placeholder="Choose a Meme!",
-        min_values = 1,
+        min_values=1,
-        max_values = 1,
+        max_values=1,
-        options = [
+        options=[
-            discord.SelectOption(
+            discord.SelectOption(label=meme_label) for meme_label in meme_choices[0:24]
-                label=meme_label
+        ],
-            ) for meme_label in meme_choices[0:24]
-        ]
     )
-    async def select_callback(self, select: discord.ui.Select,
+    async def select_callback(
-                              interaction: discord.Interaction) -> None:
+        self, select: discord.ui.Select, interaction: discord.Interaction
+    ) -> None:
         """Meme Selection Callback"""
         if not isinstance(select.values[0], str):
             return
-        modal: discord.ui.Modal = MemeModal(meme=select.values[0], title="Meme Selected")
+        modal: discord.ui.Modal = MemeModal(
+            meme=select.values[0], title="Meme Selected"
+        )
         await interaction.response.send_modal(modal)
 
+
 class MemeModal(discord.ui.Modal):
     """Meme Creation discord.ui.Modal"""
+
     def __init__(self, *args, meme: Optional[str] = None, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self.selected_meme: Optional[str] = meme
         self.meme_generator = JesusMemeGenerator()
         self.TEXT_LIMIT: int = 80
 
-        self.add_item(discord.ui.InputText(label="Top Text",
+        self.add_item(
-                                           style=discord.InputTextStyle.singleline))
+            discord.ui.InputText(
-        self.add_item(discord.ui.InputText(label="Bottom Text",
+                label="Top Text", style=discord.InputTextStyle.singleline
-                                           style=discord.InputTextStyle.singleline))
+            )
+        )
+        self.add_item(
+            discord.ui.InputText(
+                label="Bottom Text", style=discord.InputTextStyle.singleline
+            )
+        )
 
     async def callback(self, interaction: discord.Interaction) -> None:
-        if not self.selected_meme: # No meme selected
+        if not self.selected_meme:  # No meme selected
             return
         selected_meme: str = self.selected_meme
-        if not self.children or len(self.children) < 2: # Invalid request
+        if not self.children or len(self.children) < 2:  # Invalid request
+            return
+        if not isinstance(self.children[0].value, str) or not isinstance(
+            self.children[1].value, str
+        ):  # Invalid request
             return
-        if not isinstance(self.children[0].value, str)\
-            or not isinstance(self.children[1].value, str): # Invalid request
-                return
         meme_top_line: str = self.children[0].value.strip()
         meme_bottom_line: str = self.children[1].value.strip()
-        if len(meme_top_line) > self.TEXT_LIMIT or len(meme_bottom_line) > self.TEXT_LIMIT:
+        if (
-            await interaction.response.send_message("ERR: Text is limited to 80 characters for each the top and bottom lines.")
+            len(meme_top_line) > self.TEXT_LIMIT
+            or len(meme_bottom_line) > self.TEXT_LIMIT
+        ):
+            await interaction.response.send_message(
+                "ERR: Text is limited to 80 characters for each the top and bottom lines."
+            )
             return
 
-        meme_link: Optional[str] = await self.meme_generator.create_meme(top_line=meme_top_line,
+        meme_link: Optional[str] = await self.meme_generator.create_meme(
-                                                               bottom_line=meme_bottom_line, meme=selected_meme)
+            top_line=meme_top_line, bottom_line=meme_bottom_line, meme=selected_meme
+        )
         if not meme_link:
             await interaction.response.send_message("Failed!")
             return
@@ -106,67 +129,74 @@ class MemeModal(discord.ui.Modal):
         await interaction.response.send_message(embeds=[embed])
         return
 
+
 class Meme(commands.Cog):
     """Meme Cog for Havoc"""
 
     def __init__(self, bot: Havoc) -> None:
         self.bot: Havoc = bot
-        self.stats_db_path: LiteralString = os.path.join("/usr/local/share",
+        self.stats_db_path: str = os.path.join(
-                                          "sqlite_dbs", "stats.db")
+            "/", "usr", "local", "share", "sqlite_dbs", "stats.db"
+        )
+        self.meme_db_path: str = os.path.join(
+            "/", "usr", "local", "share", "sqlite_dbs", "meme.db"
+        )
         self.meme_choices: list = []
         self.meme_counter: int = 0
         self.THREADS: dict[str, dict[int, list]] = {
             # Format: Guild1: [ChanId : [Webhook, ThreadId], Guild2: [ChanId : [Webhook, ThreadId]
-            'comic_explosm': {
+            "comic_explosm": {
                 1298729744216359055: [constants.EXPLOSM_WEBHOOK, 1299165855493390367],
                 1306414795049926676: [constants.EXPLOSM_WEBHOOK2, 1306416492304138364],
             },
-            'comic_xkcd': {
+            "comic_xkcd": {
                 1298729744216359055: [constants.XKCD_WEBHOOK, 1299165928755433483],
                 1306414795049926676: [constants.XKCD_WEBHOOK2, 1306416681991798854],
             },
-            'comic_smbc': {
+            "comic_smbc": {
                 1298729744216359055: [constants.SMBC_WEBHOOK, 1299166071038808104],
                 1306414795049926676: [constants.SMBC_WEBHOOK2, 1306416842511745024],
             },
-            'comic_qc': {
+            "comic_qc": {
                 1298729744216359055: [constants.QC_WEBHOOK, 1299392115364593674],
                 1306414795049926676: [constants.QC_WEBHOOK2, 1306417084774744114],
             },
-            'comic_dino': {
+            "comic_dino": {
                 1298729744216359055: [constants.DINO_WEBHOOK, 1299771918886506557],
                 1306414795049926676: [constants.DINO_WEBHOOK2, 1306417286713704548],
-            }
+            },
         }
 
         self.NO_THREAD_WEBHOOKS: dict[str, list] = {
-            'theonion': [constants.ONION_WEBHOOK, constants.ONION_WEBHOOK2],
+            "theonion": [constants.ONION_WEBHOOK, constants.ONION_WEBHOOK2],
-            'thn': [constants.THN_WEBHOOK],
+            "thn": [constants.THN_WEBHOOK],
-            'memes': [constants.MEME_WEBHOOK1, constants.MEME_WEBHOOK2],
+            "memes": [constants.MEME_WEBHOOK1, constants.MEME_WEBHOOK2],
         }
 
         global BOT_CHANIDS
-        BOT_CHANIDS = self.bot.BOT_CHANIDS # Inherit
+        BOT_CHANIDS = self.bot.BOT_CHANIDS  # Inherit
 
         self.meme_stream_loop.start()
         self.explosm_loop.start()
         self.update_meme_lb.start()
         asyncio.get_event_loop().create_task(self.init_meme_leaderboard())
 
-    def is_spamchan() -> bool: # type: ignore
+    def is_spamchan() -> bool:  # type: ignore
         """Check if channel is spamchan"""
+
         def predicate(ctx):
             try:
-                if not ctx.channel.id in BOT_CHANIDS:
+                if ctx.channel.id not in BOT_CHANIDS:
                     logging.debug("%s not found in %s", ctx.channel.id, BOT_CHANIDS)
                 return ctx.channel.id in BOT_CHANIDS
-            except:
+            except Exception as e:
+                logging.debug("Exception: %s", str(e))
                 traceback.print_exc()
                 return False
-        return commands.check(predicate) # type: ignore
 
-    async def leaderboard_increment(self, 
+        return commands.check(predicate)  # type: ignore
-                                    uid: int) -> None:
+
+    async def leaderboard_increment(self, uid: int) -> None:
         """
         Increment leaderboard for uid
         Args:
@@ -175,13 +205,12 @@ class Meme(commands.Cog):
                 None
         """
 
-        
+        if uid not in self.meme_leaderboard:
-        if not uid in self.meme_leaderboard:
             self.meme_leaderboard[uid] = 1
         else:
             self.meme_leaderboard[uid] += 1
 
-        async with sqlite3.connect(self.stats_db_path, timeout=2) as db_conn:
+        async with sqlite3.connect(self.stats_db_path, timeout=5) as db_conn:
             """Attempts both insert/update"""
             query_1: str = "UPDATE memes SET count = count + 1 WHERE discord_uid = ?"
             query_1_params: tuple = (uid,)
@@ -189,30 +218,92 @@ class Meme(commands.Cog):
             query_2_params: tuple = (uid, self.meme_leaderboard[uid])
             try:
                 await db_conn.execute(query_1, query_1_params)
-            except:
+            except:  # noqa
+                """Safe to ignore"""
                 pass
             try:
                 await db_conn.execute(query_2, query_2_params)
-            except:
+            except:  # noqa
+                """Safe to ignore"""
                 pass
             await db_conn.commit()
-                
+        try:
+            await self.update_meme_lb()
+        except Exception as e:
+            logging.info(
+                "Failed to update meme leaderboard following increment: %s", str(e)
+            )
 
     async def init_meme_leaderboard(self) -> None:
         """
         INIT MEME LEADERBOARD
         """
-        self.meme_leaderboard: dict [int, int] = {}
+        self.meme_leaderboard: dict[int, int] = {}
-        async with sqlite3.connect(self.stats_db_path, timeout=2) as db_conn:
+        async with sqlite3.connect(self.stats_db_path, timeout=5) as db_conn:
             db_conn.row_factory = sqlite3.Row
             db_query: str = "SELECT discord_uid, count FROM memes WHERE count > 0"
             async with db_conn.execute(db_query) as db_cursor:
                 results = await db_cursor.fetchall()
                 for result in results:
-                    uid = result['discord_uid']
+                    uid = result["discord_uid"]
-                    count = result['count']
+                    count = result["count"]
                     self.meme_leaderboard[uid] = count
 
+    async def insert_meme(
+        self, discord_uid: int, timestamp: int, message_id: int, image: io.BytesIO
+    ) -> Optional[bool]:
+        """
+        INSERT MEME -> SQLITE DB
+        """
+        try:
+            try:
+                image.seek(0)
+                _image = Image.open(image)
+            except UnidentifiedImageError:
+                return None
+            phash: str = str(imagehash.phash(_image))
+            query: str = "INSERT INTO memes(discord_uid, timestamp, image, message_ids, phash) VALUES(?, ?, ?, ?, ?)"
+            image.seek(0)
+            if not self.is_png(image):
+                store_image = self.convert_to_png(image)
+            else:
+                store_image = image.read()
+            async with sqlite3.connect(self.meme_db_path, timeout=5) as db_conn:
+                insert = await db_conn.execute_insert(
+                    query, (discord_uid, timestamp, store_image, message_id, phash)
+                )
+                if insert:
+                    await db_conn.commit()
+                    return True
+                return None
+        except Exception as e:
+            await log_to_playground(
+                self.bot,
+                f"Exception occurred while attempting to insert meme (message id: {message_id}):\n{str(e)}",
+            )
+            return None
+
+    async def dupe_check(self, image) -> bool | int:
+        """
+        CHECK DB FOR DUPLICATE MEMES!
+        """
+        try:
+            phash: str = str(imagehash.phash(image))
+            query: str = "SELECT message_ids FROM memes WHERE phash = ? LIMIT 1"
+            async with sqlite3.connect(self.meme_db_path, timeout=2) as db_conn:
+                db_conn.row_factory = sqlite3.Row
+                async with await db_conn.execute(query, (phash,)) as db_cursor:
+                    result = await db_cursor.fetchone()
+                    if result:
+                        return result["message_ids"]
+            return False
+        except Exception as e:
+            await log_to_playground(
+                self.bot,
+                f"Exception occurred while checking image for duplicates in DB:\n{str(e)}",
+            )
+            return False
+
     @commands.Cog.listener()
     async def on_ready(self) -> None:
         """Run on Bot Ready"""
@@ -246,26 +337,29 @@ class Meme(commands.Cog):
             try:
                 try:
                     explosm_comics = await explosm_grabber.get()
-                except:
+                except:  # noqa
+                    """Safe to ignore"""
                     pass
                 try:
                     xkcd_comics = await xkcd_grabber.get()
-                except:
+                except:  # noqa
+                    """Safe to ignore"""
                     pass
                 try:
                     smbc_comics = await smbc_grabber.get()
-                except:
+                except:  # noqa
+                    """Safe to ignore"""
                     pass
                 try:
                     qc_comics = await qc_grabber.get()
                     print(f"QC: {qc_comics}")
-                except:
+                except:  # noqa
+                    """Safe to ignore"""
                     pass
                 try:
                     dino_comics = await dino_grabber.get()
                 except Exception as e:
                     logging.debug("Dino failed: %s", str(e))
-                    pass
                 try:
                     onions = await onion_grabber.get()
                 except Exception as e:
@@ -276,33 +370,41 @@ class Meme(commands.Cog):
                 except Exception as e:
                     logging.debug("THNs failed: %s", str(e))
                     pass
-            except:
+            except Exception as e:
+                logging.debug("Exception: %s", str(e))
                 traceback.print_exc()
             agents: list[str] = constants.HTTP_UA_LIST
-            headers: dict = {
+            headers: dict = {"User-Agent": random.choice(agents)}
-                'User-Agent': random.choice(agents)
-            }
             if not only_comics:
                 try:
                     for meme in memes:
                         if not meme:
                             continue
                         (meme_id, meme_title, meme_url) = meme
-                        request = requests.get(meme_url, stream=True, timeout=(5, 30), headers=headers)
+                        request = requests.get(
+                            meme_url, stream=True, timeout=(5, 30), headers=headers
+                        )
                         if not request.status_code == 200:
                             continue
                         meme_content: bytes = request.raw.read()
-                        for meme_hook in self.NO_THREAD_WEBHOOKS.get('memes', {}):
+                        for meme_hook in self.NO_THREAD_WEBHOOKS.get("memes", {}):
                             meme_image: io.BytesIO = io.BytesIO(meme_content)
-                            ext: str = meme_url.split(".")[-1]\
+                            ext: str = (
-                                .split("?")[0].split("&")[0]
+                                meme_url.split(".")[-1].split("?")[0].split("&")[0]
+                            )
                             async with ClientSession() as session:
-                                webhook: discord.Webhook = discord.Webhook.from_url(meme_hook,
+                                webhook: discord.Webhook = discord.Webhook.from_url(
-                                                                session=session)
+                                    meme_hook, session=session
-                                await webhook.send(file=discord.File(meme_image,
+                                )
-                                                                    filename=f'img.{ext}'), username="r/memes")
+                                await webhook.send(
+                                    file=discord.File(
+                                        meme_image, filename=f"img.{ext}"
+                                    ),
+                                    username="r/memes",
+                                )
                         await asyncio.sleep(2)
-                except:
+                except:  # noqa
+                    """Safe to ignore"""
                     pass
             try:
                 for comic in explosm_comics:
@@ -310,27 +412,36 @@ class Meme(commands.Cog):
                         continue
                     (comic_title, comic_url) = comic
                     comic_title = discord.utils.escape_markdown(comic_title)
-                    comic_request = requests.get(comic_url, stream=True, timeout=(5, 20), headers=headers)
+                    comic_request = requests.get(
+                        comic_url, stream=True, timeout=(5, 20), headers=headers
+                    )
                     comic_request.raise_for_status()
                     comic_content: bytes = comic_request.raw.read()
-                    ext = comic_url.split(".")[-1]\
+                    ext = comic_url.split(".")[-1].split("?")[0].split("&")[0]
-                        .split("?")[0].split("&")[0]
 
                     async with ClientSession() as session:
-                        for chanid, _hook in self.THREADS.get('comic_explosm', {}).items():
+                        for chanid, _hook in self.THREADS.get(
+                            "comic_explosm", {}
+                        ).items():
                             comic_image: io.BytesIO = io.BytesIO(comic_content)
                             channel: int = chanid
                             (hook_uri, thread_id) = _hook
-                            webhook = discord.Webhook.from_url(hook_uri,
+                            webhook = discord.Webhook.from_url(
-                                                        session=session)
+                                hook_uri, session=session
+                            )
                             _channel: Any = self.bot.get_channel(channel)
                             if not _channel:
                                 return
                             thread = _channel.get_thread(thread_id)
-                            await webhook.send(f"**{comic_title}**", file=discord.File(comic_image, filename=f'img.{ext}'),
+                            await webhook.send(
-                                                    username="Cyanide & Happiness", thread=thread)
+                                f"**{comic_title}**",
+                                file=discord.File(comic_image, filename=f"img.{ext}"),
+                                username="Cyanide & Happiness",
+                                thread=thread,
+                            )
                         await asyncio.sleep(2)
-            except:
+            except:  # noqa
+                """Safe to ignore"""
                 pass
             try:
                 for comic in xkcd_comics:
@@ -338,28 +449,35 @@ class Meme(commands.Cog):
                         continue
                     (comic_title, comic_url) = comic
                     comic_title = discord.utils.escape_markdown(comic_title)
-                    comic_request = requests.get(comic_url, stream=True, timeout=(5, 20), headers=headers)
+                    comic_request = requests.get(
+                        comic_url, stream=True, timeout=(5, 20), headers=headers
+                    )
                     comic_request.raise_for_status()
                     comic_content = comic_request.raw.read()
                     comic_image = io.BytesIO(comic_request.raw.read())
-                    ext = comic_url.split(".")[-1]\
+                    ext = comic_url.split(".")[-1].split("?")[0].split("&")[0]
-                        .split("?")[0].split("&")[0]
 
                     async with ClientSession() as session:
-                        for chanid, _hook in self.THREADS.get('comic_xkcd', {}).items():
+                        for chanid, _hook in self.THREADS.get("comic_xkcd", {}).items():
                             comic_image = io.BytesIO(comic_content)
                             channel = chanid
                             (hook_uri, thread_id) = _hook
-                            webhook = discord.Webhook.from_url(hook_uri,
+                            webhook = discord.Webhook.from_url(
-                                                        session=session)
+                                hook_uri, session=session
+                            )
                             _channel = self.bot.get_channel(channel)
                             if not _channel:
                                 return
                             thread = _channel.get_thread(thread_id)
-                            await webhook.send(f"**{comic_title}**", file=discord.File(comic_image, filename=f'img.{ext}'),
+                            await webhook.send(
-                                                    username="xkcd", thread=thread)
+                                f"**{comic_title}**",
+                                file=discord.File(comic_image, filename=f"img.{ext}"),
+                                username="xkcd",
+                                thread=thread,
+                            )
                         await asyncio.sleep(2)
-            except:
+            except:  # noqa
+                """Safe to ignore"""
                 pass
             try:
                 for comic in smbc_comics:
@@ -367,27 +485,34 @@ class Meme(commands.Cog):
                         continue
                     (comic_title, comic_url) = comic
                     comic_title = discord.utils.escape_markdown(comic_title)
-                    comic_request = requests.get(comic_url, stream=True, timeout=(5, 20), headers=headers)
+                    comic_request = requests.get(
+                        comic_url, stream=True, timeout=(5, 20), headers=headers
+                    )
                     comic_request.raise_for_status()
                     comic_content = comic_request.raw.read()
-                    ext = comic_url.split(".")[-1]\
+                    ext = comic_url.split(".")[-1].split("?")[0].split("&")[0]
-                        .split("?")[0].split("&")[0]
 
                     async with ClientSession() as session:
-                        for chanid, _hook in self.THREADS.get('comic_smbc', {}).items():
+                        for chanid, _hook in self.THREADS.get("comic_smbc", {}).items():
                             comic_image = io.BytesIO(comic_content)
                             channel = chanid
                             (hook_uri, thread_id) = _hook
-                            webhook = discord.Webhook.from_url(hook_uri,
+                            webhook = discord.Webhook.from_url(
-                                                        session=session)
+                                hook_uri, session=session
+                            )
                             _channel = self.bot.get_channel(channel)
                             if not _channel:
                                 return
                             thread = _channel.get_thread(thread_id)
-                            await webhook.send(f"**{comic_title}**", file=discord.File(comic_image, filename=f'img.{ext}'),
+                            await webhook.send(
-                                                    username="SMBC", thread=thread)
+                                f"**{comic_title}**",
+                                file=discord.File(comic_image, filename=f"img.{ext}"),
+                                username="SMBC",
+                                thread=thread,
+                            )
                         await asyncio.sleep(2)
-            except:
+            except:  # noqa
+                """Safe to ignore"""
                 pass
             try:
                 for comic in qc_comics:
@@ -396,81 +521,97 @@ class Meme(commands.Cog):
                         continue
                     (comic_title, comic_url) = comic
                     comic_title = discord.utils.escape_markdown(comic_title)
-                    comic_url = regex.sub(r'^http://ww\.', 'http://www.',
+                    comic_url = regex.sub(r"^http://ww\.", "http://www.", comic_url)
-                                               comic_url)
+                    comic_url = regex.sub(r"\.pmg$", ".png", comic_url)
-                    comic_url = regex.sub(r'\.pmg$', '.png',
+                    comic_request = requests.get(
-                                               comic_url)
+                        comic_url, stream=True, timeout=(5, 20), headers=headers
-                    comic_request = requests.get(comic_url, stream=True,
+                    )
-                                                 timeout=(5, 20), headers=headers)
                     comic_request.raise_for_status()
                     comic_content = comic_request.raw.read()
-                    ext = comic_url.split(".")[-1]\
+                    ext = comic_url.split(".")[-1].split("?")[0].split("&")[0]
-                        .split("?")[0].split("&")[0]
 
                     async with ClientSession() as session:
-                        for chanid, _hook in self.THREADS.get('comic_qc', {}).items():
+                        for chanid, _hook in self.THREADS.get("comic_qc", {}).items():
                             comic_image = io.BytesIO(comic_content)
                             channel = chanid
                             (hook_uri, thread_id) = _hook
-                            webhook = discord.Webhook.from_url(hook_uri,
+                            webhook = discord.Webhook.from_url(
-                                                            session=session)
+                                hook_uri, session=session
+                            )
                             _channel = self.bot.get_channel(channel)
                             if not _channel:
                                 return
                             thread = _channel.get_thread(thread_id)
-                            await webhook.send(f"**{comic_title}**", file=discord.File(comic_image, filename=f'img.{ext}'),
+                            await webhook.send(
-                                                        username="Questionable Content", thread=thread)
+                                f"**{comic_title}**",
+                                file=discord.File(comic_image, filename=f"img.{ext}"),
+                                username="Questionable Content",
+                                thread=thread,
+                            )
                     await asyncio.sleep(2)
-            except:
+            except Exception as e:
+                logging.debug("Exception: %s", str(e))
                 traceback.print_exc()
-                pass                                                                 
             try:
                 for comic in dino_comics:
                     if not comic:
                         continue
                     (comic_title, comic_url) = comic
                     comic_title = discord.utils.escape_markdown(comic_title)
-                    comic_request = requests.get(comic_url, stream=True, timeout=(5, 20), headers=headers)
+                    comic_request = requests.get(
+                        comic_url, stream=True, timeout=(5, 20), headers=headers
+                    )
                     comic_request.raise_for_status()
                     comic_content = comic_request.raw.read()
-                    ext = comic_url.split(".")[-1]\
+                    ext = comic_url.split(".")[-1].split("?")[0].split("&")[0]
-                        .split("?")[0].split("&")[0]
 
                     async with ClientSession() as session:
-                        for chanid, _hook in self.THREADS.get('comic_dino', {}).items():
+                        for chanid, _hook in self.THREADS.get("comic_dino", {}).items():
                             comic_image = io.BytesIO(comic_content)
                             channel = chanid
                             (hook_uri, thread_id) = _hook
-                            webhook = discord.Webhook.from_url(hook_uri,
+                            webhook = discord.Webhook.from_url(
-                                                            session=session)
+                                hook_uri, session=session
+                            )
                             _channel = self.bot.get_channel(channel)
                             if not _channel:
                                 return
                             thread = _channel.get_thread(thread_id)
-                            await webhook.send(f"**{comic_title}**", file=discord.File(comic_image, filename=f'img.{ext}'),
+                            await webhook.send(
-                                                        username="Dinosaur Comics", thread=thread)
+                                f"**{comic_title}**",
+                                file=discord.File(comic_image, filename=f"img.{ext}"),
+                                username="Dinosaur Comics",
+                                thread=thread,
+                            )
                         await asyncio.sleep(2)
-            except:
+            except:  # noqa
+                """Safe to ignore"""
                 pass
             try:
                 for onion in onions:
                     if not onion:
                         continue
                     (onion_title, onion_description, onion_link, onion_video) = onion
-                    onion_description = textwrap.wrap(text=onion_description, 
+                    onion_description = textwrap.wrap(
-                                                        width=860, max_lines=1)[0]
+                        text=onion_description, width=860, max_lines=1
+                    )[0]
                     embed: discord.Embed = discord.Embed(title=onion_title)
-                    embed.add_field(name="Content", value=f"{onion_description[0:960]}\n-# {onion_link}")
+                    embed.add_field(
+                        name="Content",
+                        value=f"{onion_description[0:960]}\n-# {onion_link}",
+                    )
                     async with ClientSession() as session:
-                        for hook in self.NO_THREAD_WEBHOOKS.get('theonion', {}):
+                        for hook in self.NO_THREAD_WEBHOOKS.get("theonion", {}):
                             hook_uri = hook
-                            webhook = discord.Webhook.from_url(hook_uri,
+                            webhook = discord.Webhook.from_url(
-                                session=session)
+                                hook_uri, session=session
+                            )
                             await webhook.send(embed=embed, username="The Onion")
                             if onion_video:
                                 await webhook.send(f"^ video: {onion_video}")
                         await asyncio.sleep(2)
-            except:
+            except:  # noqa
+                """Safe to ignore"""
                 pass
             try:
                 for thn in thns:
@@ -478,49 +619,56 @@ class Meme(commands.Cog):
                     if not thn:
                         continue
                     (thn_title, thn_description, thn_link, thn_pubdate, thn_video) = thn
-                    thn_description = textwrap.wrap(text=thn_description, 
+                    thn_description = textwrap.wrap(
-                                                    width=860, max_lines=1)[0]
+                        text=thn_description, width=860, max_lines=1
+                    )[0]
                     embed = discord.Embed(title=thn_title)
-                    embed.add_field(name="Content", value=f"{thn_description[0:960]}\n-# {thn_link}")
+                    embed.add_field(
+                        name="Content", value=f"{thn_description[0:960]}\n-# {thn_link}"
+                    )
                     embed.add_field(name="Published", value=thn_pubdate, inline=False)
                     async with ClientSession() as session:
-                        for hook in self.NO_THREAD_WEBHOOKS.get('thn', {}):
+                        for hook in self.NO_THREAD_WEBHOOKS.get("thn", {}):
                             hook_uri = hook
-                            webhook = discord.Webhook.from_url(hook_uri,
+                            webhook = discord.Webhook.from_url(
-                                session=session)
+                                hook_uri, session=session
+                            )
                             await webhook.send(embed=embed, username="The Hacker News")
                             if thn_video:
                                 await webhook.send(f"^ video: {thn_video}")
                     await asyncio.sleep(2)
-            except:
+            except:  # noqa
+                """Safe to ignore"""
                 pass
-        except:
+        except Exception as e:
-            # await self.bot.get_channel(self.MEMESTREAM_CHANID).send(f"FUCK, MY MEEMER!  YOU DENTED MY MEEMER!")
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
 
     @tasks.loop(hours=12.0)
     async def meme_stream_loop(self) -> None:
         """Meme Stream Loop (r/memes)"""
         try:
-            await asyncio.sleep(10) # Try to ensure we are ready first
+            await asyncio.sleep(10)  # Try to ensure we are ready first
             self.meme_counter += 1
             if self.meme_counter == 1:
-                return await self.do_autos(only_comics=True) # Skip first iteration!
+                return await self.do_autos(only_comics=True)  # Skip first iteration!
 
             await self.do_autos()
-        except:
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
 
     @tasks.loop(hours=0.5)
     async def explosm_loop(self) -> None:
         """Comic Loop"""
         try:
-            await asyncio.sleep(10) # Try to ensure we are ready first
+            await asyncio.sleep(10)  # Try to ensure we are ready first
             await self.do_autos(only_comics=True)
-        except:
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
 
-    @bridge.bridge_command() # type: ignore
+    @bridge.bridge_command()  # type: ignore
     @is_spamchan()
     async def meme(self, ctx) -> None:
         """Create Meme"""
@@ -533,9 +681,10 @@ class Meme(commands.Cog):
         try:
             await ctx.respond("Trying!", ephemeral=True)
             await self.do_autos()
-        except:
+        except Exception as e:
-            await ctx.respond("Fuck! :(", ephemeral=True)
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
+            await ctx.respond("Fuck! :(", ephemeral=True)
 
     @bridge.bridge_command(hidden=True)
     @commands.is_owner()
@@ -544,9 +693,10 @@ class Meme(commands.Cog):
         try:
             await ctx.respond("Trying!", ephemeral=True)
             await self.do_autos(only_comics=True)
-        except:
+        except Exception as e:
-            await ctx.respond("Fuck! :(", ephemeral=True)
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
+            await ctx.respond("Fuck! :(", ephemeral=True)
 
     @commands.Cog.listener()
     async def on_message(self, message: discord.Message) -> None:
@@ -555,30 +705,64 @@ class Meme(commands.Cog):
         Also monitors for messages to #memes-top-10 to autodelete, only Havoc may post in #memes-top-10!
         """
         lb_chanid: int = 1352373745108652145
-        if not self.bot.user: # No valid client instance
+        meme_chanid: int = 1147229098544988261
+        if not self.bot.user:  # No valid client instance
             return
         if not isinstance(message.channel, discord.TextChannel):
             return
-        if message.channel.id == lb_chanid\
+        if (
-            and not message.author.id == self.bot.user.id:
+            message.channel.id == lb_chanid
+            and not message.author.id == self.bot.user.id
+        ):
             """Message to #memes-top-10 not by Havoc, delete it"""
-            await message.delete(reason=f"Messages to #{message.channel.name} are not allowed")
+            await message.delete(
+                reason=f"Messages to #{message.channel.name} are not allowed"
+            )
             removal_embed: discord.Embed = discord.Embed(
                 title="Message Deleted",
-                description=f"Your message to **#{message.channel.name}** has been automatically deleted.\n**Reason**: Messages to this channel by users is not allowed."
+                description=f"Your message to **#{message.channel.name}** has been automatically deleted.\n**Reason**: Messages to this channel by users is not allowed.",
             )
             await message.author.send(embed=removal_embed)
 
-        if message.author.id == self.bot.user.id: # Bots own message
+        if message.author.id == self.bot.user.id:  # Bots own message
             return
         if not message.guild:
             return
-        if not message.channel.id == 1147229098544988261: # Not meme channel
+        if message.channel.id not in [
+            1157529874936909934,
+            meme_chanid,
+        ]:  # Not meme channel
             return
-        if not message.attachments: # No attachments to consider a meme
+        if not message.attachments:  # No attachments to consider a meme
             return
 
-        await self.leaderboard_increment(message.author.id)
+        unique_memes: list = []
+        for item in message.attachments:
+            if item.url and len(item.url) >= 20:
+                image: io.BytesIO = io.BytesIO(
+                    requests.get(item.url, stream=True, timeout=20).raw.read()
+                )
+                dupe_check = await self.dupe_check(Image.open(image))
+                if dupe_check:
+                    channel = message.channel
+                    try:
+                        original_message = await channel.fetch_message(dupe_check)  # type: ignore
+                        original_message_url = original_message.jump_url
+                        await message.add_reaction(
+                            emoji="<:quietscheentchen:1255956612804247635>"
+                        )
+                        await message.reply(original_message_url)
+                    except Exception as e:
+                        logging.info("Failed to mark original image: %s", str(e))
+                else:
+                    image.seek(0)
+                    unique_memes.append(image)
+        if unique_memes:
+            await self.leaderboard_increment(message.author.id)
+            for meme_image in unique_memes:
+                author_id: int = message.author.id
+                timestamp: int = int(message.created_at.timestamp())
+                await self.insert_meme(author_id, timestamp, message.id, meme_image)
 
     async def get_top(self, n: int = 10) -> Optional[list[tuple]]:
         """
@@ -591,14 +775,14 @@ class Meme(commands.Cog):
         """
         try:
             out_top: list[tuple[int, int]] = []
-            async with sqlite3.connect(self.stats_db_path, timeout=2) as db_conn:
+            async with sqlite3.connect(self.stats_db_path, timeout=5) as db_conn:
                 db_conn.row_factory = sqlite3.Row
                 query: str = "SELECT discord_uid, count FROM memes WHERE count > 0 ORDER BY count DESC"
                 async with db_conn.execute(query) as db_cursor:
                     db_result = await db_cursor.fetchall()
                     for res in db_result:
-                        uid = res['discord_uid']
+                        uid = res["discord_uid"]
-                        count = res['count']
+                        count = res["count"]
                         out_top.append((uid, count))
             # Check for and remove missing members
             guild_id: int = 1145182936002482196
@@ -610,12 +794,13 @@ class Meme(commands.Cog):
                 member: Optional[discord.Member] = guild.get_member(uid)
                 if not member:
                     out_top.pop(x)
-            return out_top[0:(n+1)] 
+            return out_top[0 : (n + 1)]
-        except:
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
             return None
 
-    async def get_top_embed(self, n:int = 10) -> Optional[discord.Embed]:
+    async def get_top_embed(self, n: int = 10) -> Optional[discord.Embed]:
         """
         Get Top Memes Embed
 
@@ -638,11 +823,11 @@ class Meme(commands.Cog):
             if not member:
                 continue
             display_name: str = member.display_name
-            top_formatted += f"{x+1}. **{discord.utils.escape_markdown(display_name)}**: *{count}*\n"
+            top_formatted += f"{x + 1}. **{discord.utils.escape_markdown(display_name)}**: *{count}*\n"
         top_formatted = top_formatted.strip()
-        embed: discord.Embed = discord.Embed(title=f"Top {n} Memes",
+        embed: discord.Embed = discord.Embed(
-                            description=top_formatted,
+            title=f"Top {n} Memes", description=top_formatted, colour=0x25BD6B
-                            colour=0x25bd6b)
+        )
         return embed
 
     @tasks.loop(seconds=30, reconnect=True)
@@ -656,9 +841,12 @@ class Meme(commands.Cog):
             if not isinstance(channel, discord.TextChannel):
                 return
             message_to_edit = await channel.fetch_message(message_id)
-            await message_to_edit.edit(embed=top_embed,
+            await message_to_edit.edit(
-                                    content="## This message will automatically update periodically.")
+                embed=top_embed,
-        except:
+                content="## This message will automatically update periodically.",
+            )
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
 
     @bridge.bridge_command(hidden=True)
@@ -666,17 +854,57 @@ class Meme(commands.Cog):
     async def doembed(self, ctx) -> None:
         """Do Meme Embed"""
         meme_lb_chan_id: int = 1352373745108652145
-        meme_lb_chan: Union[discord.TextChannel, Any] = self.bot.get_channel(meme_lb_chan_id)
+        meme_lb_chan: Union[discord.TextChannel, Any] = self.bot.get_channel(
+            meme_lb_chan_id
+        )
         embed = await self.get_top_embed()
         if embed:
             await meme_lb_chan.send(embed=embed)
         else:
             await ctx.respond("NO embed :(")
+
+    def is_png(self, buffer: bytes | io.BytesIO) -> bool:
+        """
+        Check if image (in-memory buffer, or bytes) is a PNG
+        Args:
+            buffer (bytes|io.BytesIO)
+        Returns:
+            bool
+        """
+        # Accepts either bytes or a BytesIO-like object
+        if isinstance(buffer, io.BytesIO):
+            if hasattr(buffer, "read") and hasattr(buffer, "seek"):
+                pos = buffer.tell()
+                buffer.seek(0)
+                signature = buffer.read(8)
+                buffer.seek(pos)
+            else:
+                signature = buffer[:8]
+            return signature == b"\x89PNG\r\n\x1a\n"
+
+    def convert_to_png(self, in_buffer: io.BytesIO) -> bytes:
+        """
+        Convert an in-memory buffer to PNG
+        Args:
+            in_buffer (io.BytesIO)
+        Returns:
+            bytes
+        """
+        in_buffer.seek(0)
+        with Image.open(in_buffer) as im:
+            if im.format == "PNG":
+                raise ValueError("Already a PNG")
+            out_buffer = io.BytesIO()
+            im.save(out_buffer, format="PNG")
+            out_buffer.seek(0)
+        return out_buffer.read()
+
     def cog_unload(self) -> None:
         self.meme_stream_loop.cancel()
         self.explosm_loop.cancel()
         self.update_meme_lb.cancel()
 
+
 def setup(bot) -> None:
     """Run on Cog Load"""
     bot.add_cog(Meme(bot))

cogs/misc_util.py

@@ -1,453 +0,0 @@
-import os
-import logging
-import traceback
-import random
-import datetime
-import pytz
-from typing import Optional, LiteralString, Union
-import regex
-import aiosqlite as sqlite3
-from aiohttp import ClientSession, ClientTimeout
-from bohancompliment import ComplimentGenerator
-from discord import Embed
-
-class Util:
-    """Misc Utility"""
-    def __init__(self) -> None:
-        self.URL_URBANDICTIONARY: str = "http://api.urbandictionary.com/v0/define"
-        self.URL_INSULTAPI: str = "https://insult.mattbas.org/api/insult"
-        self.COMPLIMENT_GENERATOR = ComplimentGenerator()
-        self.dbs: dict[str, str|LiteralString] = {
-            'whisky': os.path.join("/usr/local/share",
-                                   "sqlite_dbs", "whiskey.db"),
-            'drinks': os.path.join("/usr/local/share",
-                                   "sqlite_dbs", "cocktails.db"),
-            'strains': os.path.join("/usr/local/share",
-                                    "sqlite_dbs", "strains.db"),
-            'qajoke': os.path.join("/usr/local/share",
-                                   "sqlite_dbs", "qajoke.db"),
-            'rjokes': os.path.join("/usr/local/share",
-                                   "sqlite_dbs", "rjokes.db"),
-            'randmsg': os.path.join("/usr/local/share",
-                                    "sqlite_dbs", "randmsg.db"),
-            'stats': os.path.join("/usr/local/share",
-                                  "sqlite_dbs", "havoc_stats.db"),
-            'cookies': os.path.join("/usr/local/share",
-                                    "sqlite_dbs", "cookies.db"),
-        }
-        self.COFFEES: list = ['a cup of french-pressed coffee', 'a cup of cold brew', 'a cup of flash brew',
-                        'a cup of Turkish coffee', 'a cup of Moka', 'an espresso',
-                        'a cup of Nescafe coffee',
-                        'an iced coffee', 'a Frappé', 'a freddo cappuccino',
-                        'a cup of Chock full o\'Nuts', 'a cup of Folgers', 'a cup of Lavazza',
-                        'a cup of Maxwell House', 'a cup of Moccona', 'a cup of Mr. Brown Coffee',
-                        'a cup of affogato al caffè',
-                        'a cup of Caffè Medici', 'a cup of Café Touba',
-                        'a double-double', 'an indian filter coffee', 'a cup of pocillo',
-                        'a cup of caffè americano', 'a cup of caffè lungo', 'a latte', 'a manilo',
-                        'a flat white', 'a cup of café cubano', 'a cup of caffè crema',
-                        'a cup of cafe zorro', 'an espresso roberto', 'an espresso romano',
-                        'an espresso sara', 'a guillermo', 'a ristretto', 'a cup of melya',
-                        'a cup of caffè marocchino', 'a cup of café miel', 'a cup of café de olla',
-                        'a Mazagran', 'a Palazzo', 'an ice shot', 'a macchiato',
-                        'a cortado', 'a red eye', 'a cappuccino',
-                        'a mocha', 'a café au lait', 'a bicerin',
-                        'a caffè corretto', 'a ca phe trung', 'a café bombón', 'a Vienna coffee',
-                        'a flat black', 'a lungo', 'a doppio', 'a ristretto bianco', 'a piccolo latte',
-                        'a gibraltar', 'a breve', 'a café con leche', 'a su café', 'a café del tiempo',
-                        'a java chip frappuccino', 'a pumpkin spice latte', 'a caramel macchiato',
-                        'a white chocolate mocha', 'a hazelnut coffee', 'a toffee nut latte',
-                        'a peppermint mocha', 'a cinnamon dolce latte', 'a coconut milk latte',
-                        'an almond milk cappuccino', 'an oat milk latte', 'a caramel frappuccino',
-                        'a chocolate frappuccino', 'a butter pecan coffee', 'a maple pecan latte',
-                        'a sea salt caramel mocha', 'a nitro cold brew', 'a pumpkin cold brew',
-                        'a honey almond flat white', 'a sweet cream cold brew', 'a matcha latte',
-                        'a golden latte', 'a turmeric latte', 'a beetroot latte', 'a kopi luwak']    
-        self.LAST_5_COFFEES: list = []
-        
-
-    def tdTuple(self, td:datetime.timedelta) -> tuple:
-        """
-        Create TimeDelta Tuple
-        
-        Args:
-            td (datetime.timedelta)
-        Returns:
-            tuple
-            
-        """
-        def _t(t, n):
-            if t < n: 
-                return (t, 0)
-            v = t//n
-            return (t -  (v * n), v)
-        (s, h) = _t(td.seconds, 3600)
-        (s, m) = _t(s, 60)    
-        (mics, mils) = _t(td.microseconds, 1000)
-        return (td.days, h, m, s, mics, mils)
-
-    async def get_counter(self, counter: Optional[str] = None) -> Optional[dict]:
-        """
-        Get Counter
-        
-        Args:
-            counter (Optional[str])
-        Returns:
-            Optional[dict]
-            
-        """
-        stats_db: str|LiteralString = self.dbs.get('stats', '')
-        if not stats_db:
-            return None
-        async with sqlite3.connect(stats_db,
-                                         timeout=3) as db_conn:
-            db_conn.row_factory = sqlite3.Row
-            query: str = "SELECT ? FROM stats LIMIT 1"
-            if not counter:
-                query = "SELECT * FROM stats LIMIT 1"
-            async with await db_conn.execute(query, (counter,) if counter else None) as db_cursor:
-                result = await db_cursor.fetchone()
-                return result
-            
-    async def get_stats_embed(self) -> Optional[Embed]:
-        """
-        Get Stats Embed
-        
-        Returns:
-            Optional[Embed]
-            
-        """
-        counters: Optional[dict] = await self.get_counter()
-        if not counters:
-            return None
-        embed: Embed = Embed(title="Stats")
-        counter_message: str = ""
-        counters_sorted: dict = dict(sorted(counters.items(), 
-                          key=lambda item: item[1], reverse=True))
-        for counter, value in counters_sorted.items():
-            counter = regex.sub(r'_', ' ',
-                                     counter.strip()).title()
-            counter_message += f"- {value} {counter}\n"
-        embed.description = counter_message.strip()
-        return embed
-            
-    async def increment_counter(self, counter: str) -> bool:
-        """
-        Increment Counter
-        
-        Args:
-            counter (str)
-        Returns:
-            bool
-            
-        """
-        stats_db: str|LiteralString = self.dbs.get('stats', '')
-        if not stats_db:
-            return False
-        async with sqlite3.connect(stats_db,
-                                         timeout=3) as db_conn:
-            async with await db_conn.execute(f"UPDATE stats SET {counter} = {counter} + 1") as db_cursor:
-                if db_cursor.rowcount < 0:
-                    logging.critical("[karma::increment_counter] Fail! %s", db_cursor.rowcount)
-                    return False
-                await db_conn.commit()
-                return True
-
-    async def get_ud_def(self, term: str) -> tuple[str, str]:
-        """
-        Get Definition from UD
-        
-        Args:
-            term (str)
-        Returns:
-            tuple[str, str]
-            
-        """
-        try:
-            async with ClientSession() as session:
-                async with await session.get(self.URL_URBANDICTIONARY,
-                                             params={
-                                                 "term": term,
-                                                 },
-                                             headers = {
-                                                 'content-type': 'application/json; charset=utf-8',
-                                                 }, timeout=ClientTimeout(connect=5, sock_read=5)) as request:
-                    logging.debug("UD returned: %s",
-                                  await request.text())
-                    data: dict = await request.json()
-                    if "list" in data:
-                        definitions: list[dict] = data["list"]
-                        if definitions:
-                            definition: dict = definitions[0]
-                            definition_word: str = definition.get("word", "N/A")
-                            definition_text: str = regex.sub(r'(\r|\n|\r\n)', ' ', definition["definition"].strip())
-                            return (definition_word, definition_text)  # Tuple: Returned word, returned definition
-                        else:
-                            return (term, "Not found!")
-                    else:
-                        return (term, "Error retrieving data from Urban Dictionary")
-        except Exception as e:
-            traceback.print_exc()
-            return (term, f"ERR: {str(e)}")
-
-    async def get_insult(self, recipient: str) -> str:
-        """
-        Get Insult
-        
-        Args:
-            recipient (str)
-        Returns:
-            str
-            
-        """
-        async with ClientSession() as session:
-            async with await session.get(f"{self.URL_INSULTAPI}?who={recipient}") as request:
-                request.raise_for_status()
-                return await request.text()
-            
-
-    async def get_compliment(self, subject: str,
-                             language: Optional[str] = 'en') -> str:
-        """
-        Get Compliment
-        
-        Args:
-            subject (str)
-            language (Optional[str]) (default: 'en')
-        Returns:
-            str
-
-        """
-        return self.COMPLIMENT_GENERATOR.compliment_in_language(subject, language)
-
-    async def get_whisky(self) -> Optional[tuple]:
-        """
-        Get Whisky
-        
-        Returns:
-            Optional[tuple]
-            
-        """
-        whisky_db: str|LiteralString = self.dbs.get('whisky', '')
-        if not whisky_db:
-            return None
-        async with sqlite3.connect(database=whisky_db,
-                                   timeout=2) as db_conn:
-            db_query: str = "SELECT name, category, description FROM whiskeys ORDER BY random() LIMIT 1"
-            async with await db_conn.execute(db_query) as db_cursor:
-                db_result: Optional[Union[sqlite3.Row, tuple]] = await db_cursor.fetchone()
-                if not db_result:
-                    return None
-                (name, category, description) = db_result
-                name = regex.sub(r'(^\p{White_Space}|\r|\n)', '',
-                                regex.sub(r'\p{White_Space}{2,}', ' ',
-                                        name.strip()))
-                category = regex.sub(r'(^\p{White_Space}|\r|\n)', '',
-                                    regex.sub(r'\p{White_Space}{2,}', ' ',
-                                            category.strip()))
-                description = regex.sub(r'(^\p{White_Space}|\r|\n)', '',
-                                        regex.sub(r'\p{White_Space}{2,}', ' ',
-                                                description.strip()))
-                return (name, category, description)
-        
-    async def get_drink(self) -> Optional[tuple]:
-        """
-        Get Drink
-        
-        Returns:
-            Optional[tuple]
-            
-        """
-        drinks_db: str|LiteralString = self.dbs.get('drinks', '')
-        if not drinks_db:
-            return None
-        async with sqlite3.connect(database=drinks_db,
-                                   timeout=2) as db_conn:
-            db_query: str = "SELECT name, ingredients FROM cocktails ORDER BY random() LIMIT 1"
-            async with await db_conn.execute(db_query) as db_cursor:
-                db_result: tuple = await db_cursor.fetchone()
-                
-                (name, ingredients) = db_result
-                name = regex.sub(r'(^\p{White_Space}|\r|\n)', '', regex.sub(r'\p{White_Space}{2,}', ' ', name.strip()))
-                ingredients = regex.sub(r'(^\p{White_Space}|\r|\n)', '', regex.sub(r'\p{White_Space}{2,}', ' ', ingredients.strip()))
-                ingredients = regex.sub(r'\*', '\u2731', ingredients.strip())
-                return (name, ingredients)
-        
-    async def get_strain(self, strain: Optional[str] = None) -> Optional[tuple]:
-        """
-        Get Strain
-        
-        Args:
-            strain (Optional[str])
-        Returns:
-            Optional[tuple]
-            
-        """
-        strains_db: str|LiteralString = self.dbs.get('strains', '')
-        if not strains_db:
-            return None
-        async with sqlite3.connect(database=strains_db,
-                                   timeout=2) as db_conn:
-            db_params: Optional[tuple] = None
-            if not strain:
-                db_query: str = "SELECT name, description FROM strains_w_desc ORDER BY random() LIMIT 1"
-            else:
-                db_query = "SELECT name, description FROM strains_w_desc WHERE name LIKE ?"
-                db_params = (f"%{strain.strip()}%",) 
-            async with await db_conn.execute(db_query, db_params) as db_cursor:
-                db_result: Optional[tuple] = await db_cursor.fetchone()
-                return db_result
-        
-    async def get_qajoke(self) -> Optional[tuple]:
-        """
-        Get QA Joke
-        
-        Returns:
-            Optional[tuple]
-            
-        """
-        qajoke_db: str|LiteralString = self.dbs.get('qajoke', '')
-        if not qajoke_db:
-            return None
-        async with sqlite3.connect(database=qajoke_db,
-                                   timeout=2) as db_conn:
-            db_query: str = "SELECT question, answer FROM jokes ORDER BY RANDOM() LIMIT 1"
-            async with await db_conn.execute(db_query) as cursor:
-                (question, answer) = await cursor.fetchone()
-                return (question, answer)
-        return None
-
-    async def get_rjoke(self) -> Optional[tuple]:
-        """
-        Get r/joke Joke
-        
-        Returns:
-            Optional[tuple]
-            
-        """
-        rjokes_db: str|LiteralString = self.dbs.get('rjokes', '')
-        if not rjokes_db:
-            return None
-        async with sqlite3.connect(database=rjokes_db, timeout=2) as db_conn:
-            db_query: str = "SELECT title, body, score FROM jokes WHERE score >= 100 ORDER BY RANDOM() LIMIT 1'"
-            async with await db_conn.execute(db_query) as cursor:
-                (title, body, score) = await cursor.fetchone()
-                return (title, body, score)
-        return None        
-
-
-    async def get_random_fact(self) -> str:
-        """
-        Get Random Fact
-        
-        Returns:
-            str
-            
-        """
-        try:
-            facts_api_url: str = "https://uselessfacts.jsph.pl/api/v2/facts/random"
-            facts_backup_url: str = "https://cnichols1734.pythonanywhere.com/facts/random"
-            async with ClientSession() as client:
-                try:
-                    async with await client.get(facts_api_url,
-                                                timeout=ClientTimeout(connect=5, sock_read=5)) as request:
-                        _json: dict = await request.json()
-                        fact: str = _json.get('text', None)
-                        if not fact:
-                            raise BaseException("RandFact Src 1 Failed")
-                        return fact
-                except:
-                    async with await client.get(facts_backup_url,
-                                                timeout=ClientTimeout(connect=5, sock_read=5)) as request:
-                        _json = await request.json()
-                        fact = _json.get('fact', None)
-                        return fact
-        except Exception as e:
-            traceback.print_exc()
-            return f"Failed to get a random fact :( [{str(e)}]"
-        
-    async def get_cookie(self) -> Optional[dict]:
-        """
-        Get Cookie
-        
-        Returns:
-            Optional[dict]
-            
-        """
-        cookies_db = self.dbs.get('cookies', '')
-        if not cookies_db:
-            return None
-        async with sqlite3.connect(cookies_db,
-                                   timeout=2) as db_conn:
-            db_query: str = "SELECT name, origin, image_url FROM cookies ORDER BY RANDOM() LIMIT 1"
-            async with await db_conn.execute(db_query) as db_cursor:
-                (name, origin, image_url) = await db_cursor.fetchone()
-                return {
-                    'name': name,
-                    'origin': origin,
-                    'image_url': image_url
-                }
-                
-
-    def get_coffee(self,
-                   recipient_allergic: Optional[bool] = False) -> Optional[str]:
-        """
-        Get Coffee
-        
-        Args:
-            recipient_allergic (bool): Is the recipient allergic? (so we know when to keep our nuts out of it)
-        
-        Returns:
-            str
-            
-        """
-        try:
-            randomCoffee: str = random.choice(self.COFFEES)
-            if self.LAST_5_COFFEES and randomCoffee in self.LAST_5_COFFEES\
-                or (recipient_allergic and "nut" in randomCoffee.lower()):
-                return self.get_coffee() # Recurse
-            if len(self.LAST_5_COFFEES) >= 5:
-                self.LAST_5_COFFEES.pop() # Store no more than 5 of the last served coffees
-            self.LAST_5_COFFEES.append(randomCoffee)
-            return randomCoffee
-        except:
-            traceback.print_exc()
-            return None
-        
-    def get_days_to_xmas(self) -> Optional[tuple]:
-        """
-        Get # of Days until Xmas
-        
-        Returns:
-            Optional[tuple]
-            
-        """
-        today: datetime.datetime = datetime.datetime.now(tz=pytz.UTC)
-        xmas: datetime.datetime = datetime.datetime(
-            year=today.year,
-            month=12,
-            day=25,
-            tzinfo=pytz.UTC,
-        )
-        td: datetime.timedelta = (xmas - today)
-        days, hours, minutes, seconds, us, ms = self.tdTuple(td)
-        
-        return (days, hours, minutes, seconds, ms, us)
-    
-    async def get_randmsg(self) -> Optional[str]:
-        """
-        Get Random Message from randmsg.db
-        
-        Returns:
-            Optional[str]
-            
-        """
-        randmsg_db: str|LiteralString = self.dbs.get('randmsg', '')
-        if not randmsg_db:
-            return None
-        async with sqlite3.connect(database=randmsg_db,
-                                         timeout=2) as db_conn:
-            db_query: str = "SELECT msg FROM msgs ORDER BY RANDOM() LIMIT 1"
-            async with await db_conn.execute(db_query) as db_cursor:
-                (result,) = await db_cursor.fetchone()
-                return result

cogs/owner.py

@@ -1,6 +1,7 @@
 import io
 import random
 import asyncio
+import logging
 import traceback
 from typing import Optional
 import discord
@@ -9,130 +10,107 @@ from discord.ext import bridge, commands
 from disc_havoc import Havoc
 import util
 
+
 class Owner(commands.Cog):
     """Owner Cog for Havoc"""
+
     def __init__(self, bot: Havoc) -> None:
         self.bot: Havoc = bot
         self.former_roles_store: dict[int, list[discord.Role]] = {}
         self._temperature: int = random.randrange(20, 30)
 
     @bridge.bridge_command(guild_ids=[1145182936002482196])
-    async def temperature(self, ctx, temp: Optional[int|str] = None) -> None:
+    async def temperature(self, ctx, temp: Optional[int | str] = None) -> None:
         """
         Set Temperature
-        
-        Args:
-            ctx (Any): Discord context
-            temperature (Optional[int|str]): New temperature
-        Returns:
-            None
         """
         if not temp:
-            return await ctx.respond(f"The current temperature is: {self._temperature} °C")
+            return await ctx.respond(
+                f"The current temperature is: {self._temperature} °C"
+            )
 
         if not self.bot.is_owner(ctx.author):
             return await ctx.respond("I am afraid I can't let you do that.")
         try:
             _temperature: int = int(temp)
-        except:
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
             return await ctx.respond("Invalid input")
         if _temperature < -15:
             return await ctx.respond("Too cold! (-15°C minimum)")
         elif _temperature > 35:
             return await ctx.respond("Too hot! (35°C maximum)")
         self._temperature = _temperature
-        return await ctx.respond(f"As per your request, I have adjusted the temperature to {_temperature} °C.")
+        return await ctx.respond(
+            f"As per your request, I have adjusted the temperature to {_temperature} °C."
+        )
 
     @bridge.bridge_command()
     @commands.is_owner()
-    async def editmsg(self, ctx,
+    async def editmsg(self, ctx, msgid: str, *, newcontent: str) -> None:
-                      msgid: str,
-                      *,
-                      newcontent: str
-                      ) -> None:
         """
         Edit a message previously sent by the bot
-        
-        Args:
-            ctx (Any): Discord context
-            msgid (str): Should be an int, the message id to edit
-            newcontent (str): Content to replace message with
         """
 
         try:
             message: Optional[discord.Message] = self.bot.get_message(int(msgid))
             if not message:
-                await ctx.respond(f"**Failed:** Message {msgid} not found.",
+                await ctx.respond(
-                                  ephemeral=True)
+                    f"**Failed:** Message {msgid} not found.", ephemeral=True
+                )
                 return None
             await message.edit(content=newcontent)
             await ctx.respond("**Done!**", ephemeral=True)
         except Exception as e:
-            await ctx.respond(f"**Failed:** {str(e)}",
+            await ctx.respond(f"**Failed:** {str(e)}", ephemeral=True)
-                              ephemeral=True)
 
     @bridge.bridge_command()
     @commands.is_owner()
     async def reload(self, ctx) -> None:
         """
         Reload Cogs
-        
-        Args:
-            ctx (Any): Discord context
-        Returns:
-            None
         """
 
         self.bot.load_exts(False)
         await ctx.respond("Reloaded!", ephemeral=True)
 
-
     @bridge.bridge_command()
     @commands.is_owner()
-    async def say(self, ctx, *,
+    async def say(self, ctx, *, parameters: str) -> None:
-                  parameters: str) -> None:
         """
         Make me say something in a channel
-        
-        Args:
-            ctx (Any): Discord context
-            parameters (str): Channel <space> Message
-        Returns:
-            None
         """
         _parameters: list[str] = parameters.split(" ")
 
         if not len(_parameters) > 1:
-            return await ctx.respond("**Error**: Incorrect command usage; required: <chan> <msg>", ephemeral=True)
+            return await ctx.respond(
+                "**Error**: Incorrect command usage; required: <chan> <msg>",
+                ephemeral=True,
+            )
 
         channel: str = _parameters[0]
         channel_mentions: list[int] = discord.utils.raw_channel_mentions(channel)
         if channel_mentions:
             channel = str(channel_mentions[0])
         msg: str = " ".join(_parameters[1:])
-        await util.discord_helpers.send_message(self.bot, channel=channel,
+        await util.discord_helpers.send_message(self.bot, channel=channel, message=msg)
-                                                       message=msg)
         return await ctx.respond("**Done.**", ephemeral=True)
 
     @bridge.bridge_command()
     @commands.is_owner()
-    async def chgstatus(self, ctx, *,
+    async def chgstatus(self, ctx, *, status: Optional[str] = None) -> None:
-                        status: Optional[str] = None) -> None:
         """
         Change bots status
-        
-        Args:
-            ctx (Any): Discord context
-            status (Optional[str]): The new status to set
-        Returns:
-            None
         """
         if not status:
-            return await ctx.respond("ERR: No status provided to change to!",
+            return await ctx.respond(
-                                     ephemeral=True)
+                "ERR: No status provided to change to!", ephemeral=True
+            )
 
-        await self.bot.change_presence(status=discord.Status.online,
+        await self.bot.change_presence(
-                                       activity=discord.CustomActivity(name=status.strip()))
+            status=discord.Status.online,
+            activity=discord.CustomActivity(name=status.strip()),
+        )
         await ctx.respond("Done!", ephemeral=True)
 
     @commands.message_command(name="Remove Messages Starting Here")
@@ -148,10 +126,12 @@ class Owner(commands.Cog):
             None
         """
         try:
-            await ctx.channel.purge(after=message,
+            await ctx.channel.purge(
-                                    bulk=True,
+                after=message,
-                                    limit=900000,
+                bulk=True,
-                                    reason=f"Purge initiated by {ctx.author.display_name}")
+                limit=900000,
+                reason=f"Purge initiated by {ctx.author.display_name}",
+            )
             await message.delete(reason=f"Purge initiated by {ctx.author.display_name}")
             await ctx.respond("**Done!**")
             # Wait 3 seconds, then delete interaction
@@ -177,25 +157,31 @@ class Owner(commands.Cog):
         try:
             if not isinstance(message.channel, discord.TextChannel):
                 return
-            memes_channel: discord.TextChannel = ctx.guild.get_channel(1147229098544988261)
+            memes_channel: discord.TextChannel = ctx.guild.get_channel(
-            message_content: str  = message.content
+                1147229098544988261
+            )
+            message_content: str = message.content
             message_author: str = message.author.display_name
             message_channel: str = message.channel.name
             _file: Optional[discord.File] = None
             if message.attachments:
                 for item in message.attachments:
                     if item.url and len(item.url) >= 20:
-                        image: io.BytesIO = io.BytesIO(requests.get(item.url, stream=True,
+                        image: io.BytesIO = io.BytesIO(
-                                                                    timeout=20).raw.read())
+                            requests.get(item.url, stream=True, timeout=20).raw.read()
-                        ext: str = item.url.split(".")[-1]\
+                        )
-                            .split("?")[0].split("&")[0]
+                        ext: str = item.url.split(".")[-1].split("?")[0].split("&")[0]
-                        _file = discord.File(image, filename=f'img.{ext}')
+                        _file = discord.File(image, filename=f"img.{ext}")
             if not _file:
-                return # No file to move
+                return  # No file to move
-            await memes_channel.send(f"*Performing bureaucratic duties (this didn't belong in #{message_channel})...*\n**{message_author}:** {message_content}", file=_file)            
+            await memes_channel.send(
+                f"*Performing bureaucratic duties (this didn't belong in #{message_channel})...*\n**{message_author}:** {message_content}",
+                file=_file,
+            )
             await message.delete()
             await ctx.respond("OK!", ephemeral=True)
-        except:
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
             return await ctx.respond("Failed! :(", ephemeral=True)
 
@@ -214,7 +200,9 @@ class Owner(commands.Cog):
         try:
             if not isinstance(message.channel, discord.TextChannel):
                 return
-            drugs_channel: discord.TextChannel = ctx.guild.get_channel(1172247451047034910)
+            drugs_channel: discord.TextChannel = ctx.guild.get_channel(
+                1172247451047034910
+            )
             message_content: str = message.content
             message_author: str = message.author.display_name
             message_channel: str = message.channel.name
@@ -222,18 +210,22 @@ class Owner(commands.Cog):
             if message.attachments:
                 for item in message.attachments:
                     if item.url and len(item.url) >= 20:
-                        image: io.BytesIO = io.BytesIO(requests.get(item.url, stream=True,
+                        image: io.BytesIO = io.BytesIO(
-                                                                    timeout=20).raw.read())
+                            requests.get(item.url, stream=True, timeout=20).raw.read()
-                        ext: str = item.url.split(".")[-1]\
+                        )
-                            .split("?")[0].split("&")[0]
+                        ext: str = item.url.split(".")[-1].split("?")[0].split("&")[0]
-                        _file = discord.File(image, filename=f'img.{ext}')
+                        _file = discord.File(image, filename=f"img.{ext}")
             if not _file:
-                return # No file to move
+                return  # No file to move
-            await drugs_channel.send(f"*Performing bureaucratic duties (this didn't belong in #{message_channel})...\
+            await drugs_channel.send(
-                *\n**{message_author}:** {message_content}", file=_file)
+                f"*Performing bureaucratic duties (this didn't belong in #{message_channel})...\
+                *\n**{message_author}:** {message_content}",
+                file=_file,
+            )
             await message.delete()
             await ctx.respond("OK!", ephemeral=True)
-        except:
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
             return await ctx.respond("Failed! :(", ephemeral=True)
 
@@ -252,7 +244,9 @@ class Owner(commands.Cog):
         try:
             if not isinstance(message.channel, discord.TextChannel):
                 return
-            funhouse_channel: discord.TextChannel = ctx.guild.get_channel(1213160512364478607)
+            funhouse_channel: discord.TextChannel = ctx.guild.get_channel(
+                1213160512364478607
+            )
             message_content: str = message.content
             message_author: str = message.author.display_name
             message_channel: str = message.channel.name
@@ -260,16 +254,19 @@ class Owner(commands.Cog):
             if message.attachments:
                 for item in message.attachments:
                     if item.url and len(item.url) >= 20:
-                        image: io.BytesIO = io.BytesIO(requests.get(item.url, stream=True,
+                        image: io.BytesIO = io.BytesIO(
-                                                                    timeout=20).raw.read())
+                            requests.get(item.url, stream=True, timeout=20).raw.read()
-                        ext: str = item.url.split(".")[-1]\
+                        )
-                            .split("?")[0].split("&")[0]
+                        ext: str = item.url.split(".")[-1].split("?")[0].split("&")[0]
-                        _file = discord.File(image, filename=f'img.{ext}')
+                        _file = discord.File(image, filename=f"img.{ext}")
-            await funhouse_channel.send(f"*Performing bureaucratic duties (this didn't belong in #{message_channel})\
+            await funhouse_channel.send(
-                ...*\n**{message_author}:** {message_content}")            
+                f"*Performing bureaucratic duties (this didn't belong in #{message_channel})\
+                ...*\n**{message_author}:** {message_content}"
+            )
             await message.delete()
             await ctx.respond("OK!", ephemeral=True)
-        except:
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
             return await ctx.respond("Failed! :(", ephemeral=True)
 
@@ -287,45 +284,63 @@ class Owner(commands.Cog):
         """
         try:
             if not ctx.guild.id == 1145182936002482196:
-                return # Not home server!
+                return  # Not home server!
             if not member.roles:
-                return # No roles
+                return  # No roles
             audit_reason: str = f"Einsperren von {ctx.user.display_name}"
             member = ctx.guild.get_member(member.id)
             member_display: str = member.display_name
-            einsperren_role: discord.Role = ctx.guild.get_role(1235415059300093973) if ctx.guild.id != 1145182936002482196\
+            einsperren_role: discord.Role = (
+                ctx.guild.get_role(1235415059300093973)
+                if ctx.guild.id != 1145182936002482196
                 else ctx.guild.get_role(1235406301614309386)
-            member_roles: list = [role for role in member.roles if not role.name == "@everyone"]
+            )
-            member_role_names: list[str] = [str(role.name).lower() for role in member_roles]
+            member_roles: list = [
+                role for role in member.roles if not role.name == "@everyone"
+            ]
+            member_role_names: list[str] = [
+                str(role.name).lower() for role in member_roles
+            ]
             opers_chan: discord.TextChannel = ctx.guild.get_channel(1181416083287187546)
-            if not "einsperren" in member_role_names:
+            if "einsperren" not in member_role_names:
                 try:
                     if member.id in self.former_roles_store:
                         self.former_roles_store.pop(member.id)
                     self.former_roles_store[member.id] = member.roles
-                except:
+                except:  # noqa
-                    pass # Safe to ignore
+                    """Safe to ignore"""
+                    pass
                 try:
                     await member.edit(roles=[einsperren_role], reason=audit_reason)
-                    await ctx.respond(f"Gesendet {member_display} an einsperren.", ephemeral=True)
+                    await ctx.respond(
-                    await opers_chan.send(f"@everyone: {ctx.user.display_name} gesendet {member_display} an einsperren.")
+                        f"Gesendet {member_display} an einsperren.", ephemeral=True
-                except:
+                    )
+                    await opers_chan.send(
+                        f"@everyone: {ctx.user.display_name} gesendet {member_display} an einsperren."
+                    )
+                except Exception as e:
+                    logging.debug("Exception: %s", str(e))
                     traceback.print_exc()
                     return await ctx.respond("GOTTVERDAMMT!!", ephemeral=True)
                 self.former_roles_store[member.id] = member.roles
 
-            if not member.id in self.former_roles_store:
+            if member.id not in self.former_roles_store:
                 await member.edit(roles=[])  # No roles
             else:
                 former_roles: list = self.former_roles_store.get(member.id, [0])
                 await member.edit(roles=former_roles, reason=f"De-{audit_reason}")
 
-            await ctx.respond(f"{member_display} wurde von der Einsperre befreit.", ephemeral=True)
+            await ctx.respond(
-            await opers_chan.send(f"{member_display} wurde von {ctx.user.display_name} aus der Einsperre befreit.")
+                f"{member_display} wurde von der Einsperre befreit.", ephemeral=True
+            )
+            await opers_chan.send(
+                f"{member_display} wurde von {ctx.user.display_name} aus der Einsperre befreit."
+            )
         except Exception as e:
             traceback.print_exc()
             return await ctx.respond(f"ERR: {str(e)}", ephemeral=True)
 
+
 def setup(bot) -> None:
     """Run on Cog Load"""
     bot.add_cog(Owner(bot))

cogs/quote.py

@@ -0,0 +1,329 @@
+#!/usr/bin/env python3.12
+# pylint: disable=bare-except, broad-exception-caught
+
+"""
+Quote cog for Havoc
+"""
+
+import traceback
+import time
+import os
+import datetime
+from typing import Optional
+import asyncio
+import discord
+import aiosqlite as sqlite3
+from discord.ext import bridge, commands
+from disc_havoc import Havoc
+
+class DB:
+    """DB Utility for Quote Cog"""
+    def __init__(self, bot: Havoc):
+        self.bot: Havoc = bot
+        self.db_path = os.path.join("/", "usr", "local", "share",
+                                    "sqlite_dbs", "quotes.db")
+        self.hp_chanid = 1157529874936909934
+        
+
+    async def get_quote_count(self):
+        """Get Quote Count"""
+        async with sqlite3.connect(self.db_path, timeout=2) as db_conn:
+            async with await db_conn.execute("SELECT COUNT (*) FROM quotes") as db_cursor:
+                result = await db_cursor.fetchone()
+                return result[-1]
+            
+    async def remove_quote(self, quote_id: int):
+        """Remove Quote from DB"""
+        try:
+            async with sqlite3.connect(self.db_path, timeout=2) as db_conn:
+                async with await db_conn.execute("DELETE FROM quotes WHERE id = ?", (quote_id,)) as _:
+                    await db_conn.commit()
+                    return True
+        except Exception as e: # noqa
+            _channel = self.bot.get_channel(self.hp_chanid)
+            if isinstance(_channel, discord.TextChannel):
+                await _channel.send(traceback.format_exc())
+            return False
+        
+    async def add_quote(self, message_id: int, channel_id: int,
+                        quoted_member_id: int,
+                        message_time: int,
+                        quoter_friendly: str,
+                        quoted_friendly: str,
+                        channel_friendly: str,
+                        message_content: str,
+                        ):
+        """Add Quote to DB"""
+        params = (
+            quoter_friendly,
+            int(time.time()),
+            quoted_friendly,
+            quoted_member_id,
+            channel_friendly,
+            channel_id,
+            message_id,
+            message_time,
+            quoter_friendly,
+            message_content,
+        )
+
+        try:
+            async with sqlite3.connect(self.db_path, timeout=2) as db_conn:
+                # pylint: disable=line-too-long
+                db_conn.row_factory = sqlite3.Row
+                async with await db_conn.execute("INSERT INTO quotes (added_by, added_at, quoted_user_display, quoted_user_memberid, quoted_channel_display, quoted_channel_id, quoted_message_id, quoted_message_time, added_by_friendly, quoted_message) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                                           params) as _: # pylint: enable=line-too-long
+                    await db_conn.commit()
+                    return True
+        except Exception as e: # noqa
+            return traceback.format_exc()
+        
+    async def fetch_quote(self, random: bool = False, quoteid: Optional[int] = None,
+                          added_by: Optional[str] = None, quoted_user: Optional[str] = None,
+                          content: Optional[str] = None):
+        """Fetch Quote from DB"""
+        try:
+            query_head = "SELECT id, added_by_friendly, added_at, quoted_user_display, quoted_channel_display, quoted_message_time, quoted_message FROM quotes"
+            query = ""
+            params: Optional[tuple] = None
+
+            if random:
+                query = f"{query_head} ORDER BY RANDOM() LIMIT 1"
+            elif quoteid:
+                query = f"{query_head} WHERE id = ? LIMIT 1"
+                params = (quoteid,)
+            elif added_by:
+                query = f"{query_head} WHERE added_by_friendly LIKE ? ORDER BY RANDOM() LIMIT 5"
+                params = (f"%{added_by}%",)
+            elif quoted_user:
+                query = f"{query_head} WHERE quoted_user_display LIKE ? ORDER BY RANDOM() LIMIT 5"
+                params = (f"%{quoted_user}%",)
+            elif content:
+                query = f"{query_head} WHERE quoted_message LIKE ? ORDER BY RANDOM() LIMIT 5"
+                params = (f"%{content}%",)
+
+            async with sqlite3.connect(self.db_path, timeout=2) as db_conn:
+                db_conn.row_factory = sqlite3.Row
+                async with await db_conn.execute(query, params) as db_cursor:
+                    results = await db_cursor.fetchall()
+                    if not results:
+                        return {
+                            'err': 'No results for query',
+                        }
+                    if random or quoteid:
+                        chosen = results[-1]
+                        return {
+                            str(k): v for k,v in chosen.items()
+                        }
+                    else:
+                        return [
+                            { str(k): v for k,v in _.items() }
+                            for _ in results
+                        ]
+        except Exception as e: # noqa
+            return traceback.format_exc()
+
+
+class Quote(commands.Cog):
+    """Quote Cog for Havoc"""
+    def __init__(self, bot: Havoc):
+        self.bot: Havoc = bot
+        self.db = DB(self.bot)
+
+    def is_homeserver(): # type: ignore
+        """Check if channel/interaction is within homeserver"""
+        def predicate(ctx):
+            try:
+                return ctx.guild.id == 1145182936002482196
+            except Exception as e: # noqa
+                traceback.print_exc()
+                return False
+        return commands.check(predicate)
+
+    @commands.message_command(name="Add Quote")
+    async def add_quote(self, ctx, message: discord.Message):
+        """Add A Quote"""
+        hp_chanid = 1157529874936909934
+        try:
+            if message.author.bot:
+                return await ctx.respond("Quotes are for real users, not bots.", ephemeral=True)
+            quoter_friendly = ctx.author.display_name
+            quoted_message_id = message.id            
+            quoted_channel_friendly = f'#{ctx.channel.name}'
+            quoted_channel_id = ctx.channel.id
+            message_content = message.content
+            message_author_friendly = message.author.display_name
+            message_author_id = message.author.id
+            message_time = int(message.created_at.timestamp())
+            message_escaped = discord.utils.escape_mentions(discord.utils.escape_markdown(message_content)).strip()
+
+            if len(message_escaped) < 3:
+                return await ctx.respond("**Error**: Message (text content) is not long enough to quote.", ephemeral=True)
+            
+            if len(message_escaped) > 512:
+                return await ctx.respond("**Error**: Message (text content) is too long to quote.", ephemeral=True)
+
+            result = await self.db.add_quote(message_id=quoted_message_id,
+                                    channel_id=quoted_channel_id,
+                                    quoted_member_id=message_author_id,
+                                    message_time=message_time,
+                                    quoter_friendly=quoter_friendly,
+                                    quoted_friendly=message_author_friendly,
+                                    channel_friendly=quoted_channel_friendly,
+                                    message_content=message_content)
+            if not result:
+                return await ctx.respond("Failed!", ephemeral=True)
+            else:
+                return await ctx.respond("OK!", ephemeral=True)
+        except Exception as e: # noqa
+            _channel = self.bot.get_channel(hp_chanid)
+            if not isinstance(_channel, discord.TextChannel):
+                return
+            await _channel.send(traceback.format_exc())
+
+    
+    @bridge.bridge_command(aliases=['rand'])
+    @is_homeserver() # pylint: disable=too-many-function-args
+    async def randquote(self, ctx):
+        """Get a random quote"""
+        try:
+            random_quote = await self.db.fetch_quote(random=True)
+            if random_quote.get('err'):
+                return await ctx.respond("Failed to get a quote")
+            
+            quote_id = random_quote.get('id')
+            quoted_friendly = random_quote.get('quoted_user_display', 'Unknown')
+            adder_friendly = random_quote.get('added_by_friendly', 'Unknown')
+            message_time = datetime.datetime.fromtimestamp(random_quote.get('quoted_message_time'))
+            message_channel = random_quote.get('quoted_channel_display')
+            quote_added_at = datetime.datetime.fromtimestamp(random_quote.get('added_at'))
+            quote_content = random_quote.get('quoted_message')
+
+            embed = discord.Embed(
+                colour=discord.Colour.orange(),
+                title=f"Quote #{quote_id}",
+            )
+            embed.description = f"**{quoted_friendly}:** {quote_content}"
+            embed.add_field(name="Original Message Time", value=message_time)
+            embed.add_field(name="Channel", value=message_channel)
+            embed.add_field(name="Quote ID", value=quote_id)
+            embed.footer = discord.EmbedFooter(text=f"Added by {adder_friendly} {quote_added_at}")
+
+            return await ctx.respond(embed=embed)
+        except Exception as e: # noqa
+            error = await ctx.respond(traceback.format_exc())
+            await asyncio.sleep(10)
+            await error.delete()
+
+    @bridge.bridge_command(aliases=['qg'])
+    @is_homeserver() # pylint: disable=too-many-function-args
+    async def quoteget(self, ctx, quoteid):
+        """Get a specific quote by ID"""
+        try:
+            if not str(quoteid).strip().isnumeric():
+                return await ctx.respond("**Error**: Quote ID must be numeric.")
+            fetched_quote = await self.db.fetch_quote(quoteid=quoteid)
+            if fetched_quote.get('err'):
+                return await ctx.respond("**Error**: Quote not found")
+            
+            quote_id = fetched_quote.get('id')
+            quoted_friendly = fetched_quote.get('quoted_user_display', 'Unknown')
+            adder_friendly = fetched_quote.get('added_by_friendly', 'Unknown')
+            message_time = datetime.datetime.fromtimestamp(fetched_quote.get('quoted_message_time'))
+            message_channel = fetched_quote.get('quoted_channel_display')
+            quote_added_at = datetime.datetime.fromtimestamp(fetched_quote.get('added_at'))
+            quote_content = fetched_quote.get('quoted_message')
+
+            embed = discord.Embed(
+                colour=discord.Colour.orange(),
+                title=f"Quote #{quote_id}",
+            )
+            embed.description = f"**{quoted_friendly}:** {quote_content}"
+            embed.add_field(name="Original Message Time", value=message_time)
+            embed.add_field(name="Channel", value=message_channel)
+            embed.add_field(name="Quote ID", value=quote_id)
+            embed.footer = discord.EmbedFooter(text=f"Added by {adder_friendly} {quote_added_at}")
+
+            return await ctx.respond(embed=embed)
+        except Exception as e: # noqa
+            error = await ctx.respond(traceback.format_exc())
+            await asyncio.sleep(10)
+            await error.delete()
+
+    @bridge.bridge_command(aliases=['qs'])
+    @is_homeserver() # pylint: disable=too-many-function-args
+    async def quotesearch(self, ctx, *, content: str):
+        """Search for a quote (by content)"""
+        try:
+            found_quotes = await self.db.fetch_quote(content=content)
+            if isinstance(found_quotes, dict) and found_quotes.get('err'):
+                return await ctx.respond(f"Quote search failed: {found_quotes.get('err')}")
+            
+            embeds = []
+
+            for quote in found_quotes:
+                quote_id = quote.get('id')
+                quoted_friendly = quote.get('quoted_user_display', 'Unknown')
+                adder_friendly = quote.get('added_by_friendly', 'Unknown')
+                message_time = datetime.datetime.fromtimestamp(quote.get('quoted_message_time'))
+                message_channel = quote.get('quoted_channel_display')
+                quote_added_at = datetime.datetime.fromtimestamp(quote.get('added_at'))
+                quote_content = quote.get('quoted_message')
+
+                # await ctx.respond(f"**{quoted_friendly}**: {quote}")ed_friendly = quote.get('quoted_user_display', 'Unknown')
+                adder_friendly = quote.get('added_by_friendly', 'Unknown')
+                message_time = datetime.datetime.fromtimestamp(quote.get('quoted_message_time'))
+                message_channel = quote.get('quoted_channel_display')
+                quote_added_at = datetime.datetime.fromtimestamp(quote.get('added_at'))
+                quote = quote.get('quoted_message')
+
+                # await ctx.respond(f"**{quoted_friendly}**: {quote}")
+                embed = discord.Embed(
+                    colour=discord.Colour.orange(),
+                    title=f"Quote #{quote_id}",
+                )
+                embed.description = f"**{quoted_friendly}:** {quote_content}"
+                embed.add_field(name="Original Message Time", value=str(message_time))
+                embed.add_field(name="Channel", value=message_channel)
+                embed.add_field(name="Quote ID", value=quote_id)
+                embed.footer = discord.EmbedFooter(text=f"Added by {adder_friendly} {quote_added_at}")
+                embeds.append(embed)
+
+            return await ctx.respond(embeds=embeds)
+        except Exception as e:
+            await ctx.respond(f"Error: {type(e).__name__} - {str(e)}")
+
+    @bridge.bridge_command(aliases=['nq'])
+    @is_homeserver() # pylint: disable=too-many-function-args
+    async def nquotes(self, ctx):
+        """Get # of quotes stored"""
+        try:
+            quote_count = await self.db.get_quote_count()
+            if not quote_count:
+                return await ctx.respond("**Error**: No quotes found!")
+            return await ctx.respond(f"I currently have **{quote_count}** quotes stored.")
+
+        except Exception as e:
+            await ctx.respond(f"Error: {type(e).__name__} - {str(e)}")
+
+    @bridge.bridge_command(aliases=['qr'])
+    @commands.is_owner()
+    @is_homeserver() # pylint: disable=too-many-function-args
+    async def quoteremove(self, ctx, quoteid):
+        """Remove a quote (by id)
+        Owner only"""
+        try:
+            if not str(quoteid).strip().isnumeric():
+                return await ctx.respond("**Error**: Quote ID must be numeric.")
+            quoteid = int(quoteid)
+            remove_quote = await self.db.remove_quote(quoteid) 
+            if not remove_quote:
+                return await ctx.respond("**Error**: Failed!", ephemeral=True)
+            return await ctx.respond("Removed!", ephemeral=True)
+
+        except Exception as e:
+            await ctx.respond(f"Error: {type(e).__name__} - {str(e)}")
+
+def setup(bot):
+    """Run on Cog Load"""
+    bot.add_cog(Quote(bot))

cogs/radio.py

@@ -6,34 +6,41 @@ from util.radio_util import get_now_playing, skip
 import discord
 from disc_havoc import Havoc
 
+
 class Radio(commands.Cog):
     """Radio Cog for Havoc"""
+
     def __init__(self, bot: Havoc) -> None:
         self.bot: Havoc = bot
         self.channels: dict[str, tuple] = {
-            'sfm': (1145182936002482196, 1221615558492029050), # Tuple: Guild Id, Chan Id
+            "sfm": (
+                1145182936002482196,
+                1221615558492029050,
+            ),  # Tuple: Guild Id, Chan Id
         }
         self.STREAM_URL: str = "https://stream.codey.lol/sfm.ogg"
         self.LAST_NP_TRACK: Optional[str] = None
         try:
             self.radio_state_loop.cancel()
         except Exception as e:
-            logging.debug("Failed to cancel radio_state_loop: %s", 
+            logging.debug("Failed to cancel radio_state_loop: %s", str(e))
-                          str(e))
 
     @commands.Cog.listener()
     async def on_ready(self) -> None:
         """Run on Bot Ready"""
         await self.radio_init()
 
-    def is_radio_chan(): # type: ignore
+    def is_radio_chan():  # type: ignore
         """Check if channel is radio chan"""
+
         def predicate(ctx):
             try:
                 return ctx.channel.id == 1221615558492029050
-            except:
+            except Exception as e:
+                logging.debug("Exception: %s", str(e))
                 traceback.print_exc()
                 return False
+
         return commands.check(predicate)
 
     @bridge.bridge_command()
@@ -41,11 +48,6 @@ class Radio(commands.Cog):
     async def reinitradio(self, ctx) -> None:
         """
         Reinitialize serious.FM
-        
-        Args:
-            ctx (Any): Discord context
-        Returns:
-            None
         """
         loop: discord.asyncio.AbstractEventLoop = self.bot.loop
         loop.create_task(self.radio_init())
@@ -54,7 +56,7 @@ class Radio(commands.Cog):
     async def radio_init(self) -> None:
         """Init Radio"""
         try:
-            (radio_guild, radio_chan) = self.channels['sfm']
+            (radio_guild, radio_chan) = self.channels["sfm"]
             guild: Optional[discord.Guild] = self.bot.get_guild(radio_guild)
             if not guild:
                 return
@@ -67,14 +69,14 @@ class Radio(commands.Cog):
                 try:
                     self.radio_state_loop.cancel()
                 except Exception as e:
-                    logging.debug("Failed to cancel radio_state_loop: %s", 
+                    logging.debug("Failed to cancel radio_state_loop: %s", str(e))
-                                  str(e))
                 self.radio_state_loop.start()
                 logging.info("radio_state_loop task started!")
-            except:
+            except Exception as e:
-                logging.critical("Could not start task...")
+                logging.critical("Could not start task... Exception: %s", str(e))
                 traceback.print_exc()
-        except:
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
             return
 
@@ -82,11 +84,14 @@ class Radio(commands.Cog):
     async def radio_state_loop(self) -> None:
         """Radio State Loop"""
         try:
-            (radio_guild, radio_chan) = self.channels['sfm']
+            (radio_guild, radio_chan) = self.channels["sfm"]
             try:
                 vc: discord.VoiceProtocol = self.bot.voice_clients[-1]
-            except:
+            except Exception as e:
-                logging.debug("No voice client, establishing new VC connection...")
+                logging.debug(
+                    "No voice client, establishing new VC connection... (Exception: %s)",
+                    str(e),
+                )
                 guild: Optional[discord.Guild] = self.bot.get_guild(radio_guild)
                 if not guild:
                     return
@@ -102,18 +107,22 @@ class Radio(commands.Cog):
                 but they exist.
                 """
                 logging.info("Detected VC not playing... playing!")
-                source: discord.FFmpegAudio = discord.FFmpegOpusAudio(self.STREAM_URL,
+                source: discord.FFmpegAudio = discord.FFmpegOpusAudio(self.STREAM_URL)
-                                                 before_options="-timeout 3000000")
+                vc.play(  # type: ignore
-                vc.play(source, # type: ignore
+                    source,
-                        after=lambda e: logging.info("Error: %s", e) if e\
+                    after=lambda e: logging.info("Error: %s", e) if e else None,
-                            else None) 
+                )
-            # Get Now Playing (disabled)
+            # Get Now Playing
-            # np_track: Optional[str] = await get_now_playing()
+            np_track: Optional[str] = await get_now_playing()
-            # if np_track and not self.LAST_NP_TRACK == np_track:
+            if np_track and not self.LAST_NP_TRACK == np_track:
-            #     self.LAST_NP_TRACK = np_track
+                self.LAST_NP_TRACK = np_track
-            #     if isinstance(vc.channel, discord.VoiceChannel):
+                await self.bot.change_presence(
-            #         await vc.channel.set_status(f"Now playing: {np_track}")
+                    activity=discord.Activity(
-        except:
+                        type=discord.ActivityType.listening, name=np_track
+                    )
+                )
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
 
     @bridge.bridge_command()
@@ -121,20 +130,16 @@ class Radio(commands.Cog):
     async def skip(self, ctx) -> None:
         """
         Skip - Convenience Command
-        Args:
-            ctx (Any)
-        Returns:
-            None
         """
 
         await skip()
         return await ctx.respond("OK", ephemeral=True)
 
-        
     def cog_unload(self) -> None:
         """Run on Cog Unload"""
         self.radio_state_loop.cancel()
 
+
 def setup(bot) -> None:
     """Run on Cog Load"""
     bot.add_cog(Radio(bot))

cogs/sing.py

@@ -2,7 +2,6 @@ import traceback
 import logging
 from typing import Optional, Union
 from regex import Pattern
-import urllib
 import discord
 import regex
 from util.sing_util import Utility
@@ -11,44 +10,42 @@ from disc_havoc import Havoc
 
 BOT_CHANIDS = []
 
+
 class Sing(commands.Cog):
     """Sing Cog for Havoc"""
+
     def __init__(self, bot: Havoc) -> None:
         self.bot: Havoc = bot
         self.utility = Utility()
         global BOT_CHANIDS
-        BOT_CHANIDS = self.bot.BOT_CHANIDS # Inherit
+        BOT_CHANIDS = self.bot.BOT_CHANIDS  # Inherit
-        self.control_strip_regex: Pattern = regex.compile(r"\x0f|\x1f|\035|\002|\u2064|\x02|(\x03([0-9]{1,2}))|(\x03|\003)(?:\d{1,2}(?:,\d{1,2})?)?",
+        self.control_strip_regex: Pattern = regex.compile(
-                                                 regex.UNICODE)
+            r"\x0f|\x1f|\035|\002|\u2064|\x02|(\x03([0-9]{1,2}))|(\x03|\003)(?:\d{1,2}(?:,\d{1,2})?)?",
+            regex.UNICODE,
+        )
 
-    def is_spamchan(): # type: ignore
+    def is_spamchan():  # type: ignore
         """Check if channel is spam chan"""
+
         def predicate(ctx):
             try:
-                if not ctx.channel.id in BOT_CHANIDS:
+                if ctx.channel.id not in BOT_CHANIDS:
                     logging.debug("%s not found in %s", ctx.channel.id, BOT_CHANIDS)
                 return ctx.channel.id in BOT_CHANIDS
-            except:
+            except Exception as e:
+                logging.debug("Exception: %s", str(e))
                 traceback.print_exc()
                 return False
+
         return commands.check(predicate)
 
-    @bridge.bridge_command(aliases=['sing'])  
+    @bridge.bridge_command(aliases=["sing"])
-    async def s(self, ctx, *,
+    async def s(self, ctx, *, song: Optional[str] = None) -> None:
-                song: Optional[str] = None) -> None:
         """
         Search for lyrics, format is artist : song.  Also reads activity.
-        
-        Args:
-            ctx (Any): Discord context
-            song (Optional[str]): Song to search
-        Returns:
-            None
         """
         try:
             with ctx.channel.typing():
-                interaction: bool = isinstance(ctx,
-                                               discord.ext.bridge.BridgeApplicationContext)
                 activity: Optional[discord.Activity] = None
                 if not song:
                     if not ctx.author.activities:
@@ -59,10 +56,13 @@ class Sing(commands.Cog):
                             activity = _activity
 
                     if not activity:
-                        return await ctx.respond("**Error**: No song specified, no activity found to read.")
+                        return await ctx.respond(
+                            "**Error**: No song specified, no activity found to read."
+                        )
 
-                    if interaction:
+                await ctx.respond(
-                        await ctx.respond("*Searching...*", ephemeral=True) # Must respond to interactions within 3 seconds, per Discord
+                    "*Searching...*"
+                )  # Must respond to interactions within 3 seconds, per Discord
 
                 parsed = self.utility.parse_song_input(song, activity)
 
@@ -70,51 +70,56 @@ class Sing(commands.Cog):
                     (search_artist, search_song, search_subsearch) = parsed
 
                 # await ctx.respond(f"So, {search_song} by {search_artist}?  Subsearch: {search_subsearch} I will try...") # Commented, useful for debugging
-                search_result: Optional[list] = await self.utility.lyric_search(search_artist, search_song,
+                search_result: Optional[list] = await self.utility.lyric_search(
-                                                                           search_subsearch)
+                    search_artist, search_song, search_subsearch
+                )
 
                 if not search_result:
                     await ctx.respond("ERR: No search result.")
                     return
 
                 if len(search_result) == 1:
-                    return await ctx.respond("ERR: Not found!")
+                    # Error response from API
+                    error, *_ = search_result[0]
+                    return await ctx.respond(error)
                 if not isinstance(search_result[0], tuple):
-                    return # Invalid data type
+                    return  # Invalid data type
                 (
-                    search_result_artist, search_result_song, search_result_src,
+                    search_result_artist,
-                    search_result_confidence, search_result_time_taken
+                    search_result_song,
-                ) = search_result[0] #  First index is a tuple
+                    search_result_src,
-                search_result_wrapped: list[str] = search_result[1] # Second index is the wrapped lyrics
+                    search_result_confidence,
-                search_result_wrapped_short: list[str] = search_result[2] # Third is short wrapped lyrics
+                    search_result_time_taken,
-                if not ctx.channel.id in BOT_CHANIDS:
+                ) = search_result[0]  #  First index is a tuple
-                    search_result_wrapped = search_result_wrapped_short # Replace with shortened lyrics for non spamchans
+                search_result_wrapped: list[str] = search_result[
-                embeds: list[Optional[discord.Embed]] = []
+                    1
-                embed_url: str = f"[on codey.lol](https://codey.lol/#{urllib.parse.quote(search_artist)}/{urllib.parse.quote(search_song)})"
+                ]  # Second index is the wrapped lyrics
-                c: int = 0
+                search_result_wrapped_short: list[str] = search_result[
-                footer: str = "To be continued..."   #Placeholder
+                    2
-                for section in search_result_wrapped:
+                ]  # Third is short wrapped lyrics
-                    c+=1
+                if ctx.channel.id not in BOT_CHANIDS:
+                    short_lyrics = " ".join(
+                        search_result_wrapped_short
+                    )  # Replace with shortened lyrics for non spamchans
+                    short_lyrics = regex.sub(
+                        r"\p{Vert_Space}", " / ", short_lyrics.strip()
+                    )
+                    return await ctx.respond(
+                        f"**{search_result_song}** by **{search_result_artist}**\n-# {short_lyrics}"
+                    )
+
+                out_messages: list = []
+                footer: str = ""  # Placeholder
+                for c, section in enumerate(search_result_wrapped):
                     if c == len(search_result_wrapped):
-                        footer = f"Found on: {search_result_src}"
+                        footer = f"`Found on: {search_result_src}`"
-                    section = self.control_strip_regex.sub('', section)
+                    section = regex.sub(r"\p{Vert_Space}", " / ", section.strip())
-                    # if ctx.guild.id == 1145182936002482196:
+                    msg: str = f"**{search_result_song}** by **{search_result_artist}**\n-# {section}\n{footer}"
-                    #     section = section.upper()
+                    if c > 1:
-                    embed: discord.Embed = discord.Embed(
+                        msg = "\n".join(msg.split("\n")[1:])
-                    title=f"{search_result_song} by {search_result_artist}",
+                    out_messages.append(msg.strip())
-                    description=discord.utils.escape_markdown(section)
+                for msg in out_messages:
-                )
+                    await ctx.send(msg)
-                    embed.add_field(name="Confidence", value=search_result_confidence,
-                                    inline=True)
-                    embed.add_field(name="Time Taken", value=search_result_time_taken,
-                                    inline=True)
-                    embed.add_field(name="Link", value=embed_url)
-                    embed.set_footer(text=footer)
-                    embeds.append(embed)
-                await ctx.respond(embed=embeds[0])    
-                for _embed in embeds[1:]:
-                    if isinstance(_embed, discord.Embed):
-                        await ctx.send(embed=_embed)
         except Exception as e:
             traceback.print_exc()
             await ctx.respond(f"ERR: {str(e)}")
@@ -133,70 +138,93 @@ class Sing(commands.Cog):
         try:
             PODY_ID: int = 1172340700663255091
             IS_SPAMCHAN: bool = ctx.channel.id in BOT_CHANIDS
-            member_display = ctx.interaction.guild.get_member(member.id)\
+            member_display = ctx.interaction.guild.get_member(member.id).display_name
-                .display_name
+            if (
-            if not(ctx.interaction.guild.get_member(member.id).activities)\
+                not (ctx.interaction.guild.get_member(member.id).activities)
-                and not member.id == PODY_ID:
+                and not member.id == PODY_ID
-                return await ctx.respond(f"No activity detected to read for {member_display}.", ephemeral=True)
+            ):
-            member_id: int = member.id #if not(member.id == PODY_ID) else 1234134345497837679 # Use Thomas for Pody!
+                return await ctx.respond(
+                    f"No activity detected to read for {member_display}.",
+                    ephemeral=True,
+                )
+            member_id: int = member.id  # if not(member.id == PODY_ID) else 1234134345497837679 # Use Thomas for Pody!
             activity: Optional[discord.Activity] = None
             if IS_SPAMCHAN:
                 await ctx.respond(f"***Reading activity of {member_display}...***")
             for _activity in ctx.interaction.guild.get_member(member_id).activities:
                 if _activity.type == discord.ActivityType.listening:
                     activity = _activity
-            parsed: Union[tuple, bool] = self.utility.parse_song_input(song=None,
+            parsed: Union[tuple, bool] = self.utility.parse_song_input(
-                                                               activity=activity)
+                song=None, activity=activity
+            )
             if not parsed:
-                return await ctx.respond(f"Could not parse activity of {member_display}.", ephemeral=True)
+                return await ctx.respond(
+                    f"Could not parse activity of {member_display}.", ephemeral=True
+                )
 
             if isinstance(parsed, tuple):
                 (search_artist, search_song, search_subsearch) = parsed
-                await ctx.respond("*Searching...*", ephemeral=True) # Must respond to interactions within 3 seconds, per Discord
+                await ctx.respond(
-                search_result: Optional[list] = await self.utility.lyric_search(search_artist, search_song,
+                    "*Searching...*"
-                                                                  search_subsearch)
+                )  # Must respond to interactions within 3 seconds, per Discord
+                search_result: Optional[list] = await self.utility.lyric_search(
+                    search_artist, search_song, search_subsearch
+                )
                 if not search_result:
                     await ctx.respond("ERR: No search result")
                     return
 
+                if len(search_result) == 1 and isinstance(search_result[0][0], str):
+                    return await ctx.send(
+                        "ERR: No search result"
+                    )  # Error message from API
 
-                if len(search_result) == 1 and\
+                (
-                    isinstance(search_result[0][0], str):
+                    search_result_artist,
-                    return await ctx.send("ERR: No search result") # Error message from API           
+                    search_result_song,
-                
+                    search_result_src,
-                (search_result_artist, search_result_song, search_result_src,
+                    search_result_confidence,
-                search_result_confidence, search_result_time_taken) = search_result[0] #  First index is a tuple
+                    search_result_time_taken,
-                search_result_wrapped: list = search_result[1] # Second index is the wrapped lyrics
+                ) = search_result[0]  #  First index is a tuple
-                search_result_wrapped_short: list[str] = search_result[2] # Third index is shortened lyrics
+                search_result_wrapped: list = search_result[
+                    1
+                ]  # Second index is the wrapped lyrics
+                search_result_wrapped_short: list[str] = search_result[
+                    2
+                ]  # Third index is shortened lyrics
 
                 if not IS_SPAMCHAN:
-                    search_result_wrapped = search_result_wrapped_short # Swap for shortened lyrics if not spam chan
+                    short_lyrics = " ".join(
+                        search_result_wrapped_short
+                    )  # Replace with shortened lyrics for non spamchans
+                    short_lyrics = regex.sub(
+                        r"\p{Vert_Space}", " / ", short_lyrics.strip()
+                    )
+                    return await ctx.respond(
+                        f"**{search_result_song}** by **{search_result_artist}**\n-# {short_lyrics}"
+                    )
 
-                embeds: list[Optional[discord.Embed]] = []
+                out_messages: list = []
+                footer: str = ""
                 c: int = 0
-                footer: str = "To be continued..."   #Placeholder
                 for section in search_result_wrapped:
-                    c+=1
+                    c += 1
                     if c == len(search_result_wrapped):
-                        footer = f"Found on: {search_result_src}"
+                        footer = f"`Found on: {search_result_src}`"
                     # if ctx.guild.id == 1145182936002482196:
                     #     section = section.upper()
-                    embed: discord.Embed = discord.Embed(
+                    section = regex.sub(r"\p{Vert_Space}", " / ", section.strip())
-                    title=f"{search_result_song} by {search_result_artist}",
+                    msg: str = f"**{search_result_song}** by **{search_result_artist}**\n-# {section}\n{footer}"
-                    description=discord.utils.escape_markdown(section)
+                    if c > 1:
-                )
+                        msg = "\n".join(msg.split("\n")[1:])
-                    embed.add_field(name="Confidence", value=search_result_confidence, inline=True)
+                    out_messages.append(msg.strip())
-                    embed.add_field(name="Time Taken", value=search_result_time_taken, inline=True)
+                for msg in out_messages:
-                    embed.add_field(name="Link", value=f"[on codey.lol](https://codey.lol/#{urllib.parse.quote(search_result_artist)}/{urllib.parse.quote(search_result_song)})")
+                    await ctx.send(msg)
-                    embed.set_footer(text=footer)
-                    embeds.append(embed)
-
-                for _embed in embeds:
-                    await ctx.send(embed=_embed)
         except Exception as e:
             traceback.print_exc()
             return await ctx.respond(f"ERR: {str(e)}")
 
+
 def setup(bot) -> None:
     """Run on Cog Load"""
     bot.add_cog(Sing(bot))

constructors.py

@@ -1,22 +1,25 @@
 """
 AI
 """
+
+
 class AIException(Exception):
     """AI Exception (generic)"""
-    pass
+
 
 """
 LoveHate
 """
+
+
 class LoveHateException(Exception):
     """Love Hate Exception (generic)"""
-    pass
 
 
 """
 Misc
 """
 
+
 class MiscException(Exception):
     """Misc Exception (generic)"""
-    pass

disc_havoc.py

@@ -13,20 +13,19 @@ from termcolor import colored
 from constants import OWNERS, BOT_CHANIDS
 import api
 
-logging.basicConfig(level=logging.INFO,
+logging.basicConfig(
-                    format='%(asctime)s %(message)s',
+    level=logging.INFO, format="%(asctime)s %(message)s", encoding="utf-8"
-                    encoding='utf-8')
+)
-setproctitle.setproctitle('disc-havoc')
+setproctitle.setproctitle("disc-havoc")
 
 """Auto Load Cogs"""
 cogs_list: list[str] = [
-    'misc',
+    "misc",
-    'owner',
+    "owner",
-    'sing',
+    "sing",
-    'meme',
+    "meme",
-    'karma',
+    "lovehate",
-    'lovehate',
+    "radio",
-    'radio',
 ]
 
 bot_activity = discord.CustomActivity(name="I made cookies!")
@@ -36,15 +35,19 @@ load_dotenv()
 intents = discord.Intents.all()
 intents.message_content = True
 
+
 class Havoc(bridge.Bot):
     def __init__(self) -> None:
-        super().__init__(command_prefix=".", intents=intents,
+        super().__init__(
-                              owner_ids=OWNERS, activity=bot_activity,
+            command_prefix=".",
-                              help_command=commands.MinimalHelpCommand())
+            intents=intents,
+            owner_ids=OWNERS,
+            activity=bot_activity,
+            help_command=commands.MinimalHelpCommand(),
+        )
         self.BOT_CHANIDS = BOT_CHANIDS
         self.load_exts()
 
-        
     def load_exts(self, initialRun: Optional[bool] = True) -> None:
         """
         Load Cogs/Extensions
@@ -54,29 +57,28 @@ class Havoc(bridge.Bot):
         Returns:
             None
         """
-        load_method = self.load_extension if initialRun\
+        load_method = self.load_extension if initialRun else self.reload_extension
-            else self.reload_extension
 
         for cog in cogs_list:
             logging.info("Loading: %s", cog)
-            load_method(f'cogs.{cog}')   
+            load_method(f"cogs.{cog}")
 
         importlib.reload(api)
-        from api import API 
+        from api import API  # noqa (voodoo)
+
         api_config = hypercorn.config.Config()
         api_config.bind = ["127.0.0.1:5992"]
         api_instance = api.API(self)
         try:
             self.fapi_task.cancel()
         except Exception as e:
-            logging.debug("Failed to cancel fapi_task: %s", 
+            logging.debug("Failed to cancel fapi_task: %s", str(e))
-                        str(e))
 
         logging.info("Starting FAPI Task")
 
-        self.fapi_task: Task = self.loop.create_task(hypercorn.asyncio.serve(api_instance.api_app,
+        self.fapi_task: Task = self.loop.create_task(
-                                                                 api_config)) 
+            hypercorn.asyncio.serve(api_instance.api_app, api_config)
-    
+        )
 
     @commands.Cog.listener()
     async def on_ready(self) -> None:
@@ -84,12 +86,17 @@ class Havoc(bridge.Bot):
         logging.info("%s online!", self.user)
 
 
-            
 def __init__() -> None:
-    logging.info(colored(f"Log level: {logging.getLevelName(logging.root.level)}",
+    logging.info(
-                         "red", attrs=['reverse']))
+        colored(
+            f"Log level: {logging.getLevelName(logging.root.level)}",
+            "red",
+            attrs=["reverse"],
+        )
+    )
     bot = Havoc()
-    bot.run(os.getenv('TOKEN'))      
+    bot.run(os.getenv("TOKEN"))
+
 
 if __name__ == "__main__":
     __init__()

requirements.txt

@@ -4,7 +4,7 @@ edge_tts==6.1.12
 feedparser==6.0.11
 Flask==3.0.3
 nvdlib==0.7.7
-openai==1.54.3
+openai==1.54.3d
 requests_async==0.6.2
 shazamio==0.7.0
 streamrip==2.0.5

tests/uploader_tests.py

@@ -12,14 +12,20 @@ from util.catbox import CatboxAsync
 logger = logging.getLogger()
 logger.setLevel(logging.INFO)
 
+
 async def test() -> None:
     f = os.path.join(os.path.expanduser("~"), "qu.png")
     box1: LitterboxAsync = LitterboxAsync()
     box2: CatboxAsync = CatboxAsync()
     url1: Optional[str] = await box1.upload(f)
     url2: Optional[str] = await box2.upload(f)
-    logging.info("""Uploaded URLs:
+    logging.info(
+        """Uploaded URLs:
           Litter - %s\n
-          Cat - %s""", url1, url2)
+          Cat - %s""",
+        url1,
+        url2,
+    )
+
 
 asyncio.run(test())

util/catbox.py

@@ -12,12 +12,13 @@ Catbox Uploader (Async)
 
 catbox_api_url: str = "https://catbox.moe/user/api.php"
 http_headers: dict[str, str] = {
-        'accept': '*/*',
+    "accept": "*/*",
-        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.64 Safari/537.36 Edg/101.0.1210.53',
+    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.64 Safari/537.36 Edg/101.0.1210.53",
-        'Accept-Language': 'en-US,en;q=0.9,it;q=0.8,es;q=0.7',
+    "Accept-Language": "en-US,en;q=0.9,it;q=0.8,es;q=0.7",
-        'referer': 'https://www.google.com/',
+    "referer": "https://www.google.com/",
-        'cookie': 'DSID=AAO-7r4OSkS76zbHUkiOpnI0kk-X19BLDFF53G8gbnd21VZV2iehu-w_2v14cxvRvrkd_NjIdBWX7wUiQ66f-D8kOkTKD1BhLVlqrFAaqDP3LodRK2I0NfrObmhV9HsedGE7-mQeJpwJifSxdchqf524IMh9piBflGqP0Lg0_xjGmLKEQ0F4Na6THgC06VhtUG5infEdqMQ9otlJENe3PmOQTC_UeTH5DnENYwWC8KXs-M4fWmDADmG414V0_X0TfjrYu01nDH2Dcf3TIOFbRDb993g8nOCswLMi92LwjoqhYnFdf1jzgK0'
+    "cookie": "DSID=AAO-7r4OSkS76zbHUkiOpnI0kk-X19BLDFF53G8gbnd21VZV2iehu-w_2v14cxvRvrkd_NjIdBWX7wUiQ66f-D8kOkTKD1BhLVlqrFAaqDP3LodRK2I0NfrObmhV9HsedGE7-mQeJpwJifSxdchqf524IMh9piBflGqP0Lg0_xjGmLKEQ0F4Na6THgC06VhtUG5infEdqMQ9otlJENe3PmOQTC_UeTH5DnENYwWC8KXs-M4fWmDADmG414V0_X0TfjrYu01nDH2Dcf3TIOFbRDb993g8nOCswLMi92LwjoqhYnFdf1jzgK0",
-        }
+}
+
 
 class CatboxAsync:
     def __init__(self) -> None:
@@ -34,7 +35,7 @@ class CatboxAsync:
             str
         """
         if not fileExt:
-            fileExt = 'png'
+            fileExt = "png"
         return f"{random.getrandbits(32)}.{fileExt}"
 
     async def upload(self, file: str) -> Optional[str]:
@@ -49,40 +50,41 @@ class CatboxAsync:
         try:
             if not file:
                 return None
-            if not(os.path.exists(file)):
+            if not (os.path.exists(file)):
-                logging.critical("Could not find %s", 
+                logging.critical("Could not find %s", file)
-                                 file)
                 return None
 
             fileExt: Optional[str] = None
             if file.find(".") > 0:
                 fileExt = "".join(file.split(".")[-1:])
 
-            with open(file, 'rb') as fileContents:
+            with open(file, "rb") as fileContents:
                 post_data: FormData = FormData()
-                post_data.add_field(name="reqtype",
+                post_data.add_field(name="reqtype", value="fileupload")
-                                    value="fileupload")
+                post_data.add_field(name="userhash", value="")
-                post_data.add_field(name="userhash",
-                                    value="")
                 with magic.Magic(flags=magic.MAGIC_MIME) as m:
                     content_type = m.id_filename(file)
-                    post_data.add_field(name="fileToUpload",
+                    post_data.add_field(
-                                        value=fileContents, 
+                        name="fileToUpload",
-                                        filename=self.generateRandomFileName(fileExt),
+                        value=fileContents,
-                                        content_type=content_type
+                        filename=self.generateRandomFileName(fileExt),
-                )
+                        content_type=content_type,
+                    )
                 async with ClientSession() as session:
-                    async with await session.post(self.catbox_api_url,
+                    async with await session.post(
-                                                  headers=self.headers,
+                        self.catbox_api_url,
-                                                  data=post_data,
+                        headers=self.headers,
-                                                  timeout=ClientTimeout(connect=10, sock_read=10)) as request:
+                        data=post_data,
+                        timeout=ClientTimeout(connect=10, sock_read=10),
+                    ) as request:
                         request.raise_for_status()
                         return await request.text()
-        except:
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
             return None
         finally:
             try:
                 fileContents.close()
-            except:
+            except:  # noqa
                 return None

util/discord_helpers.py

@@ -6,8 +6,10 @@ from typing import Optional, Any
 Discord Helper Methods
 """
 
-async def get_channel_by_name(bot: discord.Bot, channel: str,
+
-                              guild: int | None = None) -> Optional[Any]: # Optional[Any] used as pycord channel types can be ambigious
+async def get_channel_by_name(
+    bot: discord.Bot, channel: str, guild: int | None = None
+) -> Optional[Any]:  # Optional[Any] used as pycord channel types can be ambigious
     """
     Get Channel by Name
 
@@ -18,10 +20,9 @@ async def get_channel_by_name(bot: discord.Bot, channel: str,
     Returns:
         Optional[Any]
     """
-    channel = re.sub(r'^#', '', channel.strip())
+    channel = re.sub(r"^#", "", channel.strip())
     if not guild:
-        return discord.utils.get(bot.get_all_channels(),
+        return discord.utils.get(bot.get_all_channels(), name=channel)
-                             name=channel)
     else:
         _guild: Optional[discord.Guild] = bot.get_guild(guild)
         if not _guild:
@@ -32,8 +33,10 @@ async def get_channel_by_name(bot: discord.Bot, channel: str,
                 return _channel
         return None
 
-async def send_message(bot: discord.Bot, channel: str,
+
-                       message: str, guild: int | None = None) -> None:
+async def send_message(
+    bot: discord.Bot, channel: str, message: str, guild: int | None = None
+) -> None:
     """
     Send Message to the provided channel.  If guild is provided, will limit to channels within that guild to ensure the correct
     channel is selected.  Useful in the event a channel exists in more than one guild that the bot resides in.
@@ -50,9 +53,20 @@ async def send_message(bot: discord.Bot, channel: str,
         channel_int: int = int(channel)
         _channel = bot.get_channel(channel_int)
     else:
-        channel = re.sub(r'^#', '', channel.strip()) 
+        channel = re.sub(r"^#", "", channel.strip())
-        _channel = await get_channel_by_name(bot=bot,
+        _channel = await get_channel_by_name(bot=bot, channel=channel, guild=guild)
-                                        channel=channel, guild=guild)
     if not isinstance(_channel, discord.TextChannel):
         return None
     await _channel.send(message)
+
+
+async def log_to_playground(bot: discord.Bot, message: str) -> None:
+    """
+    Send {message} to playground/log chan
+    Args:
+        bot (discord.Bot): Bot instance
+        message (str): The message to send
+    Returns:
+        None
+    """
+    return await send_message(bot=bot, channel="havoc-playground", message=message)

util/jesusmemes.py

@@ -13,24 +13,23 @@ Jesus Meme Generator
 (requires Catbox uploader)
 """
 
-class JesusMemeGenerator():
+
+class JesusMemeGenerator:
     def __init__(self) -> None:
         self.MEMEAPIURL = "https://apimeme.com/meme?meme="
-        self.MEMESTORAGEDIR = os.path.join(os.path.expanduser("~"),
+        self.MEMESTORAGEDIR = os.path.join(os.path.expanduser("~"), "memes")
-                                           "memes")  
         self.top_line_regex: Pattern = regex.compile(
-            r'[^\p{Letter}\p{Number}\p{Punctuation}\p{Horiz_Space}\p{Currency_Symbol}]'
+            r"[^\p{Letter}\p{Number}\p{Punctuation}\p{Horiz_Space}\p{Currency_Symbol}]"
-            )
+        )
         self.bottom_line_regex: Pattern = regex.compile(
-            r'[^\p{Letter}\p{Number}\p{Punctuation}\p{Horiz_Space}\p{Currency_Symbol}]'
+            r"[^\p{Letter}\p{Number}\p{Punctuation}\p{Horiz_Space}\p{Currency_Symbol}]"
-            )
+        )
-        self.url_regex_1: Pattern = regex.compile(
+        self.url_regex_1: Pattern = regex.compile(r"\p{Horiz_Space}")
-            r'\p{Horiz_Space}')
+        self.url_regex_2: Pattern = regex.compile(r"#")
-        self.url_regex_2: Pattern = regex.compile(
-            r'#')
 
-    async def create_meme(self, top_line: str, bottom_line: str,
+    async def create_meme(
-                          meme="Jesus-Talking-To-Cool-Dude") -> Optional[str]:
+        self, top_line: str, bottom_line: str, meme="Jesus-Talking-To-Cool-Dude"
+    ) -> Optional[str]:
         """
         Create Meme
 
@@ -46,33 +45,35 @@ class JesusMemeGenerator():
         try:
             if not top_line or not bottom_line:
                 return None
-            top_line = self.top_line_regex.sub('', 
+            top_line = self.top_line_regex.sub("", top_line.strip())
-                                                    top_line.strip())  
+            bottom_line = self.bottom_line_regex.sub("", bottom_line.strip())
-            bottom_line = self.bottom_line_regex.sub('',
-                                                          bottom_line.strip())  
             out_fname: Optional[str] = None
 
             if len(top_line) < 1 or len(bottom_line) < 1:
                 return None
 
             formed_url: str = f"{self.MEMEAPIURL}{meme}&top={top_line.strip()}&bottom={bottom_line.strip()}"
-            formed_url = self.url_regex_1.sub('+', self.url_regex_2.sub('%23', formed_url.strip()))
+            formed_url = self.url_regex_1.sub(
+                "+", self.url_regex_2.sub("%23", formed_url.strip())
+            )
             timeout = aiohttp.ClientTimeout(total=15)
             async with aiohttp.ClientSession(timeout=timeout) as session:
                 async with session.get(formed_url) as response:
                     UUID = f"{random.getrandbits(8)}-{random.getrandbits(8)}"
                     out_fname = f"{UUID}.jpg"
-                    with open(f"{self.MEMESTORAGEDIR}/{out_fname}", 'wb') as f:
+                    with open(f"{self.MEMESTORAGEDIR}/{out_fname}", "wb") as f:
                         f.write(await response.read())
 
             if not out_fname:
                 uploader = CatboxAsync()
-                meme_link: Optional[str] = await uploader.upload(f"{self.MEMESTORAGEDIR}/{out_fname}")
+                meme_link: Optional[str] = await uploader.upload(
+                    f"{self.MEMESTORAGEDIR}/{out_fname}"
+                )
                 if not meme_link:
                     logging.info("Meme upload failed!")
                     return None
                 return meme_link
-        except:
+        except Exception as e:
-            print(traceback.format_exc())
+            logging.debug("Exception: %s", str(e))
-            pass
+            traceback.print_exc()
         return None

util/litterbox.py

@@ -13,12 +13,13 @@ import os
 
 litterbox_api_url: str = "https://litterbox.catbox.moe/resources/internals/api.php"
 http_headers: dict[str, str] = {
-        'accept': '*/*',
+    "accept": "*/*",
-        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.64 Safari/537.36 Edg/101.0.1210.53',
+    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.64 Safari/537.36 Edg/101.0.1210.53",
-        'Accept-Language': 'en-US,en;q=0.9,it;q=0.8,es;q=0.7',
+    "Accept-Language": "en-US,en;q=0.9,it;q=0.8,es;q=0.7",
-        'referer': 'https://www.google.com/',
+    "referer": "https://www.google.com/",
-        'cookie': 'DSID=AAO-7r4OSkS76zbHUkiOpnI0kk-X19BLDFF53G8gbnd21VZV2iehu-w_2v14cxvRvrkd_NjIdBWX7wUiQ66f-D8kOkTKD1BhLVlqrFAaqDP3LodRK2I0NfrObmhV9HsedGE7-mQeJpwJifSxdchqf524IMh9piBflGqP0Lg0_xjGmLKEQ0F4Na6THgC06VhtUG5infEdqMQ9otlJENe3PmOQTC_UeTH5DnENYwWC8KXs-M4fWmDADmG414V0_X0TfjrYu01nDH2Dcf3TIOFbRDb993g8nOCswLMi92LwjoqhYnFdf1jzgK0'
+    "cookie": "DSID=AAO-7r4OSkS76zbHUkiOpnI0kk-X19BLDFF53G8gbnd21VZV2iehu-w_2v14cxvRvrkd_NjIdBWX7wUiQ66f-D8kOkTKD1BhLVlqrFAaqDP3LodRK2I0NfrObmhV9HsedGE7-mQeJpwJifSxdchqf524IMh9piBflGqP0Lg0_xjGmLKEQ0F4Na6THgC06VhtUG5infEdqMQ9otlJENe3PmOQTC_UeTH5DnENYwWC8KXs-M4fWmDADmG414V0_X0TfjrYu01nDH2Dcf3TIOFbRDb993g8nOCswLMi92LwjoqhYnFdf1jzgK0",
-        }
+}
+
 
 class LitterboxAsync:
     def __init__(self) -> None:
@@ -35,12 +36,12 @@ class LitterboxAsync:
             str
         """
         if not fileExt:
-            fileExt = 'png'
+            fileExt = "png"
         return f"{random.getrandbits(32)}.{fileExt}"
 
-    async def upload(self,
+    async def upload(
-                     file: Union[str, bytes, BufferedReader],
+        self, file: Union[str, bytes, BufferedReader], time="1h"
-                     time='1h') -> Optional[str]:
+    ) -> Optional[str]:
         """
         Upload File to Litterbox
 
@@ -60,12 +61,12 @@ class LitterboxAsync:
             if isinstance(file, BufferedReader):
                 file = file.read()
 
-            fileExt: str = 'png'
+            fileExt: str = "png"
             if isinstance(file, str):
                 if file.find(".") > 0:
                     fileExt = "".join(file.split(".")[-1:])
 
-                file = open(file, 'rb').read()
+                file = open(file, "rb").read()
 
             with magic.Magic(flags=magic.MAGIC_MIME) as m:
                 if isinstance(file, BufferedReader):
@@ -74,31 +75,32 @@ class LitterboxAsync:
                     content_type = str(m.id_filename(file))
 
             post_data: FormData = FormData()
-            post_data.add_field(name="reqtype",
+            post_data.add_field(name="reqtype", value="fileupload")
-                                value="fileupload")
+            post_data.add_field(name="userhash", value="")
-            post_data.add_field(name="userhash",
+            post_data.add_field(name="time", value=time)
-                                value="")
-            post_data.add_field(name="time",
-                                value=time)
 
-            post_data.add_field(name="fileToUpload",
+            post_data.add_field(
-                                value=file, 
+                name="fileToUpload",
-                                filename=self.generateRandomFileName(fileExt),
+                value=file,
-                                content_type=content_type
+                filename=self.generateRandomFileName(fileExt),
+                content_type=content_type,
             )
             async with ClientSession() as session:
-                async with await session.post(self.api_path,
+                async with await session.post(
-                                        headers=self.headers,
+                    self.api_path,
-                                        data=post_data,
+                    headers=self.headers,
-                                        timeout=ClientTimeout(connect=5, sock_read=70)) as request:
+                    data=post_data,
+                    timeout=ClientTimeout(connect=5, sock_read=70),
+                ) as request:
                     request.raise_for_status()
                     return await request.text()
-        except:
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
             return None
         finally:
             if isinstance(file, BufferedReader):
                 try:
                     file.close()
-                except:
+                except:  # noqa
                     return None

util/lovehate_db.py

@@ -4,14 +4,18 @@ from typing import LiteralString, Optional, Union
 import aiosqlite as sqlite3
 from constructors import LoveHateException
 
+
 class DB:
     """LoveHate DB Utility Class"""
-    def __init__(self, bot) -> None:
-        self.db_path: str|LiteralString = os.path.join("/usr/local/share",
-                                    "sqlite_dbs", "lovehate.db") 
 
-    async def get_wholovehates(self, thing: str, loves: bool = False,
+    def __init__(self, bot) -> None:
-                               hates: bool = False) -> Union[list[tuple], bool]:
+        self.db_path: str | LiteralString = os.path.join(
+            "/usr/local/share", "sqlite_dbs", "lovehate.db"
+        )
+
+    async def get_wholovehates(
+        self, thing: str, loves: bool = False, hates: bool = False
+    ) -> Union[list[tuple], bool]:
         """
         Get a list of users who have professed their love OR hatred for <thing>
 
@@ -36,7 +40,10 @@ class DB:
         elif not hates and not loves:
             raise LoveHateException("Neither loves nor hates were requested")
 
-        params = (thing, flag,)
+        params = (
+            thing,
+            flag,
+        )
         async with sqlite3.connect(self.db_path, timeout=2) as db_conn:
             async with await db_conn.execute(query, params) as db_cursor:
                 result: list[tuple] = await db_cursor.fetchall()
@@ -45,8 +52,13 @@ class DB:
                     return False
                 return result
 
-    async def get_lovehates(self, loves: bool = False, hates: bool = False,
+    async def get_lovehates(
-                            user: Optional[str] = None, thing: Optional[str] = None) -> Union[list[tuple], bool]:
+        self,
+        loves: bool = False,
+        hates: bool = False,
+        user: Optional[str] = None,
+        thing: Optional[str] = None,
+    ) -> Union[list[tuple], bool]:
         """
         Get a list of either 1) what {user} loves/hates, or who loves/hates {thing}, depending on bools loves, hates
 
@@ -64,7 +76,9 @@ class DB:
         params: tuple = tuple()
 
         if not user and not thing:
-            raise LoveHateException("Neither a <user> or <thing> was specified to query against")
+            raise LoveHateException(
+                "Neither a <user> or <thing> was specified to query against"
+            )
 
         flag: Optional[int] = None
 
@@ -79,10 +93,16 @@ class DB:
 
         if user:
             query = "SELECT thing FROM lovehate WHERE display_name LIKE ? AND flag == ?"
-            params = (user, flag,)
+            params = (
+                user,
+                flag,
+            )
         elif thing:
             query = "SELECT display_name FROM lovehate WHERE thing LIKE ? AND flag == ?"
-            params = (thing, flag,)
+            params = (
+                thing,
+                flag,
+            )
 
         async with sqlite3.connect(self.db_path, timeout=2) as db_conn:
             async with await db_conn.execute(query, params) as db_cursor:
@@ -91,7 +111,6 @@ class DB:
                     return False
                 return result
 
-
     async def check_existence(self, user: str, thing: str) -> Optional[int]:
         """
         Determine whether a user is opinionated on a <thing>
@@ -103,10 +122,16 @@ class DB:
             Optional[int]
         """
 
-        params = (user, thing,)
+        params = (
+            user,
+            thing,
+        )
 
         async with sqlite3.connect(self.db_path, timeout=2) as db_conn:
-            async with await db_conn.execute("SELECT id, flag FROM lovehate WHERE display_name LIKE ? AND thing LIKE ?", params) as db_cursor:
+            async with await db_conn.execute(
+                "SELECT id, flag FROM lovehate WHERE display_name LIKE ? AND thing LIKE ?",
+                params,
+            ) as db_cursor:
                 result = await db_cursor.fetchone()
                 if not result:
                     return None
@@ -124,21 +149,30 @@ class DB:
         Returns:
             str
         """
-        if not flag in range(-1, 2):
+        if flag not in range(-1, 2):
-            raise LoveHateException(f"Invalid flag {flag} specified, is this love (1), hate (-1), or dontcare? (0)")
+            raise LoveHateException(
+                f"Invalid flag {flag} specified, is this love (1), hate (-1), or dontcare? (0)"
+            )
 
         db_query: str = ""
-        params: tuple = (user, thing,)
+        params: tuple = (
+            user,
+            thing,
+        )
 
         already_opinionated: Optional[int] = await self.check_existence(user, thing)
         if already_opinionated:
             if flag == 0:
-                db_query = "DELETE FROM lovehate WHERE display_name LIKE ? AND thing LIKE ?"
+                db_query = (
+                    "DELETE FROM lovehate WHERE display_name LIKE ? AND thing LIKE ?"
+                )
             else:
                 loves_or_hates: str = "loves"
                 if already_opinionated == -1:
                     loves_or_hates = "hates"
-                raise LoveHateException(f"But {user} already {loves_or_hates} {thing}...")
+                raise LoveHateException(
+                    f"But {user} already {loves_or_hates} {thing}..."
+                )
         else:
             match flag:
                 case -1:
@@ -148,12 +182,13 @@ class DB:
                 case _:
                     raise LoveHateException("Unknown error, default case matched")
 
-
         async with sqlite3.connect(self.db_path, timeout=2) as db_conn:
             async with await db_conn.execute(db_query, params) as db_cursor:
                 await db_conn.commit()
                 if db_cursor.rowcount != 1:
-                    raise LoveHateException(f"DB Error - RowCount: {db_cursor.rowcount} for INSERT query")
+                    raise LoveHateException(
+                        f"DB Error - RowCount: {db_cursor.rowcount} for INSERT query"
+                    )
                 match flag:
                     case -1:
                         return f"We're done here, {user} hates {thing}."
@@ -162,4 +197,6 @@ class DB:
                     case 1:
                         return f"We're done here, {user} loves {thing}."
                     case _:
-                        raise LoveHateException("Unknown error, default case matched [2]")
+                        raise LoveHateException(
+                            "Unknown error, default case matched [2]"
+                        )

util/misc_util.py

@@ -0,0 +1,581 @@
+import os
+import logging
+import traceback
+import random
+import datetime
+import pytz
+from typing import Optional, LiteralString, Union
+import regex
+import aiosqlite as sqlite3
+from aiohttp import ClientSession, ClientTimeout
+from bohancompliment import ComplimentGenerator
+from discord import Embed
+
+
+class Util:
+    """Misc Utility"""
+
+    def __init__(self) -> None:
+        self.URL_URBANDICTIONARY: str = "http://api.urbandictionary.com/v0/define"
+        self.URL_NO: str = "https://api.codey.lol/misc/no"
+        self.URL_INSULTAPI: str = "https://insult.mattbas.org/api/insult"
+        self.COMPLIMENT_GENERATOR = ComplimentGenerator()
+        self.dbs: dict[str, str | LiteralString] = {
+            "whisky": os.path.join("/usr/local/share", "sqlite_dbs", "whiskey.db"),
+            "drinks": os.path.join("/usr/local/share", "sqlite_dbs", "cocktails.db"),
+            "strains": os.path.join("/usr/local/share", "sqlite_dbs", "strains.db"),
+            "qajoke": os.path.join("/usr/local/share", "sqlite_dbs", "qajoke.db"),
+            "rjokes": os.path.join("/usr/local/share", "sqlite_dbs", "rjokes.db"),
+            "randmsg": os.path.join("/usr/local/share", "sqlite_dbs", "randmsg.db"),
+            "stats": os.path.join("/usr/local/share", "sqlite_dbs", "havoc_stats.db"),
+            "cookies": os.path.join("/usr/local/share", "sqlite_dbs", "cookies.db"),
+        }
+        self.COFFEES: list = [
+            "a cup of french-pressed coffee",
+            "a cup of cold brew",
+            "a cup of flash brew",
+            "a cup of Turkish coffee",
+            "a cup of Moka",
+            "an espresso",
+            "a cup of Nescafe coffee",
+            "an iced coffee",
+            "a Frappé",
+            "a freddo cappuccino",
+            "a cup of Chock full o'Nuts",
+            "a cup of Folgers",
+            "a cup of Lavazza",
+            "a cup of Maxwell House",
+            "a cup of Moccona",
+            "a cup of Mr. Brown Coffee",
+            "a cup of affogato al caffè",
+            "a cup of Caffè Medici",
+            "a cup of Café Touba",
+            "a double-double",
+            "an indian filter coffee",
+            "a cup of pocillo",
+            "a cup of caffè americano",
+            "a cup of caffè lungo",
+            "a latte",
+            "a manilo",
+            "a flat white",
+            "a cup of café cubano",
+            "a cup of caffè crema",
+            "a cup of cafe zorro",
+            "an espresso roberto",
+            "an espresso romano",
+            "an espresso sara",
+            "a guillermo",
+            "a ristretto",
+            "a cup of melya",
+            "a cup of caffè marocchino",
+            "a cup of café miel",
+            "a cup of café de olla",
+            "a Mazagran",
+            "a Palazzo",
+            "an ice shot",
+            "a macchiato",
+            "a cortado",
+            "a red eye",
+            "a cappuccino",
+            "a mocha",
+            "a café au lait",
+            "a bicerin",
+            "a caffè corretto",
+            "a café bombón",
+            "a Vienna coffee",
+            "a flat black",
+            "a lungo",
+            "a doppio",
+            "a ristretto bianco",
+            "a piccolo latte",
+            "a gibraltar",
+            "a breve",
+            "a café con leche",
+            "a su café",
+            "a café del tiempo",
+            "a java chip frappuccino",
+            "a pumpkin spice latte",
+            "a caramel macchiato",
+            "a white chocolate mocha",
+            "a hazelnut coffee",
+            "a toffee nut latte",
+            "a peppermint mocha",
+            "a cinnamon dolce latte",
+            "a coconut milk latte",
+            "an almond milk cappuccino",
+            "an oat milk latte",
+            "a caramel frappuccino",
+            "a chocolate frappuccino",
+            "a butter pecan coffee",
+            "a maple pecan latte",
+            "a sea salt caramel mocha",
+            "a nitro cold brew",
+            "a pumpkin cold brew",
+            "a honey almond flat white",
+            "a sweet cream cold brew",
+            "a matcha latte",
+            "a golden latte",
+            "a kopi luwak",
+        ]
+        self.LAST_5_COFFEES: list = []
+
+    def tdTuple(self, td: datetime.timedelta) -> tuple:
+        """
+        Create TimeDelta Tuple
+
+        Args:
+            td (datetime.timedelta)
+        Returns:
+            tuple
+
+        """
+
+        def _t(t, n):
+            if t < n:
+                return (t, 0)
+            v = t // n
+            return (t - (v * n), v)
+
+        (s, h) = _t(td.seconds, 3600)
+        (s, m) = _t(s, 60)
+        (mics, mils) = _t(td.microseconds, 1000)
+        return (td.days, h, m, s, mics, mils)
+
+    async def get_counter(self, counter: Optional[str] = None) -> Optional[dict]:
+        """
+        Get Counter
+
+        Args:
+            counter (Optional[str])
+        Returns:
+            Optional[dict]
+
+        """
+        stats_db: str | LiteralString = self.dbs.get("stats", "")
+        if not stats_db:
+            return None
+        async with sqlite3.connect(stats_db, timeout=3) as db_conn:
+            db_conn.row_factory = sqlite3.Row
+            query: str = "SELECT ? FROM stats LIMIT 1"
+            if not counter:
+                query = "SELECT * FROM stats LIMIT 1"
+            async with await db_conn.execute(
+                query, (counter,) if counter else None
+            ) as db_cursor:
+                result = await db_cursor.fetchone()
+                return dict(result)
+
+    async def get_stats_embed(self) -> Optional[Embed]:
+        """
+        Get Stats Embed
+
+        Returns:
+            Optional[Embed]
+
+        """
+        counters: Optional[dict] = await self.get_counter()
+        if not counters:
+            return None
+        embed: Embed = Embed(title="Stats")
+        counter_message: str = ""
+        counters_sorted: dict = dict(
+            sorted(counters.items(), key=lambda item: item[1], reverse=True)
+        )
+        for counter, value in counters_sorted.items():
+            counter = regex.sub(r"_", " ", counter.strip()).title()
+            counter_message += f"- {value} {counter}\n"
+        embed.description = counter_message.strip()
+        return embed
+
+    async def increment_counter(self, counter: str) -> bool:
+        """
+        Increment Counter
+
+        Args:
+            counter (str)
+        Returns:
+            bool
+
+        """
+        stats_db: str | LiteralString = self.dbs.get("stats", "")
+        if not stats_db:
+            return False
+        async with sqlite3.connect(stats_db, timeout=3) as db_conn:
+            async with await db_conn.execute(
+                f"UPDATE stats SET {counter} = {counter} + 1"
+            ) as db_cursor:
+                if db_cursor.rowcount < 0:
+                    logging.critical("[increment_counter] Fail! %s", db_cursor.rowcount)
+                    return False
+                await db_conn.commit()
+                return True
+
+    async def get_ud_def(self, term: str) -> tuple[str, str]:
+        """
+        Get Definition from UD
+
+        Args:
+            term (str)
+        Returns:
+            tuple[str, str]
+
+        """
+        try:
+            async with ClientSession() as session:
+                async with await session.get(
+                    self.URL_URBANDICTIONARY,
+                    params={
+                        "term": term,
+                    },
+                    headers={
+                        "content-type": "application/json; charset=utf-8",
+                    },
+                    timeout=ClientTimeout(connect=5, sock_read=5),
+                ) as request:
+                    logging.debug("UD returned: %s", await request.text())
+                    data: dict = await request.json()
+                    if "list" in data:
+                        definitions: list[dict] = data["list"]
+                        if definitions:
+                            definition: dict = definitions[0]
+                            definition_word: str = definition.get("word", "N/A")
+                            definition_text: str = regex.sub(
+                                r"(\r|\n|\r\n)", " ", definition["definition"].strip()
+                            )
+                            return (
+                                definition_word,
+                                definition_text,
+                            )  # Tuple: Returned word, returned definition
+                        else:
+                            return (term, "Not found!")
+                    else:
+                        return (term, "Error retrieving data from Urban Dictionary")
+        except Exception as e:
+            traceback.print_exc()
+            return (term, f"ERR: {str(e)}")
+
+    async def get_no(self) -> str:
+        try:
+            async with ClientSession() as session:
+                async with await session.get(
+                    self.URL_NO,
+                    headers={
+                        "content-type": "application/json; charset=utf-8",
+                    },
+                    timeout=ClientTimeout(connect=5, sock_read=5),
+                ) as request:
+                    request.raise_for_status()
+                    response = await request.json(encoding="utf-8")
+                    no: str = response.get("no", None)
+                    if not no:
+                        logging.debug(
+                            "Incorrect response received, JSON keys: %s",
+                            response.keys(),
+                        )
+                        return "No."
+                    return no
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
+            return "No."
+
+    async def get_insult(self, recipient: str) -> str:
+        """
+        Get Insult
+
+        Args:
+            recipient (str)
+        Returns:
+            str
+
+        """
+        async with ClientSession() as session:
+            async with await session.get(
+                f"{self.URL_INSULTAPI}?who={recipient}"
+            ) as request:
+                request.raise_for_status()
+                return await request.text()
+
+    async def get_compliment(self, subject: str, language: Optional[str] = "en") -> str:
+        """
+        Get Compliment
+
+        Args:
+            subject (str)
+            language (Optional[str]) (default: 'en')
+        Returns:
+            str
+
+        """
+        return self.COMPLIMENT_GENERATOR.compliment_in_language(subject, language)
+
+    async def get_whisky(self) -> Optional[tuple]:
+        """
+        Get Whisky
+
+        Returns:
+            Optional[tuple]
+
+        """
+        whisky_db: str | LiteralString = self.dbs.get("whisky", "")
+        if not whisky_db:
+            return None
+        async with sqlite3.connect(database=whisky_db, timeout=2) as db_conn:
+            db_query: str = "SELECT name, category, description FROM whiskeys ORDER BY random() LIMIT 1"
+            async with await db_conn.execute(db_query) as db_cursor:
+                db_result: Optional[
+                    Union[sqlite3.Row, tuple]
+                ] = await db_cursor.fetchone()
+                if not db_result:
+                    return None
+                (name, category, description) = db_result
+                name = regex.sub(
+                    r"(^\p{White_Space}|\r|\n)",
+                    "",
+                    regex.sub(r"\p{White_Space}{2,}", " ", name.strip()),
+                )
+                category = regex.sub(
+                    r"(^\p{White_Space}|\r|\n)",
+                    "",
+                    regex.sub(r"\p{White_Space}{2,}", " ", category.strip()),
+                )
+                description = regex.sub(
+                    r"(^\p{White_Space}|\r|\n)",
+                    "",
+                    regex.sub(r"\p{White_Space}{2,}", " ", description.strip()),
+                )
+                return (name, category, description)
+
+    async def get_drink(self) -> Optional[tuple]:
+        """
+        Get Drink
+
+        Returns:
+            Optional[tuple]
+
+        """
+        drinks_db: str | LiteralString = self.dbs.get("drinks", "")
+        if not drinks_db:
+            return None
+        async with sqlite3.connect(database=drinks_db, timeout=2) as db_conn:
+            db_query: str = (
+                "SELECT name, ingredients FROM cocktails ORDER BY random() LIMIT 1"
+            )
+            async with await db_conn.execute(db_query) as db_cursor:
+                db_result: tuple = await db_cursor.fetchone()
+
+                (name, ingredients) = db_result
+                name = regex.sub(
+                    r"(^\p{White_Space}|\r|\n)",
+                    "",
+                    regex.sub(r"\p{White_Space}{2,}", " ", name.strip()),
+                )
+                ingredients = regex.sub(
+                    r"(^\p{White_Space}|\r|\n)",
+                    "",
+                    regex.sub(r"\p{White_Space}{2,}", " ", ingredients.strip()),
+                )
+                ingredients = regex.sub(r"\*", "\u2731", ingredients.strip())
+                return (name, ingredients)
+
+    async def get_strain(self, strain: Optional[str] = None) -> Optional[tuple]:
+        """
+        Get Strain
+
+        Args:
+            strain (Optional[str])
+        Returns:
+            Optional[tuple]
+
+        """
+        strains_db: str | LiteralString = self.dbs.get("strains", "")
+        if not strains_db:
+            return None
+        async with sqlite3.connect(database=strains_db, timeout=2) as db_conn:
+            db_params: Optional[tuple] = None
+            if not strain:
+                db_query: str = "SELECT name, description FROM strains_w_desc ORDER BY random() LIMIT 1"
+            else:
+                db_query = (
+                    "SELECT name, description FROM strains_w_desc WHERE name LIKE ?"
+                )
+                db_params = (f"%{strain.strip()}%",)
+            async with await db_conn.execute(db_query, db_params) as db_cursor:
+                db_result: Optional[tuple] = await db_cursor.fetchone()
+                return db_result
+
+    async def get_qajoke(self) -> Optional[tuple]:
+        """
+        Get QA Joke
+
+        Returns:
+            Optional[tuple]
+
+        """
+        qajoke_db: str | LiteralString = self.dbs.get("qajoke", "")
+        if not qajoke_db:
+            return None
+        async with sqlite3.connect(database=qajoke_db, timeout=2) as db_conn:
+            db_query: str = (
+                "SELECT question, answer FROM jokes ORDER BY RANDOM() LIMIT 1"
+            )
+            async with await db_conn.execute(db_query) as cursor:
+                (question, answer) = await cursor.fetchone()
+                return (question, answer)
+        return None
+
+    async def get_rjoke(self) -> Optional[tuple]:
+        """
+        Get r/joke Joke
+
+        Returns:
+            Optional[tuple]
+
+        """
+        rjokes_db: str | LiteralString = self.dbs.get("rjokes", "")
+        if not rjokes_db:
+            return None
+        async with sqlite3.connect(database=rjokes_db, timeout=2) as db_conn:
+            db_query: str = "SELECT title, body, score FROM jokes WHERE score >= 100 ORDER BY RANDOM() LIMIT 1'"
+            async with await db_conn.execute(db_query) as cursor:
+                (title, body, score) = await cursor.fetchone()
+                return (title, body, score)
+        return None
+
+    async def get_random_fact(self) -> str:
+        """
+        Get Random Fact
+
+        Returns:
+            str
+
+        """
+        try:
+            facts_api_url: str = "https://uselessfacts.jsph.pl/api/v2/facts/random"
+            facts_backup_url: str = (
+                "https://cnichols1734.pythonanywhere.com/facts/random"
+            )
+            async with ClientSession() as client:
+                try:
+                    async with await client.get(
+                        facts_api_url, timeout=ClientTimeout(connect=5, sock_read=5)
+                    ) as request:
+                        _json: dict = await request.json()
+                        fact: str = _json.get("text", None)
+                        if not fact:
+                            raise BaseException("RandFact Src 1 Failed")
+                        return fact
+                except Exception as e:
+                    logging.debug("Exception: %s", str(e))
+                    async with await client.get(
+                        facts_backup_url, timeout=ClientTimeout(connect=5, sock_read=5)
+                    ) as request:
+                        _json = await request.json()
+                        fact = _json.get("fact", None)
+                        return fact
+        except Exception as e:
+            traceback.print_exc()
+            return f"Failed to get a random fact :( [{str(e)}]"
+
+    async def get_cookie(self) -> Optional[dict]:
+        """
+        Get Cookie
+
+        Returns:
+            Optional[dict]
+
+        """
+        cookies_db = self.dbs.get("cookies", "")
+        if not cookies_db:
+            return None
+        async with sqlite3.connect(cookies_db, timeout=2) as db_conn:
+            db_query: str = (
+                "SELECT name, origin, image_url FROM cookies ORDER BY RANDOM() LIMIT 1"
+            )
+            async with await db_conn.execute(db_query) as db_cursor:
+                (name, origin, image_url) = await db_cursor.fetchone()
+                return {"name": name, "origin": origin, "image_url": image_url}
+
+    def get_coffee(self, recipient_allergic: Optional[bool] = False) -> Optional[str]:
+        """
+        Get Coffee
+
+        Args:
+            recipient_allergic (bool): Is the recipient allergic? (so we know when to keep our nuts out of it)
+
+        Returns:
+            str
+
+        """
+        try:
+            randomCoffee: str = random.choice(self.COFFEES)
+            if (
+                self.LAST_5_COFFEES
+                and randomCoffee in self.LAST_5_COFFEES
+                or (recipient_allergic and "nut" in randomCoffee.lower())
+            ):
+                return self.get_coffee()  # Recurse
+            if len(self.LAST_5_COFFEES) >= 5:
+                self.LAST_5_COFFEES.pop()  # Store no more than 5 of the last served coffees
+            self.LAST_5_COFFEES.append(randomCoffee)
+            return randomCoffee
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
+            traceback.print_exc()
+            return None
+
+    def get_days_to_xmas(self) -> Optional[tuple]:
+        """
+        Get # of Days until Xmas
+
+        Returns:
+            Optional[tuple]
+
+        """
+        today: datetime.datetime = datetime.datetime.now(tz=pytz.UTC)
+        xmas: datetime.datetime = datetime.datetime(
+            year=today.year,
+            month=12,
+            day=25,
+            tzinfo=pytz.UTC,
+        )
+        td: datetime.timedelta = xmas - today
+        days, hours, minutes, seconds, us, ms = self.tdTuple(td)
+
+        return (days, hours, minutes, seconds, ms, us)
+
+    def get_days_to_halloween(self) -> Optional[tuple]:
+        """
+        Get # of Days until Halloween
+
+        Returns:
+            Optional[tuple]
+
+        """
+        today: datetime.datetime = datetime.datetime.now(tz=pytz.UTC)
+        halloween: datetime.datetime = datetime.datetime(
+            year=today.year,
+            month=10,
+            day=31,
+            tzinfo=pytz.UTC,
+        )
+        td: datetime.timedelta = halloween - today
+        days, hours, minutes, seconds, us, ms = self.tdTuple(td)
+
+        return (days, hours, minutes, seconds, ms, us)
+
+    async def get_randmsg(self) -> Optional[str]:
+        """
+        Get Random Message from randmsg.db
+
+        Returns:
+            Optional[str]
+
+        """
+        randmsg_db: str | LiteralString = self.dbs.get("randmsg", "")
+        if not randmsg_db:
+            return None
+        async with sqlite3.connect(database=randmsg_db, timeout=2) as db_conn:
+            db_query: str = "SELECT msg FROM msgs ORDER BY RANDOM() LIMIT 1"
+            async with await db_conn.execute(db_query) as db_cursor:
+                (result,) = await db_cursor.fetchone()
+                return result

util/radio_util.py

@@ -4,6 +4,7 @@ from aiohttp import ClientSession, ClientTimeout
 
 """Radio Utils"""
 
+
 async def get_now_playing() -> Optional[str]:
     """
     Get radio now playing
@@ -15,18 +16,22 @@ async def get_now_playing() -> Optional[str]:
     np_url: str = "https://api.codey.lol/radio/np"
     try:
         async with ClientSession() as session:
-            async with await session.post(np_url, headers={
+            async with await session.post(
-                'content-type': 'application/json; charset=utf-8',
+                np_url,
-            }, timeout=ClientTimeout(connect=1.5, sock_read=1.5)) as request:
+                headers={
+                    "content-type": "application/json; charset=utf-8",
+                },
+                timeout=ClientTimeout(connect=1.5, sock_read=1.5),
+            ) as request:
                 request.raise_for_status()
                 response_json = await request.json()
-                artistsong = response_json.get('artistsong')
+                artistsong = response_json.get("artistsong")
                 return artistsong
     except Exception as e:
-        logging.critical("Now playing retrieval failed: %s",
+        logging.critical("Now playing retrieval failed: %s", str(e))
-                      str(e))
         return None
 
+
 async def skip() -> bool:
     """
     Ask LiquidSoap server to skip to the next track
@@ -38,13 +43,13 @@ async def skip() -> bool:
     try:
         ls_uri: str = "http://127.0.0.1:29000"
         async with ClientSession() as session:
-                async with session.get(f"{ls_uri}/next",
+            async with session.get(
-                                timeout=ClientTimeout(connect=2, sock_read=2)) as request:
+                f"{ls_uri}/next", timeout=ClientTimeout(connect=2, sock_read=2)
-                    request.raise_for_status()
+            ) as request:
-                    text: Optional[str] = await request.text()
+                request.raise_for_status()
-                    return text == "OK"
+                text: Optional[str] = await request.text()
+                return text == "OK"
     except Exception as e:
         logging.debug("Skip failed: %s", str(e))
 
-    return False   # failsafe   
+    return False  # failsafe
-    

util/sing_util.py

@@ -6,14 +6,17 @@ import traceback
 from discord import Activity
 from typing import Optional, Union
 
+
 class Utility:
     """Sing Utility"""
+
     def __init__(self) -> None:
         self.api_url: str = "http://127.0.0.1:52111/lyric/search"
         self.api_src: str = "DISC-HAVOC"
 
-    def parse_song_input(self, song: Optional[str] = None,
+    def parse_song_input(
-                         activity: Optional[Activity] = None) -> Union[bool, tuple]:
+        self, song: Optional[str] = None, activity: Optional[Activity] = None
+    ) -> Union[bool, tuple]:
         """
         Parse Song (Sing Command) Input
 
@@ -29,13 +32,18 @@ class Utility:
                 return False
             if not song and activity:
                 if not activity.name:
-                    return False # No valid activity found
+                    return False  # No valid activity found
                 match activity.name.lower():
                     case "codey toons" | "cider" | "sonixd":
-                        search_artist: str = " ".join(str(activity.state)\
+                        search_artist: str = " ".join(
-                            .strip().split(" ")[1:])
+                            str(activity.state).strip().split(" ")[1:]
-                        search_artist = regex.sub(r"(\s{0,})(\[(spotify|tidal|sonixd|browser|yt music)])$", "",
+                        )
-                                                       search_artist.strip(), flags=regex.IGNORECASE)
+                        search_artist = regex.sub(
+                            r"(\s{0,})(\[(spotify|tidal|sonixd|browser|yt music)])$",
+                            "",
+                            search_artist.strip(),
+                            flags=regex.IGNORECASE,
+                        )
                         search_song = str(activity.details)
                         song = f"{search_artist} : {search_song}"
                     case "tidal hi-fi":
@@ -43,41 +51,54 @@ class Utility:
                         search_song = str(activity.details)
                         song = f"{search_artist} : {search_song}"
                     case "spotify":
-                        if not activity.title or not activity.artist: # type: ignore
+                        if not activity.title or not activity.artist:  # type: ignore
                             """
                             Attributes exist, but mypy does not recognize them.  Ignored.
                             """
                             return False
-                        search_artist = str(activity.title) # type: ignore
+                        search_artist = str(activity.artist)  # type: ignore
-                        search_song = str(activity.artist) # type: ignore
+                        search_song = str(activity.title)  # type: ignore
                         song = f"{search_artist} : {search_song}"
                     case "serious.fm" | "cocks.fm" | "something":
                         if not activity.details:
                             song = str(activity.state)
                         else:
-                            search_artist = str(activity.state).rsplit("[", maxsplit=1)[0] # Strip genre
+                            search_artist = str(activity.state).rsplit("[", maxsplit=1)[
+                                0
+                            ]  # Strip genre
                             search_song = str(activity.details)
                             song = f"{search_artist} : {search_song}"
                     case _:
-                        return False # Unsupported activity detected
+                        return False  # Unsupported activity detected
 
-            search_split_by: str = ":" if not(song) or len(song.split(":")) > 1\
+            search_split_by: str = (
-                else "-" # Support either : or - to separate artist/track
+                ":" if not (song) or len(song.split(":")) > 1 else "-"
+            )  # Support either : or - to separate artist/track
             if not song:
                 return False
             search_artist = song.split(search_split_by)[0].strip()
             search_song = "".join(song.split(search_split_by)[1:]).strip()
             search_subsearch: Optional[str] = None
-            if search_split_by == ":" and len(song.split(":")) > 2: # Support sub-search if : is used (per instructions)
+            if (
-                search_song = song.split(search_split_by)[1].strip() # Reduce search_song to only the 2nd split of : [the rest is meant to be lyric text]
+                search_split_by == ":" and len(song.split(":")) > 2
-                search_subsearch = "".join(song.split(search_split_by)[2:]) # Lyric text from split index 2 and beyond
+            ):  # Support sub-search if : is used (per instructions)
+                search_song = song.split(
+                    search_split_by
+                )[
+                    1
+                ].strip()  # Reduce search_song to only the 2nd split of : [the rest is meant to be lyric text]
+                search_subsearch = "".join(
+                    song.split(search_split_by)[2:]
+                )  # Lyric text from split index 2 and beyond
             return (search_artist, search_song, search_subsearch)
-        except:
+        except Exception as e:
+            logging.debug("Exception: %s", str(e))
             traceback.print_exc()
             return False
 
-    async def lyric_search(self, artist: str, song: str,
+    async def lyric_search(
-                            sub: Optional[str] = None) -> Optional[list]:
+        self, artist: str, song: str, sub: Optional[str] = None
+    ) -> Optional[list]:
         """
         Lyric Search
 
@@ -93,60 +114,76 @@ class Utility:
                 return [("FAIL! Artist/Song not provided",)]
 
             search_obj: dict = {
-                'a': artist.strip(),
+                "a": artist.strip(),
-                's': song.strip(),
+                "s": song.strip(),
-                'extra': True,
+                "extra": True,
-                'src': self.api_src,
+                "src": self.api_src,
             }
 
             if len(song.strip()) < 1:
-                search_obj.pop('a')
+                search_obj.pop("a")
-                search_obj.pop('s')
+                search_obj.pop("s")
-                search_obj['t'] = artist.strip() # Parse failed, try title without sep
+                search_obj["t"] = artist.strip()  # Parse failed, try title without sep
 
             if sub and len(sub) >= 2:
-                search_obj['sub'] = sub.strip()
+                search_obj["sub"] = sub.strip()
 
             async with aiohttp.ClientSession() as session:
-                async with await session.post(self.api_url,
+                async with await session.post(
-                                              json=search_obj,
+                    self.api_url,
-                                              timeout=aiohttp.ClientTimeout(connect=5, sock_read=10)) as request:
+                    json=search_obj,
+                    timeout=aiohttp.ClientTimeout(connect=5, sock_read=10),
+                ) as request:
                     request.raise_for_status()
                     response: dict = await request.json()
-                    if response.get('err'):
+                    if response.get("err"):
                         return [(f"ERR: {response.get('errorText')}",)]
 
-                    out_lyrics = regex.sub(r'<br>', '\u200B\n', response.get('lyrics', ''))
+                    out_lyrics = regex.sub(
+                        r"<br>", "\u200b\n", response.get("lyrics", "")
+                    )
                     response_obj: dict = {
-                        'artist': response.get('artist'),
+                        "artist": response.get("artist"),
-                        'song': response.get('song'),
+                        "song": response.get("song"),
-                        'lyrics': out_lyrics,
+                        "lyrics": out_lyrics,
-                        'src': response.get('src'),
+                        "src": response.get("src"),
-                        'confidence': float(response.get('confidence', 0.0)),
+                        "confidence": float(response.get("confidence", 0.0)),
-                        'time': float(response.get('time', -1.0)),
+                        "time": float(response.get("time", -1.0)),
                     }
 
-                    lyrics = response_obj.get('lyrics')
+                    lyrics = response_obj.get("lyrics")
                     if not lyrics:
                         return None
-                    response_obj['lyrics'] = textwrap.wrap(text=lyrics.strip(),
+                    response_obj["lyrics"] = textwrap.wrap(
-                                                        width=4000, drop_whitespace=False,
+                        text=lyrics.strip(),
-                                                        replace_whitespace=False, break_long_words=True,
+                        width=1500,
-                                                        break_on_hyphens=True, max_lines=8)
+                        drop_whitespace=False,
-                    response_obj['lyrics_short'] = textwrap.wrap(text=lyrics.strip(),
+                        replace_whitespace=False,
-                                                        width=750, drop_whitespace=False,
+                        break_long_words=True,
-                                                        replace_whitespace=False, break_long_words=True,
+                        break_on_hyphens=True,
-                                                        break_on_hyphens=True, max_lines=1)
+                        max_lines=8,
+                    )
+                    response_obj["lyrics_short"] = textwrap.wrap(
+                        text=lyrics.strip(),
+                        width=750,
+                        drop_whitespace=False,
+                        replace_whitespace=False,
+                        break_long_words=True,
+                        break_on_hyphens=True,
+                        max_lines=1,
+                    )
 
                     return [
                         (
-                            response_obj.get('artist'), response_obj.get('song'), response_obj.get('src'),
+                            response_obj.get("artist"),
+                            response_obj.get("song"),
+                            response_obj.get("src"),
                             f"{int(response_obj.get('confidence', -1.0))}%",
                             f"{response_obj.get('time', -666.0):.4f}s",
                         ),
-                            response_obj.get('lyrics'),
+                        response_obj.get("lyrics"),
-                            response_obj.get('lyrics_short'),
+                        response_obj.get("lyrics_short"),
-                        ] 
+                    ]
         except Exception as e:
             traceback.print_exc()
             return [f"Retrieval failed: {str(e)}"]