Convert bot to discord.py 2.0

TODO: Reject commands if the bot is not fully started up

Author: gccody

launcher.py

@@ -1,17 +1,17 @@
 import asyncio
 import atexit
 import glob
-import sys
-
-from time import sleep
+from http.client import HTTPException
 
+import discord
 import numpy as np
 import requests
+from discord import Embed, NotFound, Interaction
+from discord.app_commands import CommandOnCooldown, MissingPermissions, BotMissingPermissions
 
-from lib.bot import Bot
+from lib.bot import Bot, IGNORE_EXCEPTIONS
 from lib.config import Config
 from lib.progress import Progress
-from asyncer import asyncify
 
 COGS = [path.split("\\")[-1][:-3] if "\\" in path else path.split("/")[-1][:-3] for path in
         glob.glob('./lib/cogs/*.py')]
@@ -24,16 +24,62 @@
 SHARDS_SPLIT: list[np.ndarray[int]] = np.array_split(SHARDS_LIST, CLUSTERS)
 
 
-def start(cluster_id: int):
-    bot: Bot = Bot(list((SHARDS_SPLIT[cluster_id])), VERSION)
+async def start():
+    bot = Bot(SHARDS_LIST, VERSION)
     progress = Progress("Registering Cogs", len(COGS))
     for index, cog in enumerate(COGS):
-        bot.load_extension(f"lib.cogs.{cog}")
-        # sleep(.2)
+        await bot.load_extension(f"lib.cogs.{cog}")
         progress.next()
-    atexit.register(bot.db.commit)
-    bot.run(bot.config.token)
+
+        # @bot.event
+        # async def on_interaction(ctx: Interaction):
+        #     if isinstance(ctx.command, Command):
+        #         print('is Command')
+        #         raise BotNotReady()
+
+        @bot.tree.error
+        async def on_command_error(ctx: Interaction, exc) -> None:
+            if any([isinstance(exc, error) for error in IGNORE_EXCEPTIONS]):
+                pass
+            elif isinstance(exc, CommandOnCooldown):
+                embed: Embed = Embed(title='Command on Cooldown',
+                                     description=f"That command is on cooldown. Try again in {exc.retry_after:,.2f} seconds.",
+                                     colour=0xff0000)
+                await bot.send(ctx, embed=embed)
+            elif isinstance(exc, MissingPermissions):
+                embed: Embed = Embed(title='You are missing permissions', description=f'>>> {exc}', colour=0xff0000)
+                await bot.send(ctx, embed=embed)
+            elif isinstance(exc, BotMissingPermissions):
+                embed: Embed = Embed(title='Bot Missing Permissions', description=f">>> {exc}", colour=0xff0000)
+                await bot.send(ctx, embed=embed)
+            elif isinstance(exc, HTTPException):
+                embed: Embed = Embed(title="Http Error", description='Message failed to send', colour=0xff0000)
+                await bot.send(ctx, embed=embed)
+            elif isinstance(exc, NotFound):
+                await bot.send(ctx,
+                    embed=Embed(title='Not Found Error', description='One or more items could not be found.',
+                                colour=0xff0000))
+            elif hasattr(exc, "original"):
+                if isinstance(exc.original, HTTPException):
+                    embed: Embed = Embed(title="Http Error", description='Message failed to send', colour=0xff0000)
+                    await bot.send(ctx, embed=embed)
+                if isinstance(exc.original, discord.Forbidden):
+                    embed: Embed = Embed(title='Forbidden Error', description='Insufficient Permissions',
+                                         colour=0xff0000)
+                    await bot.send(ctx, embed=embed)
+                else:
+                    raise exc.original
+
+            else:
+                raise exc
+
+    async def exit_handler():
+        bot.db.commit()
+        await bot.close()
+
+    atexit.register(exit_handler)
+    await bot.start(bot.config.token)
 
 
 if __name__ == '__main__':
-    start(0)
+    asyncio.run(start())

lib/bot/__init__.py

@@ -3,30 +3,34 @@
 import os
 from datetime import datetime
 from http.client import HTTPException
+import random
 from typing import Any
 
 import discord
 import psutil
 import tzlocal
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
-from discord import Interaction, Guild
+from discord import Guild, app_commands, Interaction, VoiceChannel, TextChannel, Message
+from discord.app_commands import errors, Command
 from discord.embeds import Embed
 from discord.errors import NotFound
-from discord.ext.commands import AutoShardedBot as BaseBot
+from discord.ext.commands import AutoShardedBot, Context
+from discord import AutoShardedClient
+from discord.ext.commands._types import BotT
 from discord.ext.commands.errors import CommandNotFound, BadArgument, MissingRequiredArgument, CommandOnCooldown, \
     MissingPermissions, BotMissingPermissions
 
 from lib.config import Config
-from lib.context import CustomContext
 from lib.db import DB
