Formatted and annotated all functions and methods.

Author: Xithrius

bot/__main__.py

@@ -1,97 +1,8 @@
-"""
-Launches the bot, starts the asyncio loop when called.
-"""
-import discord
 from . import settings
-from .bot import Bot
+from bot.bot import Friendo
 
 if __name__ == "__main__":
-    bot = Bot(command_prefix=settings.COMMAND_PREFIX)
-    bot.remove_command("help")
-
-    @bot.command(name="help", help="This will be shown")
-    async def help(ctx, *, name=None):
-        char_repeat = 20
-        embed = discord.Embed(
-            title=f"{'-' * (char_repeat//2)}Friendo_Bot{'-' * (char_repeat//2)}",
-            url=settings.BASE_GITHUB_REPO,
-            color=0x1C1C1C,
-        )
-        embed.set_thumbnail(
-            url="https://images.discordapp.net/avatars/723555941118771262/8f586ecb1f89cec031d00b3a616573ea.png?size=512"
-        )
-
-        if name is None:
-            cogs = list(bot.cogs.keys())
-            field_body = "\n".join(cogs)
-            field_body = field_body.strip()
-
-            field_body += (
-                "\n\nUsage: `%shelp [Cog | Command]`. Example: `%shelp greetings`"
-                % (bot.command_prefix, bot.command_prefix)
-            )
-
-            embed.add_field(name="Cogs", value=field_body, inline=False)
-        else:
-            cog = bot.cogs.get(name.title(), None)
-
-            if cog is None:
-                # Check if this is not a command
-                command = bot.get_command(name.lower())
-
-                if command is not None:
-                    embed.title += "\n" + command.name
-
-                    field_body = (
-                        command.description
-                        if command.description != ""
-                        else (
-                            command.brief
-                            if command.brief != ""
-                            else "This command has no description."
-                        )
-                    )
-                    field_body += "\n" + (
-                        "Usage: `" + command.usage + "`"
-                        if command.usage is not None
-                        else ""
-                    )
-
-                    embed.add_field(
-                        name=command.name, value=field_body.strip(), inline=False
-                    )
-                else:
-                    field_body = (
-                        "Error: Cog or command `%s` not found! Use `%shelp` to see a list of cogs"
-                        % (name, bot.command_prefix)
-                    )
-                    embed.add_field(name="Cogs", value=field_body, inline=False)
-            else:
-                embed.title += "\n" + name.title()
-
-                for command in cog.get_commands():
-                    field_body = (
-                        (command.brief if command.brief is not None else "")
-                        + "\n"
-                        + (
-                            "Usage: `" + command.usage + "`"
-                            if command.usage is not None
-                            else ""
-                        )
-                    )
-                    field_body = field_body.strip()
-
-                    embed.add_field(
-                        name=command.name,
-                        value=(
-                            field_body + "\n"
-                            if field_body != ""
-                            else "This command has no help message"
-                        ),
-                        inline=False,
-                    )
-
-        await ctx.send(embed=embed)
+    bot = Friendo(command_prefix=settings.COMMAND_PREFIX, help_command=None)
 
     # load in basic commands
     bot.load_extension("bot.cogs.greetings")

bot/bot.py

@@ -1,20 +1,19 @@
 import asyncio
 import logging
-import traceback
 
 import aiohttp
-from discord.ext import commands
+from discord.ext.commands import Bot, CommandError, Context
 
-from .settings import NAME, API_COGS
 from .disable import DisableApi
+from .settings import API_COGS
 
-logger = logging.getLogger(__name__)
+log = logging.getLogger(__name__)
 
 
-class Bot(commands.Bot):
+class Friendo(Bot):
     """Base Class for the discord bot."""
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
 
         # Setting the loop.
@@ -23,22 +22,16 @@ def __init__(self, *args, **kwargs):
         # Creating session for web requests.
         self.session = aiohttp.ClientSession()
 
-    def __str__(self):
-        """Returns the name of the bot."""
-        return NAME
-
-    async def on_ready(self):
+    @staticmethod
+    async def on_ready() -> None:
         """Runs when the bot is connected."""
-        logger.info("Logged in as")
-        logger.info(self.user.name)
-        logger.info(self.user.id)
-        logger.info("------")
+        log.info('Awaiting...')
 
-    async def on_command_error(self, ctx, exception):
+    async def on_command_error(self, ctx: Context, exception: CommandError) -> None:
         """Fired when exception happens."""
