main.py

"""
Copyright © Krypton 2019-2023 - https://github.com/kkrypt0nn (https://krypton.ninja)
Description:
🐍 A simple template to start to code your own and personalized discord bot in Python programming language.

Version: 6.1.0
"""

import argparse
import json
import logging
import os
import platform
import sys

import discord
from discord.ext import commands, tasks
from discord.ext.commands import Context
from dotenv import load_dotenv

from utils.context_commands import add_context_commands

if not os.path.isfile(
    f"{os.path.realpath(os.path.dirname(__file__))}/config/config.json"
):
    sys.exit("'config.json' not found! Please add it and try again.")
else:
    with open(
        f"{os.path.realpath(os.path.dirname(__file__))}/config/config.json"
    ) as file:
        config = json.load(file)

intents = discord.Intents(messages=True, guilds=True, message_content=True)


class LoggingFormatter(logging.Formatter):
    # Colors
    black = "\x1b[30m"
    red = "\x1b[31m"
    green = "\x1b[32m"
    yellow = "\x1b[33m"
    blue = "\x1b[34m"
    gray = "\x1b[38m"
    # Styles
    reset = "\x1b[0m"
    bold = "\x1b[1m"

    COLORS = {
        logging.DEBUG: gray + bold,
        logging.INFO: blue + bold,
        logging.WARNING: yellow + bold,
        logging.ERROR: red,
        logging.CRITICAL: red + bold,
    }

    def format(self, record):
        log_color = self.COLORS[record.levelno]
        format = "(black){asctime}(reset) (levelcolor){levelname:<8}(reset) (green){name}(reset) {message}"
        format = format.replace("(black)", self.black + self.bold)
        format = format.replace("(reset)", self.reset)
        format = format.replace("(levelcolor)", log_color)
        format = format.replace("(green)", self.green + self.bold)
        formatter = logging.Formatter(format, "%Y-%m-%d %H:%M:%S", style="{")
        return formatter.format(record)


logger = logging.getLogger("Keto")
logger.setLevel(logging.INFO)

# Console handler
console_handler = logging.StreamHandler()
console_handler.setFormatter(LoggingFormatter())
# File handler
file_handler = logging.FileHandler(filename="discord.log", encoding="utf-8", mode="w")
file_handler_formatter = logging.Formatter(
    "[{asctime}] [{levelname:<8}] {name}: {message}", "%Y-%m-%d %H:%M:%S", style="{"
)
file_handler.setFormatter(file_handler_formatter)

logger.addHandler(console_handler)
logger.addHandler(file_handler)