-from lib.progress import Progress
+from lib.errors import BotNotReady
+from lib.progress import Progress, Timer
 from lib.urban import UrbanDictionary
 
 COMMAND_ERROR_REGEX = r"Command raised an exception: (.*?(?=: )): (.*)"
 IGNORE_EXCEPTIONS = (CommandNotFound, BadArgument, RuntimeError)
 
 
-class Bot(BaseBot):
+class Bot(AutoShardedBot):
     def __init__(self, shards: list[int], version: str):
         self.config: Config = Config()
         self.db: DB = DB()
@@ -36,24 +40,26 @@ def __init__(self, shards: list[int], version: str):
         self.shards_ready = False
         self.ready = False
         self.expected_shards = len(shards)
+        self.timer = Timer()
         self.shard_progress = Progress('Shards Ready', self.expected_shards)
         self.urban: UrbanDictionary = UrbanDictionary()
         self.VERSION = version
         super().__init__(
+            command_prefix=None,
             owner_id="507214515641778187",
             shards=shards,
             intents=discord.Intents.all(),
-            debug_guilds=["1064582321728143421"],
             description="Misc Bot used for advanced moderation and guild customization")
         self.tasks.add_job(self.db.commit, trigger='interval', minutes=30)
         self.shard_progress.start()
 
     async def on_connect(self):
-        await self.sync_commands()
+        await self.tree.sync()
         while not self.shards_ready:
             await asyncio.sleep(.5)
-        print(f"Signed into {self.user.display_name}#{self.user.discriminator}")
         self.register_guilds()