-        logger.error(
+        log.error(
             "Exception happened while executing command",
-            exc_info=(type(exception), exception, exception.__traceback__),
+            exc_info=(type(exception), exception, exception.__traceback__)
         )
 
     async def logout(self) -> None:
@@ -47,28 +40,37 @@ async def logout(self) -> None:
 
         return await super().logout()
 
-    def load_extension(self, name):
+    def load_extension(self, name: str) -> None:
+        """Loads an extension after checking if it's disabled or not."""
         disable_api = DisableApi()
         cog_name = name.split(".")[-1]
+
         # If no-api is passed disable API_COGS ie. memes and events
         if disable_api.get_no_api() and cog_name in API_COGS:
             return
+
         disabled_list = disable_api.get_disable()
+
         if disabled_list:
             if cog_name in disabled_list:
                 return
+
             # If cog is not disabled, load it
             else:
                 super().load_extension(name)
                 return
+
         enabled_list = disable_api.get_enable()
+
         if enabled_list:
             # If cog is enabled, load it
             if cog_name in enabled_list:
                 super().load_extension(name)
                 return
+
             # Don't load cogs not passed along with enable
             else:
                 return
+
         # load cogs if no argument is passed
         super().load_extension(name)

bot/cogs/__init__.py

@@ -1,78 +1,73 @@
-"""
-Contains all commands relating to admin duties and permissions.
-"""
-
 import json
 import logging
+from pathlib import Path
 import re
+from typing import Callable, Optional
 
-from discord.ext.commands import Bot, Cog, command, check
+from discord import Member
+from discord.ext.commands import Cog, Context, check, command
 
-from bot.settings import BASE_DIR
+from bot.bot import Friendo
 
-logger = logging.getLogger(__name__)
+log = logging.getLogger(__name__)
 
 
-def is_admin():
+def is_admin() -> Callable:
     """Return whether or not the user invoking a command is an admin."""
 
-    def predicate(ctx):
-        with open(f"{BASE_DIR}/save_data.JSON", "r") as data:
-            save_data = json.load(data)
+    def predicate(ctx: Context) -> bool:
+        """Opening the admin json config file."""
+        with open(Path.cwd() / "save_data.json", "r") as file:
+            save_data = json.load(file)
+
         return str(ctx.message.author.id) in save_data["admins"]
 
     return check(predicate)
 
 
-def id_from_mention(message_content: str):
+def id_from_mention(message_content: str) -> Optional[int]:
     """Return a user id from an @mention in a message."""
+    get_id = re.search(r"\d{18}", message_content)
 
-    pattern = r"\d{18}"
-    get_id = re.search(pattern, message_content)
     if get_id is not None:
         return int(get_id.group())
-    return None
 
 
-class AdminCommands(Cog):
-    """
-    Commands for bot and server administration, all require the admin status on the invoking user.
-    """
+class Administration(Cog):
+    """Commands for bot and server administration, all require the admin status on the invoking user."""
 
-    def __init__(self, bot: Bot):
+    def __init__(self, bot: Friendo) -> None:
         self.bot = bot
 
     @command(brief="Kills your robotic friend")
     @is_admin()
-    async def shutdown(self, ctx):
+    async def shutdown(self, ctx: Context) -> None:
         """Cleanly shuts down the bot."""
+        await ctx.send("Mr. Stark, I don't feel so good...")
+
+        log.info("Closing Client...")
 
-        msg = "Mr. Stark, I don't feel so good. . ."
-        await ctx.send(msg)
-        logger.info("Closing Client...")
         await self.bot.logout()
 
     @command(name="createadmin", brief="gives the @mention user admin permissions")
     @is_admin()
-    async def create_admin(self, ctx, user):
+    async def create_admin(self, ctx: Context, member: Member) -> None:
         """Adds a new user id to the list of admins."""
+        msg = f"Could not create admin from {member.name}"
 
-        msg = f"Could not create admin from {user}"
-
-        with open(f"{BASE_DIR}/save_data.JSON", "r") as data:
-            save_data = json.load(data)
+        with open(Path.cwd() / "save_data.json", "r") as file:
+            save_data = json.load(file)
 
-        this_user = self.bot.get_user(id_from_mention(ctx.message.content))
+        if str(member.id) not in save_data["admins"]:
+            save_data["admins"].append(str(member.id))
 
-        if this_user and str(this_user.id) not in save_data["admins"]:
-            save_data["admins"].append(str(this_user.id))
-            with open(f"{BASE_DIR}/save_data.JSON", "w") as file:
+            with open(Path.cwd() / "save_data.json", "r") as file:
                 json.dump(save_data, file)
-                msg = f"{ctx.author.mention}, {user} added to admins"
+                msg = f"{ctx.author.mention}, {member.name} has been added to admins"
 
         await ctx.send(msg)
 
 
-def setup(bot: Bot) -> None:
+def setup(bot: Friendo) -> None:
     """Load the Admin cog."""
-    bot.add_cog(AdminCommands(bot))
+    bot.add_cog(Administration(bot))