class DiscordBot(commands.AutoShardedBot):
    def __init__(self) -> None:
        super().__init__(
            command_prefix=config["prefix"],
            intents=intents,
            help_command=None,
        )
        self.logger = logger
        self.config = config

    async def load_cogs(self) -> None:
        # Get command line arguments
        parser = argparse.ArgumentParser()
        parser.add_argument(
            "--only-load", help="Comma-separated list of cog names to load", type=str
        )
        args = parser.parse_args()

        cogs_dir = f"{os.path.realpath(os.path.dirname(__file__))}/cogs"
        config_cogs = [
            file
            for file in os.listdir(cogs_dir)
            if file.startswith("config") and file.endswith(".py")
        ]
        other_cogs = [
            file
            for file in os.listdir(cogs_dir)
            if file.endswith(".py") and file not in config_cogs
        ]

        if args.only_load:
            requested_cogs = [f"{cog.strip()}.py" for cog in args.only_load.split(",")]
            config_cogs = [cog for cog in config_cogs if cog in requested_cogs]
            other_cogs = [cog for cog in other_cogs if cog in requested_cogs]
            for required_cog in ["owner.py", "config.py", "config_user.py"]:
                if required_cog not in other_cogs:
                    other_cogs.append(required_cog)
            self.logger.info(
                f"Only loading requested cogs: {', '.join(requested_cogs)}"
            )

        for file in config_cogs + other_cogs:
            extension = file[:-3]
            try:
                await self.load_extension(f"cogs.{extension}")
                self.logger.info(f"Loaded extension '{extension}'")
            except Exception as e:
                exception = f"{type(e).__name__}: {e}"
                self.logger.error(f"Failed to load extension {extension}\n{exception}")

    @tasks.loop(minutes=5.0)
    async def status_task(self) -> None:
        await bot.change_presence(
            activity=discord.Activity(
                type=discord.ActivityType.watching, name=f"{len(self.guilds)} servers"
            )
        )

    @status_task.before_loop
    async def before_status_task(self) -> None:
        await self.wait_until_ready()

    async def setup_hook(self) -> None:
        self.logger.info(f"Logged in as {self.user.name}")
        self.logger.info(f"discord.py API version: {discord.__version__}")
        self.logger.info(f"Python version: {platform.python_version()}")
        self.logger.info(
            f"Running on: {platform.system()} {platform.release()} ({os.name})"
        )
        self.logger.info("-------------------")
        await self.load_cogs()
        add_context_commands(self)
        self.status_task.start()

    async def on_message(self, message: discord.Message) -> None:
        if message.author == self.user or message.author.bot:
            return
        await self.process_commands(message)

    async def on_command_completion(self, context: Context) -> None:
        full_command_name = context.command.qualified_name
        split = full_command_name.split(" ")
        executed_command = str(split[0])
        if context.guild is not None:
            self.logger.info(
                f"Executed {executed_command} command in {context.guild.name} (ID: {context.guild.id}) by {context.author} (ID: {context.author.id})"
            )
        else:
            self.logger.info(
                f"Executed {executed_command} command by {context.author} (ID: {context.author.id}) in DMs"
            )

    async def on_error(self, event_method: str, *args, **kwargs) -> None:
        ignored_errors = (
            discord.errors.Forbidden,
            discord.errors.HTTPException,
            discord.errors.NotFound,
        )

        try:
            raise
        except tuple(ignored_errors):
            return
        except Exception:
            if os.getenv("DEBUG", "false").lower() == "true":
                raise
            return

    async def on_command_error(self, context: Context, error) -> None:
        if isinstance(error, commands.CommandOnCooldown):
            minutes, seconds = divmod(error.retry_after, 60)
            hours, minutes = divmod(minutes, 60)
            hours = hours % 24
            embed = discord.Embed(
                description=f"**Please slow down** - You can use this command again in {f'{round(hours)} hours' if round(hours) > 0 else ''} {f'{round(minutes)} minutes' if round(minutes) > 0 else ''} {f'{round(seconds)} seconds' if round(seconds) > 0 else ''}.",
                color=0xE02B2B,
            )
            await context.send(embed=embed)
        elif isinstance(error, commands.NotOwner):
            embed = discord.Embed(
                description="You are not the owner of the bot!", color=0xE02B2B
            )
            await context.send(embed=embed)
            if context.guild:
                self.logger.warning(
                    f"{context.author} (ID: {context.author.id}) tried to execute an owner only command in the guild {context.guild.name} (ID: {context.guild.id}), but the user is not an owner of the bot."
                )
            else:
                self.logger.warning(
                    f"{context.author} (ID: {context.author.id}) tried to execute an owner only command in the bot's DMs, but the user is not an owner of the bot."
                )
        elif isinstance(error, commands.MissingPermissions):
            embed = discord.Embed(
                description="You are missing the permission(s) `"
                + ", ".join(error.missing_permissions)
                + "` to execute this command!",
                color=0xE02B2B,
            )
            await context.send(embed=embed)
        elif isinstance(error, commands.BotMissingPermissions):
            embed = discord.Embed(
                description="I am missing the permission(s) `"
                + ", ".join(error.missing_permissions)
                + "` to fully perform this command!",
                color=0xE02B2B,
            )
            await context.send(embed=embed)
        elif isinstance(error, commands.MissingRequiredArgument):
            embed = discord.Embed(
                title="Error!",
                # We need to capitalize because the command arguments have no capital letter in the code and they are the first word in the error message.
                description=str(error).capitalize(),
                color=0xE02B2B,
            )
            await context.send(embed=embed)
        else:
            raise error


load_dotenv()

bot = DiscordBot()
bot.run(os.getenv("TOKEN"))