739 lines
29 KiB
Python
739 lines
29 KiB
Python
# I M P O R T S
|
|
import os
|
|
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
|
|
|
|
|
|
|
|
#########################################################################################################################
|
|
|
|
# MMMMMMMM MMMMMMMMUUUUUUUU UUUUUUUU SSSSSSSSSSSSSSS IIIIIIIIII CCCCCCCCCCCCC
|
|
# M:::::::M M:::::::MU::::::U U::::::U SS:::::::::::::::SI::::::::I CCC::::::::::::C
|
|
# M::::::::M M::::::::MU::::::U U::::::US:::::SSSSSS::::::SI::::::::I CC:::::::::::::::C
|
|
# M:::::::::M M:::::::::MUU:::::U U:::::UUS:::::S SSSSSSSII::::::IIC:::::CCCCCCCC::::C
|
|
# M::::::::::M M::::::::::M U:::::U U:::::U S:::::S I::::I C:::::C CCCCCC
|
|
# M:::::::::::M M:::::::::::M U:::::D D:::::U S:::::S I::::IC:::::C
|
|
# M:::::::M::::M M::::M:::::::M U:::::D D:::::U S::::SSSS I::::IC:::::C
|
|
# M::::::M M::::M M::::M M::::::M U:::::D D:::::U SS::::::SSSSS I::::IC:::::C
|
|
# M::::::M M::::M::::M M::::::M U:::::D D:::::U SSS::::::::SS I::::IC:::::C
|
|
# M::::::M M:::::::M M::::::M U:::::D D:::::U SSSSSS::::S I::::IC:::::C
|
|
# M::::::M M:::::M M::::::M U:::::D D:::::U S:::::S I::::IC:::::C
|
|
# M::::::M MMMMM M::::::M U::::::U U::::::U S:::::S I::::I C:::::C CCCCCC
|
|
# M::::::M M::::::M U:::::::UUU:::::::U SSSSSSS S:::::SII::::::IIC:::::CCCCCCCC::::C
|
|
# M::::::M M::::::M UU:::::::::::::UU S::::::SSSSSS:::::SI::::::::I CC:::::::::::::::C
|
|
# M::::::M M::::::M UU:::::::::UU S:::::::::::::::SS I::::::::I CCC::::::::::::C
|
|
# MMMMMMMM MMMMMMMM UUUUUUUUU SSSSSSSSSSSSSSS IIIIIIIIII CCCCCCCCCCCCC
|
|
|
|
# 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=commands.when_mentioned_or("/"),
|
|
description="SnakieCat bot")
|
|
token = os.getenv("TOKEN")
|
|
|
|
########################################################################################################################
|
|
|
|
#
|
|
# /$$ /$$ /$$
|
|
# | $$ | $$ |__/
|
|
# /$$$$$$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$ /$$$$$$$ /$$$$$$$ /$$ /$$ /$$ /$$$$$$ /$$$$$$ /$$ /$$$$$$$ /$$$$$$
|
|
# |_ $$_/ /$$__ $$| $$ /$$/|_ $$_/ |____ $$| $$__ $$ /$$_____/| $$ | $$ | $$ /$$__ $$ /$$__ $$| $$| $$__ $$ /$$__ $$
|
|
# | $$ | $$$$$$$$ \ $$$$/ | $$ /$$$$$$$| $$ \ $$| $$$$$$ | $$ | $$ | $$| $$$$$$$$| $$ \__/| $$| $$ \ $$| $$ \ $$
|
|
# | $$ /$$| $$_____/ >$$ $$ | $$ /$$ /$$__ $$| $$ | $$ \____ $$| $$ | $$ | $$| $$_____/| $$ | $$| $$ | $$| $$ | $$
|
|
# | $$$$/| $$$$$$$ /$$/\ $$ | $$$$/ | $$$$$$$| $$ | $$ /$$$$$$$/| $$$$$/$$$$/| $$$$$$$| $$ | $$| $$ | $$| $$$$$$$
|
|
# \___/ \_______/|__/ \__/ \___/ \_______/|__/ |__/|_______/ \_____/\___/ \_______/|__/ |__/|__/ |__/ \____ $$
|
|
# /$$ \ $$
|
|
# | $$$$$$/
|
|
# \______/
|
|
|
|
class Answers(commands.Cog):
|
|
def __init__(self, bot):
|
|
self.bot = bot
|
|
|
|
@bot.listen('on_message')
|
|
async def on_message(message):
|
|
if message.author == bot.user:
|
|
return
|
|
|
|
if "hello" in message.content:
|
|
await message.channel.send('Hello!')
|
|
|
|
if "ABOBA" in message.content or "aboba" in message.content:
|
|
await message.channel.send(
|
|
':regional_indicator_a: :regional_indicator_b: :regional_indicator_o: :regional_indicator_b: :regional_indicator_a:')
|
|
await message.add_reaction("<:A_:834325182332141581>")
|
|
await message.add_reaction("<:B_:834325182658904124>")
|
|
await message.add_reaction("<:O_:834346623923388456>")
|
|
await message.add_reaction("<:B2:834346698763010078>")
|
|
await message.add_reaction("<:A1:834346603711955014>")
|
|
|
|
|
|
########################################################################################################################
|
|
|
|
# ____ __ ___ __
|
|
# / __ \/ / / / | / /
|
|
# / /_/ / / / / |/ /
|
|
# / _, _/ /_/ / /| /
|
|
#/_/ |_|\____/_/ |_/
|
|
@bot.event
|
|
async def on_ready():
|
|
print('Yeah, I have started and my name is {0.user}'.format(bot))
|
|
|
|
bot.add_cog(Music(bot))
|
|
bot.add_cog(Answers(bot))
|
|
bot.run(token)
|