Legacy

legacy/.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+.env

legacy/README.md

@@ -0,0 +1,55 @@
+# KasBot
+## Bot do Kasino para o Discord.
+
+## Executar
+1. Tenha `python3`, `pip3` e `ffmpeg` instalado.
+2. `git checkout https://github.com/ivanch/kasbot`
+3. `pip3 install -r requirements.txt`
+3. Exporte o token do seu bot com `export TOKEN=[token]`
+4. `python main.py`
+
+#### Keepalive
+Para executar com *keepalive* (manter o servidor vivo com um servidor web):
+1. Instale o flask utilizando `pip3 install flask`
+2. Defina uma variável de ambiente *alive* com `export alive`
+3. Execute os [passos acima](#executar).
+
+## Comandos
+* `kasino`
+    * Toca o famoso SABADAÇO.
+* `shakeit`
+    * Toca o hit SHAKE IT.
+* `jetmusic`
+    * NAS PISTAS DO JET MUSIC!
+* `pare`
+    * Para de tocar e desconecta.
+* `companhia`
+    * Entra no canal e te faz companhia, sem falar nem ouvir nada, apenas o doce som do silêncio.
+
+## Player
+* `-play [url/query]` (`-p`)
+    * Toca música do u2b.
+    * Flags:
+        * `-q`: não envia mensagem (e remove o comando)
+* `-stop`
+    * Para de tocar.
+* `-leave` (`-disconnect`, `-dc`, `-q`)
+    * Desconecta do canal.
+* `-volume [volume]`
+    * Ajuda volume (WIP).
+* `-now` (`-current`, `-playing`)
+    * Mostra o que tá tocando atualmente.
+* `-pause`
+    * Pausa.
+* `-resume` (`-r`)
+    * Dá play de novo (depois de pausar).
+* `-skip` (`-next`, `-s`, `-n`)
+    * Pula pra próxima música na fila.
+* `-queue`
+    * Mostra a fila de músicas.
+* `-shuffle` (`-sf`)
+    * Embaralha as músicas dentro da fila.
+* `-remove [indice]`
+    * Remove uma música baseada no indice na fila.
+* `-loop` (`-l`)
+    * Deixa a música atual em loop.

legacy/kasino.py

@@ -0,0 +1,74 @@
+import discord
+import asyncio
+from discord.ext import commands
+
+class Kasino(commands.Cog):
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+
+    @commands.command(name='kasino')
+    async def _kasino(self, ctx: commands.Context):
+        await self.play_song("./mp3/sabadaco.mp3", ctx)
+        await ctx.message.delete()
+
+    @commands.command(name='shakeit')
+    async def _shake_it(self, ctx: commands.Context):
+        await self.play_song("./mp3/shake it.mp3", ctx)
+        await ctx.message.delete()
+
+    @commands.command(name='jetmusic')
+    async def _jet_music(self, ctx: commands.Context):
+        await self.play_song("./mp3/jet music.mp3", ctx)
+        await ctx.message.delete()
+
+    @commands.command(name='companhia', aliases=['compania'])
+    async def _companhia(self, ctx: commands.Context):
+        voice_state = ctx.message.author.voice
+        if voice_state == None:
+            return
+
+        voice_channel = voice_state.channel
+        await voice_channel.connect()
+        await ctx.message.delete()
+
+    @commands.command(name='pare')
+    async def _pare(self, ctx: commands.Context):
+        voice_channel = ctx.message.author.voice
+        if voice_channel == None:
+            return
+
+        voice_clients = self.bot.voice_clients
+        for vc in voice_clients:
+            if vc.channel == voice_channel.channel:
+                await vc.disconnect()
+                break
+
+        # Delete command after action is done.
+        await ctx.message.delete()
+
+    async def play_song(self, filename: str, ctx: commands.Context):
+        if ctx.author.voice == None:
+            return
+
+        voice_client = discord.utils.get(self.bot.voice_clients, guild=ctx.guild)
+
+        if voice_client == None:
+            voice_channel = ctx.message.author.voice.channel
+            voice_client = await voice_channel.connect()
+        elif voice_client.is_playing():
+            return
+
+        voice_client.play(discord.FFmpegPCMAudio(source=filename))
+
+        # Sleep while audio is playing, then disconnect
+        while voice_client.is_playing() and voice_client.is_connected():
+            await asyncio.sleep(0.3)
+        await voice_client.disconnect()
+
+    async def join(self, ctx: commands.Context):
+        destination = ctx.author.voice.channel
+
+        voice_client = discord.utils.get(self.bot.voice_clients, guild=ctx.guild)
+
+        if voice_client == None or voice_client.channel != destination:
+            voice_client = await destination.connect()

legacy/main.py

@@ -0,0 +1,44 @@
+import os
+import discord
+
+from discord.ext import commands
+from player import Music
+from kasino import Kasino
+
+from dotenv import load_dotenv
+load_dotenv()
+
+# Setup suffixes, set env suffixes if they're set, otherwise default
+MUSIC_SUFFIX = os.getenv("MUSIC_SUFFIX") or "-"
+KASINO_SUFFIX = os.getenv('KASINO_SUFFIX') or ""
+
+client = commands.Bot(command_prefix=[MUSIC_SUFFIX, KASINO_SUFFIX], description='Kasino DEEJAY.')
+music = Music(client)
+kasino = Kasino(client)
+client.add_cog(music)
+client.add_cog(kasino)
+
+kasino_commands = []
+for cmd in kasino.get_commands():
+	kasino_commands.append(KASINO_SUFFIX + cmd.name)
+
+@client.event
+async def on_ready():
+	print('Logged in as {0.user}!'.format(client))
+
+@client.event
+async def on_message(message: discord.Message):
+	# Verifica se é um comando ou não
+	if message.content in kasino_commands or message.content.startswith(MUSIC_SUFFIX):
+		await client.process_commands(message)
+
+# #
+# Init KASINÂO
+# #
+
+alive = os.getenv('alive')
+if alive is not None:
+	from utils.keepalive import keep_alive
+	keep_alive()
+
+client.run(os.getenv("TOKEN"))

legacy/player.py

@@ -0,0 +1,249 @@
+import math
+
+import discord
+from discord import guild
+from discord.ext.commands.errors import CommandError
+import youtube_dl
+from discord.ext import commands
+
+from utils.models import VoiceState,YTDLSource, YTDLError, Song, VoiceError
+
+# Silence useless bug reports messages
+youtube_dl.utils.bug_reports_message = lambda: ''
+
+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 = VoiceState(self.bot, ctx)
+
+        voice_client = discord.utils.get(self.bot.voice_clients, guild=ctx.guild)
+        if voice_client is not None:
+            state.voice = voice_client
+
+        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('An error occurred: {}'.format(str(error)))
+        pass
+
+    @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
+
+        voice_client = discord.utils.get(self.bot.voice_clients, guild=ctx.guild)
+
+        if voice_client == None:
+            ctx.voice_state.voice = await destination.connect()
+        else:
+            ctx.voice_state.voice = voice_client
+
+    @commands.command(name='summon')
+    async def _summon(self, ctx: commands.Context, *, channel: discord.VoiceChannel = None):
+        """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='leave', aliases=['disconnect', 'q', 'dc'])
+    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('Not connected to any voice channel.')
+
+        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('Nothing being played at the moment.')
+
+        if 0 > volume > 100:
+            return await ctx.send('Volume must be between 0 and 100')
+
+        ctx.voice_state.volume = volume / 100
+        await ctx.send('Volume of the player set to {}%'.format(volume))
+
+    @commands.command(name='now', aliases=['current', 'playing'])
+    async def _now(self, ctx: commands.Context):
+        """Displays the currently 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 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=['r'])
+    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='stop')
+    async def _stop(self, ctx: commands.Context):
+        """Stops playing song and clears the queue."""
+
+        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', 'next', 'n'])
+    async def _skip(self, ctx: commands.Context):
+        """Vote to skip a song. The requester can automatically skip."""
+
+        if not ctx.voice_state.is_playing:
+            return await ctx.send('Not playing any music right now...')
+
+
+        await ctx.message.add_reaction('⏭')
+        ctx.voice_state.skip()
+
+
+    @commands.command(name='queue')
+    async def _queue(self, ctx: commands.Context, *, page: int = 1):
+        """Shows the player's queue.
+
+        You can optionally specify the page to show. Each page contains 10 elements.
+        """
+
+        if len(ctx.voice_state.songs) == 0:
+            return await ctx.send('Empty queue.')
+
+        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='shuffle', aliases=['sf'])
+    async def _shuffle(self, ctx: commands.Context):
+        """Shuffles the queue."""
+
+        if len(ctx.voice_state.songs) == 0:
+            return await ctx.send('Empty queue.')
+
+        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('Empty queue.')
+
+        ctx.voice_state.songs.remove(index - 1)
+        await ctx.message.add_reaction('✅')
+
+    @commands.command(name='loop', aliases=['l'])
+    async def _loop(self, ctx: commands.Context):
+        """Loops the currently playing song.
+
+        Invoke this command again to unloop the song.
+        """
+
+        if not ctx.voice_state.is_playing:
+            return await ctx.send('Nothing being played at the moment.')
+
+        # Inverse boolean value to loop and unloop.
+        ctx.voice_state.loop = not ctx.voice_state.loop
+        await ctx.message.add_reaction('✅')
+
+    @commands.command(name='play', aliases=['p'])
+    async def _play(self, ctx: commands.Context, *, search: str):
+        """Plays a song.
+
+        If there are songs in the queue, this will be queued until the
+        other songs finished playing.
+
+        This command automatically searches from various sites if no URL is provided.
+        A list of these sites can be found here: https://rg3.github.io/youtube-dl/supportedsites.html
+        """
+
+        quiet_flag = False
+        flags = ['-q']
+        for flag in flags:
+            if ' ' + flag in search:
+                search = search.replace(' ' + flag, '')
+                if flag == '-q':
+                    quiet_flag = True
+
+        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, quiet=quiet_flag)
+            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)
+
+                if not quiet_flag:
+                    await ctx.send('Enqueued {}'.format(str(source)))
+                else:
+                    await ctx.message.delete()
+
+    @_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 and ctx.voice_client.channel != ctx.author.voice.channel:
+                raise commands.CommandError('Bot is already in a voice channel.')

