ivanch/kasbot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add libs & change readme

Browse Source
This commit is contained in:
José Henrique Ivanchechen 2023-12-24 13:47:08 -03:00
parent c536678818
commit 7a38d774c3
16 changed files with 12 additions and 715 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
README.md
View File

@ -2,14 +2,23 @@
#### Inspired by a Brazilian DJ
## Running
### Docker
If using Docker, just put a token on the `docker-compose.yml` file and run it using `docker-compose up -d`.
### Manual
If deploying it by hand, you can run:
```shell
dotnet build -c Release -o bin
dotnet bin/Kasbot.dll
```
##### Windows
If you're using Windows, you will have to download these dependencies and put in the same folder as the executable:
* [FFmpeg](https://ffmpeg.org/download.html)
* [opus.dll](win-x64/opus.dll)
* [libsodium.dll](win-x64/libsodium.dll)
## Commands
| Command | Description
| -- | -- |

4
docker-compose.yml
View File

@ -4,7 +4,9 @@ services:
image: ivanch/kasbot:latest
container_name: kasbot
environment:
- TOKEN=<Your bot token here>
- TOKEN=<Your Discord bot token here>
- SPOTIFY_CLIENT_ID=<Your Spotify dev client token here>
- SPOTIFY_CLIENT_SECRET=<Your Spotify dev client secret here>
- COMMAND_PREFIX=!
- SHARDS=3
restart: unless-stopped

2
legacy/.gitignore vendored
View File

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

55
legacy/README.md
View File

@ -1,55 +0,0 @@
# 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.

74
legacy/kasino.py
View File

@ -1,74 +0,0 @@
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()

44
legacy/main.py
View File

@ -1,44 +0,0 @@
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"))

BIN
legacy/mp3/jet music.mp3
View File

Binary file not shown.

BIN
legacy/mp3/sabadaco.mp3
View File

Binary file not shown.

BIN
legacy/mp3/shake it.mp3
View File

Binary file not shown.

249
legacy/player.py
View File

@ -1,249 +0,0 @@
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.')

18
legacy/pyproject.toml
View File

@ -1,18 +0,0 @@
[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"

4
legacy/requirements.txt
View File

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

15
legacy/utils/keepalive.py
View File

@ -1,15 +0,0 @@
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()

253
legacy/utils/models.py
View File

@ -1,253 +0,0 @@
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

BIN
win-x64/libsodium.dll Normal file
View File

Binary file not shown.

BIN
win-x64/opus.dll Normal file
View File

Binary file not shown.