From cabc517861f6e15cac230283ef0d3d924bbaf716 Mon Sep 17 00:00:00 2001
From: Stefano Pigozzi <ste.pigozzi@gmail.com>
Date: Wed, 28 Nov 2018 14:47:08 +0000
Subject: [PATCH 1/9] WIP: new queue

---
 discordbot.py       | 138 +++++++++++++++++++++++++++++---------------
 template_config.ini |   1 +
 2 files changed, 94 insertions(+), 45 deletions(-)

diff --git a/discordbot.py b/discordbot.py
index d4fbb07e..1ddee98b 100644
--- a/discordbot.py
+++ b/discordbot.py
@@ -20,6 +20,7 @@ import datetime
 import sqlalchemy.exc
 import coloredlogs
 import errors
+import math
 
 logging.getLogger().disabled = True
 logger = logging.getLogger(__name__)
@@ -51,10 +52,6 @@ zalgo_middle = ['̕', '̛', '̀', '́', '͘', '̡', '̢', '̧', '̨', '̴', '̵'
 # Init the event loop
 loop = asyncio.get_event_loop()
 
-# Init the config reader
-config = configparser.ConfigParser()
-config.read("config.ini")
-
 # Radio messages
 radio_messages = ["https://www.youtube.com/watch?v=3-yeK1Ck4yk",
                   "https://youtu.be/YcR7du_A1Vc",
@@ -141,20 +138,33 @@ else:
 
 
 class Video:
+    """A video to be played in the bot."""
+
     def __init__(self, url: str = None, file: str = None, info: dict = None, enqueuer: discord.Member = None):
+        # Url of the video if it has to be downloaded
         self.url = url
+        # Filename of the downloaded video
         if file is None and info is None:
+            # Get it from the url hash
             self.file = str(hash(url)) + ".opus"
         elif info is not None:
+            # Get it from the video title
             self.file = "./opusfiles/" + re.sub(r'[/\\?*"<>|!:]', "_", info["title"]) + ".opus"
         else:
+            # The filename was explicitly passed
             self.file = file
-        self.downloaded = False if file is None else True
+        # Was the file already downloaded?
+        self.downloaded = (file is not None)
+        # Do we already have info on the video?
         self.info = info
+        # Who added the video to the queue?
         self.enqueuer = enqueuer
-        self.duration = None
+        # How long is the video?
+        if info is not None:
+            self.duration = info.get("duration")
 
     def __str__(self):
+        """Format the title to be used on Discord using Markdown."""
         if self.info is None or "title" not in self.info:
             return f"`{self.file}`"
         return f"_{self.info['title']}_"
@@ -163,11 +173,12 @@ class Video:
         return f"<discordbot.Video {str(self)}>"
 
     def plain_text(self):
+        """Format the video title without any Markdown."""
         if self.info is None or "title" not in self.info:
             return self.file
         return self.info['title']
 
-    async def download(self, progress_hooks: typing.List["function"] = None):
+    def download(self, progress_hooks: typing.List["function"] = None):
         # File already downloaded
         if self.downloaded:
             raise errors.AlreadyDownloadedError()
@@ -176,10 +187,11 @@ class Video:
             progress_hooks = []
         # Check if under max duration
         self.duration = datetime.timedelta(seconds=self.info.get("duration", 0))
-        if self.info is not None and self.duration.total_seconds() > int(config["YouTube"]["max_duration"]):
+        # Refuse downloading if over YouTube max_duration
+        if self.info is not None and self.duration.total_seconds() > self.max_duration:
             raise errors.DurationError()
         # Download the file
-        logger.info(f"Now downloading {repr(self)}.")
+        logger.info(f"Downloading: {repr(self)}")
         with youtube_dl.YoutubeDL({"noplaylist": True,
                                    "format": "best",
                                    "postprocessors": [{
@@ -189,8 +201,8 @@ class Video:
                                    "outtmpl": self.file,
                                    "progress_hooks": progress_hooks,
                                    "quiet": True}) as ytdl:
-            await loop.run_in_executor(executor, functools.partial(ytdl.download, [self.url]))
-        logger.info(f"Download of {repr(self)} complete.")
+            ytdl.download(self.url)
+        logger.info(f"Download complete: {repr(self)}")
         self.downloaded = True
 
     def create_audio_source(self) -> discord.PCMVolumeTransformer:
@@ -201,6 +213,7 @@ class Video:
 
 
 class SecretVideo(Video):
+    """A video to be played, but with a Zalgo'ed title."""
 
     def __str__(self):
         final_string = ""
@@ -220,12 +233,6 @@ class SecretVideo(Video):
             final_string += letter
         return final_string
 
-    def create_audio_source(self) -> discord.PCMVolumeTransformer:
-        # Check if the file has been downloaded
-        if not self.downloaded:
-            raise errors.FileNotDownloadedError()
-        return discord.PCMVolumeTransformer(discord.FFmpegPCMAudio(f"./opusfiles/{self.file}", **ffmpeg_settings))
-
 
 def escape(message: str):
     return message.replace("<", "&lt;").replace(">", "&gt;")
@@ -335,22 +342,61 @@ class RoyalDiscordBot(discord.Client):
             "!resume": self.cmd_resume
         }
         self.video_queue: typing.List[Video] = []
-        self.now_playing = None
-        self.radio_messages = True
-        self.next_radio_message_in = int(config["Discord"]["radio_messages_every"])
+        self.now_playing: typing.Optional[Video] = None
+        self.load_config("config.ini")
         self.inactivity_timer = 0
 
+    def load_config(self, filename):
+    # Init the config reader
+    config = configparser.ConfigParser()
+    config.read("config.ini")
+    # Token
+    try:
+        self.token = config["Discord"]["bot_token"]
+    except KeyError, ValueError:
+        raise errors.InvalidConfigError("Missing Discord bot token.")
+    # Main channels, will be fully loaded when ready
+    try:
+        self.main_guild_id = int(config["Discord"]["server_id"])
+        self.main_channel_id = int(config["Discord"]["main_channel"]
+    except KeyError, ValueError:
+        raise errors.InvalidConfigError("Missing main guild and channel ids.")
+    # Max enqueable video duration
+    try:
+        self.max_duration = int(config["YouTube"].get("max_duration"))
+    except KeyError, ValueError:
+        logger.warning("Max video duration is not set, setting it to infinity.")
+        self.max_duration = math.inf
+    # Max videos to predownload
+    try:
+        self.max_videos_to_predownload = int(config["YouTube"]["predownload_videos"])
+    except KeyError, ValueError:
+        logger.warning("Max videos to predownload is not set, setting it to infinity.")
+        self.max_videos_to_predownload = None
+    # Radio messages
+    try:
+        self.radio_messages_enabled = True if config["Discord"]["radio_messages_enabled"] == "True" else False
+        self.radio_messages_every = int(config["Discord"]["radio_messages_every"])
+        self.radio_messages_next_in = self.radio_messages_every
+    except KeyError, ValueError:
+        logger.warning("Radio messages config error, disabling them.")
+        self.radio_messages_enabled = False
+        self.radio_messages_every = mathf.inf
+        self.radio_messages_next_in = mathf.inf
+
     async def on_ready(self):
-        # Get the main channel
-        self.main_channel = self.get_channel(int(config["Discord"]["main_channel"]))
-        if not isinstance(self.main_channel, discord.TextChannel):
-            raise errors.InvalidConfigError("The main channel is not a TextChannel!")
         # Get the main guild
-        self.main_guild = self.get_guild(int(config["Discord"]["server_id"]))
+        self.main_guild = self.get_guild(self.main_guild_id)
         if not isinstance(self.main_guild, discord.Guild):
             raise errors.InvalidConfigError("The main guild does not exist!")
+        # Get the main channel
+        self.main_channel = self.get_channel(self.main_channel_id)
+        if not isinstance(self.main_channel, discord.TextChannel):
+            raise errors.InvalidConfigError("The main channel is not a TextChannel!")
+        # Show yourself!
         await self.change_presence(status=discord.Status.online, activity=None)
         logger.info("Bot is ready!")
+        # Start the bot tasks
         asyncio.ensure_future(self.queue_predownload_videos())
         asyncio.ensure_future(self.queue_play_next_video())
         asyncio.ensure_future(self.inactivity_countdown())
@@ -504,12 +550,12 @@ class RoyalDiscordBot(discord.Client):
 
     async def queue_predownload_videos(self):
         while True:
-            for index, video in enumerate(self.video_queue[:int(config["YouTube"]["predownload_videos"])].copy()):
+            for index, video in enumerate(self.video_queue[:(None if self.max_videos_to_predownload == math.inf else self.max_videos_to_predownload].copy()):
                 if video.downloaded:
                     continue
                 try:
                     with async_timeout.timeout(int(config["YouTube"]["download_timeout"])):
-                        await video.download()
+                        await loop.run_in_executor(executor, video.download)
                 except asyncio.TimeoutError:
                     logger.warning(f"Video download took more than {config['YouTube']['download_timeout']}s:"
                                    f" {video.plain_text()}")
@@ -520,7 +566,7 @@ class RoyalDiscordBot(discord.Client):
                     continue
                 except DurationError:
                     await self.main_channel.send(f"⚠️ {str(video)} dura più di"
-                                                 f" {str(int(config['YouTube']['max_duration']) // 60)}"
+                                                 f" {self.max_duration // 60}"
                                                  f" minuti, quindi è stato rimosso dalla coda.")
                     del self.video_queue[index]
                     continue
@@ -560,7 +606,7 @@ class RoyalDiscordBot(discord.Client):
                 now_playing = self.video_queue[0]
                 try:
                     audio_source = now_playing.create_audio_source()
-                except FileNotDownloadedError:
+                except errors.FileNotDownloadedError:
                     continue
                 logger.info(f"Started playing {repr(now_playing)}.")
                 voice_client.play(audio_source)
@@ -750,15 +796,13 @@ class RoyalDiscordBot(discord.Client):
                                "Sintassi: `!play <url|ricercayoutube|nomefile>`")
             return
         channel.typing()
-        # If the radio messages are enabled...
-        if self.radio_messages:
-            self.next_radio_message_in -= 1
-            if self.next_radio_message_in <= 0:
-                radio_message = random.sample(radio_messages, 1)[0]
-                self.next_radio_message_in = int(config["Discord"]["radio_messages_every"])
-                await self.add_video_from_url(radio_message)
-                await channel.send(f"📻 Aggiunto un messaggio radio, disattiva con `!radiomessages off`.")
-                logger.info(f"Radio message added to the queue.")
+        self.next_radio_message_in -= 1
+        if self.next_radio_message_in <= 0:
+            radio_message = random.sample(radio_messages, 1)[0]
+            self.next_radio_message_in = self.radio_messages_every
+            await self.add_video_from_url(radio_message)
+            await channel.send(f"📻 Aggiunto un messaggio radio, disattiva con `!radiomessages off`.")
+            logger.info(f"Radio message added to the queue.")
         # Parse the parameter as URL
         url = re.match(r"(?:https?://|ytsearch[0-9]*:).*", " ".join(params[1:]).strip("<>"))
         if url is not None:
@@ -931,19 +975,23 @@ class RoyalDiscordBot(discord.Client):
 
     @command
     async def cmd_radiomessages(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]):
+        if not self.radio_messages_enabled:
+            await channel.send("⚠ I messaggi radio sono stati disabilitati dall'amministratore del bot.")
+            return
         if len(params) < 2:
-            self.radio_messages = not self.radio_messages
+            await channel.send("⚠ Sintassi del comando non valida.\n"
+                               "Sintassi: `!radiomessages <on|off>`")
         else:
             if params[1].lower() == "on":
-                self.radio_messages = True
+                self.radio_messages_next_in = self.radio_messages_every
             elif params[1].lower() == "off":
-                self.radio_messages = False
+                self.radio_messages_next_in = math.inf
             else:
                 await channel.send("⚠ Sintassi del comando non valida.\n"
-                                   "Sintassi: `!radiomessages [on|off]`")
+                                   "Sintassi: `!radiomessages <on|off>`")
                 return
-        logger.info(f"Radio messages status toggled to {self.radio_messages}.")
-        await channel.send(f"📻 Messaggi radio **{'attivati' if self.radio_messages else 'disattivati'}**.")
+        logger.info(f"Radio messages status to {'enabled' if self.radio_messages.next_in < math.inf else 'disabled'}.")
+        await channel.send(f"📻 Messaggi radio **{'attivati' if self.radio_messages.next_in < math.inf else 'disattivati'}**.")
 
     @command
     @requires_connected_voice_client
@@ -972,7 +1020,7 @@ def process(users_connection=None):
         logger.info("Initializing Telegram-Discord connection...")
         asyncio.ensure_future(bot.feed_pipe(users_connection))
     logger.info("Logging in...")
-    loop.run_until_complete(bot.login(config["Discord"]["bot_token"], bot=True))
+    loop.run_until_complete(bot.login(bot.token, bot=True))
     logger.info("Connecting...")
     loop.run_until_complete(bot.connect())
     logger.info("Now stopping...")
diff --git a/template_config.ini b/template_config.ini
index 8d7a40ff..1143a95b 100644
--- a/template_config.ini
+++ b/template_config.ini
@@ -15,6 +15,7 @@ bot_token =
 server_id =
 main_channel =
 afk_timer = 10
+radio_messages_enabled = True
 radio_messages_every = 5
 
 [Telegram]

From 6fbc9898ddecc82220aaf85fed6e48e562f3f713 Mon Sep 17 00:00:00 2001
From: Stefano Pigozzi <ste.pigozzi@gmail.com>
Date: Wed, 28 Nov 2018 15:44:34 +0000
Subject: [PATCH 2/9] WIP: new queue2

---
 discordbot.py | 136 ++++++++++++++++++++++++++------------------------
 1 file changed, 70 insertions(+), 66 deletions(-)

diff --git a/discordbot.py b/discordbot.py
index 1ddee98b..e66840fb 100644
--- a/discordbot.py
+++ b/discordbot.py
@@ -159,9 +159,15 @@ class Video:
         self.info = info
         # Who added the video to the queue?
         self.enqueuer = enqueuer
-        # How long is the video?
+        # How long and what title has the video?
         if info is not None:
             self.duration = info.get("duration")
+            self.title = info.get("title")
+        else:
+            self.duration = None
+            self.title = None
+        # No audio source exists yet
+        self.audio_source = None
 
     def __str__(self):
         """Format the title to be used on Discord using Markdown."""
@@ -205,11 +211,56 @@ class Video:
         logger.info(f"Download complete: {repr(self)}")
         self.downloaded = True
 
-    def create_audio_source(self) -> discord.PCMVolumeTransformer:
+    def load(self) -> None:
         # Check if the file has been downloaded
         if not self.downloaded:
             raise errors.FileNotDownloadedError()
-        return discord.PCMVolumeTransformer(discord.FFmpegPCMAudio(f"{self.file}", **ffmpeg_settings))
+        self.audio_source = discord.PCMVolumeTransformer(discord.FFmpegPCMAudio(f"{self.file}", **ffmpeg_settings))
+
+
+class VideoQueue():
+    """The queue of videos to be played."""
+
+    def __init__(self):
+        self.list: typing.List[Video] = []
+        self.now_playing: typing.Optional[Video] = None
+
+    def __len__(self) -> int:
+        return len(self.list)
+
+    def add(self, video: Video, position: int=None) -> None:
+        if position is None:
+            self.list.append(video)
+            return
+        self.list.insert(position, video)
+    
+    def next_video(self) -> typing.Optional[Video]:
+        if len(self.list) == 0:
+            return None
+        return self.list[0]
+
+    def shuffle(self):
+        random.shuffle(self.list)
+
+    def clear(self):
+        self.list = None
+        self.now_playing = None
+
+    def forward(self) -> None:
+        self.now_playing = self.list.pop(0)
+
+    def find_video(self, title: str) -> typing.Optional[Video]:
+        """Returns the first video with a certain title (or filename)."""
+        for video in self.list:
+            if title in video.title:
+                return video
+            elif title in video.file:
+                return video
+        return None
+    
+    def __getitem__(self, index: int) -> Video:
+        """Get an element from the list."""
+        return self.list[index]
 
 
 class SecretVideo(Video):
@@ -341,8 +392,7 @@ class RoyalDiscordBot(discord.Client):
             "!pause": self.cmd_pause,
             "!resume": self.cmd_resume
         }
-        self.video_queue: typing.List[Video] = []
-        self.now_playing: typing.Optional[Video] = None
+        self.video_queue: VideoQueue = VideoQueue()
         self.load_config("config.ini")
         self.inactivity_timer = 0
 
@@ -550,7 +600,7 @@ class RoyalDiscordBot(discord.Client):
 
     async def queue_predownload_videos(self):
         while True:
-            for index, video in enumerate(self.video_queue[:(None if self.max_videos_to_predownload == math.inf else self.max_videos_to_predownload].copy()):
+            for index, video in enumerate(self.video_queue.list[:(None if self.max_videos_to_predownload == math.inf else self.max_videos_to_predownload].copy()):
                 if video.downloaded:
                     continue
                 try:
@@ -562,13 +612,13 @@ class RoyalDiscordBot(discord.Client):
                     await self.main_channel.send(f"⚠️ Il download di {str(video)} ha richiesto più di"
                                                  f" {config['YouTube']['download_timeout']} secondi, pertanto è stato"
                                                  f" rimosso dalla coda.")
-                    del self.video_queue[index]
+                    del self.video_queue.list[index]
                     continue
                 except DurationError:
                     await self.main_channel.send(f"⚠️ {str(video)} dura più di"
                                                  f" {self.max_duration // 60}"
                                                  f" minuti, quindi è stato rimosso dalla coda.")
-                    del self.video_queue[index]
+                    del self.video_queue.list[index]
                     continue
                 except Exception as e:
                     sentry.user_context({
@@ -589,53 +639,15 @@ class RoyalDiscordBot(discord.Client):
                                                  f"```python\n"
                                                  f"{str(e)}"
                                                  f"```")
-                    del self.video_queue[index]
+                    del self.video_queue.list[index]
                     continue
             await asyncio.sleep(1)
 
     async def queue_play_next_video(self):
         await self.wait_until_ready()
         while True:
-            # Fun things will happen with multiple voice clients!
-            for voice_client in self.voice_clients:
-                if not voice_client.is_connected() or voice_client.is_playing() or voice_client.is_paused():
-                    continue
-                if len(self.video_queue) == 0:
-                    self.now_playing = None
-                    continue
-                now_playing = self.video_queue[0]
-                try:
-                    audio_source = now_playing.create_audio_source()
-                except errors.FileNotDownloadedError:
-                    continue
-                logger.info(f"Started playing {repr(now_playing)}.")
-                voice_client.play(audio_source)
-                del self.video_queue[0]
-                activity = discord.Activity(name=now_playing.plain_text(),
-                                            type=discord.ActivityType.listening)
-                logger.debug(f"Updated bot presence to {now_playing.plain_text()}.")
-                await self.change_presence(status=discord.Status.online, activity=activity)
-                if now_playing.enqueuer is not None:
-                    try:
-                        session = db.Session()
-                        enqueuer = await loop.run_in_executor(executor, session.query(db.Discord)
-                                                              .filter_by(discord_id=now_playing.enqueuer.id)
-                                                              .one_or_none)
-                        played_music = db.PlayedMusic(enqueuer=enqueuer,
-                                                      filename=now_playing.plain_text(),
-                                                      timestamp=datetime.datetime.now())
-                        session.add(played_music)
-                        await loop.run_in_executor(executor, session.commit)
-                        await loop.run_in_executor(executor, session.close)
-                    except sqlalchemy.exc.OperationalError:
-                        pass
-                for key in song_special_messages:
-                    if key in now_playing.file.lower():
-                        await self.main_channel.send(song_special_messages[key].format(song=str(now_playing)))
-                        break
-                else:
-                    await self.main_channel.send(f":arrow_forward: Ora in riproduzione: {str(now_playing)}")
-            await asyncio.sleep(1)
+            # TODO
+            raise NotImplementedError("queue_play_next_video isn't done yet!")
 
     async def inactivity_countdown(self):
         while True:
@@ -709,22 +721,13 @@ class RoyalDiscordBot(discord.Client):
         if "entries" in info:
             logger.debug(f"Playlist detected at {url}.")
             for entry in info["entries"]:
-                if index is not None:
-                    self.video_queue.insert(index, Video(url=entry["webpage_url"], info=entry, enqueuer=enqueuer))
-                else:
-                    self.video_queue.append(Video(url=entry["webpage_url"], info=entry, enqueuer=enqueuer))
+                self.video_queue.add(Video(url=entry["webpage_url"], info=entry, enqueuer=enqueuer), index)
             return
         logger.debug(f"Single video detected at {url}.")
-        if index is not None:
-            self.video_queue.insert(index, Video(url=url, info=info, enqueuer=enqueuer))
-        else:
-            self.video_queue.append(Video(url=url, info=info, enqueuer=enqueuer))
+        self.video_queue.add(Video(url=entry["webpage_url"], info=entry, enqueuer=enqueuer), index)
 
     async def add_video_from_file(self, file, index: typing.Optional[int] = None, enqueuer: discord.Member = None):
-        if index is not None:
-            self.video_queue.insert(index, Video(file=file, enqueuer=enqueuer))
-        else:
-            self.video_queue.append(Video(file=file, enqueuer=enqueuer))
+        self.video_queue.add(Video(file=file, enqueuer=enqueuer), index)
 
     @command
     async def null(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]):
@@ -865,7 +868,7 @@ class RoyalDiscordBot(discord.Client):
                 await channel.send("⚠ Il numero inserito non corrisponde a nessun video nella playlist.\n"
                                    "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`")
                 return
-            video = self.video_queue.pop(index)
+            video = self.video_queue.list.pop(index)
             await channel.send(f":regional_indicator_x: {str(video)} è stato rimosso dalla coda.")
             logger.debug(f"Removed from queue: {video.plain_text()}")
             return
@@ -895,7 +898,7 @@ class RoyalDiscordBot(discord.Client):
             await channel.send("⚠ Il numero iniziale è maggiore del numero finale.\n"
                                "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`")
             return
-        del self.video_queue[start:end]
+        del self.video_queue.list[start:end]
         await channel.send(f":regional_indicator_x: {end - start} video rimossi dalla coda.")
         logger.debug(f"Removed from queue {end - start} videos.")
 
@@ -906,7 +909,7 @@ class RoyalDiscordBot(discord.Client):
                                "nessuno")
             return
         msg = "**Video in coda:**\n"
-        for index, video in enumerate(self.video_queue[:10]):
+        for index, video in enumerate(self.video_queue.list[:10]):
             msg += f"{queue_emojis[index]} {str(video)}\n"
         if len(self.video_queue) > 10:
             msg += f"più altri {len(self.video_queue) - 10} video!"
@@ -918,7 +921,7 @@ class RoyalDiscordBot(discord.Client):
         if len(self.video_queue) == 0:
             await channel.send("⚠ Non ci sono video in coda!")
             return
-        random.shuffle(self.video_queue)
+        random.shuffle(self.video_queue.list)
         logger.info(f"The queue was shuffled by {author.name}#{author.discriminator}.")
         await channel.send("♠️ ♦️ ♣️ ♥️ Shuffle completo!")
 
@@ -928,7 +931,8 @@ class RoyalDiscordBot(discord.Client):
         if len(self.video_queue) == 0:
             await channel.send("⚠ Non ci sono video in coda!")
             return
-        self.video_queue = []
+        # TODO
+        raise NotImplementedError()
         logger.info(f"The queue was cleared by {author.name}#{author.discriminator}.")
         await channel.send(":regional_indicator_x: Tutti i video in coda rimossi.")
 

From 8556a2f0dcb0978c3343b92e9caee3e1aca96042 Mon Sep 17 00:00:00 2001
From: Stefano Pigozzi <ste.pigozzi@gmail.com>
Date: Mon, 3 Dec 2018 11:00:37 +0000
Subject: [PATCH 3/9] WIP: new video stuff

---
 discordbot.py | 119 +++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 117 insertions(+), 2 deletions(-)

diff --git a/discordbot.py b/discordbot.py
index e66840fb..d3681c1b 100644
--- a/discordbot.py
+++ b/discordbot.py
@@ -21,6 +21,7 @@ import sqlalchemy.exc
 import coloredlogs
 import errors
 import math
+import enum
 
 logging.getLogger().disabled = True
 logger = logging.getLogger(__name__)
@@ -137,7 +138,7 @@ else:
     sentry = Succ()
 
 
-class Video:
+class OldVideo:
     """A video to be played in the bot."""
 
     def __init__(self, url: str = None, file: str = None, info: dict = None, enqueuer: discord.Member = None):
@@ -217,6 +218,92 @@ class Video:
             raise errors.FileNotDownloadedError()
         self.audio_source = discord.PCMVolumeTransformer(discord.FFmpegPCMAudio(f"{self.file}", **ffmpeg_settings))
 
+    def suggestion(self) -> typing.Optional[str]:
+        """The suggested video to add to the queue after this one."""
+        raise NotImplementedError()
+
+
+class Video:
+    def __init__(self, enqueuer: typing.Optional[discord.Member]=None):
+        self.is_ready = False
+        self.name = None
+        self.enqueuer = enqueuer
+        self.audio_source = None
+
+    def __str__(self):
+        return self.name
+
+    def plain_text(self):
+        """Title without formatting to be printed on terminals."""
+        return self.name
+
+    def database_text(self):
+        """The text to be stored in the database for the stats. Usually the same as plain_text()."""
+        return self.name
+
+    def __repr__(self):
+        return f"<Video {self.name} ({'' if self.is_ready else 'not '}ready) added by {self.enqueuer}>"
+
+    def ready_up(self):
+        """Prepare the video for playback in some way. For example, download it."""
+        raise NotImplementedError()
+
+    def make_audio_source(self):
+        """Create an AudioSource to be played through Discord, and store and return it."""
+        raise NotImplementedError()
+    
+    def get_suggestion(self):
+        """Get the next suggested video, to be used when the queue is in LoopMode.FOLLOW_SUGGESTION"""
+        raise NotImplementedError()
+
+# TODO: split Video in YoutubeDLVideo and LocalFileVideo
+
+class YoutubeDLVideo(Video):
+    """A file sourcing from YoutubeDL."""
+
+    def __init__(self, url, enqueuer: typing.Optional[discord.Member]=None):
+        super().__init__(enqueuer)
+        self.url = url
+        self.info = None
+
+    def get_info(self):
+        """Get info about the video."""
+        ...
+
+    def ready_up(self):
+        """Download the video."""
+        ...
+
+    def get_filename(self):
+        """Generate the filename of the video."""
+        ...
+
+    def make_audio_source(self):
+        ...
+
+    def get_suggestion(self):
+        ...
+    
+
+class LocalFileVideo(Video):
+    """A file sourcing from the local opusfiles folder."""
+
+    def __init__(self, filename):
+        super().__init__()
+        self.filename = filename
+
+    def suggestion(self) -> typing.Optional[str]:
+        return None
+
+    ...
+
+
+class LoopMode(enum.Enum):
+    NORMAL = enum.auto()
+    LOOP_QUEUE = enum.auto()
+    LOOP_SINGLE = enum.auto()
+    FOLLOW_SUGGESTIONS = enum.auto()
+
 
 class VideoQueue():
     """The queue of videos to be played."""
@@ -224,16 +311,37 @@ class VideoQueue():
     def __init__(self):
         self.list: typing.List[Video] = []
         self.now_playing: typing.Optional[Video] = None
+        self.loop_mode = LoopMode.NORMAL
 
     def __len__(self) -> int:
         return len(self.list)
 
+    def __next__(self) -> Video:
+        video = self.next_video()
+        self.advance_queue()
+        return video
+
+    def __repr__(self) -> str:
+        return f"<VideoQueue of length {len(self)}>"
+
     def add(self, video: Video, position: int=None) -> None:
         if position is None:
             self.list.append(video)
             return
         self.list.insert(position, video)
     
+    def advance_queue(self):
+        if loop_mode == LoopMode.NORMAL:
+            del self.list[0]
+        elif loop_mode == LoopMode.LOOP_QUEUE:
+            self.add(self.list[0])
+            del self.list[0]
+        elif loop_mode == LoopMode.LOOP_SINGLE:
+            pass
+        elif loop_mode == LoopMode.FOLLOW_SUGGESTIONS:
+            self.add(self.list[0].suggestion(), 0)
+            del self.list[0]
+    
     def next_video(self) -> typing.Optional[Video]:
         if len(self.list) == 0:
             return None
@@ -257,6 +365,13 @@ class VideoQueue():
             elif title in video.file:
                 return video
         return None
+
+    def undownloaded_videos(self, limit: typing.Optional[int]=None):
+        l = []
+        for video in self.list[:limit]:
+            if not video.downloaded:
+                l.append(video)
+        return l
     
     def __getitem__(self, index: int) -> Video:
         """Get an element from the list."""
@@ -600,7 +715,7 @@ class RoyalDiscordBot(discord.Client):
 
     async def queue_predownload_videos(self):
         while True:
-            for index, video in enumerate(self.video_queue.list[:(None if self.max_videos_to_predownload == math.inf else self.max_videos_to_predownload].copy()):
+            for index, video in enumerate(self.video_queue.undownloaded_videos(self.max_videos_to_predownload)):
                 if video.downloaded:
                     continue
                 try:

From d3f9bedf0beec9dc66790b85fb9ba2842cc215c6 Mon Sep 17 00:00:00 2001
From: Stefano Pigozzi <ste.pigozzi@gmail.com>
Date: Mon, 3 Dec 2018 15:53:03 +0000
Subject: [PATCH 4/9] WIP: moar stuff

---
 discordbot.py | 295 ++++++++++++++++++++------------------------------
 1 file changed, 116 insertions(+), 179 deletions(-)

diff --git a/discordbot.py b/discordbot.py
index d3681c1b..8fb1a3c9 100644
--- a/discordbot.py
+++ b/discordbot.py
@@ -40,16 +40,6 @@ queue_emojis = [":one:",
                 ":nine:",
                 ":keycap_ten:"]
 
-# Zalgo text
-zalgo_up = ['̍', '̎', '̄', '̅', '̿', '̑', '̆', '̐', '͒', '͗', '͑', '̇', '̈', '̊', '͂', '̓', '̈́', '͊',
-            '͋', '͌', '̃', '̂', '̌', '͐', '́', '̋', '̏', '̽', '̉', 'ͣ', 'ͤ', 'ͥ', 'ͦ', 'ͧ', 'ͨ', 'ͩ',
-            'ͪ', 'ͫ', 'ͬ', 'ͭ', 'ͮ', 'ͯ', '̾', '͛', '͆', '̚', ]
-zalgo_down = ['̖', '̗', '̘', '̙', '̜', '̝', '̞', '̟', '̠', '̤', '̥', '̦', '̩', '̪', '̫', '̬', '̭', '̮',
-              '̯', '̰', '̱', '̲', '̳', '̹', '̺', '̻', '̼', 'ͅ', '͇', '͈', '͉', '͍', '͎', '͓', '͔', '͕',
-              '͖', '͙', '͚', '', ]
-zalgo_middle = ['̕', '̛', '̀', '́', '͘', '̡', '̢', '̧', '̨', '̴', '̵', '̶', '͜', '͝', '͞', '͟', '͠', '͢',
-                '̸', '̷', '͡', ]
-
 # Init the event loop
 loop = asyncio.get_event_loop()
 
@@ -138,91 +128,6 @@ else:
     sentry = Succ()
 
 
-class OldVideo:
-    """A video to be played in the bot."""
-
-    def __init__(self, url: str = None, file: str = None, info: dict = None, enqueuer: discord.Member = None):
-        # Url of the video if it has to be downloaded
-        self.url = url
-        # Filename of the downloaded video
-        if file is None and info is None:
-            # Get it from the url hash
-            self.file = str(hash(url)) + ".opus"
-        elif info is not None:
-            # Get it from the video title
-            self.file = "./opusfiles/" + re.sub(r'[/\\?*"<>|!:]', "_", info["title"]) + ".opus"
-        else:
-            # The filename was explicitly passed
-            self.file = file
-        # Was the file already downloaded?
-        self.downloaded = (file is not None)
-        # Do we already have info on the video?
-        self.info = info
-        # Who added the video to the queue?
-        self.enqueuer = enqueuer
-        # How long and what title has the video?
-        if info is not None:
-            self.duration = info.get("duration")
-            self.title = info.get("title")
-        else:
-            self.duration = None
-            self.title = None
-        # No audio source exists yet
-        self.audio_source = None
-
-    def __str__(self):
-        """Format the title to be used on Discord using Markdown."""
-        if self.info is None or "title" not in self.info:
-            return f"`{self.file}`"
-        return f"_{self.info['title']}_"
-
-    def __repr__(self):
-        return f"<discordbot.Video {str(self)}>"
-
-    def plain_text(self):
-        """Format the video title without any Markdown."""
-        if self.info is None or "title" not in self.info:
-            return self.file
-        return self.info['title']
-
-    def download(self, progress_hooks: typing.List["function"] = None):
-        # File already downloaded
-        if self.downloaded:
-            raise errors.AlreadyDownloadedError()
-        # No progress hooks
-        if progress_hooks is None:
-            progress_hooks = []
-        # Check if under max duration
-        self.duration = datetime.timedelta(seconds=self.info.get("duration", 0))
-        # Refuse downloading if over YouTube max_duration
-        if self.info is not None and self.duration.total_seconds() > self.max_duration:
-            raise errors.DurationError()
-        # Download the file
-        logger.info(f"Downloading: {repr(self)}")
-        with youtube_dl.YoutubeDL({"noplaylist": True,
-                                   "format": "best",
-                                   "postprocessors": [{
-                                       "key": 'FFmpegExtractAudio',
-                                       "preferredcodec": 'opus'
-                                   }],
-                                   "outtmpl": self.file,
-                                   "progress_hooks": progress_hooks,
-                                   "quiet": True}) as ytdl:
-            ytdl.download(self.url)
-        logger.info(f"Download complete: {repr(self)}")
-        self.downloaded = True
-
-    def load(self) -> None:
-        # Check if the file has been downloaded
-        if not self.downloaded:
-            raise errors.FileNotDownloadedError()
-        self.audio_source = discord.PCMVolumeTransformer(discord.FFmpegPCMAudio(f"{self.file}", **ffmpeg_settings))
-
-    def suggestion(self) -> typing.Optional[str]:
-        """The suggested video to add to the queue after this one."""
-        raise NotImplementedError()
-
-
 class Video:
     def __init__(self, enqueuer: typing.Optional[discord.Member]=None):
         self.is_ready = False
@@ -231,14 +136,20 @@ class Video:
         self.audio_source = None
 
     def __str__(self):
+        if self.name is None:
+            return "_Untitled_"
         return self.name
 
     def plain_text(self):
         """Title without formatting to be printed on terminals."""
+        if self.name is None:
+            return "Untitled"
         return self.name
 
     def database_text(self):
         """The text to be stored in the database for the stats. Usually the same as plain_text()."""
+        if self.name is None:
+            raise errors.VideoHasNoName()
         return self.name
 
     def __repr__(self):
@@ -256,11 +167,10 @@ class Video:
         """Get the next suggested video, to be used when the queue is in LoopMode.FOLLOW_SUGGESTION"""
         raise NotImplementedError()
 
-# TODO: split Video in YoutubeDLVideo and LocalFileVideo
 
 class YoutubeDLVideo(Video):
     """A file sourcing from YoutubeDL."""
-
+    
     def __init__(self, url, enqueuer: typing.Optional[discord.Member]=None):
         super().__init__(enqueuer)
         self.url = url
@@ -268,34 +178,67 @@ class YoutubeDLVideo(Video):
 
     def get_info(self):
         """Get info about the video."""
-        ...
+        if self.info:
+            return
+        with youtube_dl.YoutubeDL({"quiet": True,
+                                   "ignoreerrors": True,
+                                   "simulate": True}) as ytdl:
+            data = ytdl.extract_info(url=self.url, download=False)
+        if data is None:
+            raise errors.VideoInfoExtractionFailed()
+        if "entries" in info:
+            raise errors.VideoIsPlaylist()
+        self.info = data
+        self.name = data.get("title")
 
-    def ready_up(self):
-        """Download the video."""
-        ...
+    def __str__(self):
+        if self.info is None:
+            return f"`{self.url}`"
+        return f"_{self.name}_"
+
+    def plain_text(self):
+        if self.info is None:
+            return self.url
+        if not self.name.isprintable():
+            return self.url
+        return self.name
 
     def get_filename(self):
         """Generate the filename of the video."""
-        ...
-
-    def make_audio_source(self):
-        ...
-
-    def get_suggestion(self):
-        ...
+        if info is None:
+            raise errors.VideoInfoUnknown()
+        return f"./opusfiles/{re.sub(r'[/\\?*"<>|!:]', "_", info["title"])}.opus"
     
-
-class LocalFileVideo(Video):
-    """A file sourcing from the local opusfiles folder."""
-
-    def __init__(self, filename):
-        super().__init__()
-        self.filename = filename
-
-    def suggestion(self) -> typing.Optional[str]:
-        return None
-
-    ...
+    def ready_up(self):
+        """Download the video."""
+        # Skip download if it is already ready
+        if self.is_ready:
+            return
+        # Retrieve info about the video
+        self.get_info()
+        # Check if the file to download already exists
+        if os.path.exists(self.get_filename()):
+            self.is_ready = True
+            return
+        # Download the file
+        logger.info(f"Starting youtube_dl download of {repr(self)}")
+        with youtube_dl.YoutubeDL({"noplaylist": True,
+                                   "format": "best",
+                                   "postprocessors": [{
+                                       "key": 'FFmpegExtractAudio',
+                                       "preferredcodec": 'opus'
+                                   }],
+                                   "outtmpl": self.get_filename(),
+                                   "quiet": True}) as ytdl:
+            ytdl.download(self.url)
+        logger.info(f"Completed youtube_dl download of {repr(self)}")
+        self.is_ready = True
+        
+    def make_audio_source(self):
+        if not self.is_ready:
+            raise errors.VideoIsNotReady()
+        self.audio_source = discord.PCMVolumeTransformer(discord.FFmpegPCMAudio(self.get_filename(), **ffmpeg_settings))
+        return self.audio_source
 
 
 class LoopMode(enum.Enum):
@@ -332,15 +275,20 @@ class VideoQueue():
     
     def advance_queue(self):
         if loop_mode == LoopMode.NORMAL:
-            del self.list[0]
+            try:
+                self.now_playing = self.list.pop(0)
+            except IndexError:
+                self.now_playing = None
         elif loop_mode == LoopMode.LOOP_QUEUE:
             self.add(self.list[0])
-            del self.list[0]
+            self.now_playing = self.list.pop(0)
         elif loop_mode == LoopMode.LOOP_SINGLE:
             pass
         elif loop_mode == LoopMode.FOLLOW_SUGGESTIONS:
-            self.add(self.list[0].suggestion(), 0)
-            del self.list[0]
+            if now_playing is None:
+                self.now_playing = None
+                return
+            self.now_playing = self.now_playing.suggestion()
     
     def next_video(self) -> typing.Optional[Video]:
         if len(self.list) == 0:
@@ -357,19 +305,18 @@ class VideoQueue():
     def forward(self) -> None:
         self.now_playing = self.list.pop(0)
 
-    def find_video(self, title: str) -> typing.Optional[Video]:
-        """Returns the first video with a certain title (or filename)."""
+    def find_video(self, name: str) -> typing.Optional[Video]:
+        """Returns the first video with a certain name."""
         for video in self.list:
-            if title in video.title:
-                return video
-            elif title in video.file:
+            if name in video.name:
                 return video
         return None
 
-    def undownloaded_videos(self, limit: typing.Optional[int]=None):
+    def not_ready_videos(self, limit: typing.Optional[int]=None):
+        """Return the non-ready videos in the first limit positions of the queue."""
         l = []
         for video in self.list[:limit]:
-            if not video.downloaded:
+            if not video.is_ready:
                 l.append(video)
         return l
     
@@ -378,28 +325,6 @@ class VideoQueue():
         return self.list[index]
 
 
-class SecretVideo(Video):
-    """A video to be played, but with a Zalgo'ed title."""
-
-    def __str__(self):
-        final_string = ""
-        for letter in self.file:
-            final_string += random.sample(zalgo_up, 1)[0]
-            final_string += random.sample(zalgo_middle, 1)[0]
-            final_string += random.sample(zalgo_down, 1)[0]
-            final_string += letter
-        return final_string
-
-    def plain_text(self):
-        final_string = ""
-        for letter in self.file:
-            final_string += random.sample(zalgo_up, 1)[0]
-            final_string += random.sample(zalgo_middle, 1)[0]
-            final_string += random.sample(zalgo_down, 1)[0]
-            final_string += letter
-        return final_string
-
-
 def escape(message: str):
     return message.replace("<", "&lt;").replace(">", "&gt;")
 
@@ -527,17 +452,19 @@ class RoyalDiscordBot(discord.Client):
     except KeyError, ValueError:
         raise errors.InvalidConfigError("Missing main guild and channel ids.")
     # Max enqueable video duration
-    try:
-        self.max_duration = int(config["YouTube"].get("max_duration"))
-    except KeyError, ValueError:
-        logger.warning("Max video duration is not set, setting it to infinity.")
-        self.max_duration = math.inf
+    # Defined in the YoutubeDLVideo class
     # Max videos to predownload
     try:
-        self.max_videos_to_predownload = int(config["YouTube"]["predownload_videos"])
+        self.max_videos_to_predownload = int(config["Video"]["cache_size"])
     except KeyError, ValueError:
         logger.warning("Max videos to predownload is not set, setting it to infinity.")
         self.max_videos_to_predownload = None
+    # Max time to ready a video
+    try:
+        self.max_video_ready_time = int(config["Video"]["max_ready_time"])
+    except KeyError, ValueError:
+        logger.warning("Max time to ready a video is not set, setting it to infinity. ")
+        self.max_video_ready_time = mathf.inf
     # Radio messages
     try:
         self.radio_messages_enabled = True if config["Discord"]["radio_messages_enabled"] == "True" else False
@@ -715,24 +642,15 @@ class RoyalDiscordBot(discord.Client):
 
     async def queue_predownload_videos(self):
         while True:
+            await asyncio.sleep(1)
+            # Might have some problems with del
             for index, video in enumerate(self.video_queue.undownloaded_videos(self.max_videos_to_predownload)):
-                if video.downloaded:
-                    continue
                 try:
-                    with async_timeout.timeout(int(config["YouTube"]["download_timeout"])):
-                        await loop.run_in_executor(executor, video.download)
+                    with async_timeout.timeout(self.max_video_ready_time):
+                        loop.run_in_executor(executor, video.ready_up)
                 except asyncio.TimeoutError:
-                    logger.warning(f"Video download took more than {config['YouTube']['download_timeout']}s:"
-                                   f" {video.plain_text()}")
-                    await self.main_channel.send(f"⚠️ Il download di {str(video)} ha richiesto più di"
-                                                 f" {config['YouTube']['download_timeout']} secondi, pertanto è stato"
-                                                 f" rimosso dalla coda.")
-                    del self.video_queue.list[index]
-                    continue
-                except DurationError:
-                    await self.main_channel.send(f"⚠️ {str(video)} dura più di"
-                                                 f" {self.max_duration // 60}"
-                                                 f" minuti, quindi è stato rimosso dalla coda.")
+                    logger.warning(f"Video {repr(video)} took more than {self.max_video_ready_time} to download, skipping...")
+                    await self.main_channel.send(f"⚠️ La preparazione di {video} ha richiesto più di {self.max_video_ready_time} secondi, pertanto è stato rimosso dalla coda.")
                     del self.video_queue.list[index]
                     continue
                 except Exception as e:
@@ -747,22 +665,41 @@ class RoyalDiscordBot(discord.Client):
                         "video": video.plain_text()
                     })
                     sentry.captureException()
-                    logger.error(f"Video download error: {str(e)}")
+                    logger.error(f"Uncaught video download error: {e}")
                     await self.main_channel.send(f"⚠️ E' stato incontrato un errore durante il download di "
                                                  f"{str(video)}, quindi è stato rimosso dalla coda.\n\n"
-                                                 f"**Dettagli sull'errore:**\n"
                                                  f"```python\n"
                                                  f"{str(e)}"
                                                  f"```")
                     del self.video_queue.list[index]
                     continue
-            await asyncio.sleep(1)
 
     async def queue_play_next_video(self):
         await self.wait_until_ready()
         while True:
-            # TODO
-            raise NotImplementedError("queue_play_next_video isn't done yet!")
+            await asyncio.sleep(1)
+            for voice_client in self.voice_clients:
+                # Do not add play videos if something else is playing!
+                if not voice_client.is_connected():
+                    continue
+                if voice_client.is_playing():
+                    continue
+                if voice_client.is_paused():
+                    continue
+                # Advance the queue
+                self.voice_queue.advance_queue()
+                # Try to generate an AudioSource
+                if self.voice_queue.now_playing is None:
+                    continue
+                try:
+                    audio_source = self.voice_queue.now_playing.make_audio_source()
+                except errors.VideoIsNotReady():
+                    continue
+                # Start playing the AudioSource
+                logger.info(f"Started playing {self.voice_queue.now_playing}")
+                voice_client.play(audio_source)
+
+                
 
     async def inactivity_countdown(self):
         while True:

From ab5f333135ea295f72e6cda9e8e23348c68b7045 Mon Sep 17 00:00:00 2001
From: Stefano Pigozzi <ste.pigozzi@gmail.com>
Date: Mon, 3 Dec 2018 15:53:14 +0000
Subject: [PATCH 5/9] asjdiad

---
 discordbot.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/discordbot.py b/discordbot.py
index 8fb1a3c9..2d9a9126 100644
--- a/discordbot.py
+++ b/discordbot.py
@@ -698,6 +698,7 @@ class RoyalDiscordBot(discord.Client):
                 # Start playing the AudioSource
                 logger.info(f"Started playing {self.voice_queue.now_playing}")
                 voice_client.play(audio_source)
+                #TODO
 
                 
 

From 954ba6faf43fb3f4615097eeef6af598a9c87686 Mon Sep 17 00:00:00 2001
From: Stefano Pigozzi <ste.pigozzi@gmail.com>
Date: Tue, 4 Dec 2018 00:56:29 +0100
Subject: [PATCH 6/9] something works, something does not

---
 discordbot.py | 249 +++++++++++++++++++++++++-------------------------
 errors.py     |  20 ++++
 2 files changed, 145 insertions(+), 124 deletions(-)

diff --git a/discordbot.py b/discordbot.py
index 2d9a9126..2268816a 100644
--- a/discordbot.py
+++ b/discordbot.py
@@ -15,7 +15,6 @@ import configparser
 import async_timeout
 import raven
 import logging