legacy/pyproject.toml

@@ -0,0 +1,18 @@
+[tool.poetry]
+name = "repl_python3_kasbot"
+version = "0.1.0"
+description = ""
+authors = ["Your Name <you@example.com>"]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+discord = "^1.7.3"
+Flask = "^2.0.1"
+youtube_dl = "^2021.6.6"
+PyNaCl = "^1.4.0"
+
+[tool.poetry.dev-dependencies]
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

legacy/requirements.txt

@@ -0,0 +1,4 @@
+discord[voice]
+pynacl
+youtube-dl
+python-dotenv

legacy/utils/keepalive.py

@@ -0,0 +1,15 @@
+from flask import Flask
+from threading import Thread
+
+app = Flask('')
+
+@app.route('/')
+def home():
+    return "I'm alive"
+
+def run():
+  app.run(host='0.0.0.0',port=8080)
+
+def keep_alive():
+    t = Thread(target=run)
+    t.start()

legacy/utils/models.py

@@ -0,0 +1,253 @@
+import asyncio
+import functools
+import itertools
+import random
+
+import discord
+import youtube_dl
+from async_timeout import timeout
+from discord.ext import commands
+
+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, quiet: bool = False):
+        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')
+        self.quiet = quiet
+
+    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, quiet: bool = False):
+        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, quiet=quiet)
+
+    @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:
+    __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))
+
+        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, client: commands.Bot, ctx: commands.Context):
+        self.client = client
+        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 = client.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:
+                # 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.
+                # try:
+                #     async with timeout(180):  # 3 minutes
+                #         self.current = await self.songs.get()
+                # except asyncio.TimeoutError:
+                #     self.client.loop.create_task(self.stop())
+                #     return
+                self.current = await self.songs.get()
+
+            self.current.source.volume = self._volume
+            self.voice.play(self.current.source, after=self.play_next_song)
+
+            if not self.current.source.quiet:
+                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