diff --git a/discordbot.py b/discordbot.py index 6caf52dc..34e802fd 100644 --- a/discordbot.py +++ b/discordbot.py @@ -8,7 +8,6 @@ import sys import db import youtube_dl import concurrent.futures -import platform import typing import os import asyncio @@ -19,8 +18,9 @@ import raven import logging import errors import datetime +import sqlalchemy.exc -logging.basicConfig() +logging.getLogger().setLevel(level=20) # Queue emojis queue_emojis = [":one:", @@ -42,578 +42,7 @@ config = configparser.ConfigParser() config.read("config.ini") # Radio messages -radio_messages = ["https://www.youtube.com/watch?v=3-yeK1Ck4yk&feature=youtu.be"] -radio_messages_enabled = False -radio_message_in = int(config["Discord"]["radio_messages_every"]) - - -class DurationError(Exception): - pass - - -class InfoNotRetrievedError(Exception): - pass - - -class FileNotDownloadedError(Exception): - pass - - -class AlreadyDownloadedError(Exception): - pass - - -class Video: - def __init__(self, url: str=None, file: str=None, info: dict=None, enqueuer: discord.Member=None): - self.url = url - if file is None and info is None: - self.file = str(hash(url)) + ".opus" - elif info is not None: - self.file = re.sub(r'[/\\?*"<>|!:]', "_", info["title"]) + ".opus" - else: - self.file = file - self.downloaded = False if file is None else True - self.info = info - self.enqueuer = enqueuer - - def __str__(self): - if self.info is None or "title" not in self.info: - return f"`{self.file}`" - return f"_{self.info['title']}_" - - def plain_text(self): - 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): - # File already downloaded - if self.downloaded: - raise AlreadyDownloadedError() - # No progress hooks - if progress_hooks is None: - progress_hooks = [] - # Check if under max duration - if self.info is not None and self.info.get("duration", 0) > int(config["YouTube"]["max_duration"]): - raise DurationError() - # Download the file - with youtube_dl.YoutubeDL({"noplaylist": True, - "format": "best", - "postprocessors": [{ - "key": 'FFmpegExtractAudio', - "preferredcodec": 'opus' - }], - "outtmpl": f"./opusfiles/{self.file}", - "progress_hooks": progress_hooks, - "quiet": True}) as ytdl: - await loop.run_in_executor(executor, functools.partial(ytdl.download, [self.url])) - self.downloaded = True - - async def create_player(self) -> discord.voice_client.ProcessPlayer: - # Check if the file has been downloaded - if not self.downloaded: - raise FileNotDownloadedError() - global voice_client - return voice_client.create_ffmpeg_player(f"./opusfiles/{self.file}") - - -# noinspection PyUnreachableCode -if __debug__: - version = "Dev" - commit_msg = "_in sviluppo_" -else: - # Find the latest git tag - old_wd = os.getcwd() - try: - os.chdir(os.path.dirname(__file__)) - version = str(subprocess.check_output(["git", "describe", "--tags"]), encoding="utf8").strip() - commit_msg = str(subprocess.check_output(["git", "log", "-1", "--pretty=%B"]), encoding="utf8").strip() - except Exception: - version = "❓" - finally: - os.chdir(old_wd) - -# Init the discord bot -client = discord.Client() -if platform.system() == "Linux": - discord.opus.load_opus("/usr/lib/x86_64-linux-gnu/libopus.so") -elif platform.system() == "Windows": - discord.opus.load_opus("libopus-0.dll") - -voice_client = None -voice_player = None -now_playing = None -voice_queue = [] - -# Init the executor -executor = concurrent.futures.ThreadPoolExecutor(max_workers=3) - -# Init the Sentry client -sentry = raven.Client(config["Sentry"]["token"], - release=version, - install_logging_hook=False, - hook_libraries=[]) - - -async def on_error(event, *args, **kwargs): - ei = sys.exc_info() - print("ERRORE CRITICO:\n" + repr(ei[1]) + "\n\n" + repr(ei)) - try: - await client.send_message(client.get_channel(config["Discord"]["main_channel"]), - f"☢️ **ERRORE CRITICO NELL'EVENTO** `{event}`\n" - f"Il bot si è chiuso e si dovrebbe riavviare entro qualche minuto.\n" - 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"```") - if voice_client is not None: - await voice_client.disconnect() - await client.change_presence(status=discord.Status.invisible) - await client.close() - except Exception as e: - print("ERRORE CRITICO PIU' CRITICO:\n" + repr(e) + "\n\n" + repr(sys.exc_info())) - loop.stop() - sentry.captureException(exc_info=ei) - os._exit(1) - pass - - -@client.event -async def on_ready(): - await client.send_message(client.get_channel(config["Discord"]["main_channel"]), - f"ℹ Royal Bot avviato e pronto a ricevere comandi!\n" - f"Ultimo aggiornamento: `{version}: {commit_msg}`") - await client.change_presence(game=None, status=discord.Status.online) - - -@client.event -async def on_message(message: discord.Message): - global voice_client - global voice_player - if message.channel != client.get_channel(config["Discord"]["main_channel"]) or message.author.bot: - return - sentry.user_context({ - "discord": { - "discord_id": message.author.id, - "name": message.author.name, - "discriminator": message.author.discriminator - } - }) - if not message.content.startswith("!"): - client.send_message(message.channel, - ":warning: In questa chat sono consentiti solo comandi per il bot.\n" - "Riinvia il tuo messaggio in <#425780562805129226>!") - client.delete_message(message) - return - data = message.content.split(" ") - if data[0] not in commands: - await client.send_message(message.channel, ":warning: Comando non riconosciuto.") - return - await commands[data[0]](channel=client.get_channel(config["Discord"]["main_channel"]), - author=message.author, - params=data) - - -async def update_users_pipe(users_connection): - await client.wait_until_ready() - while True: - msg = await loop.run_in_executor(executor, users_connection.recv) - if msg == "get cv": - discord_members = list(client.get_server(config["Discord"]["server_id"]).members) - users_connection.send(discord_members) - elif msg == "stop": - await client.logout() - exit(0) - elif msg.startswith("!"): - data = msg.split(" ") - if data[0] not in commands: - users_connection.send("error") - continue - await commands[data[0]](channel=client.get_channel(config["Discord"]["main_channel"]), - author=None, - params=data) - users_connection.send("success") - - -def command(func): - """Decorator. Runs the function as a Discord command.""" - async def new_func(channel: discord.Channel, author: discord.Member, params: typing.List[str], *args, **kwargs): - if author is not None: - sentry.user_context({ - "discord_id": author.id, - "username": f"{author.name}#{author.discriminator}" - }) - else: - sentry.user_context({ - "source": "Telegram" - }) - try: - result = await func(channel=channel, author=author, params=params, *args, **kwargs) - except Exception: - ei = sys.exc_info() - try: - await client.send_message(channel, - f"☢ **ERRORE DURANTE L'ESECUZIONE DEL COMANDO {params[0]}**\n" - f"Il comando è stato ignorato.\n" - 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"```") - except Exception: - pass - sentry.captureException(exc_info=ei) - else: - return result - return new_func - - -def requires_voice_client(func): - "Decorator. Ensures the voice client is connected before running the command." - async def new_func(channel: discord.Channel, author: discord.Member, params: typing.List[str], *args, **kwargs): - global voice_client - if voice_client is None or not voice_client.is_connected(): - await client.send_message(channel, - "⚠️ Non sono connesso alla cv!\n" - "Fammi entrare scrivendo `!cv` mentre sei in chat vocale.") - return - return await func(channel=channel, author=author, params=params, *args, **kwargs) - return new_func - - -def requires_rygdb(func, optional=False): - async def new_func(channel: discord.Channel, author: discord.Member, params: typing.List[str], *args, **kwargs): - session = db.Session() - dbuser = await loop.run_in_executor(executor, - session.query(db.Discord) - .filter_by(discord_id=author.id) - .join(db.Royal) - .first) - await loop.run_in_executor(executor, session.close) - if not optional and dbuser is None: - await client.send_message(channel, - "⚠️ Devi essere registrato su Royalnet per poter utilizzare questo comando.") - return - return await func(channel=channel, author=author, params=params, dbuser=dbuser, *args, **kwargs) - return new_func - - -@command -async def cmd_ping(channel: discord.Channel, author: discord.Member, params: typing.List[str]): - await client.send_message(channel, f"Pong!") - - -@command -async def cmd_cv(channel: discord.Channel, author: discord.Member, params: typing.List[str]): - if author is None: - await client.send_message(channel, "⚠ Questo comando richiede un autore.") - if author.voice is None or author.voice.voice_channel is None: - await client.send_message(channel, "⚠ Non sei in nessun canale!") - return - global voice_client - if voice_client is not None and voice_client.is_connected(): - await voice_client.move_to(author.voice.voice_channel) - else: - voice_client = await client.join_voice_channel(author.voice.voice_channel) - await client.send_message(channel, f"✅ Mi sono connesso in <#{author.voice.voice_channel.id}>.") - - -async def add_video_from_url(url, index: typing.Optional[int]=None, enqueuer: discord.Member=None): - # Retrieve info - with youtube_dl.YoutubeDL({"quiet": True, - "ignoreerrors": True, - "simulate": True}) as ytdl: - info = await loop.run_in_executor(executor, - functools.partial(ytdl.extract_info, url=url, download=False)) - if info is None: - await client.send_message(client.get_channel(config["Discord"]["main_channel"]), - f"⚠ Non è stato trovato nessun video all'URL `{url}`," - f" pertanto non è stato aggiunto alla coda.") - return - if "entries" in info: - # This is a playlist - for entry in info["entries"]: - if index is not None: - voice_queue.insert(index, Video(url=entry["webpage_url"], info=entry, enqueuer=enqueuer)) - else: - voice_queue.append(Video(url=entry["webpage_url"], info=entry, enqueuer=enqueuer)) - return - # This is a single video - if index is not None: - voice_queue.insert(index, Video(url=url, info=info, enqueuer=enqueuer)) - else: - voice_queue.append(Video(url=url, info=info, enqueuer=enqueuer)) - - -async def add_video_from_file(file, index: typing.Optional[int]=None, enqueuer: discord.Member=None): - if index is not None: - voice_queue.insert(index, Video(file=file, enqueuer=enqueuer)) - else: - voice_queue.append(Video(file=file, enqueuer=enqueuer)) - - -@command -@requires_voice_client -async def cmd_play(channel: discord.Channel, author: discord.Member, params: typing.List[str]): - if len(params) < 2: - await client.send_message(channel, "⚠ Non hai specificato una canzone da riprodurre!\n" - "Sintassi: `!play `") - return - # If the radio messages are enabled... - global radio_messages_enabled - if radio_messages_enabled: - global radio_message_in - radio_message_in -= 1 - if radio_message_in <= 0: - radio_message = random.sample(radio_messages, 1)[0] - radio_message_in = int(config["Discord"]["radio_messages_every"]) - await add_video_from_url(radio_message) - await client.send_message(channel, f"✅ Aggiunto un messaggio radio, disattiva con `!radiomessages off`.") - # 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 add_video_from_url(url.group(0), enqueuer=author) - await client.send_message(channel, f"✅ Video aggiunto alla coda.") - 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 add_video_from_file(file=file_path, enqueuer=author) - await client.send_message(channel, f"✅ Video aggiunto alla coda.") - return - file_path += ".opus" - if os.path.exists(file_path): - # This is a file - await add_video_from_file(file=file_path, enqueuer=author) - await client.send_message(channel, f"✅ Video aggiunto alla coda.") - return - # Search the parameter on youtube - search = " ".join(params[1:]) - # This is a search - await add_video_from_url(url=f"ytsearch:{search}", enqueuer=author) - await client.send_message(channel, f"✅ Video aggiunto alla coda.") - - -@command -@requires_voice_client -async def cmd_skip(channel: discord.Channel, author: discord.Member, params: typing.List[str]): - global voice_player - if voice_player is None: - await client.send_message(channel, "⚠ Non c'è nessun video in riproduzione.") - return - voice_player.stop() - await client.send_message(channel, f"⏩ Video saltato.") - - -@command -@requires_voice_client -async def cmd_remove(channel: discord.Channel, author: discord.Member, params: typing.List[str]): - if len(voice_queue) == 0: - await client.send_message(channel, "⚠ Non c'è nessun video in coda.") - return - if len(params) == 1: - index = len(voice_queue) - 1 - else: - try: - index = int(params[1]) - 1 - except ValueError: - await client.send_message(channel, "⚠ Il numero inserito non è valido.\n" - "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`") - return - if len(params) < 3: - if abs(index) >= len(voice_queue): - await client.send_message(channel, "⚠ Il numero inserito non corrisponde a nessun video nella playlist.\n" - "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`") - return - video = voice_queue.pop(index) - await client.send_message(channel, f":regional_indicator_x: {str(video)} è stato rimosso dalla coda.") - return - try: - start = int(params[1]) - 1 - except ValueError: - await client.send_message(channel, "⚠ Il numero iniziale inserito non è valido.\n" - "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`") - return - if start >= len(voice_queue): - await client.send_message(channel, "⚠ 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 client.send_message(channel, "⚠ Il numero finale inserito non è valido.\n" - "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`") - return - if end >= len(voice_queue): - await client.send_message(channel, "⚠ Il numero finale inserito non corrisponde a nessun video nella" - " playlist.\n" - "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`") - return - if start > end: - await client.send_message(channel, "⚠ Il numero iniziale è maggiore del numero finale.\n" - "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`") - return - del voice_queue[start:end] - await client.send_message(channel, f":regional_indicator_x: {end - start} video rimossi dalla coda.") - - -@command -async def cmd_queue(channel: discord.Channel, author: discord.Member, params: typing.List[str]): - if len(voice_queue) == 0: - await client.send_message(channel, "**Video in coda:**\n" - "nessuno") - return - msg = "**Video in coda:**\n" - for index, video in enumerate(voice_queue[:10]): - msg += f"{queue_emojis[index]} {str(video)}\n" - if len(voice_queue) > 10: - msg += f"più altri {len(voice_queue) - 10} video!" - await client.send_message(channel, msg) - - -@command -@requires_voice_client -async def cmd_shuffle(channel: discord.Channel, author: discord.Member, params: typing.List[str]): - if len(voice_queue) == 0: - await client.send_message(channel, "⚠ Non ci sono video in coda!") - return - random.shuffle(voice_queue) - await client.send_message(channel, "♠️ ♦️ ♣️ ♥️ Shuffle completo!") - - -@command -@requires_voice_client -async def cmd_clear(channel: discord.Channel, author: discord.Member, params: typing.List[str]): - global voice_queue - if len(voice_queue) == 0: - await client.send_message(channel, "⚠ Non ci sono video in coda!") - return - voice_queue = [] - await client.send_message(channel, ":regional_indicator_x: Tutti i video in coda rimossi.") - - -@command -@requires_voice_client -async def cmd_dump_voice_player_error(channel: discord.Channel, author: discord.Member, params: typing.List[str]): - global voice_player - if voice_player is None: - return - await client.send_message(channel, f"```\n{str(voice_player.error)}\n```") - - -@command -async def cmd_register(channel: discord.Channel, author: discord.Member, params: typing.List[str]): - session = db.Session() - if len(params) < 1: - await client.send_message(channel, "⚠️ Non hai specificato un username!\n" - "Sintassi corretta: `!register `") - return - try: - d = db.Discord.create(session, - royal_username=params[0], - discord_user=author) - except errors.AlreadyExistingError: - await client.send_message(channel, - "⚠ 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) - session.commit() - session.close() - await client.send_message(channel, "✅ Sincronizzazione completata!") - - -@command -@requires_voice_client -async def cmd_forceplay(channel: discord.Channel, author: discord.Member, params: typing.List[str]): - if voice_player is not None: - voice_player.stop() - if len(params) < 2: - await client.send_message(channel, "⚠ Non hai specificato una canzone da riprodurre!\n" - "Sintassi: `!forceplay `") - return - # 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 add_video_from_url(url.group(0), enqueuer=author, index=0) - await client.send_message(channel, f"✅ Riproduzione del video forzata.") - 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 add_video_from_file(file=file_path, enqueuer=author, index=0) - await client.send_message(channel, f"✅ Riproduzione del video forzata.") - return - file_path += ".opus" - if os.path.exists(file_path): - # This is a file - await add_video_from_file(file=file_path, enqueuer=author, index=0) - await client.send_message(channel, f"✅ Riproduzione del video forzata.") - return - # Search the parameter on youtube - search = " ".join(params[1:]) - # This is a search - await add_video_from_url(url=f"ytsearch:{search}", enqueuer=author, index=0) - await client.send_message(channel, f"✅ Riproduzione del video forzata.") - - -@command -async def cmd_radiomessages(channel: discord.Channel, author: discord.Member, params: typing.List[str]): - global radio_messages_enabled - if len(params) < 2: - radio_messages_enabled = not radio_messages_enabled - else: - if params[1].lower() == "on": - radio_messages_enabled = True - elif params[1].lower() == "off": - radio_messages_enabled = False - else: - await client.send_message(channel, "⚠ Sintassi del comando non valida.\n" - "Sintassi: `!radiomessages [on|off]`") - return - await client.send_message(channel, - f"📻 Messaggi radio **{'attivati' if radio_messages_enabled else 'disattivati'}**.") - - -async def queue_predownload_videos(): - while True: - for index, video in enumerate(voice_queue[:int(config["YouTube"]["predownload_videos"])].copy()): - if video.downloaded: - continue - try: - with async_timeout.timeout(int(config["YouTube"]["download_timeout"])): - await video.download() - except asyncio.TimeoutError: - await client.send_message(client.get_channel(config["Discord"]["main_channel"]), - f"⚠️ Il download di {str(video)} ha richiesto più di" - f" {config['YouTube']['download_timeout']} secondi, pertanto è stato rimosso" - f" dalla coda.") - del voice_queue[index] - continue - except DurationError: - await client.send_message(client.get_channel(config["Discord"]["main_channel"]), - f"⚠️ {str(video)} dura più di" - f" {str(int(config['YouTube']['max_duration']) // 60)}" - f" minuti, quindi è stato rimosso dalla coda.") - del voice_queue[index] - continue - except Exception as e: - await client.send_message(client.get_channel(config["Discord"]["main_channel"]), - f"⚠️ E' stato incontrato un errore durante il download di {str(video)}," - f" quindi è stato rimosso dalla coda.\n\n" - f"```python\n" - f"{str(e)}" - f"```") - del voice_queue[index] - continue - await asyncio.sleep(1) - +radio_messages = ["https://www.youtube.com/watch?v=3-yeK1Ck4yk"] song_special_messages = { "despacito": ":arrow_forward: this is so sad. alexa play {song}", @@ -651,85 +80,656 @@ song_special_messages = { "jump up superstar": ":arrow_forward: Is {song} the Tengen Toppa Guren Lagann opening?" } +# noinspection PyUnreachableCode +if __debug__: + version = "discord-py-rewrite" + commit_msg = "_Aggiornamento di Discordbot all'APIv6_" +else: + # Find the latest git tag + old_wd = os.getcwd() + try: + os.chdir(os.path.dirname(__file__)) + version = str(subprocess.check_output(["git", "describe", "--tags"]), encoding="utf8").strip() + commit_msg = str(subprocess.check_output(["git", "log", "-1", "--pretty=%B"]), encoding="utf8").strip() + except Exception: + version = "❓" + finally: + os.chdir(old_wd) -async def queue_play_next_video(): - await client.wait_until_ready() - global voice_client - global voice_player - global now_playing - while True: - if voice_client is None: - await asyncio.sleep(1) - continue - if voice_player is not None and not voice_player.is_done(): - await asyncio.sleep(0.5) - continue - if len(voice_queue) == 0: - await asyncio.sleep(0.5) - if now_playing is not None: - await client.change_presence() - now_playing = None - continue - now_playing = voice_queue[0] - if not now_playing.downloaded: - await asyncio.sleep(0.5) - continue - voice_player = await now_playing.create_player() - voice_player.start() - if now_playing.enqueuer is not None: - 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) - await client.change_presence(game=discord.Game(name=now_playing.plain_text(), type=2)) - for key in song_special_messages: - if key in now_playing.file.lower(): - await client.send_message(client.get_channel(config["Discord"]["main_channel"]), - song_special_messages[key].format(song=str(now_playing))) +# FFmpeg settings +ffmpeg_settings = {} + +# Init the executor +executor = concurrent.futures.ThreadPoolExecutor(max_workers=3) + +# Init the Sentry client +sentry = raven.Client(config["Sentry"]["token"], + release=version, + install_logging_hook=False, + hook_libraries=[]) + + +class DurationError(Exception): + pass + + +class InfoNotRetrievedError(Exception): + pass + + +class FileNotDownloadedError(Exception): + pass + + +class AlreadyDownloadedError(Exception): + pass + + +class InvalidConfigError(Exception): + pass + + +class Video: + def __init__(self, url: str = None, file: str = None, info: dict = None, enqueuer: discord.Member = None): + self.url = url + if file is None and info is None: + self.file = str(hash(url)) + ".opus" + elif info is not None: + self.file = re.sub(r'[/\\?*"<>|!:]', "_", info["title"]) + ".opus" + else: + self.file = file + self.downloaded = False if file is None else True + self.info = info + self.enqueuer = enqueuer + self.duration = None + + def __str__(self): + if self.info is None or "title" not in self.info: + return f"`{self.file}`" + return f"_{self.info['title']}_" + + def plain_text(self): + 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): + # File already downloaded + if self.downloaded: + raise 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)) + if self.info is not None and self.duration.total_seconds() > int(config["YouTube"]["max_duration"]): + raise DurationError() + # Download the file + with youtube_dl.YoutubeDL({"noplaylist": True, + "format": "best", + "postprocessors": [{ + "key": 'FFmpegExtractAudio', + "preferredcodec": 'opus' + }], + "outtmpl": f"./opusfiles/{self.file}", + "progress_hooks": progress_hooks, + "quiet": True}) as ytdl: + await loop.run_in_executor(executor, functools.partial(ytdl.download, [self.url])) + self.downloaded = True + + def create_audio_source(self) -> discord.PCMVolumeTransformer: + # Check if the file has been downloaded + if not self.downloaded: + raise FileNotDownloadedError() + return discord.PCMVolumeTransformer(discord.FFmpegPCMAudio(f"./opusfiles/{self.file}", **ffmpeg_settings)) + + +def command(func): + """Decorator. Runs the function as a Discord command.""" + + async def new_func(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str], *args, + **kwargs): + if author is not None: + sentry.user_context({ + "discord_id": author.id, + "username": f"{author.name}#{author.discriminator}" + }) + else: + sentry.user_context({ + "source": "Telegram" + }) + try: + result = await func(self, channel=channel, author=author, params=params, *args, **kwargs) + except Exception: + ei = sys.exc_info() + try: + await channel.send(f"☢ **ERRORE DURANTE L'ESECUZIONE DEL COMANDO {params[0]}**\n" + f"Il comando è stato ignorato.\n" + 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"```") + except Exception: + pass + sentry.captureException(exc_info=ei) + else: + return result + + return new_func + + +def requires_connected_voice_client(func): + """Decorator. Ensures the voice client is connected before running the command.""" + + async def new_func(self: "RoyalDiscordBot", channel: discord.TextChannel, author: discord.Member, + params: typing.List[str], *args, **kwargs): + for voice_client in self.voice_clients: + if voice_client.channel in self.main_guild.channels and voice_client.is_connected(): break else: - await client.send_message(client.get_channel(config["Discord"]["main_channel"]), - f":arrow_forward: Ora in riproduzione: {str(now_playing)}") - del voice_queue[0] + await channel.send("⚠️ Non sono connesso alla cv!\n" + "Fammi entrare scrivendo `!cv` mentre sei in chat vocale.") + return + return await func(self, channel=channel, author=author, params=params, *args, **kwargs) + + return new_func -commands = { - "!ping": cmd_ping, - "!cv": cmd_cv, - "!summon": cmd_cv, - "!play": cmd_play, - "!p": cmd_play, - "!search": cmd_play, - "!file": cmd_play, - "!skip": cmd_skip, - "!s": cmd_skip, - "!remove": cmd_remove, - "!cancel": cmd_remove, - "!queue": cmd_queue, - "!q": cmd_queue, - "!shuffle": cmd_shuffle, - "!clear": cmd_clear, - "!dump_vp": cmd_dump_voice_player_error, - "!register": cmd_register, - "!forceplay": cmd_forceplay, - "!fp": cmd_forceplay, - "!radiomessages": cmd_radiomessages -} +def requires_rygdb(func, optional=False): + async def new_func(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str], *args, + **kwargs): + session = db.Session() + dbuser = await loop.run_in_executor(executor, + session.query(db.Discord) + .filter_by(discord_id=author.id) + .join(db.Royal) + .first) + await loop.run_in_executor(executor, session.close) + if not optional and dbuser is None: + await channel.send("⚠️ Devi essere registrato su Royalnet per poter utilizzare questo comando.") + return + return await func(self, channel=channel, author=author, params=params, dbuser=dbuser, *args, **kwargs) + + return new_func + + +class RoyalDiscordBot(discord.Client): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.main_channel: typing.Optional[discord.TextChannel] = None + self.main_guild: typing.Optional[discord.Guild] = None + self.commands = { + "!ping": self.cmd_ping, + "!cv": self.cmd_cv, + "!summon": self.cmd_cv, + "!play": self.cmd_play, + "!p": self.cmd_play, + "!search": self.cmd_play, + "!file": self.cmd_play, + "!skip": self.cmd_skip, + "!s": self.cmd_skip, + "!remove": self.cmd_remove, + "!cancel": self.cmd_remove, + "!queue": self.cmd_queue, + "!q": self.cmd_queue, + "!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 + } + self.video_queue: typing.List[Video] = [] + self.now_playing = None + self.radio_messages = False + self.next_radio_message_in = int(config["Discord"]["radio_messages_every"]) + asyncio.ensure_future(self.queue_predownload_videos()) + asyncio.ensure_future(self.queue_play_next_video()) + + 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 InvalidConfigError("The main channel is not a TextChannel!") + # Get the main guild + self.main_guild = self.get_guild(int(config["Discord"]["server_id"])) + if not isinstance(self.main_guild, discord.Guild): + raise InvalidConfigError("The main guild does not exist!") + await self.main_channel.send(f"ℹ Royal Bot avviato e pronto a ricevere comandi!\n" + f"Ultimo aggiornamento: `{version}: {commit_msg}`") + await self.change_presence(status=discord.Status.online, activity=None) + + async def on_message(self, message: discord.Message): + if message.channel != self.main_channel or message.author.bot: + return + sentry.user_context({ + "discord": { + "discord_id": message.author.id, + "name": message.author.name, + "discriminator": message.author.discriminator + } + }) + if not message.content.startswith("!"): + await message.channel.send(f":warning: 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.") + return + await self.commands[data[0]](channel=message.channel, + author=message.author, + params=data) + + async def on_error(self, event_method, *args, **kwargs): + ei = sys.exc_info() + print("ERRORE CRITICO:\n" + repr(ei[1]) + "\n\n" + repr(ei)) + try: + await self.main_channel.send(f"☢️ **ERRORE CRITICO NELL'EVENTO** `{event_method}`\n" + f"Il bot si è chiuso e si dovrebbe riavviare entro qualche minuto.\n" + 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"```") + await self.change_presence(status=discord.Status.invisible) + await self.close() + except Exception as e: + print("ERRORE CRITICO PIU' CRITICO:\n" + repr(e) + "\n\n" + repr(sys.exc_info())) + loop.stop() + sentry.captureException(exc_info=ei) + exit(1) + + async def feed_pipe(self, connection): + await self.wait_until_ready() + while True: + msg = await loop.run_in_executor(executor, connection.recv) + if msg == "get cv": + discord_members = list(self.main_guild.members) + connection.send(discord_members) + elif msg == "stop": + await self.logout() + exit(0) + elif msg.startswith("!"): + data = msg.split(" ") + if data[0] not in self.commands: + connection.send("error") + continue + await self.main_channel.send(f"{msg}\n" + f"_(da Telegram)_") + await self.commands[data[0]](channel=self.get_channel(config["Discord"]["main_channel"]), + author=None, + params=data) + connection.send("success") + + async def queue_predownload_videos(self): + while True: + for index, video in enumerate(self.video_queue[:int(config["YouTube"]["predownload_videos"])].copy()): + if video.downloaded: + continue + try: + with async_timeout.timeout(int(config["YouTube"]["download_timeout"])): + await video.download() + except asyncio.TimeoutError: + 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] + continue + except DurationError: + await self.main_channel.send(f"⚠️ {str(video)} dura più di" + f" {str(int(config['YouTube']['max_duration']) // 60)}" + f" minuti, quindi è stato rimosso dalla coda.") + del self.video_queue[index] + continue + except Exception as 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[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(): + continue + if len(self.video_queue) == 0: + self.now_playing = None + await self.change_presence() + continue + now_playing = self.video_queue[0] + try: + audio_source = now_playing.create_audio_source() + except FileNotDownloadedError: + continue + voice_client.play(audio_source) + del self.video_queue[0] + activity = discord.Activity(name=now_playing.plain_text(), + type=discord.ActivityType.playing) + 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) + + async def add_video_from_url(self, url, index: typing.Optional[int] = None, enqueuer: discord.Member = None): + # Retrieve info + with youtube_dl.YoutubeDL({"quiet": True, + "ignoreerrors": True, + "simulate": True}) as ytdl: + info = await loop.run_in_executor(executor, + functools.partial(ytdl.extract_info, url=url, download=False)) + if info is None: + 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: + # This is a playlist + 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)) + return + # This is a single video + 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)) + + 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)) + + @command + async def null(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]): + pass + + @command + async def cmd_ping(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]): + await channel.send(f"Pong!") + + @command + async def cmd_register(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]): + session = db.Session() + if len(params) < 1: + await channel.send("⚠️ Non hai specificato un username!\n" + "Sintassi corretta: `!register `") + return + try: + # noinspection PyTypeChecker + d = db.Discord.create(session, + royal_username=params[0], + discord_user=author) + except errors.AlreadyExistingError: + 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) + session.commit() + session.close() + await channel.send("✅ Sincronizzazione completata!") + + @command + 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.") + return + if author.voice is None: + 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!") + return + if author.voice.channel.bitrate < 64000: + await channel.send("ℹ️ Sei in un canale con un bitrate ridotto.\n" + "L'utilizzo del bot in quel canale ignorerà il limite di bitrate e potrebbe causare lag" + " o eccessivo consumo di dati.\n" + "Se vuoi procedere comunque, scrivi `!yes`.") + try: + await self.wait_for("message", check=lambda m: m.content == "!yes", timeout=10.0) + except asyncio.TimeoutError: + return + # Check if there's already a connected client + for voice_client in self.voice_clients: + if voice_client.channel in self.main_guild.channels and voice_client.is_connected(): + await voice_client.move_to(author.voice.channel) + await channel.send(f"⤵️ Mi sono spostato in <#{author.voice.channel.id}>.") + break + else: + await author.voice.channel.connect() + await channel.send(f"⤵️ Mi sono connesso in <#{author.voice.channel.id}>.") + + @command + @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" + "Sintassi: `!play `") + 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`.") + # 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.") + 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.") + 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.") + 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.") + + @command + @requires_connected_voice_client + async def cmd_skip(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]): + for voice_client in self.voice_clients: + if voice_client.is_playing(): + voice_client.stop() + await channel.send(f"⏩ Video saltato.") + break + else: + 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.") + return + if len(params) == 1: + index = len(self.video_queue) - 1 + else: + try: + index = int(params[1]) - 1 + except ValueError: + 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" + "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`") + return + video = self.video_queue.pop(index) + await channel.send(f":regional_indicator_x: {str(video)} è stato rimosso dalla coda.") + return + try: + start = int(params[1]) - 1 + except ValueError: + 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" + " 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" + "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`") + return + if end >= len(self.video_queue): + 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" + "Sintassi: `!remove [numerovideoiniziale] [numerovideofinale]`") + return + del self.video_queue[start:end] + await channel.send(f":regional_indicator_x: {end - start} video rimossi dalla coda.") + + @command + async def cmd_queue(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]): + 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[: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!" + await channel.send(msg) + + @command + @requires_connected_voice_client + async def cmd_shuffle(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]): + if len(self.video_queue) == 0: + await channel.send("⚠ Non ci sono video in coda!") + return + random.shuffle(self.video_queue) + await channel.send("♠️ ♦️ ♣️ ♥️ Shuffle completo!") + + @command + @requires_connected_voice_client + async def cmd_clear(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]): + if len(self.video_queue) == 0: + await channel.send("⚠ Non ci sono video in coda!") + return + self.video_queue = [] + 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 `") + return + for voice_client in self.voice_clients: + if voice_client.is_playing(): + voice_client.stop() + # 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, index=0) + await channel.send(f"✅ Riproduzione del video forzata.") + 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, index=0) + await channel.send(f"✅ Riproduzione del video forzata.") + 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, index=0) + await channel.send(f"✅ Riproduzione del video forzata.") + 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, index=0) + await channel.send(f"✅ Riproduzione del video forzata.") + + @command + async def cmd_radiomessages(self, channel: discord.TextChannel, author: discord.Member, params: typing.List[str]): + if len(params) < 2: + self.radio_messages = not self.radio_messages + else: + if params[1].lower() == "on": + self.radio_messages = True + elif params[1].lower() == "off": + self.radio_messages = False + else: + await channel.send("⚠ Sintassi del comando non valida.\n" + "Sintassi: `!radiomessages [on|off]`") + return + await channel.send(f"📻 Messaggi radio **{'attivati' if self.radio_messages else 'disattivati'}**.") def process(users_connection=None): - print("Discordbot starting...") + logging.info("Initializing the bot...") + bot = RoyalDiscordBot() if users_connection is not None: - asyncio.ensure_future(update_users_pipe(users_connection)) - asyncio.ensure_future(queue_predownload_videos()) - asyncio.ensure_future(queue_play_next_video()) - client.on_error = on_error - loop.run_until_complete(client.login(config["Discord"]["bot_token"], bot=True)) - loop.run_until_complete(client.connect()) + logging.info("Initializing Telegram-Discord connection...") + asyncio.ensure_future(bot.feed_pipe(users_connection)) + logging.info("Logging in...") + loop.run_until_complete(bot.login(config["Discord"]["bot_token"], bot=True)) + logging.info("Connecting...") + loop.run_until_complete(bot.connect()) if __name__ == "__main__": diff --git a/requirements.txt b/requirements.txt index dbb21185..5165a6db 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -discord.py[voice] +discord.py==1.0.0a1504+gf06563c python-telegram-bot flask sqlalchemy