-import errors
 import datetime
 import sqlalchemy.exc
 import coloredlogs
@@ -104,7 +103,7 @@ class Succ:
     def __bool__(self):
         return False
     
-    def __getattr__(self):
+    def __getattr__(self, attr):
         return Succ()
 
     def __call__(self, *args, **kwargs):
@@ -117,15 +116,16 @@ class Succ:
         return "<Succ>"
 
 
+# TODO
 # Init the Sentry client
-if config.get("Sentry") and config["Sentry"].get("token"):
-    sentry = raven.Client(config["Sentry"]["token"],
-                        release=raven.fetch_git_sha(os.path.dirname(__file__)),
-                        install_logging_hook=False,
-                        hook_libraries=[])
-else:
-    logger.warning("Sentry not set, ignoring all calls to it.")
-    sentry = Succ()
+# if config.get("Sentry") and config["Sentry"].get("token"):
+#     sentry = raven.Client(config["Sentry"]["token"],
+#                         release=raven.fetch_git_sha(os.path.dirname(__file__)),
+#                         install_logging_hook=False,
+#                         hook_libraries=[])
+# else:
+logger.warning("Sentry not set, ignoring all calls to it.")
+sentry = Succ()
 
 
 class Video:
@@ -186,7 +186,7 @@ class YoutubeDLVideo(Video):
             data = ytdl.extract_info(url=self.url, download=False)
         if data is None:
             raise errors.VideoInfoExtractionFailed()
-        if "entries" in info:
+        if "entries" in data:
             raise errors.VideoIsPlaylist()
         self.info = data
         self.name = data.get("title")
@@ -205,9 +205,9 @@ class YoutubeDLVideo(Video):
 
     def get_filename(self):
         """Generate the filename of the video."""
-        if info is None:
+        if self.info is None:
             raise errors.VideoInfoUnknown()
-        return f"./opusfiles/{re.sub(r'[/\\?*"<>|!:]', "_", info["title"])}.opus"
+        return "./opusfiles/{}.opus".format(re.sub(r'[/\\?*"<>|!:]', "_", self.info.get("title", self.info["id"])))
     
     def ready_up(self):
         """Download the video."""
@@ -274,18 +274,18 @@ class VideoQueue():
         self.list.insert(position, video)
     
     def advance_queue(self):
-        if loop_mode == LoopMode.NORMAL:
+        if self.loop_mode == LoopMode.NORMAL:
             try:
                 self.now_playing = self.list.pop(0)
             except IndexError:
                 self.now_playing = None
-        elif loop_mode == LoopMode.LOOP_QUEUE:
+        elif self.loop_mode == LoopMode.LOOP_QUEUE:
             self.add(self.list[0])
             self.now_playing = self.list.pop(0)
-        elif loop_mode == LoopMode.LOOP_SINGLE:
+        elif self.loop_mode == LoopMode.LOOP_SINGLE:
             pass
-        elif loop_mode == LoopMode.FOLLOW_SUGGESTIONS:
-            if now_playing is None:
+        elif self.loop_mode == LoopMode.FOLLOW_SUGGESTIONS:
+            if self.now_playing is None:
                 self.now_playing = None
                 return
             self.now_playing = self.now_playing.suggestion()