+        print(f"Signed into {self.user.display_name}#{self.user.discriminator}")
+        # asyncio.ensure_future(self.timer.start())
 
     async def on_shard_ready(self, shard_id):
         await self.change_presence(activity=discord.Activity(type=discord.ActivityType.watching,
@@ -63,6 +69,34 @@ async def on_shard_ready(self, shard_id):
         if shard_id + 1 == self.expected_shards:
             self.shards_ready = True
 
+    async def on_interaction(self, ctx: Interaction):
+        if isinstance(ctx.command, Command):
+            name_list, options = self.get_name(ctx.data, [])
+            name = " ".join(name_list)
+            self.db.execute(f"""INSERT INTO commands VALUES (?,?,?,?,?)""", name, ctx.guild_id,
+                            ctx.user.id, json.dumps(options), datetime.now().timestamp())
+
+    @staticmethod
+    async def send(ctx: Interaction, *args, **kwargs):
+        if kwargs.get('embed'):
+            embed: Embed = kwargs['embed']
+            if not isinstance(embed.colour, discord.Colour):
+                color = int("0x" + ''.join([random.choice('0123456789ABCDEF') for j in range(6)]), 16)
+                embed.colour = color
+            embed.set_footer(text="Made by Gccody")
+            embed.timestamp = datetime.now()
+            # embed.set_thumbnail(url=self.logo_path)
+            kwargs['embed'] = embed
+        if ctx.is_expired():
+            channel = ctx.channel
+            if not isinstance(channel, VoiceChannel):
+                return await ctx.channel.send(*args, **kwargs)
+        try:
+            await ctx.original_response()
+            return await ctx.followup.send(*args, **kwargs)
+        except NotFound:
+            return await ctx.response.send_message(*args, **kwargs)
+
     def register_guilds(self):
         progress = Progress('Registering guilds', len(self.guilds))
         for guild in self.guilds:
@@ -71,12 +105,6 @@ def register_guilds(self):
         self.db.commit()
         self.ready = True
         self.tasks.start()
-        print('\nEverything is ready!')
-
-    async def get_application_context(
-            self, interaction: Interaction, cls=CustomContext
-    ):
-        return await super().get_application_context(interaction, cls=cls)
 
     async def on_guild_join(self, guild: Guild):
         self.db.execute("""INSERT OR IGNORE INTO guilds VALUES (?,?,?)""", guild.id, None, None)
@@ -105,50 +133,6 @@ def get_name(self, data: Any, groups: list[str]):
                 else:
                     return self.get_name(data.get('options'), [*groups, data.get('name')])
 
-    async def on_interaction(self, interaction: discord.Interaction):
-        if not self.ready: return
-        if interaction.is_command():
-            name_list, options = self.get_name(interaction.data, [])
-            name = " ".join(name_list)
-            self.db.execute(f"""INSERT INTO commands VALUES (?,?,?,?,?)""", name, interaction.guild_id,
-                            interaction.user.id, json.dumps(options), datetime.now().timestamp())
-        return await super().on_interaction(interaction=interaction)
-
-    async def on_application_command_error(self, ctx: CustomContext, exc) -> None:
-        if any([isinstance(exc, error) for error in IGNORE_EXCEPTIONS]):
-            pass
-        elif isinstance(exc, MissingRequiredArgument):
-            await ctx.respond("One or more required arguments are missing.")
-        elif isinstance(exc, CommandOnCooldown):
-            embed: Embed = Embed(title='Command on Cooldown',
-                                 description=f"That command is on cooldown. Try again in {exc.retry_after:,.2f} seconds.",
-                                 colour=0xff0000)
-            await ctx.respond(embed=embed)
-        elif isinstance(exc, MissingPermissions):
-            embed: Embed = Embed(title='You are missing permissions', description=f'>>> {exc}', colour=0xff0000)
-        elif isinstance(exc, BotMissingPermissions):
-            embed: Embed = Embed(title='Bot Missing Permissions', description=f">>> {exc}", colour=0xff0000)
-            await ctx.respond(embed=embed)
-        elif isinstance(exc, HTTPException):
-            embed: Embed = Embed(title="Http Error", description='Message failed to send', colour=0xff0000)
-            await ctx.respond(embed=embed)
-        elif isinstance(exc, NotFound):
-            await ctx.respond(embed=Embed(title='Not Found Error', description='One or more items could not be found.',
-                                          colour=0xff0000))
-        elif hasattr(exc, "original"):
-            if isinstance(exc.original, HTTPException):
-                embed: Embed = Embed(title="Http Error", description='Message failed to send', colour=0xff0000)
-                await ctx.respond(embed=embed)
-            if isinstance(exc.original, discord.Forbidden):
-                await ctx.message.delete()
-                embed: Embed = Embed(title='Forbidden Error', description='Insufficient Permissions', colour=0xff0000)
-                await ctx.respond(embed=embed)
-            else:
-                raise exc.original
-
-        else:
-            raise exc
-
     @staticmethod
     async def cpu_percent(interval=None, *args, **kwargs):
         python_process = psutil.Process(os.getpid())

lib/cogs/Announce.py renamed to lib/cogs/Announcment.py

@@ -1,46 +1,50 @@
+from typing import Optional
+
 import discord
-from discord.ext.commands import Cog, has_guild_permissions, bot_has_guild_permissions
-from discord.commands import SlashCommandGroup, option
+from discord import app_commands, Interaction
 from discord.channel import TextChannel
 from discord.embeds import Embed
+from discord.ext.commands import Cog, has_guild_permissions, bot_has_guild_permissions
 
 from lib.bot import Bot
-from lib.context import CustomContext
 
 
 class Announce(Cog):
+    announce = app_commands.Group(name='announcements', description='Enable and disable announcements')
+
     def __init__(self, bot):
         self.bot: Bot = bot
 
-    announce = SlashCommandGroup('announcements')
-
     @staticmethod
     def get_news(channels: list[TextChannel]) -> TextChannel | None:
         for ch in channels:
             if ch.is_news():
                 return ch
 
     @announce.command(name="enable", description='Enable bot announcements')
-    @option(name='channel',
-            type=discord.TextChannel,
-            description='Bot Announcements Channel',
-            required=False)
+    @app_commands.describe(channel='Bot Announcements Channel')
     @has_guild_permissions(manage_guild=True)
     @bot_has_guild_permissions(send_messages=True)
-    async def announce_enable(self, ctx: CustomContext, channel: discord.TextChannel | None):
+    async def announce_enable(self, ctx: Interaction, channel: Optional[discord.TextChannel]):
         channel = channel if channel is not None else self.get_news(ctx.guild.text_channels)
         if channel is None:
-            return await ctx.respond(Embed(title='Channel Not Found', description=f">>> Can't find an announcements channel to enable", colour=0xff0000))
+            return await ctx.response.send_message(
+                Embed(title=f">>> Can't find an announcements channel to enable", colour=0xff0000))
         if not channel.permissions_for(await ctx.guild.fetch_member(self.bot.user.id)).send_messages:
-            return await ctx.respond(Embed(title='Missing Permissions', description=f">>> I can't send messages in channel: {channel.name} ({channel.id})"))
+            return await ctx.response.send_message(
+                Embed(title=f">>> I can't send messages in channel: {channel.name} ({channel.id})", colour=0xff0000))
         self.bot.db.execute("""UPDATE guilds SET a_id=? WHERE id=?""", channel.id, ctx.guild.id)
-        await ctx.respond(embed=Embed(title='Update Announcments', description=f">>> Successfully Enabled Announcments in {channel.mention} ({channel.id})", colour=0x00ff00))
+        print('here at send')
+        await self.bot.send(ctx, embed=Embed(
+            title=f">>> Successfully Enabled Announcements in {channel.mention} ({channel.id})"))
 
     @announce.command(name='disable', description='Disable bot announcements')
     @has_guild_permissions(manage_guild=True)
-    async def announce_disable(self, ctx: CustomContext):
+    async def announce_disable(self, ctx: Interaction):
         self.bot.db.execute("""UPDATE guilds SET a_id=?""")
+        await self.bot.send(ctx,
+                            embed=Embed(title=f">>> Successfully Disabled Announcements"))
 
 
-def setup(bot):
-    bot.add_cog(Announce(bot))
+async def setup(bot):
+    await bot.add_cog(Announce(bot))