Start adding audio clips

aquabot.py

@@ -36,14 +36,11 @@ bot = commands.Bot(command_prefix=PREFIX, description="Holy Goddess Aqua!")
 
 # Preloaded Cogs
 cogs = ["cogs.admin",
-        "cogs.anime",
         "cogs.help",
         "cogs.jikan",
         "cogs.meme",
-#        "cogs.music",
         "cogs.reddit",
-        "cogs.utility",
+        "cogs.utility"]
-        "cogs.welcome"]
 
 for cog in cogs:
     try:

cogs/audio.py

@@ -0,0 +1,77 @@
+"""
+Play some audio samples
+"""
+
+import discord
+from discord.ext import commands
+from discord import FFmpegPCMAudio
+from asyncio import Lock
+
+
+class Player:
+    lock = Lock()
+
+    async def __aenter__(self):
+        await self.__class__.lock.acquire()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        self.__class__.lock.release()
+
+    @staticmethod
+    async def play(vc, audio_source):
+        vc.play(audio_source)
+        while vc.is_playing():
+            await asyncio.sleep(0.1)
+        await vc.disconnect()
+
+
+class Audio(commands.Cog):
+    def __init__(self, bot):
+        self.bot = bot
+
+    async def connect(bot: Bot, voice_channel: VoiceChannel) -> VoiceClient:
+        assert isinstance(voice_channel, VoiceChannel)
+        if bot.voice_clients:
+            vc: VoiceClient = bot.voice_clients[0]
+            if vc.channel.id != voice_channel.id:
+                await vc.move_to(voice_channel)
+        else:
+            await voice_channel.connect()
+        vc: VoiceClient = bot.voice_clients[0]
+        assert isinstance(vc, VoiceClient)
+        await asyncio.sleep(0.3)
+        return vc
+
+    def parse(query):
+        memes = {"schokobons": "https://www.youtube.com/watch?v=qX7V3EVr1BA"}
+        try:
+            return memes[query]
+        except KeyError as e:
+            return None
+
+    @commands.command(name="play")
+    async def play(self, ctx, query):
+
+        ydl_opts = {
+            'format': 'bestaudio/best',
+            'postprocessors': [{
+                'key': 'FFmpegExtractAudio',
+                'preferredcodec': 'mp3',
+                'preferredquality': '192',
+            }],
+        }
+
+        uri = parse(query)
+        with youtube_dl.YoutubeDL(ydl_opts) as ydl:
+            song_info = ydl.extract_info(uri, download=False)
+            audio_stream = song_info["formats"][0]["url"]
+
+        audio_source = FFmpegPCMAudio(audio_stream)
+        async with self.lock as player:
+            vc = await connect(self.bot, member.voice.channel)
+            await player.play(vc, audio_source)
+
+
+def setup(bot):
+    bot.add_cog(Audio(bot))

cogs/music.py