@@ -436,46 +436,54 @@ class RoyalDiscordBot(discord.Client):
         self.load_config("config.ini")
         self.inactivity_timer = 0
 
+    # noinspection PyAttributeOutsideInit
     def load_config(self, filename):
-    # Init the config reader
-    config = configparser.ConfigParser()
-    config.read("config.ini")
-    # Token
-    try:
-        self.token = config["Discord"]["bot_token"]
-    except KeyError, ValueError:
-        raise errors.InvalidConfigError("Missing Discord bot token.")
-    # Main channels, will be fully loaded when ready
-    try:
-        self.main_guild_id = int(config["Discord"]["server_id"])
-        self.main_channel_id = int(config["Discord"]["main_channel"]
-    except KeyError, ValueError:
-        raise errors.InvalidConfigError("Missing main guild and channel ids.")
-    # Max enqueable video duration
-    # Defined in the YoutubeDLVideo class
-    # Max videos to predownload
-    try:
-        self.max_videos_to_predownload = int(config["Video"]["cache_size"])
-    except KeyError, ValueError:
-        logger.warning("Max videos to predownload is not set, setting it to infinity.")
-        self.max_videos_to_predownload = None
-    # Max time to ready a video
-    try:
-        self.max_video_ready_time = int(config["Video"]["max_ready_time"])
-    except KeyError, ValueError:
-        logger.warning("Max time to ready a video is not set, setting it to infinity. ")
-        self.max_video_ready_time = mathf.inf
-    # Radio messages
-    try:
-        self.radio_messages_enabled = True if config["Discord"]["radio_messages_enabled"] == "True" else False
-        self.radio_messages_every = int(config["Discord"]["radio_messages_every"])
-        self.radio_messages_next_in = self.radio_messages_every
-    except KeyError, ValueError:
-        logger.warning("Radio messages config error, disabling them.")
-        self.radio_messages_enabled = False
-        self.radio_messages_every = mathf.inf
-        self.radio_messages_next_in = mathf.inf
+        # Init the config reader
+        config = configparser.ConfigParser()
+        config.read("config.ini")
+        # Token
+        try:
+            self.token = config["Discord"]["bot_token"]
+        except (KeyError, ValueError):
+            raise errors.InvalidConfigError("Missing Discord bot token.")
+        # Main channels, will be fully loaded when ready
+        try:
+            self.main_guild_id = int(config["Discord"]["server_id"])
+            self.main_channel_id = int(config["Discord"]["main_channel"])
+        except (KeyError, ValueError):
+            raise errors.InvalidConfigError("Missing main guild and channel ids.")
+        # Max enqueable video duration
+        # Defined in the YoutubeDLVideo class
+        # Max videos to predownload
+        try:
+            self.max_videos_to_predownload = int(config["Video"]["cache_size"])
+        except (KeyError, ValueError):
+            logger.warning("Max videos to predownload is not set, setting it to infinity.")
+            self.max_videos_to_predownload = None
+        # Max time to ready a video
+        try:
+            self.max_video_ready_time = int(config["Video"]["max_ready_time"])
+        except (KeyError, ValueError):
+            logger.warning("Max time to ready a video is not set, setting it to infinity. ")
+            self.max_video_ready_time = math.inf
+        # Radio messages
+        try:
+            self.radio_messages_enabled = True if config["Discord"]["radio_messages_enabled"] == "True" else False
+            self.radio_messages_every = int(config["Discord"]["radio_messages_every"])
+            self.radio_messages_next_in = self.radio_messages_every
+        except (KeyError, ValueError):
+            logger.warning("Radio messages config error, disabling them.")
+            self.radio_messages_enabled = False
+            self.radio_messages_every = math.inf
+            self.radio_messages_next_in = math.inf
+        # Activity reporting
+        try:
+            self.activity_report_sample_time = int(config["Discord"]["activityreport_sample_time"])
+        except (KeyError, ValueError):
+            logger.warning("Activity reporting config error, disabling it.")
+            self.activity_report_sample_time = math.inf
 
+    # noinspection PyAsyncCall
     async def on_ready(self):
         # Get the main guild
         self.main_guild = self.get_guild(self.main_guild_id)
@@ -525,7 +533,7 @@ class RoyalDiscordBot(discord.Client):
 
     async def on_error(self, event_method, *args, **kwargs):
         ei = sys.exc_info()
-        logger.error(f"Critical error: {repr(ei[1])}")
+        logger.critical(f"Critical error: {repr(ei)}")
         # noinspection PyBroadException
         try:
             await self.main_channel.send(f"☢️ **ERRORE CRITICO NELL'EVENTO** `{event_method}`!\n"
@@ -533,7 +541,7 @@ class RoyalDiscordBot(discord.Client):
                                          f"Una segnalazione di errore è stata automaticamente mandata a Steffo.\n\n"
                                          f"Dettagli dell'errore:\n"
                                          f"```python\n"
-                                         f"{repr(ei[1])}\n"
+                                         f"{repr(ei)}\n"
                                          f"```")
             await self.change_presence(status=discord.Status.invisible)
             await self.close()
@@ -644,10 +652,10 @@ class RoyalDiscordBot(discord.Client):
         while True:
             await asyncio.sleep(1)
             # Might have some problems with del
-            for index, video in enumerate(self.video_queue.undownloaded_videos(self.max_videos_to_predownload)):
+            for index, video in enumerate(self.video_queue.not_ready_videos(self.max_videos_to_predownload)):
                 try:
                     with async_timeout.timeout(self.max_video_ready_time):
-                        loop.run_in_executor(executor, video.ready_up)
+                        await loop.run_in_executor(executor, video.ready_up)
                 except asyncio.TimeoutError:
                     logger.warning(f"Video {repr(video)} took more than {self.max_video_ready_time} to download, skipping...")
                     await self.main_channel.send(f"⚠️ La preparazione di {video} ha richiesto più di {self.max_video_ready_time} secondi, pertanto è stato rimosso dalla coda.")
@@ -669,7 +677,7 @@ class RoyalDiscordBot(discord.Client):
                     await self.main_channel.send(f"⚠️ E' stato incontrato un errore durante il download di "
                                                  f"{str(video)}, quindi è stato rimosso dalla coda.\n\n"
                                                  f"```python\n"
-                                                 f"{str(e)}"
+                                                 f"{str(e.args)}"
                                                  f"```")
                     del self.video_queue.list[index]
                     continue
@@ -687,20 +695,45 @@ class RoyalDiscordBot(discord.Client):
                 if voice_client.is_paused():
                     continue
                 # Advance the queue
-                self.voice_queue.advance_queue()
+                self.video_queue.advance_queue()
                 # Try to generate an AudioSource
-                if self.voice_queue.now_playing is None:
+                if self.video_queue.now_playing is None:
                     continue
                 try:
-                    audio_source = self.voice_queue.now_playing.make_audio_source()
-                except errors.VideoIsNotReady():
+                    audio_source = self.video_queue.now_playing.make_audio_source()
+                except errors.VideoIsNotReady:
                     continue
                 # Start playing the AudioSource
-                logger.info(f"Started playing {self.voice_queue.now_playing}")
+                logger.info(f"Started playing {self.video_queue.now_playing.plain_text()}.")
                 voice_client.play(audio_source)
-                #TODO
-
-                
+                # Update the voice_client activity
+                activity = discord.Activity(name=self.video_queue.now_playing.plain_text(),
+                                            type=discord.ActivityType.listening)
+                logger.debug("Updating bot presence...")
+                await self.change_presence(status=discord.Status.online, activity=activity)
+                # Record the played song in the database
+                if self.video_queue.now_playing.enqueuer is not None:
+                    logger.debug(f"Adding {self.video_queue.now_playing.plain_text()} to db.PlayedMusic...")
+                    try:
+                        session = db.Session()
+                        enqueuer = await loop.run_in_executor(executor, session.query(db.Discord)
+                                                              .filter_by(discord_id=self.video_queue.now_playing.enqueuer.id)
+                                                              .one_or_none)
+                        played_music = db.PlayedMusic(enqueuer=enqueuer,
+                                                      filename=self.video_queue.now_playing.database_text(),
+                                                      timestamp=datetime.datetime.now())
+                        session.add(played_music)
+                        await loop.run_in_executor(executor, session.commit)
+                        await loop.run_in_executor(executor, session.close)
+                    except sqlalchemy.exc.OperationalError:
+                        pass
+                # Send a message in chat
+                for key in song_special_messages:
+                    if key in self.video_queue.now_playing.name.lower():
+                        await self.main_channel.send(song_special_messages[key].format(song=str(self.video_queue.now_playing)))
+                        break
+                else:
+                    await self.main_channel.send(f":arrow_forward: Ora in riproduzione: {str(self.video_queue.now_playing)}")
 
     async def inactivity_countdown(self):
         while True:
@@ -752,11 +785,12 @@ class RoyalDiscordBot(discord.Client):
 
     async def activity_task(self):
         await self.wait_until_ready()
-        time_to_wait = int(config["Discord"]["activityreport_sample_time"])
+        if self.activity_report_sample_time == math.inf:
+            return
         while True:
             await self.create_activityreport()
-            logger.debug(f"Waiting {time_to_wait} seconds before the next record.")
-            await asyncio.sleep(time_to_wait)
+            logger.debug(f"Waiting {self.activity_report_sample_time} seconds before the next record.")
+            await asyncio.sleep(self.activity_report_sample_time)
 
     async def add_video_from_url(self, url, index: typing.Optional[int] = None, enqueuer: discord.Member = None):
         # Retrieve info
@@ -774,13 +808,10 @@ class RoyalDiscordBot(discord.Client):
         if "entries" in info:
             logger.debug(f"Playlist detected at {url}.")
             for entry in info["entries"]:
-                self.video_queue.add(Video(url=entry["webpage_url"], info=entry, enqueuer=enqueuer), index)
+                self.video_queue.add(YoutubeDLVideo(entry["webpage_url"], enqueuer=enqueuer), index)
             return
         logger.debug(f"Single video detected at {url}.")
-        self.video_queue.add(Video(url=entry["webpage_url"], info=entry, enqueuer=enqueuer), index)
-
-    async def add_video_from_file(self, file, index: typing.Optional[int] = None, enqueuer: discord.Member = None):
-        self.video_queue.add(Video(file=file, enqueuer=enqueuer), index)
+        self.video_queue.add(YoutubeDLVideo(url, enqueuer=enqueuer), index)
 
     @command
     async def null(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]):
@@ -852,10 +883,11 @@ class RoyalDiscordBot(discord.Client):
                                "Sintassi: `!play <url|ricercayoutube|nomefile>`")
             return
         channel.typing()
-        self.next_radio_message_in -= 1
-        if self.next_radio_message_in <= 0:
+        self.radio_messages_next_in -= 1
+        if self.radio_messages_next_in <= 0:
             radio_message = random.sample(radio_messages, 1)[0]
-            self.next_radio_message_in = self.radio_messages_every
+            # pycharm are you drunk
+            self.radio_messages_next_in = self.radio_messages_every
             await self.add_video_from_url(radio_message)
             await channel.send(f"📻 Aggiunto un messaggio radio, disattiva con `!radiomessages off`.")
             logger.info(f"Radio message added to the queue.")
@@ -867,21 +899,6 @@ class RoyalDiscordBot(discord.Client):
             await channel.send(f"✅ Video aggiunto alla coda.")
             logger.debug(f"Added {url} to the queue as URL.")
             return
-        # Parse the parameter as file
-        file_path = os.path.join(os.path.join(os.path.curdir, "opusfiles"), " ".join(params[1:]))
-        if os.path.exists(file_path):
-            # This is a file
-            await self.add_video_from_file(file=file_path, enqueuer=author)
-            await channel.send(f"✅ Video aggiunto alla coda.")
-            logger.debug(f"Added {file_path} to the queue as file.")
-            return
-        file_path += ".opus"
-        if os.path.exists(file_path):
-            # This is a file
-            await self.add_video_from_file(file=file_path, enqueuer=author)
-            await channel.send(f"✅ Video aggiunto alla coda.")
-            logger.debug(f"Added {file_path} to the queue as file.")
-            return
         # Search the parameter on youtube
         search = " ".join(params[1:])
         # This is a search
@@ -974,8 +991,8 @@ class RoyalDiscordBot(discord.Client):
         if len(self.video_queue) == 0:
             await channel.send("⚠ Non ci sono video in coda!")
             return
-        random.shuffle(self.video_queue.list)
         logger.info(f"The queue was shuffled by {author.name}#{author.discriminator}.")
+        self.video_queue.shuffle()
         await channel.send("♠️ ♦️ ♣️ ♥️ Shuffle completo!")
 
     @command
