Created
December 16, 2017 21:24
-
-
Save davidschaeffer2/6dc9096c1ab1b0b96f113d095a854ca1 to your computer and use it in GitHub Desktop.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import asyncio | |
| import discord | |
| from discord.ext import commands | |
| import youtube_dl | |
| if not discord.opus.is_loaded(): | |
| # the 'opus' library here is opus.dll on windows | |
| # or libopus.so on linux in the current directory | |
| # you should replace this with the location the | |
| # opus library is located in and with the proper filename. | |
| # note that on windows this DLL is automatically provided for you | |
| discord.opus.load_opus('opus') | |
| # Suppress noise about console usage from errors | |
| youtube_dl.utils.bug_reports_message = lambda: '' | |
| ytdl_format_options = {'format': 'bestaudio/best', | |
| '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': 'auto', | |
| 'source_address': '0.0.0.0'} | |
| ffmpeg_options = {'before_options': '-nostdin', 'options': '-vn'} | |
| ytdl = youtube_dl.YoutubeDL(ytdl_format_options) | |
| class YTDLSource(discord.PCMVolumeTransformer): | |
| def __init__(self, source, *, data, volume=0.5): | |
| super().__init__(source, volume) | |
| self.data = data | |
| self.title = data.get('title') | |
| self.url = data.get('url') | |
| @classmethod | |
| async def from_url(cls, url, *, loop=None): | |
| loop = loop or asyncio.get_event_loop() | |
| data = await loop.run_in_executor(None, ytdl.extract_info, url) | |
| if 'entries' in data: | |
| # take first item from a playlist | |
| data = data['entries'][0] | |
| filename = ytdl.prepare_filename(data) | |
| return cls(discord.FFmpegPCMAudio(filename, **ffmpeg_options), | |
| data=data) | |
| class VoiceEntry: | |
| def __init__(self, message, player): | |
| self.requester = message.author | |
| self.channel = message.channel | |
| self.player = player | |
| def __str__(self): | |
| fmt = '*{0.title}* uploaded by {0.uploader} and requested by {1.display_name}' | |
| duration = self.player.duration | |
| if duration: | |
| fmt = fmt + ' [length: {0[0]}m {0[1]}s]'.format(divmod(duration, 60)) | |
| return fmt.format(self.player, self.requester) | |
| class VoiceState: | |
| def __init__(self, bot): | |
| self.current = None | |
| self.voice = None | |
| self.bot = bot | |
| self.play_next_song = asyncio.Event() | |
| self.songs = asyncio.Queue() | |
| self.skip_votes = set() # a set of user_ids that voted | |
| self.audio_player = self.bot.loop.create_task(self.audio_player_task()) | |
| def is_playing(self): | |
| if self.voice is None or self.current is None: | |
| return False | |
| player = self.current.player | |
| return not player.is_done() | |
| @property | |
| def player(self): | |
| return self.current.player | |
| def skip(self): | |
| self.skip_votes.clear() | |
| if self.is_playing(): | |
| self.player.stop() | |
| def toggle_next(self): | |
| self.bot.loop.call_soon_threadsafe(self.play_next_song.set) | |
| async def audio_player_task(self): | |
| while True: | |
| self.play_next_song.clear() | |
| self.current = await self.songs.get() | |
| await self.bot.send_message(self.current.channel, 'Now playing ' + str(self.current)) | |
| self.current.player.start() | |
| await self.play_next_song.wait() | |
| class Music: | |
| """Voice related commands. | |
| Works in multiple guilds at once. | |
| """ | |
| def __init__(self, bot): | |
| self.bot = bot | |
| self.voice_states = {} | |
| def get_voice_state(self, guild): | |
| state = self.voice_states.get(guild.id) | |
| if state is None: | |
| state = VoiceState(self.bot) | |
| self.voice_states[guild.id] = state | |
| return state | |
| async def create_voice_client(self, channel): | |
| voice = await channel.connect() | |
| state = self.get_voice_state(channel.guild) | |
| state.voice = voice | |
| def __unload(self): | |
| for state in self.voice_states.values(): | |
| try: | |
| state.audio_player.cancel() | |
| if state.voice: | |
| self.bot.loop.create_task(state.voice.disconnect()) | |
| except: | |
| pass | |
| @commands.command(no_pm=True) | |
| async def join(self, ctx, *, channel: discord.VoiceChannel): | |
| """Joins a voice channel.""" | |
| try: | |
| await self.create_voice_client(channel) | |
| except discord.ClientException: | |
| await ctx.send('Already in a voice channel...') | |
| except discord.InvalidArgument: | |
| await ctx.send('This is not a voice channel...') | |
| else: | |
| await ctx.send('Ready to play audio in ' + channel.name) | |
| @commands.command(no_pm=True) | |
| async def summon(self, ctx): | |
| """Summons the bot to join your voice channel.""" | |
| summoned_channel = ctx.message.author.voice.channel | |
| if summoned_channel is None: | |
| await ctx.send('You are not in a voice channel.') | |
| return False | |
| state = self.get_voice_state(ctx.message.guild) | |
| if state.voice is None: | |
| state.voice = await summoned_channel.connect() | |
| else: | |
| await state.voice.move_to(summoned_channel) | |
| return True | |
| @commands.command(no_pm=True) | |
| async def play(self, ctx, *, song: str): | |
| """Plays a song. | |
| If there is a song currently in the queue, then it is | |
| queued until the next song is done playing. | |
| This command automatically searches as well from YouTube. | |
| The list of supported sites can be found here: | |
| https://rg3.github.io/youtube-dl/supportedsites.html | |
| """ | |
| state = self.get_voice_state(ctx.message.server) | |
| opts = {'default_search': 'auto', 'quiet': True, } | |
| if state.voice is None: | |
| success = await ctx.invoke(self.summon) | |
| if not success: | |
| return | |
| try: | |
| player = await state.voice.create_ytdl_player(song, | |
| ytdl_options=opts, | |
| after=state.toggle_next) | |
| except Exception as e: | |
| fmt = 'An error occurred while processing this request: ```py\n{}: {}\n```' | |
| await self.bot.send_message(ctx.message.channel, | |
| fmt.format(type(e).__name__, e)) | |
| else: | |
| player.volume = 0.6 | |
| entry = VoiceEntry(ctx.message, player) | |
| await self.bot.say('Enqueued ' + str(entry)) | |
| await state.songs.put(entry) | |
| @commands.command(no_pm=True) | |
| async def yt(self, ctx, *, query: str): | |
| """Performs a youtube search on the query and plays the first result | |
| """ | |
| state = self.get_voice_state(ctx.message.guild) | |
| opts = {'default_search': 'auto', 'quiet': True, } | |
| if state.voice is None: | |
| success = await ctx.invoke(self.summon) | |
| if not success: | |
| return | |
| try: | |
| player = await YTDLSource.from_url(query, loop=self.bot.loop) | |
| ctx.voice_client.play(player, after=lambda e: print( | |
| 'Player error: %s' % e) if e else None) | |
| await ctx.send('Now playing: {}'.format(query)) | |
| except Exception as e: | |
| fmt = 'An error occurred while processing this request: ```py\n{}: {}\n```' | |
| await ctx.send(fmt.format(type(e).__name__, e)) | |
| else: | |
| player.volume = 0.9 | |
| entry = VoiceEntry(ctx.message, player) | |
| await ctx.send('Enqueued ' + str(entry)) | |
| await state.songs.put(entry) | |
| @commands.command(no_pm=True) | |
| async def volume(self, ctx, value : int): | |
| """Sets the volume of the currently playing song.""" | |
| state = self.get_voice_state(ctx.message.guild) | |
| if state.is_playing(): | |
| player = state.player | |
| player.volume = value / 100 | |
| await ctx.send('Set the volume to {:.0%}'.format(player.volume)) | |
| @commands.command(no_pm=True) | |
| async def pause(self, ctx): | |
| """Pauses the currently played song.""" | |
| state = self.get_voice_state(ctx.message.guild) | |
| if state.is_playing(): | |
| player = state.player | |
| player.pause() | |
| @commands.command(no_pm=True) | |
| async def resume(self, ctx): | |
| """Resumes the currently played song.""" | |
| state = self.get_voice_state(ctx.message.guild) | |
| if state.is_playing(): | |
| player = state.player | |
| player.resume() | |
| @commands.command(no_pm=True) | |
| async def stop(self, ctx): | |
| """Stops playing audio and leaves the voice channel. | |
| This also clears the queue. | |
| """ | |
| guild = ctx.message.guild | |
| state = self.get_voice_state(guild) | |
| if state.is_playing(): | |
| player = state.player | |
| player.stop() | |
| try: | |
| state.audio_player.cancel() | |
| del self.voice_states[guild.id] | |
| await state.voice.disconnect() | |
| except: | |
| pass | |
| @commands.command(no_pm=True) | |
| async def skip(self, ctx): | |
| """Vote to skip a song. The song requester can automatically skip. | |
| 3 skip votes are needed for the song to be skipped. | |
| """ | |
| state = self.get_voice_state(ctx.message.guild) | |
| if not state.is_playing(): | |
| await ctx.send('Not playing any music right now...') | |
| return | |
| voter = ctx.message.author | |
| if voter == state.current.requester: | |
| await ctx.send('Requester requested skipping song...') | |
| state.skip() | |
| elif voter.id not in state.skip_votes: | |
| state.skip_votes.add(voter.id) | |
| total_votes = len(state.skip_votes) | |
| if total_votes >= 3: | |
| await ctx.send('Skip vote passed, skipping song...') | |
| 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(no_pm=True) | |
| async def playing(self, ctx): | |
| """Shows info about the currently played song.""" | |
| state = self.get_voice_state(ctx.message.guild) | |
| if state.current is None: | |
| await ctx.send('Not playing anything.') | |
| else: | |
| skip_count = len(state.skip_votes) | |
| await ctx.send('Now playing {} [skips: {}/3]'.format(state.current, skip_count)) | |
| def setup(bot): | |
| bot.add_cog(Music(bot)) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment