From a935e80fea5530b1c509b6e0e004fdf1298e6883 Mon Sep 17 00:00:00 2001 From: sockheadrps Date: Tue, 9 Jul 2024 00:35:14 -0400 Subject: [PATCH] Added queuemanager to sounds.ext --- docs/changelog.rst | 18 ++++ examples/music_queue.py | 57 +++++++++++ twitchio/ext/sounds/queuemanager.py | 141 ++++++++++++++++++++++++++++ 3 files changed, 216 insertions(+) create mode 100644 examples/music_queue.py create mode 100644 twitchio/ext/sounds/queuemanager.py diff --git a/docs/changelog.rst b/docs/changelog.rst index 14213d7c..930d323a 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -1,6 +1,24 @@ :orphan: +2.10.1 +======= +- ext.sounds + - Additions + - Added :class:`Twitchio.ext.sounds.AudioQueueManager` to manage a queue of audio files to be played sequentially with optional repeat functionality. + - Added :method:`Twitchio.ext.sounds.AudioQueueManager.add_audio` to add a new audio file to the queue. + - Added :method:`Twitchio.ext.sounds.AudioQueueManager.play_next` to play the next audio file in the queue. + - Added :method:`Twitchio.ext.sounds.AudioQueueManager.skip_audio` to stop the currently playing audio file. + - Added :method:`Twitchio.ext.sounds.AudioQueueManager.stop_audio` to stop the currently playing audio file and reset the playing flag. + - Added :method:`Twitchio.ext.sounds.AudioQueueManager.pause_audio` to pause the currently playing audio file. + - Added :method:`Twitchio.ext.sounds.AudioQueueManager.resume_audio` to resume the currently paused audio file. + - Added :method:`Twitchio.ext.sounds.AudioQueueManager.clear_queue` to clear all audio files from the queue. + - Added :method:`Twitchio.ext.sounds.AudioQueueManager.pause_queue` to pause the processing of the queue. + - Added :method:`Twitchio.ext.sounds.AudioQueueManager.resume_queue` to resume the processing of the queue. + - Added :method:`Twitchio.ext.sounds.AudioQueueManager.get_queue_contents` to retrieve the current contents of the queue. + - Added :method:`Twitchio.ext.sounds.AudioQueueManager.queue_loop` to continuously check the queue and play the next audio file if not currently playing and not paused. + + 2.10.0 ======= - TwitchIO diff --git a/examples/music_queue.py b/examples/music_queue.py new file mode 100644 index 00000000..9a332ade --- /dev/null +++ b/examples/music_queue.py @@ -0,0 +1,57 @@ +import asyncio +from twitchio.ext import commands, sounds +from twitchio.ext.sounds import queuemanager + + +class Bot(commands.Bot): + + def __init__(self): + super().__init__(token="TOKEN", prefix="!", initial_channels=["CHANNEL"]) + self.audio_manager = queuemanager.AudioQueueManager() + + # Adding sound files paths to the queue for uses to choose from + song_dict = { + "song_one": "\\PATH\\TO\\FILE.mp3", + "song_two": "\\PATH\\TO\\FILE.mp3", + "song_three": "\\PATH\\TO\\FILE.mp3", + } + + async def event_ready(self): + loop = asyncio.get_event_loop() + + # Start the queue loop + self.task = loop.create_task(self.audio_manager.queue_loop()) + + @commands.command(name="sr") + async def addsound(self, ctx: commands.Context, sound: str): + sound_path = self.song_dict[sound] + await self.audio_manager.add_audio(sound_path) + await ctx.send(f"Added sound to queue: {sound_path}") + + @commands.command(name="skip") + async def skip(self, ctx: commands.Context): + await ctx.send(f"Skipped the current sound. {self.audio_manager.current_sound}") + await self.audio_manager.skip_audio() + + @commands.command(name="pause") + async def pause(self, ctx: commands.Context): + await self.audio_manager.pause_audio() + + @commands.command(name="resume") + async def resume(self, ctx: commands.Context): + await self.audio_manager.resume_audio() + + @commands.command(name="queue") + async def queue(self, ctx: commands.Context): + queue_contents = await self.audio_manager.get_queue_contents() + await ctx.send(f"Queue contents: {queue_contents}") + + # Override close method to gracefully cancel the task + async def close(self): + self.task.cancel() + await super().close() + + +if __name__ == "__main__": + bot = Bot() + bot.run() diff --git a/twitchio/ext/sounds/queuemanager.py b/twitchio/ext/sounds/queuemanager.py new file mode 100644 index 00000000..c0c1cb59 --- /dev/null +++ b/twitchio/ext/sounds/queuemanager.py @@ -0,0 +1,141 @@ +import asyncio +from twitchio.ext import sounds + + +class AudioQueueManager: + """ + Manages a queue of audio files to be played sequentially with optional repeat and pause functionalities. + + Attributes: + queue (asyncio.Queue[str]): A queue to hold paths of audio files to be played. + is_playing (bool): Indicates whether an audio file is currently being played. + repeat_queue (bool): If True, adds the current playing audio file back to the queue after playing. + queue_paused (bool): If True, pauses the processing of the queue. + player (sounds.AudioPlayer): An instance of AudioPlayer to play audio files. + current_sound (str): Path of the currently playing audio file. + """ + + def __init__(self): + """ + Initializes an instance of AudioQueueManager with an empty queue and default settings. + """ + self.queue: asyncio.Queue[str] = asyncio.Queue() + self.is_playing: bool = False + self.repeat_queue: bool = True + self.queue_paused: bool = False + self.player: sounds.AudioPlayer = sounds.AudioPlayer( + callback=self.player_done) + self.current_sound: str = "" + + async def player_done(self) -> None: + """ + Callback method called when the player finishes playing an audio file. + Resets the is_playing flag and marks the current task as done in the queue. + """ + await asyncio.sleep(0.1) + self.is_playing = False + self.queue.task_done() + + async def add_audio(self, sound_path: str) -> None: + """ + Adds a new audio file to the queue. + + Args: + sound_path (str): Path of the audio file to add to the queue. + """ + await asyncio.sleep(0.1) + await self.queue.put(sound_path) + + async def play_next(self) -> None: + """ + Plays the next audio file in the queue if the queue is not empty and not paused. + Sets the is_playing flag, retrieves the next audio file from the queue, and plays it. + If repeat_queue is True, adds the current audio file back to the queue after playing. + """ + await asyncio.sleep(0.1) + if not self.queue.empty() and not self.queue_paused: + self.is_playing = True + sound_path = await self.queue.get() + self.current_sound = sound_path + sound = sounds.Sound(source=sound_path) + self.player.play(sound) + if self.repeat_queue: + await self.queue.put(self.current_sound) + + async def skip_audio(self) -> None: + """ + Stops the currently playing audio file if there is one. + """ + await asyncio.sleep(0.1) + if self.is_playing: + self.player.stop() + self.is_playing = False + + async def stop_audio(self) -> None: + """ + Stops the currently playing audio file. + Resets the playing flag but leaves the queue intact. + """ + await asyncio.sleep(0.1) + if self.is_playing: + self.player.stop() + self.is_playing = False + + async def pause_audio(self) -> None: + """ + Pauses the currently playing audio file. + """ + await asyncio.sleep(0.1) + self.player.pause() + + async def resume_audio(self) -> None: + """ + Resumes the currently paused audio file. + """ + await asyncio.sleep(0.1) + self.player.resume() + + async def clear_queue(self) -> None: + """ + Clears all audio files from the queue. + """ + await asyncio.sleep(0.1) + while not self.queue.empty(): + await self.queue.get() + self.queue.task_done() + + async def pause_queue(self) -> None: + """ + Pauses the processing of the queue. + """ + await asyncio.sleep(0.1) + self.queue_paused = True + + async def resume_queue(self) -> None: + """ + Resumes the processing of the queue. + """ + await asyncio.sleep(0.1) + self.queue_paused = False + + async def get_queue_contents(self) -> list: + """ + Retrieves the current contents of the queue. + + Returns: + list: List of paths of audio files in the queue. + """ + await asyncio.sleep(0.1) + return list(self.queue._queue) + + async def queue_loop(self) -> None: + """ + Continuously checks the queue and plays the next audio file if not currently playing and not paused. + """ + try: + while True: + await asyncio.sleep(0.2) + if not self.is_playing and not self.queue.empty() and not self.queue_paused: + await self.play_next() + finally: + return