@@ -984,9 +1001,8 @@ class RoyalDiscordBot(discord.Client):
         if len(self.video_queue) == 0:
             await channel.send("⚠ Non ci sono video in coda!")
             return
-        # TODO
-        raise NotImplementedError()
         logger.info(f"The queue was cleared by {author.name}#{author.discriminator}.")
+        self.video_queue.clear()
         await channel.send(":regional_indicator_x: Tutti i video in coda rimossi.")
 
     @command
@@ -996,9 +1012,6 @@ class RoyalDiscordBot(discord.Client):
             await channel.send("⚠ Non hai specificato una canzone da riprodurre!\n"
                                "Sintassi: `!forceplay <url|ricercayoutube|nomefile>`")
             return
-        for voice_client in self.voice_clients:
-            if voice_client.is_playing():
-                voice_client.stop()
         logger.info(f"Video play was forced by {author.name}#{author.discriminator}.")
         # Parse the parameter as URL
         url = re.match(r"(?:https?://|ytsearch[0-9]*:).*", " ".join(params[1:]).strip("<>"))
@@ -1007,28 +1020,16 @@ class RoyalDiscordBot(discord.Client):
             await self.add_video_from_url(url.group(0), enqueuer=author)
             await channel.send(f"✅ Video aggiunto alla coda.")
             logger.debug(f"Forced {url} as URL.")
-            return
-        # Parse the parameter as file
-        file_path = os.path.join(os.path.join(os.path.curdir, "opusfiles"), " ".join(params[1:]))
-        if os.path.exists(file_path):
-            # This is a file
-            await self.add_video_from_file(file=file_path, enqueuer=author)
+        else:
+            # Search the parameter on youtube
+            search = " ".join(params[1:])
+            # This is a search
+            await self.add_video_from_url(url=f"ytsearch:{search}", enqueuer=author)
             await channel.send(f"✅ Video aggiunto alla coda.")
-            logger.debug(f"Forced {file_path} as file.")
-            return
-        file_path += ".opus"
-        if os.path.exists(file_path):
-            # This is a file
-            await self.add_video_from_file(file=file_path, enqueuer=author)
-            await channel.send(f"✅ Video aggiunto alla coda.")
-            logger.debug(f"Forced {file_path} as file.")
-            return
-        # Search the parameter on youtube
-        search = " ".join(params[1:])
-        # This is a search
-        await self.add_video_from_url(url=f"ytsearch:{search}", enqueuer=author)
-        await channel.send(f"✅ Video aggiunto alla coda.")
-        logger.debug(f"Forced ytsearch:{search} as YouTube search.")
+            logger.debug(f"Forced ytsearch:{search} as YouTube search.")
+        for voice_client in self.voice_clients:
+            if voice_client.is_playing():
+                voice_client.stop()
 
     @command
     async def cmd_radiomessages(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]):
@@ -1047,8 +1048,8 @@ class RoyalDiscordBot(discord.Client):
                 await channel.send("⚠ Sintassi del comando non valida.\n"
                                    "Sintassi: `!radiomessages <on|off>`")
                 return
-        logger.info(f"Radio messages status to {'enabled' if self.radio_messages.next_in < math.inf else 'disabled'}.")
-        await channel.send(f"📻 Messaggi radio **{'attivati' if self.radio_messages.next_in < math.inf else 'disattivati'}**.")
+        logger.info(f"Radio messages status to {'enabled' if self.radio_messages_next_in < math.inf else 'disabled'}.")
+        await channel.send(f"📻 Messaggi radio **{'attivati' if self.radio_messages_next_in < math.inf else 'disattivati'}**.")
 
     @command
     @requires_connected_voice_client
diff --git a/errors.py b/errors.py
index 4ab6529d..d3cc4bc0 100644
--- a/errors.py
+++ b/errors.py
@@ -28,3 +28,23 @@ class AlreadyDownloadedError(Exception):
 
 class InvalidConfigError(Exception):
     pass
+
+
+class VideoHasNoName(Exception):
+    pass
+
+
+class VideoInfoExtractionFailed(Exception):
+    pass
+
+
+class VideoIsPlaylist(Exception):
+    pass
+
+
+class VideoInfoUnknown(Exception):
+    pass
+
+
+class VideoIsNotReady(Exception):
+    pass

From 2a71a810e4ca5bd6f522a315cfe6413c45400a7e Mon Sep 17 00:00:00 2001
From: Stefano Pigozzi <ste.pigozzi@gmail.com>
Date: Tue, 4 Dec 2018 10:18:00 +0000
Subject: [PATCH 7/9] WIP: almost done

---
 discordbot.py | 144 ++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 115 insertions(+), 29 deletions(-)

diff --git a/discordbot.py b/discordbot.py
index 2268816a..4ad7d7b0 100644
--- a/discordbot.py
+++ b/discordbot.py
@@ -246,6 +246,8 @@ class LoopMode(enum.Enum):
     LOOP_QUEUE = enum.auto()
     LOOP_SINGLE = enum.auto()
     FOLLOW_SUGGESTIONS = enum.auto()
+    AUTO_SHUFFLE = enum.auto()
+    LOOPING_SHUFFLE = enum.auto()
 
 
 class VideoQueue():
@@ -274,6 +276,7 @@ class VideoQueue():
         self.list.insert(position, video)
     
     def advance_queue(self):
+        """Advance the queue to the next video."""
         if self.loop_mode == LoopMode.NORMAL:
             try:
                 self.now_playing = self.list.pop(0)
@@ -289,6 +292,16 @@ class VideoQueue():
                 self.now_playing = None
                 return
             self.now_playing = self.now_playing.suggestion()
+        elif self.loop_mode == LoopMode.AUTO_SHUFFLE:
+            self.shuffle()
+            try:
+                self.now_playing = self.list.pop(0)
+            except IndexError:
+                self.now_playing = None
+        elif self.loop_mode == LoopMode.LOOPING_SHUFFLE:
+            self.shuffle()
+            self.add(self.list[0])
+            self.now_playing = self.list.pop(0)
     
     def next_video(self) -> typing.Optional[Video]:
         if len(self.list) == 0:
@@ -302,9 +315,6 @@ class VideoQueue():
         self.list = None
         self.now_playing = None
 
-    def forward(self) -> None:
-        self.now_playing = self.list.pop(0)
-
     def find_video(self, name: str) -> typing.Optional[Video]:
         """Returns the first video with a certain name."""
         for video in self.list:
@@ -430,7 +440,9 @@ class RoyalDiscordBot(discord.Client):
             "!yes": self.null,
             "!no": self.null,
             "!pause": self.cmd_pause,
-            "!resume": self.cmd_resume
+            "!resume": self.cmd_resume,
+            "!loop": self.cmd_loop,
+            "!l": self.cmd_loop
         }
         self.video_queue: VideoQueue = VideoQueue()
         self.load_config("config.ini")
@@ -513,13 +525,13 @@ class RoyalDiscordBot(discord.Client):
             }
         })
         if not message.content.startswith("!"):
