307 lines
8.9 KiB
Python
307 lines
8.9 KiB
Python
import asyncio
|
|
import inspect
|
|
import traceback
|
|
import weakref
|
|
from typing import Dict
|
|
|
|
import async_timeout
|
|
import dataclasses
|
|
import discord
|
|
from discord.ext import commands
|
|
import youtube_dl
|
|
|
|
# noinspection PyUnresolvedReferences,PyUnresolvedReferences,PyPackageRequirements
|
|
from utils import noblock
|
|
|
|
|
|
YT_DL_OPTS = {
|
|
"format": 'mp3[abr>0]/bestaudio/best',
|
|
"ignoreerrors": True,
|
|
"default_search": "auto",
|
|
"source_address": "0.0.0.0",
|
|
'quiet': True
|
|
}
|
|
|
|
|
|
# Let it be waiting on an empty queue for about 30 minutes
|
|
# before closing the connection from being idle.
|
|
IDLE_FOR = 60 * 30
|
|
|
|
|
|
@dataclasses.dataclass(repr=True)
|
|
class Request:
|
|
"""Track request."""
|
|
who: discord.Member
|
|
what: str # Referral
|
|
title: str # Video title
|
|
actual_url: str # Actual URL to play
|
|
|
|
def __str__(self):
|
|
return self.title
|
|
|
|
def __hash__(self):
|
|
return hash(str(self.who.id) + self.what)
|
|
|
|
|
|
# noinspection PyBroadException
|
|
class Session:
|
|
"""
|
|
Each player being run is a session; (E.g. if you open a player in one server and I did in another).
|
|
Sessions will have a queue, an event that can fire to stop the current track and move on, and a voice
|
|
channel to bind to. This is defined as the voice channel the owner of the session was in when they made the channel.
|
|
To create a session, call ``Session.new_session``. Do not call the constructor directly.
|
|
Attributes:
|
|
ctx: discord.ext.commands.Context
|
|
The context of the original command invocation we are creating a session for.
|
|
loop: asyncio.AbstractEventLoop
|
|
The event loop to run this in.
|
|
voice_client: discord.VoiceClient
|
|
Voice client we are streaming audio through.
|
|
queue: asyncio.Queue
|
|
Track queue.
|
|
"""
|
|
@classmethod
|
|
async def new_session(cls, ctx: commands.Context):
|
|
"""
|
|
Helper to make a new session. Invoke constructor using this, as it handles any errors. It also ensures
|
|
we connect immediately.
|
|
"""
|
|
try:
|
|
s = cls(ctx)
|
|
await s.connect()
|
|
except Exception as ex:
|
|
traceback.print_exc()
|
|
await ctx.send(f"I couldn't connect! Reason: {str(ex) or type(ex).__qualname__}")
|
|
return None
|
|
else:
|
|
return s
|
|
|
|
def __init__(self, ctx: commands.Context) -> None:
|
|
"""Create a new session."""
|
|
if ctx.author.voice is None:
|
|
raise RuntimeError('Please enter a voice channel I have access to first.')
|
|
|
|
# Holds the tasks currently running associated with this.
|
|
self.voice_channel = ctx.author.voice.channel
|
|
self.ctx: commands.Context = ctx
|
|
self.voice_client: discord.VoiceClient = None
|
|
self.loop: asyncio.AbstractEventLoop = weakref.proxy(self.ctx.bot.loop)
|
|
self.queue = asyncio.Queue()
|
|
|
|
# Lock-based event to allow firing a handler to advance to the next track.
|
|
self._start_next_track_event = asyncio.Event()
|
|
self._on_stop_event = asyncio.Event()
|
|
self._player: asyncio.Task = None
|
|
self._track: asyncio.Task = None
|
|
|
|
@property
|
|
def is_connected(self) -> bool:
|
|
return self.voice_client and self.voice_client.is_connected()
|
|
|
|
async def connect(self) -> None:
|
|
"""Connects to the VC."""
|
|
if not self.is_connected and not self._player:
|
|
# noinspection PyUnresolvedReferences
|
|
self.voice_client = await self.voice_channel.connect()
|
|
self._start_next_track_event.clear()
|
|
self._player = self.__spawn_player()
|
|
else:
|
|
raise RuntimeError('I already have a voice client/player running.')
|
|
|
|
async def disconnect(self) -> None:
|
|
"""Disconnects from the VC."""
|
|
await self.voice_client.disconnect()
|
|
self.voice_client = None
|
|
|
|
def __spawn_player(self) -> asyncio.Task:
|
|
"""Starts a new player."""
|
|
async def player():
|
|
try:
|
|
while True:
|
|
# Wait on an empty queue for a finite period of time.
|
|
with async_timeout.timeout(IDLE_FOR):
|
|
request = await self.queue.get()
|
|
|
|
await self.ctx.send(f'Playing `{request}` requested by {request.who}')
|
|
|
|
# Clear the skip event if it is set.
|
|
self._start_next_track_event.clear()
|
|
|
|
# Start the player if it was a valid request, else continue to the next track.
|
|
if not self.__play(request.actual_url):
|
|
await self.ctx.send(f'{request.referral} was a bad request and was skipped.')
|
|
continue
|
|
|
|
await self._start_next_track_event.wait()
|
|
|
|
if self.voice_client.is_playing():
|
|
self.voice_client.stop()
|
|
|
|
except asyncio.CancelledError:
|
|
# Hit when someone kills the player using stop().
|
|
print('Requested to stop player', repr(self))
|
|
except asyncio.TimeoutError:
|
|
await self.ctx.send('Was idle for too long...')
|
|
print('Player queue was empty for too long and was stopped', repr(self))
|
|
except Exception:
|
|
traceback.print_exc()
|
|
finally:
|
|
if self.voice_client.is_playing():
|
|
await self.voice_client.stop()
|
|
if self.is_connected:
|
|
await self.disconnect()
|
|
return self.loop.create_task(player())
|
|
|
|
def __play(self, url):
|
|
"""Tries to play the given URL. If it fails, we return False, else we return True."""
|
|
try:
|
|
ffmpeg_player = discord.FFmpegPCMAudio(url)
|
|
|
|
# Play the stream. After we finish, either from being cancelled or otherwise, fire the
|
|
# skip track event to start the next track.
|
|
self.voice_client.play(ffmpeg_player, after=lambda error: self._start_next_track_event.set())
|
|
except Exception:
|
|
traceback.print_exc()
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
def skip(self):
|
|
"""Request to skip track."""
|
|
self._start_next_track_event.set()
|
|
|
|
def stop(self):
|
|
"""Request to stop playing."""
|
|
if self._player:
|
|
self._player.cancel()
|
|
self._on_stop_event.set()
|
|
self._on_stop_event.clear()
|
|
|
|
def on_exit(self, func):
|
|
"""Decorates a function to invoke it on exit."""
|
|
async def callback():
|
|
await self._on_stop_event.wait()
|
|
inspect.iscoroutinefunction(func) and await func() or func()
|
|
self.loop.create_task(callback())
|
|
return func
|
|
|
|
|
|
# noinspection PyBroadException
|
|
class PlayerCog:
|
|
def __init__(self):
|
|
self.sessions: Dict[discord.Guild, Session] = {}
|
|
|
|
# noinspection PyMethodMayBeStatic
|
|
async def __local_check(self, ctx):
|
|
return ctx.guild
|
|
|
|
@commands.command()
|
|
async def join(self, ctx):
|
|
if ctx.guild not in self.sessions:
|
|
p = await Session.new_session(ctx)
|
|
if p:
|
|
self.sessions[ctx.guild] = p
|
|
|
|
@p.on_exit
|
|
def when_terminated():
|
|
try:
|
|
self.sessions.pop(ctx.guild)
|
|
finally:
|
|
return
|
|
|
|
await ctx.send("*hacker voice*\n**I'm in.**", delete_after=15)
|
|
else:
|
|
await ctx.send(f'I am already playing in {self.sessions[ctx.guild].voice_channel.mention}')
|
|
|
|
# noinspection PyNestedDecorators
|
|
@staticmethod
|
|
@noblock.no_block
|
|
def _get_video_meta(referral):
|
|
downloader = youtube_dl.YoutubeDL(YT_DL_OPTS)
|
|
info = downloader.extract_info(referral, download=False)
|
|
return info
|
|
|
|
@commands.command()
|
|
async def queue(self, ctx):
|
|
if ctx.guild not in self.sessions:
|
|
return await ctx.send('Please join me into a voice channel first.')
|
|
|
|
sesh = self.sessions[ctx.guild]
|
|
if sesh.queue.empty():
|
|
return await ctx.send(
|
|
'There is nothing in the queue at the moment!\n\n'
|
|
'Add something by running `<>play https://url` or `<>play search term`!')
|
|
|
|
# We cannot faff around with the actual queue so make a shallow copy of the internal
|
|
# non-async dequeue.
|
|
# noinspection PyProtectedMember
|
|
agenda = sesh.queue._queue.copy()
|
|
|
|
message = ['**Queue**']
|
|
|
|
for i, item in enumerate(list(agenda)[:15]):
|
|
message.append(f'`{i+1: >2}: {item.title} ({item.who})`')
|
|
|
|
if len(agenda) >= 15:
|
|
message.append('')
|
|
message.append(f'There are {len(agenda)} items in the queue currently.')
|
|
|
|
await ctx.send('\n'.join(message)[:2000])
|
|
|
|
@commands.command()
|
|
async def play(self, ctx, *, referral):
|
|
if ctx.guild not in self.sessions:
|
|
return await ctx.send('Please join me into a voice channel first.')
|
|
|
|
try:
|
|
try:
|
|
info = await self._get_video_meta(referral)
|
|
|
|
# If it was interpreted as a search, it appears this happens?
|
|
# The documentation is so nice.
|
|
if info.get('_type') == 'playlist':
|
|
info = info['entries'][0]
|
|
|
|
# ...wait... did I say nice? I meant "non existent."
|
|
|
|
url = info['url']
|
|
title = info.get('title') or referral
|
|
except IndexError:
|
|
return await ctx.send('No results...', delete_after=15)
|
|
except Exception as ex:
|
|
return await ctx.send(f"Couldn't add this to the queue... reason: {ex!s}")
|
|
|
|
await self.sessions[ctx.guild].queue.put(Request(ctx.author, referral, title, url))
|
|
await ctx.send(f'Okay. Queued `{title or referral}`.')
|
|
except KeyError:
|
|
await ctx.send('I am not playing in this server.')
|
|
|
|
@commands.command()
|
|
async def stop(self, ctx):
|
|
try:
|
|
await self.sessions[ctx.guild].stop()
|
|
except KeyError:
|
|
await ctx.send('I am not playing in this server.')
|
|
except TypeError:
|
|
await ctx.send("I wasn't playing anything, but okay.", delete_after=15)
|
|
|
|
@commands.command()
|
|
async def skip(self, ctx):
|
|
try:
|
|
self.sessions[ctx.guild].skip()
|
|
try:
|
|
await ctx.message.add_reaction('\N{OK HAND SIGN}')
|
|
except discord.Forbidden:
|
|
await ctx.send('\N{OK HAND SIGN}')
|
|
except KeyError:
|
|
await ctx.send('I am not playing in this server.')
|
|
|
|
@commands.command()
|
|
async def disconnect(self, ctx):
|
|
await self.sessions[ctx.guild].stop()
|
|
await self.disconnect()
|
|
|
|
|
|
def setup(bot):
|
|
bot.add_cog(PlayerCog())
|