Adapting History, Loop, Now Playing, Remove, Shuffle and Reset commands to work with process

Handlers/HistoryHandler.py

@@ -3,6 +3,7 @@ from discord import Client
 from Handlers.AbstractHandler import AbstractHandler
 from Handlers.HandlerResponse import HandlerResponse
 from Utils.Utils import Utils
+from Parallelism.ProcessManager import ProcessManager
 
 
 class HistoryHandler(AbstractHandler):
@@ -10,11 +11,18 @@ class HistoryHandler(AbstractHandler):
         super().__init__(ctx, bot)
 
     async def run(self) -> HandlerResponse:
-        history = self.player.playlist.getSongsHistory()
+        # Get the current process of the guild
+        processManager = ProcessManager()
+        processContext = processManager.getRunningPlayerContext(self.guild)
+        if processContext:
+            with processContext.getLock():
+                playlist = processContext.getPlaylist()
+                history = playlist.getSongsHistory()
+        else:
+            history = []
 
         if len(history) == 0:
             text = self.messages.HISTORY_EMPTY
-
         else:
             text = f'\n📜 History Length: {len(history)} | Max: {self.config.MAX_SONGS_HISTORY}\n'
             for pos, song in enumerate(history, start=1):

Handlers/LoopHandler.py

@@ -3,6 +3,7 @@ from discord import Client
 from Handlers.AbstractHandler import AbstractHandler
 from Handlers.HandlerResponse import HandlerResponse
 from Config.Exceptions import BadCommandUsage
+from Parallelism.ProcessManager import ProcessManager
 
 
 class LoopHandler(AbstractHandler):
@@ -10,30 +11,41 @@ class LoopHandler(AbstractHandler):
         super().__init__(ctx, bot)
 
     async def run(self, args: str) -> HandlerResponse:
-        if args == '' or args is None:
-            self.player.playlist.loop_all()
-            embed = self.embeds.LOOP_ALL_ACTIVATED()
-            return HandlerResponse(self.ctx, embed)
-
-        args = args.lower()
-        if self.player.playlist.getCurrentSong() is None:
+        # Get the current process of the guild
+        processManager = ProcessManager()
+        processContext = processManager.getRunningPlayerContext(self.guild)
+        if not processContext:
             embed = self.embeds.NOT_PLAYING()
             error = BadCommandUsage()
             return HandlerResponse(self.ctx, embed, error)
 
-        if args == 'one':
-            self.player.playlist.loop_one()
-            embed = self.embeds.LOOP_ONE_ACTIVATED()
-            return HandlerResponse(self.ctx, embed)
-        elif args == 'all':
-            self.player.playlist.loop_all()
-            embed = self.embeds.LOOP_ALL_ACTIVATED()
-            return HandlerResponse(self.ctx, embed)
-        elif args == 'off':
-            self.player.playlist.loop_off()
-            embed = self.embeds.LOOP_DISABLE()
-            return HandlerResponse(self.ctx, embed)
-        else:
-            error = BadCommandUsage()
-            embed = self.embeds.BAD_LOOP_USE()
-            return HandlerResponse(self.ctx, embed, error)
+        playlist = processContext.getPlaylist()
+
+        with processContext.getLock():
+            if args == '' or args is None:
+                playlist.loop_all()
+                embed = self.embeds.LOOP_ALL_ACTIVATED()
+                return HandlerResponse(self.ctx, embed)
+
+            args = args.lower()
+            if playlist.getCurrentSong() is None:
+                embed = self.embeds.NOT_PLAYING()
+                error = BadCommandUsage()
+                return HandlerResponse(self.ctx, embed, error)
+
+            if args == 'one':
+                playlist.loop_one()
+                embed = self.embeds.LOOP_ONE_ACTIVATED()
+                return HandlerResponse(self.ctx, embed)
+            elif args == 'all':
+                playlist.loop_all()
+                embed = self.embeds.LOOP_ALL_ACTIVATED()
+                return HandlerResponse(self.ctx, embed)
+            elif args == 'off':
+                playlist.loop_off()
+                embed = self.embeds.LOOP_DISABLE()
+                return HandlerResponse(self.ctx, embed)
+            else:
+                error = BadCommandUsage()
+                embed = self.embeds.BAD_LOOP_USE()
+                return HandlerResponse(self.ctx, embed, error)

