Partial migration to dpy, music cog

bot.py

@@ -15,12 +15,15 @@ from discord import ActivityType
 from discord import Message
 from discord.colour import Color
 from discord.ext import commands
+from discord import app_commands
 from discord.ext import tasks
 from discord.ext.commands.errors import ExtensionAlreadyLoaded
 from discord.ext.commands.errors import ExtensionFailed
 from discord.ext.commands.errors import ExtensionNotFound
 from discord.ext.commands.errors import NoEntryPointError
 
+from utils.assets import process_colours
+from utils.log import logger
 from context import CustomContext
 from tunebot.redis import GlobalRedisAutoJoin
 from tunebot.redis import GlobalRedisPlaylist
@@ -32,8 +35,17 @@ if TYPE_CHECKING:
     from tunebot import GlobalAutoJoin
 
 
+config_path = "config.json"
+if len(sys.argv) > 1:
+    config_path = sys.argv[1]
+
+config = json.load(open(config_path, "r", encoding="utf-8"))
+redis_prefix = config["redis_prefix"]
+colors: Dict[str, Color] = process_colours(config["colors"])
+
+
 class TuneBot(commands.Bot):
-    lavalink: lavalink.Client
+    lavalink: "lavalink.Client"
     invite_link: str
 
     def __init__(self, config: Dict[Any, Any]):
@@ -42,11 +54,9 @@ class TuneBot(commands.Bot):
         )
 
         self.rpc_is_help_message = True
-        self.update_status.start()
 
         self.config = config
         self.initial_cog_names: List[str] = self.config.get("cogs", [])
-        self.colors: Dict[str, Color] = self.process_colours(config.get("colors", []))
 
         self.redis_prefix = self.config["redis_prefix"]
         self._redis_client: Redis = aioredis.from_url(
@@ -68,9 +78,7 @@ class TuneBot(commands.Bot):
 
         self.invite_link: str = ""
 
-        slash_guilds = None
-        if len(self.config["slash_command_guilds"]) > 0:
-            slash_guilds = self.config["slash_command_guilds"]
+        self.colors = colors
 
         super().__init__(
             command_prefix=self.prefix_callable,
@@ -79,49 +87,51 @@ class TuneBot(commands.Bot):
             case_insensitive=False,
             fetch_offline_members=False,
             intents=intents,
-            slash_commands=True,
-            slash_command_guilds=slash_guilds,
         )
 
-        self.loop.create_task(self.async_init())
-
-    async def async_init(self):
+    async def setup_hook(self) -> None:
         await self.load_cogs(self.initial_cog_names)
+        self.update_status.start()
 
-    async def prefix_callable(self, _, msg: Message) -> List[str]:
+    async def prefix_callable(self, _, msg: Message):
+        logger.info(f"{self.config['prefixes']=}")
         return commands.when_mentioned_or(*self.config["prefixes"])(self, msg)
 
     async def load_cogs(self, cog_names: Sequence[str]):
         for cog in cog_names:
             try:
-                self.load_extension(cog)
-                print(f"Succesfully loaded extension {cog}.")
+                await self.load_extension(cog)
+                logger.info(f"Succesfully loaded extension {cog}.")
             except (
                 ExtensionNotFound,
                 ExtensionAlreadyLoaded,
                 NoEntryPointError,
                 ExtensionFailed,
             ) as e:
-                print(f"Failed to load extension {cog}.\n\t{e}", file=sys.stderr)
+                logger.info(f"Failed to load extension {cog}.\n\t{e}")
+
+        await self.tree.sync()
 
     async def on_ready(self):
         self.invite_link = f"https://discord.com/oauth2/authorize?client_id={self.user.id}&permissions=3230720&scope=bot%20applications.commands"
 
-        print(f"Logged in as: {self.user}")
-        print(f"Version: {discord.__version__}")
-        print(f"Invite: {self.invite_link}")
+        logger.info(f"Logged in as: {self.user}")
+        logger.info(f"Version: {discord.__version__}")
+        logger.info(f"Invite: {self.invite_link}")
 
-        ll = self.config["lavalink"]
-        self.lavalink = lavalink.Client(self.user.id)
-        self.lavalink.add_node(
-            ll["host"], ll["port"], ll["password"], ll["region"], ll["name"]
+        self.lavalink = self.create_lavalink(self.user.id)
+
+    def create_lavalink(self, user_id: int) -> "lavalink.Client":
+        cfg = self.config["lavalink"]
+        client: lavalink.Client = lavalink.Client(user_id)
+        client.add_node(
+            cfg["host"],
+            cfg["port"],
+            cfg["password"],
+            cfg["region"],
+            cfg["name"],
         )
-
-    def process_colours(self, colors: Dict[str, str]) -> Dict[str, Color]:
-        colour_dict: Dict[str, Color] = {}
-        for name, color in colors.items():
-            colour_dict[name] = Color(int(color, 16))
-        return colour_dict
+        return client
 
     async def get_context(self, message: Message, *, cls=CustomContext):
         return await super().get_context(message, cls=cls)
@@ -141,21 +151,16 @@ class TuneBot(commands.Bot):
         await self.change_presence(activity=activity)
 
 
-config_path = "config.json"
-if len(sys.argv) > 1:
-    config_path = sys.argv[1]
-
-config = json.load(open(config_path, "r", encoding="utf-8"))
-redis_prefix = config["redis_prefix"]
+client = TuneBot(config)
 
 if __name__ == "__main__":
     try:
         import uvloop
 
         uvloop.install()
-        print("Succesfully initialized uvloop")
+        logger.info("Succesfully initialized uvloop")
     except ModuleNotFoundError:
         pass
 
     token = config.pop("token")
-    TuneBot(config).run(token, reconnect=True)
+    client.run(token, reconnect=True)