@@ -1,422 +0,0 @@
-"""
-Play Music
-
-A COG ORIGINALLY NOT CREATED BY ME, I ALTERED THIS ONE TO FIT MY NEEDS
-https://gist.github.com/vbe0201/ade9b80f2d3b64643d854938d40a0a2d
-"""
-
-import discord
-from discord.ext import commands
-import youtube_dl
-import functools
-import asyncio
-import itertools
-import math
-import random
-from async_timeout import timeout
-
-
-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': 'auto',
-        '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)
-
-    @staticmethod
-    def parse_duration(duration: int):
-        minutes, seconds = divmod(duration, 60)
-        hours, minutes = divmod(minutes, 60)
-        days, hours = divmod(hours, 24)
-
-        duration = []
-        if days > 0:
-            duration.append('{} days'.format(days))
-        if hours > 0:
-            duration.append('{} hours'.format(hours))
-        if minutes > 0:
-            duration.append('{} minutes'.format(minutes))
-        if seconds > 0:
-            duration.append('{} seconds'.format(seconds))
-
-        return ', '.join(duration)
-
-class Song:
-    def __init__(self, source: YTDLSource):
-        self.source = source
-        self.requester = source.requester
-
-    def create_embed(self):
-        title = "Now playing"
-        description = f"{self.source.title}"
-        embed = (discord.Embed(title=title,
-                               description=description,
-                               colour=discord.Colour.blue()
-                               ))
-        embed.add_field(name='Uploader', value='[{0.source.uploader}]({0.source.uploader_url})'.format(self))
-        embed.add_field(name="Duration", value=self.source.duration)
-        embed.add_field(name="Requested by", value=self.requester.mention)
-        embed.add_field(name='URL', value='[Click]({0.source.url})'.format(self))
-        embed.set_thumbnail(url=self.source.thumbnail)
-
-        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._loop = 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 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()
-
-            if not self.loop:
-                # 3 minute timeout
-                try:
-                    async with timeout(180):  # 3 minutes
-                        self.current = await self.songs.get()
-                except asyncio.TimeoutError:
-                    self.bot.loop.create_task(self.stop())
-                    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())
-
-            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:
-            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('{}'.format(str(error)))
-
-    ############
-    # COMMANDS #
-    ############
-
-    @commands.command(name="join")
-    async def join(self, ctx: commands.Context, channel: discord.VoiceChannel = None):
-        """
-        Joins your voice channel
-        """
-        if not channel and not ctx.author.voice:
-            raise VoiceError("You're not connected to 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()
-        await ctx.message.add_reaction('🤙')
-
-
-    @commands.command(name="leave", aliases=["dc"])
-    async def leave(self, ctx: commands.Context):
-        """
-        Leaves your voice channel
-        """
-        if not ctx.voice_state.voice:
-            return await ctx.send("You're not connected to a voice channel!")
-
-        await ctx.voice_state.stop()
-        del self.voice_states[ctx.guild.id]
-        await ctx.message.add_reaction('👋')
-
-
-    @commands.command(name="now", aliases=["np"])
-    async def now(self, ctx: commands.Context):
-        """
-        Shows the current playing song
-        """
-        await ctx.send(embed=ctx.voice_state.current.create_embed())
-
-
-    @commands.command(name='pause')
-    async def pause(self, ctx: commands.Context):
-        """
-        Pauses the currently playing song
-        """
-        if not 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')
-    async def resume(self, ctx: commands.Context):
-        """
-        Resumes a currently paused song.
-        """
-        if not 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="skip")
-    async def skip(self, ctx: commands.Context):
-        """
-        Skips the currently playing song
-        """
-        if not ctx.voice_state.is_playing:
-            return await ctx.send("Nothing is playing currently!")
-
-        await ctx.message.add_reaction('⏭')
-        ctx.voice_state.skip()
-
-
-    @commands.command(name="clear")
-    async def clear(self, ctx: commands.Context):
-        """
-        Clears the current queue
-        """
-        ctx.voice_state.songs.clear()
-        await ctx.message.add_reaction('⏹')
-
-
-    @commands.command(name='play')
-    async def play(self, ctx: commands.Context, *, search: str):
-        """
-        Plays a song
-        """
-
-        if not ctx.voice_state.voice:
-            await ctx.invoke(self.join)
-
-        async with ctx.typing():
-            try:
-                source = await YTDLSource.create_source(ctx, search, loop=self.bot.loop)
-            except YTDLError as e:
-                await ctx.send('An error occurred while processing this request: {}'.format(str(e)))
-            else:
-                song = Song(source)
-
-                await ctx.voice_state.songs.put(song)
-                await ctx.send('Enqueued {}'.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.')
-
-
-    @commands.command(name="queue")
-    async def queue(self, ctx: commands.Context):
-        """
-        Shows the queued songs
-        """
-        if len(ctx.voice_state.songs) == 0:
-            return await ctx.send("The queue is empty.")
-
-        page = 1
-
-        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)
-
-
-def setup(bot):
-    bot.add_cog(Music(bot))

cogs/reddit.py

@@ -30,16 +30,14 @@ class Reddit(commands.Cog):
         except:
             await ctx.send(f"Subreddit {sub} not found!")
 
-        try:
+        if sorting == "hot":
-            if sorting == "hot":
+            posts = reddit.subreddit(sub).hot()
-                posts = reddit.subreddit(sub).hot()
+        elif sorting == "top":
-            elif sorting == "top":
+            posts = reddit.subreddit(sub).top(time_filter)
-                posts = reddit.subreddit(sub).top(time_filter)
+        elif sorting == "new":
-            elif sorting == "new":
+            posts = reddit.subreddit(sub).new()
-                posts = reddit.subreddit(sub).new()
+        else:
-
+            await ctx.send(f"Invalid Argument: {sorting}")
-        except ValueError as e:
-            await ctx.send(f"Invalid Argument: {e}")
 
         rand_post = random.randint(1, 100)
         # Make sure you're not sending a pinned post

requirements.txt

@@ -3,3 +3,5 @@ youtube-dl
 praw
 argparse
 jikanpy
+PyNaCl
+opuslib