Handlers/NowPlayingHandler.py

@@ -3,6 +3,7 @@ from discord import Client
 from Handlers.AbstractHandler import AbstractHandler
 from Handlers.HandlerResponse import HandlerResponse
 from Utils.Cleaner import Cleaner
+from Parallelism.ProcessManager import ProcessManager
 
 
 class NowPlayingHandler(AbstractHandler):
@@ -11,16 +12,24 @@ class NowPlayingHandler(AbstractHandler):
         self.__cleaner = Cleaner()
 
     async def run(self) -> HandlerResponse:
-        if not self.player.playing:
+        # Get the current process of the guild
+        processManager = ProcessManager()
+        processContext = processManager.getRunningPlayerContext(self.guild)
+        if not processContext:
             embed = self.embeds.NOT_PLAYING()
             return HandlerResponse(self.ctx, embed)
 
-        if self.player.playlist.isLoopingOne():
+        playlist = processContext.getPlaylist()
+        if playlist.getCurrentSong() is None:
+            embed = self.embeds.NOT_PLAYING()
+            return HandlerResponse(self.ctx, embed)
+
+        if playlist.isLoopingOne():
             title = self.messages.ONE_SONG_LOOPING
         else:
             title = self.messages.SONG_PLAYING
         await self.__cleaner.clean_messages(self.ctx, self.config.CLEANER_MESSAGES_QUANT)
 
-        info = self.player.playlist.getCurrentSong().info
+        info = playlist.getCurrentSong().info
         embed = self.embeds.SONG_INFO(info, title)
         return HandlerResponse(self.ctx, embed)

Handlers/PlayHandler.py

@@ -58,7 +58,7 @@ class PlayHandler(AbstractHandler):
                 response = HandlerResponse(self.ctx, embed)
 
             # Get the process context for the current guild
-            manager = ProcessManager(self.bot)
+            manager = ProcessManager()
             processContext = manager.getPlayerContext(self.guild, self.ctx)
             # Add the downloaded song to the process playlist
             # All access to shared memory should be protect by acquire the Lock

Handlers/RemoveHandler.py

@@ -4,6 +4,8 @@ from discord import Client
 from Handlers.AbstractHandler import AbstractHandler
 from Handlers.HandlerResponse import HandlerResponse
 from Config.Exceptions import BadCommandUsage, VulkanError, ErrorRemoving, InvalidInput, NumberRequired
+from Music.Playlist import Playlist
+from Parallelism.ProcessManager import ProcessManager
 
 
 class RemoveHandler(AbstractHandler):
@@ -11,24 +13,34 @@ class RemoveHandler(AbstractHandler):
         super().__init__(ctx, bot)
 
     async def run(self, position: str) -> HandlerResponse:
-        if not self.player.playlist:
+        # Get the current process of the guild
+        processManager = ProcessManager()
+        processContext = processManager.getRunningPlayerContext(self.guild)
+        if not processContext:
+            # Clear the playlist
             embed = self.embeds.NOT_PLAYING()
             error = BadCommandUsage()
             return HandlerResponse(self.ctx, embed, error)
 
-        error = self.__validate_input(position)
+        playlist = processContext.getPlaylist()
+        if playlist.getCurrentSong() is None:
+            embed = self.embeds.NOT_PLAYING()
+            error = BadCommandUsage()
+            return HandlerResponse(self.ctx, embed, error)
+
+        error = self.__validateInput(position)
         if error:
             embed = self.embeds.ERROR_EMBED(error.message)
             return HandlerResponse(self.ctx, embed, error)
 
-        position = self.__sanitize_input(position)
-        if not self.player.playlist.validate_position(position):
+        position = self.__sanitizeInput(playlist, position)
+        if not playlist.validate_position(position):
             error = InvalidInput()
             embed = self.embeds.PLAYLIST_RANGE_ERROR()
             return HandlerResponse(self.ctx, embed, error)
 
         try:
