refactor: make players and songs object-oriented

arguments.py

@@ -17,8 +17,11 @@ class ArgumentParser:
             self.parser.print_help()
         return help_buffer.getvalue().replace(" and exit", "")
 
+    def add_mutually_exclusive_group(self, *args, **kwargs):
+        return self.parser.add_mutually_exclusive_group(*args, **kwargs)
+
     def add_argument(self, *args, **kwargs):
-        self.parser.add_argument(*args, **kwargs)
+        return self.parser.add_argument(*args, **kwargs)
 
     async def parse_args(self, message, tokens) -> argparse.Namespace | None:
         try:

commands/tools.py

@@ -1,6 +1,7 @@
 import re
 
 import arguments
+
 import commands
 import utils
 

commands/utils.py

@@ -39,30 +39,30 @@ def match(command: str) -> None | list[Command]:
 
 def tokenize(string: str) -> list[str]:
     tokens = []
-    current_token = []
+    token = ""
     in_quotes = False
-    escape_next = False
+    quote_char = None
+    escape = False
 
     for char in string[len(constants.PREFIX) :]:
-        if escape_next:
+        if escape:
-            current_token.append(char)
+            token += char
-            escape_next = False
+            escape = False
         elif char == "\\":
-            escape_next = True
+            escape = True
-        elif char in ['"', "'"]:
+        elif char in ('"', "'") and not in_quotes:
-            if in_quotes:
-                if current_token and current_token[0] == char:
-                    in_quotes = False
-            else:
             in_quotes = True
+            quote_char = char
+        elif char == quote_char and in_quotes:
+            in_quotes = False
+            quote_char = None
         elif char.isspace() and not in_quotes:
-            if current_token:
+            if token:
-                tokens.append("".join(current_token))
+                tokens.append(token)
-                current_token = []
+                token = ""
         else:
-            current_token.append(char)
+            token += char
-
-    if current_token:
-        tokens.append("".join(current_token))
 
+    if token:
+        tokens.append(token)
     return tokens

commands/voice.py

@@ -4,7 +4,7 @@ import arguments
 import commands
 import utils
 import youtubedl
-from state import client, player_current, player_queue
+from state import client, players
 
 
 async def queue_or_play(message):
@@ -12,21 +12,16 @@ async def queue_or_play(message):
     if not command_allowed(message):
         return
 
-    if message.guild.id not in player_queue:
+    if message.guild.id not in players:
-        player_queue[message.guild.id] = []
+        players[message.guild.id] = youtubedl.QueuedPlayer()
 
     tokens = commands.tokenize(message.content)
     parser = arguments.ArgumentParser(
         tokens[0], "queue a song, list the queue, or resume playback"
     )
     parser.add_argument("query", nargs="?", help="yt-dlp URL or query to get song")
-    parser.add_argument(
+    group = parser.add_mutually_exclusive_group()
-        "-c",
+    group.add_argument(
-        "--clear",
-        action="store_true",
-        help="clear all queued songs",
-    )
-    parser.add_argument(
         "-v",
         "--volume",
         default=50,
@@ -34,13 +29,68 @@ async def queue_or_play(message):
         metavar="[0-150]",
         help="the volume level (0 - 150)",
     )
+    group.add_argument(
+        "-i",
+        "--remove-index",
+        type=int,
+        help="remove a queued song by index",
+    )
+    group.add_argument(
+        "-m",
+        "--remove-multiple",
+        action="store_true",
+        help="continue removing queued songs after finding a match",
+    )
+    group.add_argument(
+        "-c",
+        "--clear",
+        action="store_true",
+        help="remove all queued songs",
+    )
+    parser.add_argument(
+        "-t",
+        "--remove-title",
+        help="remove queued songs by title",
+    )
+    parser.add_argument(
+        "-q",
+        "--remove-queuer",
+        type=int,
+        help="remove queued songs by queuer",
+    )
     if not (args := await parser.parse_args(message, tokens)):
         return
 
     if args.clear:
-        player_queue[message.guild.id] = []
+        players[message.guild.id].queue.clear()
         await utils.add_check_reaction(message)
         return
+    elif i := args.remove_index:
+        try:
+            queued = players[message.guild.id].queue[i - 1]
+            del players[message.guild.id].queue[i - 1]
+            await utils.reply(message, f"**x** {queued.format()}")
+        except:
+            await utils.reply(message, "invalid index!")
+    elif args.remove_title or args.remove_queuer:
+        targets = []
+        for queued in players[message.guild.id].queue:
+            if t := args.remove_title:
+                if t in queued.player.title:
+                    targets.append(queued)
+                    continue
+            if q := args.remove_queuer:
+                if q == queued.queuer:
+                    targets.append(queued)
+        if args.remove_multiple:
+            targets = targets[:1]
+
+        for target in targets:
+            players[message.guild.id].queue.remove(target)
+        await utils.reply(
+            message,
+            f"removed **{len(targets)}** queued {'song' if len(targets) == 1 else 'songs'}",
+        )
     elif query := args.query:
         try:
             async with message.channel.typing():
@@ -55,23 +105,21 @@ async def queue_or_play(message):
             )
             return
 
