import asyncio import functools import itertools import math import random import discord import youtube_dl from async_timeout import timeout from discord.ext import commands import httpx from bs4 import BeautifulSoup # Silence useless bug reports messages youtube_dl.utils.bug_reports_message = lambda: '' class VoiceError(Exception): pass class YTDLError(Exception): pass class YTDLSource(discord.PCMVolumeTransformer): YTDL_OPTIONS = { 'format': 'bestaudio/best', 'extractaudio': True, 'audioformat': 'mp3', 'outtmpl': '%(extractor)s-%(id)s-%(title)s.%(ext)s', 'restrictfilenames': True, 'noplaylist': True, 'nocheckcertificate': True, 'ignoreerrors': False, 'logtostderr': False, 'quiet': True, 'no_warnings': True, 'default_search': 'ytsearch', 'source_address': '0.0.0.0', } FFMPEG_OPTIONS = { 'before_options': '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5', 'options': '-vn', } ytdl = youtube_dl.YoutubeDL(YTDL_OPTIONS) def __init__(self, ctx: commands.Context, source: discord.FFmpegPCMAudio, *, data: dict, volume: float = 0.5): super().__init__(source, volume) self.requester = ctx.author self.channel = ctx.channel self.data = data self.uploader = data.get('uploader') self.uploader_url = data.get('uploader_url') date = data.get('upload_date') self.upload_date = date[6:8] + '.' + date[4:6] + '.' + date[0:4] self.title = data.get('title') self.thumbnail = data.get('thumbnail') self.description = data.get('description') self.duration = self.parse_duration(int(data.get('duration'))) self.tags = data.get('tags') self.url = data.get('webpage_url') self.views = data.get('view_count') self.likes = data.get('like_count') self.dislikes = data.get('dislike_count') self.stream_url = data.get('url') def __str__(self): return '**{0.title}** by **{0.uploader}**'.format(self) @classmethod async def create_source(cls, ctx: commands.Context, search: str, *, loop: asyncio.BaseEventLoop = None): loop = loop or asyncio.get_event_loop() partial = functools.partial(cls.ytdl.extract_info, search, download=False, process=False) data = await loop.run_in_executor(None, partial) if data is None: raise YTDLError('Couldn\'t find anything that matches `{}`'.format(search)) if 'entries' not in data: process_info = data else: process_info = None for entry in data['entries']: if entry: process_info = entry break if process_info is None: raise YTDLError('Couldn\'t find anything that matches `{}`'.format(search)) webpage_url = process_info['webpage_url'] partial = functools.partial(cls.ytdl.extract_info, webpage_url, download=False) processed_info = await loop.run_in_executor(None, partial) if processed_info is None: raise YTDLError('Couldn\'t fetch `{}`'.format(webpage_url)) if 'entries' not in processed_info: info = processed_info else: info = None while info is None: try: info = processed_info['entries'].pop(0) except IndexError: raise YTDLError('Couldn\'t retrieve any matches for `{}`'.format(webpage_url)) return cls(ctx, discord.FFmpegPCMAudio(info['url'], **cls.FFMPEG_OPTIONS), data=info) @classmethod async def search_source(cls, ctx: commands.Context, search: str, *, loop: asyncio.BaseEventLoop = None): channel = ctx.channel loop = loop or asyncio.get_event_loop() cls.search_query = '%s%s:%s' % ('ytsearch', 10, ''.join(search)) partial = functools.partial(cls.ytdl.extract_info, cls.search_query, download=False, process=False) info = await loop.run_in_executor(None, partial) cls.search = {} cls.search["title"] = f'Search results for:\n**{search}**' cls.search["type"] = 'rich' cls.search["color"] = 7506394 cls.search["author"] = {'name': f'{ctx.author.name}', 'url': f'{ctx.author.avatar_url}', 'icon_url': f'{ctx.author.avatar_url}'} lst = [] for e in info['entries']: # lst.append(f'`{info["entries"].index(e) + 1}.` {e.get("title")} **[{YTDLSource.parse_duration(int(e.get("duration")))}]**\n') VId = e.get('id') VUrl = 'https://www.youtube.com/watch?v=%s' % (VId) lst.append(f'`{info["entries"].index(e) + 1}.` [{e.get("title")}]({VUrl})\n') lst.append('\n**Type a number to make a choice, Type `cancel` to exit**') cls.search["description"] = "\n".join(lst) em = discord.Embed.from_dict(cls.search) await ctx.send(embed=em, delete_after=45.0) def check(msg): return msg.content.isdigit() == True and msg.channel == channel or msg.content == 'cancel' or msg.content == 'Cancel' try: m = await bot.wait_for('message', check=check, timeout=45.0) except asyncio.TimeoutError: rtrn = 'timeout' else: if m.content.isdigit() == True: sel = int(m.content) if 0 < sel <= 10: for key, value in info.items(): if key == 'entries': """data = value[sel - 1]""" VId = value[sel - 1]['id'] VUrl = 'https://www.youtube.com/watch?v=%s' % (VId) partial = functools.partial(cls.ytdl.extract_info, VUrl, download=False) data = await loop.run_in_executor(None, partial) rtrn = cls(ctx, discord.FFmpegPCMAudio(data['url'], **cls.FFMPEG_OPTIONS), data=data) else: rtrn = 'sel_invalid' elif m.content == 'cancel': rtrn = 'cancel' else: rtrn = 'sel_invalid' return rtrn @staticmethod def parse_duration(duration: int): if duration > 0: minutes, seconds = divmod(duration, 60) hours, minutes = divmod(minutes, 60) days, hours = divmod(hours, 24) duration = [] if days > 0: duration.append('{}'.format(days)) if hours > 0: duration.append('{}'.format(hours)) if minutes > 0: duration.append('{}'.format(minutes)) if seconds > 0: duration.append('{}'.format(seconds)) value = ':'.join(duration) elif duration == 0: value = "LIVE" return value class Song: __slots__ = ('source', 'requester') def __init__(self, source: YTDLSource): self.source = source self.requester = source.requester def create_embed(self): embed = (discord.Embed(title='Now playing', description='```css\n{0.source.title}\n```'.format(self), color=discord.Color.blurple()) .add_field(name='Duration', value=self.source.duration) .add_field(name='Requested by', value=self.requester.mention) .add_field(name='Uploader', value='[{0.source.uploader}]({0.source.uploader_url})'.format(self)) .add_field(name='URL', value='[Click]({0.source.url})'.format(self)) .set_thumbnail(url=self.source.thumbnail) .add_field(name='Views', value=self.source.views) .add_field(name='Likes', value=self.source.likes) .set_author(name=self.requester.name, icon_url=self.requester.avatar_url)) return embed class SongQueue(asyncio.Queue): def __getitem__(self, item): if isinstance(item, slice): return list(itertools.islice(self._queue, item.start, item.stop, item.step)) else: return self._queue[item] def __iter__(self): return self._queue.__iter__() def __len__(self): return self.qsize() def clear(self): self._queue.clear() def shuffle(self): random.shuffle(self._queue) def remove(self, index: int): del self._queue[index] class VoiceState: def __init__(self, bot: commands.Bot, ctx: commands.Context): self.bot = bot self._ctx = ctx self.current = None self.voice = None self.next = asyncio.Event() self.songs = SongQueue() self.exists = True self._loop = False self._autoplay = False self._volume = 0.5 self.skip_votes = set() self.audio_player = bot.loop.create_task(self.audio_player_task()) def __del__(self): self.audio_player.cancel() @property def loop(self): return self._loop @loop.setter def loop(self, value: bool): self._loop = value @property def autoplay(self): return self._autoplay @autoplay.setter def autoplay(self, value: bool): self._autoplay = value @property def volume(self): return self._volume @volume.setter def volume(self, value: float): self._volume = value @property def is_playing(self): return self.voice and self.current async def audio_player_task(self): while True: self.next.clear() self.now = None if self.loop == False: # If autoplay is turned on wait 3 seconds for a new song. # If no song is found find a new one, # else if autoplay is turned off try to get the # next song within 3 minutes. # If no song will be added to the queue in time, # the player will disconnect due to performance # reasons. if self.autoplay: try: async with timeout(3): self.current = await self.songs.get() except asyncio.TimeoutError: # Spoof user agent to show whole page. headers = { 'User-Agent': 'Mozilla/5.0 (compatible; Bingbot/2.0; +http://www.bing.com/bingbot.htm)'} song_url = self.current.source.url # Get the page async with httpx.AsyncClient() as client: response = await client.get(song_url, headers=headers) soup = BeautifulSoup(response.text, features='lxml') # Parse all the recommended videos out of the response and store them in a list recommended_urls = [] for li in soup.find_all('li', class_='related-list-item'): a = li.find('a') # Only videos (no mixes or playlists) if 'content-link' in a.attrs['class']: recommended_urls.append(f'https://www.youtube.com{a.get("href")}') ctx = self._ctx async with ctx.typing(): try: source = await YTDLSource.create_source(ctx, recommended_urls[0], loop=self.bot.loop) except YTDLError as e: await ctx.send('Booom! My mind is blown up: {}'.format(str(e))) self.bot.loop.create_task(self.stop()) self.exists = False return else: song = Song(source) self.current = song await ctx.send('Enqueued {}'.format(str(source))) else: try: async with timeout(180): # 3 minutes self.current = await self.songs.get() except asyncio.TimeoutError: self.bot.loop.create_task(self.stop()) self.exists = False return self.current.source.volume = self._volume self.voice.play(self.current.source, after=self.play_next_song) await self.current.source.channel.send(embed=self.current.create_embed()) # If the song is looped elif self.loop == True: self.now = discord.FFmpegPCMAudio(self.current.source.stream_url, **YTDLSource.FFMPEG_OPTIONS) self.voice.play(self.now, after=self.play_next_song) await self.next.wait() def play_next_song(self, error=None): if error: raise VoiceError(str(error)) self.next.set() def skip(self): self.skip_votes.clear() if self.is_playing: self.voice.stop() async def stop(self): self.songs.clear() if self.voice: await self.voice.disconnect() self.voice = None class Music(commands.Cog): def __init__(self, bot: commands.Bot): self.bot = bot self.voice_states = {} def get_voice_state(self, ctx: commands.Context): state = self.voice_states.get(ctx.guild.id) if not state or not state.exists: state = VoiceState(self.bot, ctx) self.voice_states[ctx.guild.id] = state return state def cog_unload(self): for state in self.voice_states.values(): self.bot.loop.create_task(state.stop()) def cog_check(self, ctx: commands.Context): if not ctx.guild: raise commands.NoPrivateMessage('This command can\'t be used in DM channels.') return True async def cog_before_invoke(self, ctx: commands.Context): ctx.voice_state = self.get_voice_state(ctx) async def cog_command_error(self, ctx: commands.Context, error: commands.CommandError): await ctx.send('Ooohhhh nooooo! Somn bad: {}'.format(str(error))) @commands.Cog.listener() async def on_message(self, message): if message.author.id != bot.user.id: print(f"{message.guild}/{message.channel}/{message.author.name}>{message.content}") if message.embeds: print(message.embeds[0].to_dict()) @commands.command(name='join', invoke_without_subcommand=True) async def join(self, ctx: commands.Context): """Joins a voice channel.""" destination = ctx.author.voice.channel if ctx.voice_state.voice: await ctx.voice_state.voice.move_to(destination) return ctx.voice_state.voice = await destination.connect() @commands.command(name='summon') async def summon(self, ctx: commands.Context, *, channel: discord.VoiceChannel = None): """Use join better it is easier to print lol Summons the bot to a voice channel. If no channel was specified, it joins your channel. """ if not channel and not ctx.author.voice: raise VoiceError('You are neither connected to a voice channel nor specified a channel to join.') destination = channel or ctx.author.voice.channel if ctx.voice_state.voice: await ctx.voice_state.voice.move_to(destination) return ctx.voice_state.voice = await destination.connect() @commands.command(name='stop', aliases=['disconnect']) async def leave(self, ctx: commands.Context): """Clears the queue and leaves the voice channel.""" if not ctx.voice_state.voice: return await ctx.send('First you connect to voice!') await ctx.voice_state.stop() del self.voice_states[ctx.guild.id] @commands.command(name='volume') async def volume(self, ctx: commands.Context, *, volume: int): """Sets the volume of the player.""" if not ctx.voice_state.is_playing: return await ctx.send('I can`t change volume of NoThInG') if 0 > volume > 100: return await ctx.send('Volume must be between 0 and 100, not yours ' + str(volume)) ctx.voice_state.volume = volume / 100 await ctx.send('Volume set to {}%'.format(volume)) @commands.command(name='whatsong', aliases=['current', 'playing']) async def whatsong(self, ctx: commands.Context): """Displays the currently playing song.""" embed = ctx.voice_state.current.create_embed() await ctx.send(embed=embed) @commands.command(name='pause', aliases=['pa']) async def pause(self, ctx: commands.Context): """Pauses the currently playing song.""" print(">>>Pause Command:") if ctx.voice_state.is_playing and ctx.voice_state.voice.is_playing(): ctx.voice_state.voice.pause() await ctx.message.add_reaction('⏯') @commands.command(name='resume', aliases=['re', 'res']) async def resume(self, ctx: commands.Context): """Resumes a currently paused song.""" if ctx.voice_state.is_playing and ctx.voice_state.voice.is_paused(): ctx.voice_state.voice.resume() await ctx.message.add_reaction('⏯') @commands.command(name='crashbotlol') async def stop(self, ctx: commands.Context): """DONT USE PLS, READ ABOUT IT FIRST In theory, stops playing song and clears the queue. But in real life crashes bot. If something is broken, use stop command, then play, then stop, then play. Everything will be fine""" ctx.voice_state.songs.clear() if ctx.voice_state.is_playing: ctx.voice_state.voice.stop() await ctx.message.add_reaction('⏹') @commands.command(name='skip', aliases=['s']) async def skip(self, ctx: commands.Context): """Skip a song. The requester of song can automatically skip. If you and 3 your friends don't like this song, you can vote for skipping! """ if not ctx.voice_state.is_playing: return await ctx.send('Not playing any music right now...') voter = ctx.message.author if voter == ctx.voice_state.current.requester: await ctx.message.add_reaction('⏭') ctx.voice_state.skip() elif voter.id not in ctx.voice_state.skip_votes: ctx.voice_state.skip_votes.add(voter.id) total_votes = len(ctx.voice_state.skip_votes) if total_votes >= 3: await ctx.message.add_reaction('⏭') ctx.voice_state.skip() else: await ctx.send('Skip vote added, currently at **{}/3**'.format(total_votes)) else: await ctx.send('You have already voted to skip this song.') @commands.command(name='showqueue') async def showqueue(self, ctx: commands.Context, *, page: int = 1): """Shows the player's queue""" if len(ctx.voice_state.songs) == 0: return await ctx.send('Nothing here...') items_per_page = 10 pages = math.ceil(len(ctx.voice_state.songs) / items_per_page) start = (page - 1) * items_per_page end = start + items_per_page queue = '' for i, song in enumerate(ctx.voice_state.songs[start:end], start=start): queue += '`{0}.` [**{1.source.title}**]({1.source.url})\n'.format(i + 1, song) embed = (discord.Embed(description='**{} tracks:**\n\n{}'.format(len(ctx.voice_state.songs), queue)) .set_footer(text='Viewing page {}/{}'.format(page, pages))) await ctx.send(embed=embed) @commands.command(name='bass') async def bass(self, ctx: commands.Context, *, bass: int): """Want bassbost? Use it (and don't forget to type level of bassbost like 0, 1, 2 ...)""" if bass == 0: YTDLSource.FFMPEG_OPTIONS = { 'options': '-vn', 'before_options': '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5' } else: YTDLSource.FFMPEG_OPTIONS = { 'options': '-af "equalizer=f=160:width_type=o:width=1:g={0}, equalizer=f=30:width_type=o:width=1:g={0}, equalizer=f=50:width_type=o:width=1:g={0}"'.format(bass), 'before_options': '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5' } await ctx.send('I don`t think that you will understand what that means, but FFMPEG options for bass now are: \n' + str(YTDLSource.FFMPEG_OPTIONS['options'])) @commands.command(name='clear') async def clear(self, ctx: commands.Context): """Clears the queue.""" if len(ctx.voice_state.songs) == 0: return await ctx.send('Whoooshhhh!') ctx.voice_state.songs.shuffle() await ctx.message.add_reaction('✅') @commands.command(name='remove') async def remove(self, ctx: commands.Context, index: int): """Removes a song from the queue at a given index.""" if len(ctx.voice_state.songs) == 0: return await ctx.send('Whoah, you deleted everything!') ctx.voice_state.songs.remove(index - 1) await ctx.message.add_reaction('✅') @commands.command(name='loop') async def loop(self, ctx: commands.Context): """Loops the currently playing song. Type this command again to unloop the song. """ if not ctx.voice_state.is_playing: return await ctx.send('What should I loop? Npthing is playing!') # Inverse boolean value to loop and unloop. ctx.voice_state.loop = not ctx.voice_state.loop await ctx.message.add_reaction('✅') await ctx.send('Ok, now looping is ' + ('on' if ctx.voice_state.loop else 'off')) @commands.command(name='autoplay') async def autoplay(self, ctx: commands.Context): """DONT USE PLS, READ ABOUT IT FIRST Automatically queue a new song that is related to the song at the end of the queue. Invoke this command again to toggle autoplay the song. This is strange command, so don't use it If something is broken, use stop command, then play, then stop, then play. Everything will be fine """ if not ctx.voice_state.is_playing: return await ctx.send('What? I don`t hear anything!') # Inverse boolean value to loop and unloop. ctx.voice_state.autoplay = not ctx.voice_state.autoplay await ctx.message.add_reaction('✅') await ctx.send('Autoplay after end of queue is now ' + ('off' if ctx.voice_state.autoplay else 'on')) @commands.command(name='play', aliases=['p']) async def play(self, ctx: commands.Context, *, search: str): """Adds song to queue, and you will hear it!""" async with ctx.typing(): try: source = await YTDLSource.create_source(ctx, search, loop=self.bot.loop) except YTDLError as e: await ctx.send('Somn bad: {}'.format(str(e))) else: if not ctx.voice_state.voice: await ctx.invoke(self.join) song = Song(source) await ctx.voice_state.songs.put(song) await ctx.send('You will hear {}'.format(str(source))) @join.before_invoke @play.before_invoke async def ensure_voice_state(self, ctx: commands.Context): if not ctx.author.voice or not ctx.author.voice.channel: raise commands.CommandError('You are not connected to any voice channel.') if ctx.voice_client: if ctx.voice_client.channel != ctx.author.voice.channel: raise commands.CommandError('Bot is already in a voice channel.') bot = commands.Bot(command_prefix='/', case_insensitive=True, description="Cat, that meows cool music lol") bot.add_cog(Music(bot)) @bot.event async def on_ready(): print('Logged in as:\n{0.user}\n{0.user.id}'.format(bot)) bot.run('ODMxNDg2MjU3MDYxMjk4MjA2.YHV76w.had7zpnRoJTPBzuR2KvlHeXc4c0')