-            song = self.player.playlist.remove_song(position)
+            song = playlist.remove_song(position)
             name = song.title if song.title else song.identifier
 
             embed = self.embeds.SONG_REMOVED(name)
@@ -38,15 +50,15 @@ class RemoveHandler(AbstractHandler):
             embed = self.embeds.ERROR_REMOVING()
             return HandlerResponse(self.ctx, embed, error)
 
-    def __validate_input(self, position: str) -> Union[VulkanError, None]:
+    def __validateInput(self, position: str) -> Union[VulkanError, None]:
         try:
             position = int(position)
         except:
             return NumberRequired(self.messages.ERROR_NUMBER)
 
-    def __sanitize_input(self, position: str) -> int:
+    def __sanitizeInput(self, playlist: Playlist, position: str) -> int:
         position = int(position)
 
         if position == -1:
-            position = len(self.player.playlist)
+            position = len(playlist)
         return position

Handlers/ResetHandler.py

@@ -2,19 +2,21 @@ from discord.ext.commands import Context
 from discord import Client
 from Handlers.AbstractHandler import AbstractHandler
 from Handlers.HandlerResponse import HandlerResponse
-from Handlers.PlayersController import PlayersController
+from Parallelism.ProcessManager import ProcessManager
+from Parallelism.Commands import VCommands, VCommandsType
 
 
 class ResetHandler(AbstractHandler):
     def __init__(self, ctx: Context, bot: Client) -> None:
         super().__init__(ctx, bot)
-        self.__controller = PlayersController(self.bot)
 
     async def run(self) -> HandlerResponse:
-        try:
-            await self.player.force_stop()
-            await self.bot_member.move_to(None)
-            self.__controller.reset_player(self.guild)
-            return HandlerResponse(self.ctx)
-        except Exception as e:
-            print(f'DEVELOPER NOTE -> Reset Error: {e}')
+        # Get the current process of the guild
+        processManager = ProcessManager()
+        processContext = processManager.getRunningPlayerContext(self.guild)
+        if processContext:
+            command = VCommands(VCommandsType.RESET, None)
+            queue = processContext.getQueue()
+            queue.put(command)
+
+        return HandlerResponse(self.ctx)

Handlers/ShuffleHandler.py

@@ -1,27 +1,33 @@
-import asyncio
 from discord.ext.commands import Context
 from discord import Client
 from Handlers.AbstractHandler import AbstractHandler
 from Handlers.HandlerResponse import HandlerResponse
 from Config.Exceptions import UnknownError
-from Music.Downloader import Downloader
+from Parallelism.ProcessManager import ProcessManager
 
 
 class ShuffleHandler(AbstractHandler):
     def __init__(self, ctx: Context, bot: Client) -> None:
         super().__init__(ctx, bot)
-        self.__down = Downloader()
 
     async def run(self) -> HandlerResponse:
-        try:
-            self.player.playlist.shuffle()
-            songs = self.player.playlist.getSongsToPreload()
+        processManager = ProcessManager()
+        processContext = processManager.getRunningPlayerContext(self.guild)
+        if processContext:
+            try:
+                with processContext.getLock():
+                    playlist = processContext.getPlaylist()
+                    playlist.shuffle()
 
-            asyncio.create_task(self.__down.preload(songs))
-            embed = self.embeds.SONGS_SHUFFLED()
+                embed = self.embeds.SONGS_SHUFFLED()
+                return HandlerResponse(self.ctx, embed)
+
+            except Exception as e:
+                print(f'DEVELOPER NOTE -> Error Shuffling: {e}')
+                error = UnknownError()
+                embed = self.embeds.ERROR_SHUFFLING()
+
+                return HandlerResponse(self.ctx, embed, error)
+        else:
+            embed = self.embeds.NOT_PLAYING()
             return HandlerResponse(self.ctx, embed)
-        except Exception as e:
-            print(f'DEVELOPER NOTE -> Error Shuffling: {e}')
-            error = UnknownError()
-            embed = self.embeds.ERROR_SHUFFLING()
-            return HandlerResponse(self.ctx, embed, error)