-        player_queue[message.guild.id].insert(
+        queued = youtubedl.QueuedSong(player, message.author.id)
-            0, {"player": player, "queuer": message.author.id}
+        players[message.guild.id].queue_add(queued)
-        )
 
         if (
             not message.guild.voice_client.is_playing()
             and not message.guild.voice_client.is_paused()
         ):
-            await utils.reply(message, f"**now playing:** `{player.title}`")
+            await utils.reply(message, f"**0.** {queued.format()}")
             play_next(message)
         else:
             await utils.reply(
                 message,
-                f"**+** `{player.title}`",
+                f"**+** {queued.format()}",
             )
     else:
-        if message.guild.voice_client:
         if tokens[0].lower() == "play":
             message.guild.voice_client.resume()
             await utils.reply(
@@ -79,35 +127,34 @@ async def queue_or_play(message):
                 "resumed!",
             )
         else:
-                generate_currently_playing = (
+            currently_playing = (
-                    lambda: f"**0.** {'**paused:** ' if message.guild.voice_client.is_paused() else ''}`{message.guild.voice_client.source.title}` (<@{player_current[message.guild.id]['queuer']}>)"
+                lambda: f"**0.** {'(paused) ' if message.guild.voice_client.is_paused() else ''} {players[message.guild.id].current.format(with_queuer=True)}"
+            )
+            queue_list = lambda: "\n".join(
+                [
+                    f"**{i + 1}.** {queued.format(with_queuer=True, hide_preview=True)}"
+                    for i, queued in enumerate(players[message.guild.id].queue)
+                ]
             )
             if (
-                    not player_queue[message.guild.id]
+                not players[message.guild.id].queue
                 and not message.guild.voice_client.source
             ):
                 await utils.reply(
                     message,
                     "nothing is playing or queued!",
                 )
-                elif not player_queue[message.guild.id]:
+            elif not players[message.guild.id].queue:
-                    await utils.reply(message, generate_currently_playing())
+                await utils.reply(message, currently_playing())
             elif not message.guild.voice_client.source:
                 await utils.reply(
                     message,
-                        generate_queue_list(player_queue[message.guild.id]),
+                    queue_list(),
                 )
             else:
                 await utils.reply(
                     message,
-                        generate_currently_playing()
+                    currently_playing() + "\n" + queue_list(),
-                        + "\n"
-                        + generate_queue_list(player_queue[message.guild.id]),
-                    )
-        else:
-            await utils.reply(
-                message,
-                "nothing is currently queued!",
                 )
 
 
@@ -115,7 +162,7 @@ async def skip(message):
     if not command_allowed(message):
         return
 
-    if not player_queue[message.guild.id]:
+    if not players[message.guild.id].queue:
         message.guild.voice_client.stop()
         await utils.reply(
             message,
@@ -144,10 +191,13 @@ async def resume(message):
     if not command_allowed(message):
         return
 
+    if message.guild.voice_client.is_paused():
         message.guild.voice_client.resume()
+        await utils.add_check_reaction(message)
+    else:
         await utils.reply(
             message,
-        "resumed!",
+            "nothing is paused!",
         )
 
 
@@ -155,10 +205,13 @@ async def pause(message):
     if not command_allowed(message):
         return
 
+    if message.guild.voice_client.is_playing():
         message.guild.voice_client.pause()
+        await utils.add_check_reaction(message)
+    else:
         await utils.reply(
             message,
-        "paused!",
+            "nothing is playing!",
         )
 
 
@@ -184,7 +237,7 @@ async def volume(message):
     if not message.guild.voice_client.source:
         await utils.reply(
             message,
-            f"there is no player currently active!",
+            f"nothing is playing!",
         )
         return
 
@@ -198,13 +251,19 @@ async def volume(message):
         await utils.add_check_reaction(message)
 
 
+def play_after_callback(e, message, once):
+    if e:
+        print(f"player error: {e}")
+    if not once:
+        play_next(message)
+
+
 def play_next(message, once=False):
     message.guild.voice_client.stop()
-    if player_queue[message.guild.id]:
+    if players[message.guild.id].queue:
-        queued = player_queue[message.guild.id].pop()
+        queued = players[message.guild.id].queue_pop()
-        player_current[message.guild.id] = queued
         message.guild.voice_client.play(
-            queued["player"], after=lambda _: play_next(message) if not once else None
+            queued.player, after=lambda e: play_after_callback(e, message, once)
         )
 
 
@@ -220,12 +279,3 @@ def command_allowed(message):
     if not message.guild.voice_client:
         return False
     return message.author.voice.channel.id == message.guild.voice_client.channel.id
-
-
-def generate_queue_list(queue: list):
-    return "\n".join(
-        [
-            f"**{i + 1}.** `{queued['player'].title}` (<@{queued['queuer']}>)"
-            for i, queued in enumerate(queue)
-        ]
-    )

constants.py

@@ -13,6 +13,7 @@ RELOADABLE_MODULES = [
     "constants",
     "core",
     "events",
+    "player",
     "utils",
     "voice",
     "youtubedl",

core.py

@@ -30,6 +30,9 @@ async def on_message(message):
         )
         return
 
+    if message.guild.id not in command_locks:
+        command_locks[message.guild.id] = asyncio.Lock()
+
     C = commands.Command
     try:
         match matched[0]:
@@ -95,8 +98,6 @@ async def on_message(message):
             case C.LEAVE:
                 await commands.voice.leave(message)
             case C.QUEUE | C.PLAY:
-                if message.guild.id not in command_locks:
-                    command_locks[message.guild.id] = asyncio.Lock()
                 async with command_locks[message.guild.id]:
                     await commands.voice.queue_or_play(message)
             case C.SKIP:

state.py

@@ -2,8 +2,7 @@ import time
 
 import disnake
 
-player_queue = {}
+players = {}
-player_current = {}
 command_locks = {}
 
 intents = disnake.Intents.default()

youtubedl.py

@@ -14,7 +14,9 @@ class YTDLSource(disnake.PCMVolumeTransformer):
         self, source: disnake.AudioSource, *, data: dict[str, Any], volume: float = 0.5
     ):
         super().__init__(source, volume)
+        print(data)
         self.title = data.get("title")
+        self.original_url = data.get("original_url")
 
     @classmethod
     async def from_url(
@@ -41,6 +43,33 @@ class YTDLSource(disnake.PCMVolumeTransformer):
         )
 
 
+class QueuedPlayer:
+    def __init__(self):
+        self.queue = []
+        self.current = None
+
+    def queue_pop(self):
+        popped = self.queue[0]
+        del self.queue[0]
+        self.current = popped
+        return popped
+
+    def queue_add(self, item):
+        self.queue.append(item)
+
+
+class QueuedSong:
+    def __init__(self, player, queuer):
+        self.player = player
+        self.queuer = queuer
+
+    def format(self, with_queuer=False, hide_preview=False):
+        return (
+            f"[`{self.player.title}`]({'<' if hide_preview else ''}{self.player.original_url}{'>' if hide_preview else ''})"
+            + (f" (<@{self.queuer}>)" if with_queuer else "")
+        )
+
+
 def __reload_module__():
     global ytdl
     ytdl = yt_dlp.YoutubeDL(constants.YTDL_OPTIONS)