-            await message.channel.send(f":warning: In questa chat sono consentiti solo comandi per il bot.\n"
+            await message.channel.send(f"⚠️ In questa chat sono consentiti solo comandi per il bot.\n"
                                        f"Riinvia il tuo messaggio in un altro canale!")
             await message.delete()
             return
         data = message.content.split(" ")
         if data[0] not in self.commands:
-            await message.channel.send(":warning: Comando non riconosciuto.")
+            await message.channel.send("⚠️ Comando non riconosciuto.")
             return
         logger.debug(f"Received command: {message.content}")
         sentry.extra_context({
@@ -802,7 +814,7 @@ class RoyalDiscordBot(discord.Client):
                                               functools.partial(ytdl.extract_info, url=url, download=False))
         if info is None:
             logger.debug(f"No video found at {url}.")
-            await self.main_channel.send(f"⚠ Non è stato trovato nessun video all'URL `{url}`,"
+            await self.main_channel.send(f"⚠️ Non è stato trovato nessun video all'URL `{url}`,"
                                          f" pertanto non è stato aggiunto alla coda.")
             return
         if "entries" in info:
@@ -834,7 +846,7 @@ class RoyalDiscordBot(discord.Client):
                                   royal_username=params[0],
                                   discord_user=author)
         except errors.AlreadyExistingError:
-            await channel.send("⚠ Il tuo account Discord è già collegato a un account RYG "
+            await channel.send("⚠️ Il tuo account Discord è già collegato a un account RYG "
                                "o l'account RYG che hai specificato è già collegato a un account Discord.")
             return
         session.add(d)
@@ -846,13 +858,13 @@ class RoyalDiscordBot(discord.Client):
     async def cmd_cv(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]):
         """Summon the bot in the author's voice channel."""
         if author is None:
-            await channel.send("⚠ Questo comando richiede un autore.")
+            await channel.send("⚠️ Questo comando richiede un autore.")
             return
         if author.voice is None:
-            await channel.send("⚠ Non sei in nessun canale!")
+            await channel.send("⚠️ Non sei in nessun canale!")
             return
         if author.voice.channel == self.main_guild.afk_channel:
-            await channel.send("⚠ Non posso connettermi al canale AFK!")
+            await channel.send("⚠️ Non posso connettermi al canale AFK!")
             return
         if author.voice.channel.bitrate < 64000:
             await channel.send("ℹ️ Sei in un canale con un bitrate ridotto.\n"
@@ -879,7 +891,7 @@ class RoyalDiscordBot(discord.Client):
     @requires_connected_voice_client
     async def cmd_play(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]):
         if len(params) < 2:
-            await channel.send("⚠ Non hai specificato una canzone da riprodurre!\n"
+            await channel.send("⚠️ Non hai specificato una canzone da riprodurre!\n"
                                "Sintassi: `!play <url|ricercayoutube|nomefile>`")
             return
         channel.typing()
@@ -916,13 +928,13 @@ class RoyalDiscordBot(discord.Client):
                 logger.debug(f"A song was skipped.")
                 break
         else:
-            await channel.send("⚠ Non c'è nessun video in riproduzione.")
+            await channel.send("⚠️ Non c'è nessun video in riproduzione.")
 
     @command
     @requires_connected_voice_client
     async def cmd_remove(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]):
         if len(self.video_queue) == 0:
-            await channel.send("⚠ Non c'è nessun video in coda.")
+            await channel.send("⚠️ Non c'è nessun video in coda.")
             return
         if len(params) == 1:
             index = len(self.video_queue) - 1
@@ -930,12 +942,12 @@ class RoyalDiscordBot(discord.Client):
             try:
                 index = int(params[1]) - 1
             except ValueError:
-                await channel.send("⚠ Il numero inserito non è valido.\n"
+                await channel.send("⚠️ Il numero inserito non è valido.\n"
                                    "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`")
                 return
         if len(params) < 3:
             if abs(index) >= len(self.video_queue):
-                await channel.send("⚠ Il numero inserito non corrisponde a nessun video nella playlist.\n"
+                await channel.send("⚠️ Il numero inserito non corrisponde a nessun video nella playlist.\n"
                                    "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`")
                 return
             video = self.video_queue.list.pop(index)
@@ -945,27 +957,27 @@ class RoyalDiscordBot(discord.Client):
         try:
             start = int(params[1]) - 1
         except ValueError:
-            await channel.send("⚠ Il numero iniziale inserito non è valido.\n"
+            await channel.send("⚠️ Il numero iniziale inserito non è valido.\n"
                                "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`")
             return
         if start >= len(self.video_queue):
-            await channel.send("⚠ Il numero iniziale inserito non corrisponde a nessun video nella"
+            await channel.send("⚠️ Il numero iniziale inserito non corrisponde a nessun video nella"
                                " playlist.\n"
                                "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`")
             return
         try:
             end = int(params[2]) - 2
         except ValueError:
-            await channel.send("⚠ Il numero finale inserito non è valido.\n"
+            await channel.send("⚠️ Il numero finale inserito non è valido.\n"
                                "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`")
             return
         if end >= len(self.video_queue):
-            await channel.send("⚠ Il numero finale inserito non corrisponde a nessun video nella"
+            await channel.send("⚠️ Il numero finale inserito non corrisponde a nessun video nella"
                                " playlist.\n"
                                "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`")
             return
         if start > end:
-            await channel.send("⚠ Il numero iniziale è maggiore del numero finale.\n"
+            await channel.send("⚠️ Il numero iniziale è maggiore del numero finale.\n"
                                "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`")
             return
         del self.video_queue.list[start:end]
@@ -974,15 +986,61 @@ class RoyalDiscordBot(discord.Client):
 
     @command
     async def cmd_queue(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]):
+        msg = ""
+        if self.loop_mode == LoopMode.NORMAL:
+            msg += "Modalità attuale: ➡️ **Nessuna ripetizione**\n\n"
+        elif self.loop_mode == LoopMode.LOOP_QUEUE:
+            msg += "Modalità attuale: 🔁 **Ripeti intera coda**\n\n"
+        elif self.loop_mode == LoopMode.LOOP_SINGLE:
+            msg += "Modalità attuale: 🔂 **Ripeti canzone singola**\n\n"
+        elif self.loop_mode == LoopMode.FOLLOW_SUGGESTIONS:
+            msg += "Modalità attuale: 🔃 **Continua con video suggeriti**\n\n"
+        elif self.loop_mode == LoopMode.AUTO_SHUFFLE:
+            msg += "Modalità attuale: 🔀 **Video casuale dalla coda**\n\n"
+        elif self.loop_mode == LoopMode.LOOPING_SHUFFLE:
+            msg += "Modalità attuale: 🔄 **Ripeti casualmente dalla coda**\n\n"
+        msg += "**Video in coda:**\n"
         if len(self.video_queue) == 0:
-            await channel.send("**Video in coda:**\n"
-                               "nessuno")
-            return
-        msg = "**Video in coda:**\n"
-        for index, video in enumerate(self.video_queue.list[:10]):
-            msg += f"{queue_emojis[index]} {str(video)}\n"
-        if len(self.video_queue) > 10:
-            msg += f"più altri {len(self.video_queue) - 10} video!"
+            msg += "☁️ _nessuno_"
+        if self.loop_mode == LoopMode.NORMAL:
+            for index, video in enumerate(self.video_queue.list[:10]):
+                msg += f"{queue_emojis[index]} {str(video)}\n"
+            if len(self.video_queue) > 10:
+                msg += f"più altri {len(self.video_queue) - 10} video!"
+        elif self.loop_mode == LoopMode.LOOP_QUEUE:
+            for index, video in enumerate(self.video_queue.list[:10]):
+                msg += f"{queue_emojis[index]} {str(video)}\n"
+            if len(self.video_queue) > 10:
+                msg += f"più altri {len(self.video_queue) - 10} video che si ripetono!"
+            if len(self.video_queue) < 6:
+                count = len(self.video_queue)
+                while count < 10:
+                    for index, video in enumerate(self.video_queue.list[:10]):
+                        msg += f"*️⃣ {str(video)}\n"
+                    count += len(self.video_queue)
+        elif self.loop_mode == LoopMode.LOOP_SINGLE:
+            video = self.video_queue[0]
+            msg += f"1️⃣ {str(video)}\n"
+            for index in range(9):
+                msg += f"*️⃣ {str(video)}\n"
+        elif self.loop_mode == LoopMode.FOLLOW_SUGGESTIONS:
+            msg += "🌈"
+        elif self.loop_mode == LoopMode.AUTO_SHUFFLE:
+            for index, video in enumerate(self.video_queue.list[:10]):
+                msg += f"#️⃣ {str(video)}\n"
+            if len(self.video_queue) > 10:
+                msg += f"più altri {len(self.video_queue) - 10} video!"
+        elif self.loop_mode == LoopMode.LOOPING_SHUFFLE:
+            for index, video in enumerate(self.video_queue.list[:10]):
+                msg += f"#️⃣ {str(video)}\n"
+            if len(self.video_queue) > 10:
+                msg += f"più altri {len(self.video_queue) - 10} video che si ripetono!"
+            if len(self.video_queue) < 6:
+                count = len(self.video_queue)
+                while count < 10:
+                    for index, video in enumerate(self.video_queue.list[:10]):
+                        msg += f"*️⃣ {str(video)}\n"
+                    count += len(self.video_queue)
         await channel.send(msg)
 
     @command
@@ -1070,6 +1128,34 @@ class RoyalDiscordBot(discord.Client):
                 logger.debug(f"The audio stream was resumed.")
                 await channel.send(f"⏯ Riproduzione ripresa.")
 
+    @command
+    @requires_connected_voice_client
+    async def cmd_loop(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]):
+        if len(params) < 2:
+            await channel.send("⚠ Sintassi del comando non valida.\n"
+                               "Sintassi: `!loop <off|loop1|loopall|suggest|shuffle|loopshuffle>`")
+        if params[1] == "off":
+            self.video_queue.loop_mode = LoopMode.NORMAL
+            await channel.send("➡️ Modalità di coda impostata: **Nessuna ripetizione**")
+        elif params[1] == "loop1":
+            self.video_queue.loop_mode = LoopMode.LOOP_SINGLE
+            await channel.send("🔂 Modalità di coda impostata: **Ripeti canzone singola**")
+        elif params[1] == "loopall":
+            self.video_queue.loop_mode = LoopMode.LOOP_QUEUE
+            await channel.send("🔁 Modalità di coda impostata: **Ripeti intera coda**")
+        elif params[1] == "suggest":
+            # self.video_queue.loop_mode = LoopMode.FOLLOW_SUGGESTIONS
+            await channel.send("⚠️ La modalità **Continua con video suggeriti** non è ancora stata implementata.")
+        elif params[1] == "shuffle":
+            self.video_queue.loop_mode = LoopMode.AUTO_SHUFFLE
+            await channel.send("🔀 Modalità di coda impostata: **Video casuale dalla coda**")
+        elif params[1] == "loopshuffle":
+            self.video_queue.loop_mode = LoopMode.LOOPING_SHUFFLE
+            await channel.send("🔄 Modalità di coda impostata: **Ripeti casualmente dalla coda**")
+        else:
+            await channel.send("⚠️ Sintassi del comando non valida.\n"
+                               "Sintassi: `!loop <off|loop1|loopall|suggest|shuffle|loopshuffle>`")
+
 
 def process(users_connection=None):
     logger.info("Initializing the bot...")

From 311cf8aa03621aff73d87492dd060608d4e5bcc3 Mon Sep 17 00:00:00 2001
From: Stefano Pigozzi <ste.pigozzi@gmail.com>
Date: Tue, 4 Dec 2018 15:21:09 +0100
Subject: [PATCH 8/9] Fix bug

---
 discordbot.py | 66 +++++++++++++++++++++++++++++----------------------
 1 file changed, 37 insertions(+), 29 deletions(-)

diff --git a/discordbot.py b/discordbot.py
index 2268816a..35cbe6f3 100644
--- a/discordbot.py
+++ b/discordbot.py
@@ -87,7 +87,7 @@ song_special_messages = {
     "police academy": ":arrow_forward: {song} - freedom.png",
     "super smash bros. ultimate": ":arrow_forward: Re-awaken the undying light with {song}!",
     "powerwolf": ":arrow_forward: Spaggia, ma non ti sei un po' stancato di {song}?",
-    "eurobeat": ":arrow_forward: Nemesis approva la scelta di {song}. Ben fatto, amico."   
+    "eurobeat": ":arrow_forward: Nemesis approva la scelta di {song}. Ben fatto, amico."
 }
 
 # FFmpeg settings
@@ -102,7 +102,7 @@ class Succ:
 
     def __bool__(self):
         return False
-    
+
     def __getattr__(self, attr):
         return Succ()
 
@@ -129,7 +129,7 @@ sentry = Succ()
 
 
 class Video:
-    def __init__(self, enqueuer: typing.Optional[discord.Member]=None):
+    def __init__(self, enqueuer: typing.Optional[discord.Member] = None):
         self.is_ready = False
         self.name = None
         self.enqueuer = enqueuer
@@ -162,7 +162,7 @@ class Video:
     def make_audio_source(self):
         """Create an AudioSource to be played through Discord, and store and return it."""
         raise NotImplementedError()
-    
+
     def get_suggestion(self):
         """Get the next suggested video, to be used when the queue is in LoopMode.FOLLOW_SUGGESTION"""
         raise NotImplementedError()
@@ -170,8 +170,8 @@ class Video:
 
 class YoutubeDLVideo(Video):
     """A file sourcing from YoutubeDL."""
-    
-    def __init__(self, url, enqueuer: typing.Optional[discord.Member]=None):
+
+    def __init__(self, url, enqueuer: typing.Optional[discord.Member] = None):
         super().__init__(enqueuer)
         self.url = url
         self.info = None
@@ -208,7 +208,7 @@ class YoutubeDLVideo(Video):
         if self.info is None:
             raise errors.VideoInfoUnknown()
         return "./opusfiles/{}.opus".format(re.sub(r'[/\\?*"<>|!:]', "_", self.info.get("title", self.info["id"])))
-    
+
     def ready_up(self):
         """Download the video."""
         # Skip download if it is already ready
@@ -230,10 +230,10 @@ class YoutubeDLVideo(Video):
                                    }],
                                    "outtmpl": self.get_filename(),
                                    "quiet": True}) as ytdl:
-            ytdl.download(self.url)
+            ytdl.download([self.url])
         logger.info(f"Completed youtube_dl download of {repr(self)}")
         self.is_ready = True
-        
+
     def make_audio_source(self):
         if not self.is_ready:
             raise errors.VideoIsNotReady()
@@ -267,12 +267,12 @@ class VideoQueue():
     def __repr__(self) -> str:
         return f"<VideoQueue of length {len(self)}>"
 
-    def add(self, video: Video, position: int=None) -> None:
+    def add(self, video: Video, position: int = None) -> None:
         if position is None:
             self.list.append(video)
             return
         self.list.insert(position, video)
-    
+
     def advance_queue(self):
         if self.loop_mode == LoopMode.NORMAL:
             try:
@@ -289,7 +289,7 @@ class VideoQueue():
                 self.now_playing = None
                 return
             self.now_playing = self.now_playing.suggestion()
-    
+
     def next_video(self) -> typing.Optional[Video]:
         if len(self.list) == 0:
             return None
@@ -312,14 +312,14 @@ class VideoQueue():
                 return video
         return None
 
-    def not_ready_videos(self, limit: typing.Optional[int]=None):
+    def not_ready_videos(self, limit: typing.Optional[int] = None):
         """Return the non-ready videos in the first limit positions of the queue."""
-        l = []
+        video_list = []
         for video in self.list[:limit]:
             if not video.is_ready:
-                l.append(video)
-        return l
-    
+                video_list.append(video)
+        return video_list
+
     def __getitem__(self, index: int) -> Video:
         """Get an element from the list."""
         return self.list[index]
@@ -657,8 +657,10 @@ class RoyalDiscordBot(discord.Client):
                     with async_timeout.timeout(self.max_video_ready_time):
                         await loop.run_in_executor(executor, video.ready_up)
                 except asyncio.TimeoutError:
-                    logger.warning(f"Video {repr(video)} took more than {self.max_video_ready_time} to download, skipping...")
-                    await self.main_channel.send(f"⚠️ La preparazione di {video} ha richiesto più di {self.max_video_ready_time} secondi, pertanto è stato rimosso dalla coda.")
+                    logger.warning(
+                        f"Video {repr(video)} took more than {self.max_video_ready_time} to download, skipping...")
+                    await self.main_channel.send(
+                        f"⚠️ La preparazione di {video} ha richiesto più di {self.max_video_ready_time} secondi, pertanto è stato rimosso dalla coda.")
                     del self.video_queue.list[index]
                     continue
                 except Exception as e:
@@ -699,10 +701,12 @@ class RoyalDiscordBot(discord.Client):
                 # Try to generate an AudioSource
                 if self.video_queue.now_playing is None:
                     continue
-                try:
-                    audio_source = self.video_queue.now_playing.make_audio_source()
-                except errors.VideoIsNotReady:
-                    continue
+                while True:
+                    try:
+                        audio_source = self.video_queue.now_playing.make_audio_source()
+                        break
+                    except errors.VideoIsNotReady:
+                        await asyncio.sleep(1)
                 # Start playing the AudioSource
                 logger.info(f"Started playing {self.video_queue.now_playing.plain_text()}.")
                 voice_client.play(audio_source)
@@ -717,7 +721,8 @@ class RoyalDiscordBot(discord.Client):
                     try:
                         session = db.Session()
                         enqueuer = await loop.run_in_executor(executor, session.query(db.Discord)
-                                                              .filter_by(discord_id=self.video_queue.now_playing.enqueuer.id)
+                                                              .filter_by(
+                            discord_id=self.video_queue.now_playing.enqueuer.id)
                                                               .one_or_none)
                         played_music = db.PlayedMusic(enqueuer=enqueuer,
                                                       filename=self.video_queue.now_playing.database_text(),
@@ -730,10 +735,12 @@ class RoyalDiscordBot(discord.Client):
                 # Send a message in chat
                 for key in song_special_messages:
                     if key in self.video_queue.now_playing.name.lower():
-                        await self.main_channel.send(song_special_messages[key].format(song=str(self.video_queue.now_playing)))
+                        await self.main_channel.send(
+                            song_special_messages[key].format(song=str(self.video_queue.now_playing)))
                         break
                 else:
-                    await self.main_channel.send(f":arrow_forward: Ora in riproduzione: {str(self.video_queue.now_playing)}")
+                    await self.main_channel.send(
+                        f":arrow_forward: Ora in riproduzione: {str(self.video_queue.now_playing)}")
 
     async def inactivity_countdown(self):
         while True:
@@ -792,7 +799,7 @@ class RoyalDiscordBot(discord.Client):
             logger.debug(f"Waiting {self.activity_report_sample_time} seconds before the next record.")
             await asyncio.sleep(self.activity_report_sample_time)
 
-    async def add_video_from_url(self, url, index: typing.Optional[int] = None, enqueuer: discord.Member = None):
+    async def add_video_from_url(self, url: str, index: typing.Optional[int] = None, enqueuer: discord.Member = None):
         # Retrieve info
         logger.debug(f"Retrieving info for {url}.")
         with youtube_dl.YoutubeDL({"quiet": True,
@@ -904,7 +911,7 @@ class RoyalDiscordBot(discord.Client):
         # This is a search
         await self.add_video_from_url(url=f"ytsearch:{search}", enqueuer=author)
         await channel.send(f"✅ Video aggiunto alla coda.")
-        logger.debug(f"Added ytsearch:{search} to the queue as YouTube search.")
+        logger.debug(f"Added ytsearch:{search} to the queue.")
 
     @command
     @requires_connected_voice_client
@@ -1049,7 +1056,8 @@ class RoyalDiscordBot(discord.Client):
                                    "Sintassi: `!radiomessages <on|off>`")
                 return
         logger.info(f"Radio messages status to {'enabled' if self.radio_messages_next_in < math.inf else 'disabled'}.")
-        await channel.send(f"📻 Messaggi radio **{'attivati' if self.radio_messages_next_in < math.inf else 'disattivati'}**.")
+        await channel.send(
+            f"📻 Messaggi radio **{'attivati' if self.radio_messages_next_in < math.inf else 'disattivati'}**.")
 
     @command
     @requires_connected_voice_client

From 46e7ba6b2f87746c8f5a951e57ead2fca7e1ec77 Mon Sep 17 00:00:00 2001
From: Stefano Pigozzi <ste.pigozzi@gmail.com>
Date: Tue, 4 Dec 2018 17:55:43 +0100
Subject: [PATCH 9/9] Complete!

---
 discordbot.py | 117 +++++++++++++++++++++-----------------------------
 1 file changed, 48 insertions(+), 69 deletions(-)

diff --git a/discordbot.py b/discordbot.py
index 5439c261..e9248926 100644
--- a/discordbot.py
+++ b/discordbot.py
@@ -250,7 +250,7 @@ class LoopMode(enum.Enum):
     LOOPING_SHUFFLE = enum.auto()
 
 
-class VideoQueue():
+class VideoQueue:
     """The queue of videos to be played."""
 
     def __init__(self):
@@ -291,7 +291,7 @@ class VideoQueue():
             if self.now_playing is None:
                 self.now_playing = None
                 return
-            self.now_playing = self.now_playing.suggestion()
+            self.now_playing = self.now_playing.get_suggestion()
         elif self.loop_mode == LoopMode.AUTO_SHUFFLE:
             self.shuffle()
             try:
@@ -434,8 +434,6 @@ class RoyalDiscordBot(discord.Client):
             "!shuffle": self.cmd_shuffle,
             "!clear": self.cmd_clear,
             "!register": self.cmd_register,
-            "!forceplay": self.cmd_forceplay,
-            "!fp": self.cmd_forceplay,
             "!radiomessages": self.cmd_radiomessages,
             "!yes": self.null,
             "!no": self.null,
@@ -911,7 +909,7 @@ class RoyalDiscordBot(discord.Client):
             await channel.send(f"📻 Aggiunto un messaggio radio, disattiva con `!radiomessages off`.")
             logger.info(f"Radio message added to the queue.")
         # Parse the parameter as URL
-        url = re.match(r"(?:https?://|ytsearch[0-9]*:).*", " ".join(params[1:]).strip("<>"))
+        url = re.match(r"(?:https?://|ytsearch[0-9]*:|scsearch[0-9]*:).*", " ".join(params[1:]).strip("<>"))
         if url is not None:
             # This is a url
             await self.add_video_from_url(url.group(0), enqueuer=author)
@@ -994,60 +992,66 @@ class RoyalDiscordBot(discord.Client):
     @command
     async def cmd_queue(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]):
         msg = ""
-        if self.loop_mode == LoopMode.NORMAL:
-            msg += "Modalità attuale: ➡️ **Nessuna ripetizione**\n\n"
-        elif self.loop_mode == LoopMode.LOOP_QUEUE:
-            msg += "Modalità attuale: 🔁 **Ripeti intera coda**\n\n"
-        elif self.loop_mode == LoopMode.LOOP_SINGLE:
-            msg += "Modalità attuale: 🔂 **Ripeti canzone singola**\n\n"
-        elif self.loop_mode == LoopMode.FOLLOW_SUGGESTIONS:
-            msg += "Modalità attuale: 🔃 **Continua con video suggeriti**\n\n"
-        elif self.loop_mode == LoopMode.AUTO_SHUFFLE:
-            msg += "Modalità attuale: 🔀 **Video casuale dalla coda**\n\n"
-        elif self.loop_mode == LoopMode.LOOPING_SHUFFLE:
-            msg += "Modalità attuale: 🔄 **Ripeti casualmente dalla coda**\n\n"
+        if self.video_queue.loop_mode == LoopMode.NORMAL:
+            msg += "Modalità attuale: :arrow_right: **Nessuna ripetizione**\n"
+        elif self.video_queue.loop_mode == LoopMode.LOOP_QUEUE:
+            msg += "Modalità attuale: :repeat: **Ripeti intera coda**\n"
+        elif self.video_queue.loop_mode == LoopMode.LOOP_SINGLE:
+            msg += "Modalità attuale: :repeat_one: **Ripeti canzone singola**\n"
+        elif self.video_queue.loop_mode == LoopMode.FOLLOW_SUGGESTIONS:
+            msg += "Modalità attuale: :arrows_clockwise: **Continua con video suggeriti**\n"
+        elif self.video_queue.loop_mode == LoopMode.AUTO_SHUFFLE:
+            msg += "Modalità attuale: :twisted_rightwards_arrows: **Video casuale dalla coda**\n"
+        elif self.video_queue.loop_mode == LoopMode.LOOPING_SHUFFLE:
+            msg += "Modalità attuale: :arrows_counterclockwise: **Ripeti casualmente dalla coda**\n"
         msg += "**Video in coda:**\n"
-        if len(self.video_queue) == 0:
-            msg += "☁️ _nessuno_"
-        if self.loop_mode == LoopMode.NORMAL:
+        if self.video_queue.now_playing is None:
+            msg += ":cloud: _nessuno_"
+        else:
+            msg += f":arrow_forward: {str(self.video_queue.now_playing)}\n"
+        if self.video_queue.loop_mode == LoopMode.NORMAL:
             for index, video in enumerate(self.video_queue.list[:10]):
                 msg += f"{queue_emojis[index]} {str(video)}\n"
             if len(self.video_queue) > 10:
                 msg += f"più altri {len(self.video_queue) - 10} video!"
-        elif self.loop_mode == LoopMode.LOOP_QUEUE:
+        elif self.video_queue.loop_mode == LoopMode.LOOP_QUEUE:
             for index, video in enumerate(self.video_queue.list[:10]):
                 msg += f"{queue_emojis[index]} {str(video)}\n"
             if len(self.video_queue) > 10:
                 msg += f"più altri {len(self.video_queue) - 10} video che si ripetono!"
-            if len(self.video_queue) < 6:
-                count = len(self.video_queue)
-                while count < 10:
-                    for index, video in enumerate(self.video_queue.list[:10]):
-                        msg += f"*️⃣ {str(video)}\n"
-                    count += len(self.video_queue)
-        elif self.loop_mode == LoopMode.LOOP_SINGLE:
-            video = self.video_queue[0]
-            msg += f"1️⃣ {str(video)}\n"
+            else:
+                if len(self.video_queue) < 6:
+                    count = len(self.video_queue)
+                    while count < 10:
+                        for index, video in enumerate(self.video_queue.list[:10]):
+                            msg += f":asterisk: {str(video)}\n"
+                        count += len(self.video_queue)
+                msg += "e avanti così!"
+        elif self.video_queue.loop_mode == LoopMode.LOOP_SINGLE:
+            video = self.video_queue.now_playing
             for index in range(9):
-                msg += f"*️⃣ {str(video)}\n"
-        elif self.loop_mode == LoopMode.FOLLOW_SUGGESTIONS:
-            msg += "🌈"
-        elif self.loop_mode == LoopMode.AUTO_SHUFFLE:
+                msg += f":asterisk: {str(video)}\n"
+            msg += "all'infinito!"
+        elif self.video_queue.loop_mode == LoopMode.FOLLOW_SUGGESTIONS:
+            msg += ":rainbow:"
+        elif self.video_queue.loop_mode == LoopMode.AUTO_SHUFFLE:
             for index, video in enumerate(self.video_queue.list[:10]):
-                msg += f"#️⃣ {str(video)}\n"
+                msg += f":hash: {str(video)}\n"
             if len(self.video_queue) > 10:
                 msg += f"più altri {len(self.video_queue) - 10} video!"
-        elif self.loop_mode == LoopMode.LOOPING_SHUFFLE:
+        elif self.video_queue.loop_mode == LoopMode.LOOPING_SHUFFLE:
             for index, video in enumerate(self.video_queue.list[:10]):
-                msg += f"#️⃣ {str(video)}\n"
+                msg += f":hash: {str(video)}\n"
             if len(self.video_queue) > 10:
                 msg += f"più altri {len(self.video_queue) - 10} video che si ripetono!"
-            if len(self.video_queue) < 6:
-                count = len(self.video_queue)
-                while count < 10:
-                    for index, video in enumerate(self.video_queue.list[:10]):
-                        msg += f"*️⃣ {str(video)}\n"
-                    count += len(self.video_queue)
+            else:
+                if len(self.video_queue) < 6:
+                    count = len(self.video_queue)
+                    while count < 10:
+                        for index, video in enumerate(self.video_queue.list[:10]):
+                            msg += f":asterisk: {str(video)}\n"
+                        count += len(self.video_queue)
+                msg += "a ripetizione casuale!"
         await channel.send(msg)
 
     @command
@@ -1070,32 +1074,6 @@ class RoyalDiscordBot(discord.Client):
         self.video_queue.clear()
         await channel.send(":regional_indicator_x: Tutti i video in coda rimossi.")
 
-    @command
-    @requires_connected_voice_client
-    async def cmd_forceplay(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]):
-        if len(params) < 2:
-            await channel.send("⚠ Non hai specificato una canzone da riprodurre!\n"
-                               "Sintassi: `!forceplay <url|ricercayoutube|nomefile>`")
-            return
-        logger.info(f"Video play was forced by {author.name}#{author.discriminator}.")
-        # Parse the parameter as URL
-        url = re.match(r"(?:https?://|ytsearch[0-9]*:).*", " ".join(params[1:]).strip("<>"))
-        if url is not None:
-            # This is a url
-            await self.add_video_from_url(url.group(0), enqueuer=author)
-            await channel.send(f"✅ Video aggiunto alla coda.")
-            logger.debug(f"Forced {url} as URL.")
-        else:
-            # Search the parameter on youtube
-            search = " ".join(params[1:])
-            # This is a search
-            await self.add_video_from_url(url=f"ytsearch:{search}", enqueuer=author)
-            await channel.send(f"✅ Video aggiunto alla coda.")
-            logger.debug(f"Forced ytsearch:{search} as YouTube search.")
-        for voice_client in self.voice_clients:
-            if voice_client.is_playing():
-                voice_client.stop()
-
     @command
     async def cmd_radiomessages(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]):
         if not self.radio_messages_enabled:
@@ -1142,6 +1120,7 @@ class RoyalDiscordBot(discord.Client):
         if len(params) < 2:
             await channel.send("⚠ Sintassi del comando non valida.\n"
                                "Sintassi: `!loop <off|loop1|loopall|suggest|shuffle|loopshuffle>`")
+            return
         if params[1] == "off":
             self.video_queue.loop_mode = LoopMode.NORMAL
             await channel.send("➡️ Modalità di coda impostata: **Nessuna ripetizione**")