EvieePy · August 30, 2025 05:56 · RedstonedLife · Dec 18, 2020 · quinton-oglesby · Mar 5, 2021
diff --git a/music.py b/music.py
 """A Rewrite example of a cross guild music player with playlist support.

 Please understand Music bots are complex, and that even this basic example can be daunting to a beginner.
 For this reason it's highly advised you familiarize yourself with discord.py, python and asyncio, BEFORE
 you attempt to write a music bot.

 This example makes use of: Python 3.6 and the Rewrite Branch of Discord.py.

 For a more basic voice example please read:
    https://github.com/Rapptz/discord.py/blob/rewrite/examples/basic_voice.py
 """

 import discord
 from discord.ext import commands

 import asyncio
 import async_timeout
 import youtube_dl


 opts = {
    'format': 'bestaudio/best',
    'outtmpl': 'downloads/%(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'  # ipv6 addresses cause issues sometimes
    }
 ytdl = youtube_dl.YoutubeDL(opts)


 ffmpeg_options = {
    'before_options': '-nostdin',
    'options': '-vn'
    }


 class YTDLSource(discord.PCMVolumeTransformer):
    """A class which uses YTDL to retrieve a song and returns it as a source for Discord."""
    def __init__(self, source, *, data, volume=.4):
        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:
            data = data['entries'][0]

        filename = ytdl.prepare_filename(data)
        return cls(discord.FFmpegPCMAudio(filename, **ffmpeg_options), data=data)


 class MusicPlayer:
    """Music Player instance.

    Each guild using music will have a separate instance."""

    def __init__(self, bot, ctx):
        self.bot = bot

        self.queue = asyncio.Queue()
        self.next = asyncio.Event()
        self.die = asyncio.Event()

        self.guild = ctx.guild
        self.default_chan = ctx.channel
        self.current = None
        self.volume = .4

        self.now_playing = None

        self.player_task = self.bot.loop.create_task(self.player_loop())
        self.inactive_task = self.bot.loop.create_task(self.inactive_check(ctx))

    async def inactive_check(self, ctx):
        await self.die.wait()
        await ctx.invoke(self.bot.get_command('stop'))

    async def player_loop(self):
        await self.bot.wait_until_ready()

        while not self.bot.is_closed():
            self.next.clear()

            try:
                with async_timeout.timeout(10):  # Auto leave after 5 minutes of inactivity.
                    entry = await self.queue.get()
            except asyncio.TimeoutError:
                await self.default_chan.send('I have been inactive for 5 minutes. Goodbye!')
                return self.die.set()

            try:
                info = await YTDLSource.from_url(entry.query, loop=self.bot.loop)
                info.volume = self.volume
            except Exception:
                await self.default_chan.send(f'There was an error with the request: `{entry.query}`')
                continue

            channel = entry.channel
            requester = entry.requester
            self.guild.voice_client.play(info, after=lambda s: self.bot.loop.call_soon_threadsafe(self.next.set()))

            self.now_playing = await channel.send(f'**Now Playing:** `{info.title}` requested by `{requester}`')
            await self.next.wait()  # Wait until the players after function is called.

            try:
                await self.now_playing.delete()
            except (discord.Forbidden, discord.HTTPException):
                pass


 class MusicEntry:
    def __init__(self, ctx, query):
        self.requester = ctx.author
        self.channel = ctx.channel
        self.query = query


 class Music:
    """Music Cog containing various commands for playing music.

    This cog supports cross guild music playing and implements a queue for playlists."""

    def __init__(self, bot):
        self.bot = bot
        self.players = {}

    async def __local_check(self, ctx):
        """A check which applies to all commands in Music."""
        if not ctx.guild:
            await ctx.send('Music commands can not be used in DMs.')
            return False

    def get_player(self, ctx):
        try:
            player = self.players[ctx.guild.id]
        except KeyError:
            player = MusicPlayer(self.bot, ctx)
            self.players[ctx.guild.id] = player

        return player

    @commands.command(name='connect', aliases=['summon', 'join', 'move'])
    async def voice_connect(self, ctx, *, channel: discord.VoiceChannel=None):
        """Summon the bot to a voice channel.

        This command handles both summoning and moving the bot."""
        channel = getattr(ctx.author.voice, 'channel', channel)
        vc = ctx.guild.voice_client

        if not channel:
            return await ctx.send('No channel to join. Please either specify a valid channel or join one.')

        if not vc:
            try:
                await channel.connect(timeout=10)
            except asyncio.TimeoutError:
                return await ctx.send('Unable to connect to the voice channel at this time. Please try again.')
            await ctx.send(f'Connected to: **{channel}**', delete_after=15)
        else:
            if channel == vc.channel:
                return
            try:
                await vc.move_to(channel)
            except Exception:
                return await ctx.send('Unable to move this channel. Perhaps missing permissions?')
            await ctx.send(f'Moved to: **{channel}**', delete_after=15)

    @commands.command(name='play')
    async def play_song(self, ctx, *, query: str):
        """Add a song to the queue.

        Uses YTDL to auto search for a song. A URL may also be provided."""
        vc = ctx.guild.voice_client

        if vc is None:
            await ctx.invoke(self.voice_connect)
            if not ctx.guild.voice_client:
                return
        else:
            if ctx.author not in vc.channel.members:
                return await ctx.send(f'You must be in **{vc.channel}** to request songs.', delete_after=30)

        player = self.get_player(ctx)

        entry = MusicEntry(ctx, query)
        await player.queue.put(entry)
        await ctx.send(f'Added: `{query}` to the queue.', delete_after=30)

    @commands.command(name='stop')
    async def stop_player(self, ctx):
        """Stops the player and clears the queue."""
        vc = ctx.guild.voice_client

        if vc is None:
            return

        player = self.get_player(ctx)
        inact = player.inactive_task

        vc.stop()
        try:
            player.player_task.cancel()
            del self.players[ctx.guild.id]
        except Exception as e:
            return print(e)

        await vc.disconnect()
        await ctx.send('Disconnected from voice and cleared your queue. Goodbye!', delete_after=15)

        try:
            inact.cancel()
        except Exception as e:
            print(e)

    @commands.command(name='pause')
    async def pause_song(self, ctx):
        """Pause the currently playing song."""
        vc = ctx.guild.voice_client

        if vc is None or not vc.is_playing():
            return await ctx.send('I am not currently playing anything.', delete_after=20)

        if vc.is_paused():
            return await ctx.send('I am already paused.', delete_after=20)

        vc.pause()
        await ctx.send(f'{ctx.author.mention} has paused the song.')

    @commands.command(name='resume')
    async def resume_song(self, ctx):
        """Resume a song if it is currently paused."""
        vc = ctx.guild.voice_client

        if vc is None or not vc.is_connected():
            return await ctx.send('I am not currently playing anything.', delete_after=20)

        if vc.is_paused():
            vc.resume()
            await ctx.send(f'{ctx.author.mention} has resumed the song.')

    @commands.command(name='skip')
    async def skip_song(self, ctx):
        """Skip the current song."""
        vc = ctx.guild.voice_client

        if vc is None or not vc.is_connected():
            return await ctx.send('I am not currently playing anything.', delete_after=20)

        vc.stop()
        await ctx.send(f'{ctx.author.mention} has skipped the song.')

    @commands.command(name='current', aliases=['currentsong', 'nowplaying', 'np'])
    async def current_song(self, ctx):
        """Return some information about the current song."""
        vc = ctx.guild.voice_client

        if not vc.is_playing():
            return await ctx.send('Not currently playing anything.')

        player = self.get_player(ctx)
        msg = player.now_playing.content

        try:
            await player.now_playing.delete()
        except (discord.Forbidden, discord.HTTPException):
            pass

        player.now_playing = await ctx.send(msg)

    @commands.command(name='volume', aliases=['vol'])
    async def adjust_volume(self, ctx, *, vol: int):
        """Adjust the player volume."""

        if not 0 < vol < 101:
            return await ctx.send('Please enter a value between 1 and 100.')

        vc = ctx.guild.voice_client

        if vc is None:
            return await ctx.send('I am not currently connected to voice.')

        player = self.get_player(ctx)
        adj = float(vol) / 100

        try:
            vc.source.volume = adj
        except AttributeError:
            pass
        finally:
            player.volume = adj
            await ctx.send(f'Changed player volume to: **{vol}%**')


 def setup(bot):
    bot.add_cog(Music(bot))
	"""A Rewrite example of a cross guild music player with playlist support.

	Please understand Music bots are complex, and that even this basic example can be daunting to a beginner.
	For this reason it's highly advised you familiarize yourself with discord.py, python and asyncio, BEFORE
	you attempt to write a music bot.

	This example makes use of: Python 3.6 and the Rewrite Branch of Discord.py.

	For a more basic voice example please read:
	https://github.com/Rapptz/discord.py/blob/rewrite/examples/basic_voice.py
	"""

	import discord
	from discord.ext import commands

	import asyncio
	import async_timeout
	import youtube_dl


	opts = {
	'format': 'bestaudio/best',
	'outtmpl': 'downloads/%(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' # ipv6 addresses cause issues sometimes
	}
	ytdl = youtube_dl.YoutubeDL(opts)


	ffmpeg_options = {
	'before_options': '-nostdin',
	'options': '-vn'
	}


	class YTDLSource(discord.PCMVolumeTransformer):
	"""A class which uses YTDL to retrieve a song and returns it as a source for Discord."""
	def __init__(self, source, *, data, volume=.4):
	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:
	data = data['entries'][0]

	filename = ytdl.prepare_filename(data)
	return cls(discord.FFmpegPCMAudio(filename, **ffmpeg_options), data=data)


	class MusicPlayer:
	"""Music Player instance.

	Each guild using music will have a separate instance."""

	def __init__(self, bot, ctx):
	self.bot = bot

	self.queue = asyncio.Queue()
	self.next = asyncio.Event()
	self.die = asyncio.Event()

	self.guild = ctx.guild
	self.default_chan = ctx.channel
	self.current = None
	self.volume = .4

	self.now_playing = None

	self.player_task = self.bot.loop.create_task(self.player_loop())
	self.inactive_task = self.bot.loop.create_task(self.inactive_check(ctx))

	async def inactive_check(self, ctx):
	await self.die.wait()
	await ctx.invoke(self.bot.get_command('stop'))

	async def player_loop(self):
	await self.bot.wait_until_ready()

	while not self.bot.is_closed():
	self.next.clear()

	try:
	with async_timeout.timeout(10): # Auto leave after 5 minutes of inactivity.
	entry = await self.queue.get()
	except asyncio.TimeoutError:
	await self.default_chan.send('I have been inactive for 5 minutes. Goodbye!')
	return self.die.set()

	try:
	info = await YTDLSource.from_url(entry.query, loop=self.bot.loop)
	info.volume = self.volume
	except Exception:
	await self.default_chan.send(f'There was an error with the request: `{entry.query}`')
	continue

	channel = entry.channel
	requester = entry.requester
	self.guild.voice_client.play(info, after=lambda s: self.bot.loop.call_soon_threadsafe(self.next.set()))

	self.now_playing = await channel.send(f'Now Playing: `{info.title}` requested by `{requester}`')
	await self.next.wait() # Wait until the players after function is called.

	try:
	await self.now_playing.delete()
	except (discord.Forbidden, discord.HTTPException):
	pass


	class MusicEntry:
	def __init__(self, ctx, query):
	self.requester = ctx.author
	self.channel = ctx.channel
	self.query = query


	class Music:
	"""Music Cog containing various commands for playing music.

	This cog supports cross guild music playing and implements a queue for playlists."""

	def __init__(self, bot):
	self.bot = bot
	self.players = {}

	async def __local_check(self, ctx):
	"""A check which applies to all commands in Music."""
	if not ctx.guild:
	await ctx.send('Music commands can not be used in DMs.')
	return False

	def get_player(self, ctx):
	try:
	player = self.players[ctx.guild.id]
	except KeyError:
	player = MusicPlayer(self.bot, ctx)
	self.players[ctx.guild.id] = player

	return player

	@commands.command(name='connect', aliases=['summon', 'join', 'move'])
	async def voice_connect(self, ctx, *, channel: discord.VoiceChannel=None):
	"""Summon the bot to a voice channel.

	This command handles both summoning and moving the bot."""
	channel = getattr(ctx.author.voice, 'channel', channel)
	vc = ctx.guild.voice_client

	if not channel:
	return await ctx.send('No channel to join. Please either specify a valid channel or join one.')

	if not vc:
	try:
	await channel.connect(timeout=10)
	except asyncio.TimeoutError:
	return await ctx.send('Unable to connect to the voice channel at this time. Please try again.')
	await ctx.send(f'Connected to: {channel}', delete_after=15)
	else:
	if channel == vc.channel:
	return
	try:
	await vc.move_to(channel)
	except Exception:
	return await ctx.send('Unable to move this channel. Perhaps missing permissions?')
	await ctx.send(f'Moved to: {channel}', delete_after=15)

	@commands.command(name='play')
	async def play_song(self, ctx, *, query: str):
	"""Add a song to the queue.

	Uses YTDL to auto search for a song. A URL may also be provided."""
	vc = ctx.guild.voice_client

	if vc is None:
	await ctx.invoke(self.voice_connect)
	if not ctx.guild.voice_client:
	return
	else:
	if ctx.author not in vc.channel.members:
	return await ctx.send(f'You must be in {vc.channel} to request songs.', delete_after=30)

	player = self.get_player(ctx)

	entry = MusicEntry(ctx, query)
	await player.queue.put(entry)
	await ctx.send(f'Added: `{query}` to the queue.', delete_after=30)

	@commands.command(name='stop')
	async def stop_player(self, ctx):
	"""Stops the player and clears the queue."""
	vc = ctx.guild.voice_client

	if vc is None:
	return

	player = self.get_player(ctx)
	inact = player.inactive_task

	vc.stop()
	try:
	player.player_task.cancel()
	del self.players[ctx.guild.id]
	except Exception as e:
	return print(e)

	await vc.disconnect()
	await ctx.send('Disconnected from voice and cleared your queue. Goodbye!', delete_after=15)

	try:
	inact.cancel()
	except Exception as e:
	print(e)

	@commands.command(name='pause')
	async def pause_song(self, ctx):
	"""Pause the currently playing song."""
	vc = ctx.guild.voice_client

	if vc is None or not vc.is_playing():
	return await ctx.send('I am not currently playing anything.', delete_after=20)

	if vc.is_paused():
	return await ctx.send('I am already paused.', delete_after=20)

	vc.pause()
	await ctx.send(f'{ctx.author.mention} has paused the song.')

	@commands.command(name='resume')
	async def resume_song(self, ctx):
	"""Resume a song if it is currently paused."""
	vc = ctx.guild.voice_client

	if vc is None or not vc.is_connected():
	return await ctx.send('I am not currently playing anything.', delete_after=20)

	if vc.is_paused():
	vc.resume()
	await ctx.send(f'{ctx.author.mention} has resumed the song.')

	@commands.command(name='skip')
	async def skip_song(self, ctx):
	"""Skip the current song."""
	vc = ctx.guild.voice_client

	if vc is None or not vc.is_connected():
	return await ctx.send('I am not currently playing anything.', delete_after=20)

	vc.stop()
	await ctx.send(f'{ctx.author.mention} has skipped the song.')

	@commands.command(name='current', aliases=['currentsong', 'nowplaying', 'np'])
	async def current_song(self, ctx):
	"""Return some information about the current song."""
	vc = ctx.guild.voice_client

	if not vc.is_playing():
	return await ctx.send('Not currently playing anything.')

	player = self.get_player(ctx)
	msg = player.now_playing.content

	try:
	await player.now_playing.delete()
	except (discord.Forbidden, discord.HTTPException):
	pass

	player.now_playing = await ctx.send(msg)

	@commands.command(name='volume', aliases=['vol'])
	async def adjust_volume(self, ctx, *, vol: int):
	"""Adjust the player volume."""

	if not 0 < vol < 101:
	return await ctx.send('Please enter a value between 1 and 100.')

	vc = ctx.guild.voice_client

	if vc is None:
	return await ctx.send('I am not currently connected to voice.')

	player = self.get_player(ctx)
	adj = float(vol) / 100

	try:
	vc.source.volume = adj
	except AttributeError:
	pass
	finally:
	player.volume = adj
	await ctx.send(f'Changed player volume to: {vol}%')


	def setup(bot):
	bot.add_cog(Music(bot))