Code style upgrade

DiscordCogs/ControlCog.py

@@ -0,0 +1,118 @@
+from discord import Client, Game, Status, Embed
+from discord.ext.commands.errors import CommandNotFound, MissingRequiredArgument
+from discord.ext import commands
+from Config.Configs import Configs
+from Config.Helper import Helper
+from Config.Messages import Messages
+from Config.Colors import Colors
+from Views.Embeds import Embeds
+
+helper = Helper()
+
+
+class ControlCog(commands.Cog):
+    """Class to handle discord events"""
+
+    def __init__(self, bot: Client):
+        self.__bot = bot
+        self.__config = Configs()
+        self.__messages = Messages()
+        self.__colors = Colors()
+        self.__embeds = Embeds()
+        self.__comandos = {
+            'MUSIC': ['resume', 'pause', 'loop', 'stop',
+                      'skip', 'play', 'queue', 'clear',
+                      'np', 'shuffle', 'move', 'remove',
+                      'reset', 'prev', 'history'],
+            'RANDOM': ['choose', 'cara', 'random']
+
+        }
+
+    @commands.Cog.listener()
+    async def on_ready(self):
+        print(self.__messages.STARTUP_MESSAGE)
+        await self.__bot.change_presence(status=Status.online, activity=Game(name=f"Vulkan | {self.__config.BOT_PREFIX}help"))
+        print(self.__messages.STARTUP_COMPLETE_MESSAGE)
+
+    @commands.Cog.listener()
+    async def on_command_error(self, ctx, error):
+        if isinstance(error, MissingRequiredArgument):
+            embed = self.__embeds.MISSING_ARGUMENTS()
+            await ctx.send(embed=embed)
+
+        elif isinstance(error, CommandNotFound):
+            embed = self.__embeds.COMMAND_NOT_FOUND()
+            await ctx.send(embed=embed)
+
+        else:
+            print(f'DEVELOPER NOTE -> Command Error: {error}')
+            embed = self.__embeds.UNKNOWN_ERROR()
+            await ctx.send(embed=embed)
+
+    @commands.command(name="help", help=helper.HELP_HELP, description=helper.HELP_HELP_LONG, aliases=['h', 'ajuda'])
+    async def help_msg(self, ctx, command_help=''):
+        if command_help != '':
+            for command in self.__bot.commands:
+                if command.name == command_help:
+                    txt = command.description if command.description else command.help
+
+                    embedhelp = Embed(
+                        title=f'**Description of {command_help}** command',
+                        description=txt,
+                        colour=self.__colors.BLUE
+                    )
+
+                    await ctx.send(embed=embedhelp)
+                    return
+
+            embedhelp = Embed(
+                title='Command Help',
+                description=f'Command {command_help} Not Found',
+                colour=self.__colors.RED
+            )
+
+            await ctx.send(embed=embedhelp)
+        else:
+
+            helptxt = ''
+            help_music = '🎧 `MUSIC`\n'
+            help_random = '🎲 `RANDOM`\n'
+            help_help = '👾 `HELP`\n'
+
+            for command in self.__bot.commands:
+                if command.name in self.__comandos['MUSIC']:
+                    help_music += f'**{command}** - {command.help}\n'
+
+                elif command.name in self.__comandos['RANDOM']:
+                    help_random += f'**{command}** - {command.help}\n'
+
+                else:
+                    help_help += f'**{command}** - {command.help}\n'
+
+            helptxt = f'\n{help_music}\n{help_help}\n{help_random}'
+            helptxt += f'\n\nType {self.__config.BOT_PREFIX}help "command" for more information about the command chosen'
+            embedhelp = Embed(
+                title=f'**Available Commands of {self.__bot.user.name}**',
+                description=helptxt,
+                colour=self.__colors.BLUE
+            )
+
+            embedhelp.set_thumbnail(url=self.__bot.user.avatar_url)
+            await ctx.send(embed=embedhelp)
+
+    @commands.command(name='invite', help=helper.HELP_INVITE, description=helper.HELP_INVITE_LONG, aliases=['convite', 'inv', 'convidar'])
+    async def invite_bot(self, ctx):
+        invite_url = self.__config.INVITE_URL.format(self.__bot.user.id)
+        txt = self.__config.INVITE_MESSAGE.format(invite_url, invite_url)
+
+        embed = Embed(
+            title="Invite Vulkan",
+            description=txt,
+            colour=self.__colors.BLUE
+        )
+
+        await ctx.send(embed=embed)
+
+
+def setup(bot):
+    bot.add_cog(ControlCog(bot))

DiscordCogs/MusicCog.py

@@ -0,0 +1,203 @@
+from discord import Guild, Client
+from discord.ext import commands
+from discord.ext.commands import Context
+from Config.Helper import Helper
+from Handlers.ClearHandler import ClearHandler
+from Handlers.MoveHandler import MoveHandler
+from Handlers.NowPlayingHandler import NowPlayingHandler
+from Handlers.PlayHandler import PlayHandler
+from Handlers.PlayersController import PlayersController
+from Handlers.PrevHandler import PrevHandler
+from Handlers.RemoveHandler import RemoveHandler
+from Handlers.ResetHandler import ResetHandler
+from Handlers.ShuffleHandler import ShuffleHandler
+from Utils.Cleaner import Cleaner
+from Handlers.SkipHandler import SkipHandler
+from Handlers.PauseHandler import PauseHandler
+from Handlers.StopHandler import StopHandler
+from Handlers.ResumeHandler import ResumeHandler
+from Handlers.HistoryHandler import HistoryHandler
+from Handlers.QueueHandler import QueueHandler
+from Handlers.LoopHandler import LoopHandler
+from Views.EmoteView import EmoteView
+from Views.EmbedView import EmbedView
+from Parallelism.ProcessManager import ProcessManager
+
+helper = Helper()
+
+
+class MusicCog(commands.Cog):
+    """
+    Class to listen to Music commands
+    It'll listen for commands from discord, when triggered will create a specific Handler for the command
+    Execute the handler and then create a specific View to be showed in Discord
+    """
+
+    def __init__(self, bot) -> None:
+        self.__bot: Client = bot
+        self.__cleaner = Cleaner(self.__bot)
+        self.__controller = PlayersController(self.__bot)
+
+    @commands.Cog.listener()
+    async def on_ready(self) -> None:
+        self.__controller = PlayersController(self.__bot)
+
+    @commands.Cog.listener()
+    async def on_guild_join(self, guild: Guild) -> None:
+        self.__controller.create_player(guild)
+
+    @commands.command(name="play", help=helper.HELP_PLAY, description=helper.HELP_PLAY_LONG, aliases=['p', 'tocar'])
+    async def play(self, ctx: Context, *args) -> None:
+        controller = PlayHandler(ctx, self.__bot)
+
+        response = await controller.run(args)
+        if response is not None:
+            view1 = EmbedView(response)
+            view2 = EmoteView(response)
+            await view1.run()
+            await view2.run()
+
+    @commands.command(name="queue", help=helper.HELP_QUEUE, description=helper.HELP_QUEUE_LONG, aliases=['q', 'fila', 'musicas'])
+    async def queue(self, ctx: Context) -> None:
+        controller = QueueHandler(ctx, self.__bot)
+
+        response = await controller.run()
+        view2 = EmbedView(response)
+        await view2.run()
+
+    @commands.command(name="skip", help=helper.HELP_SKIP, description=helper.HELP_SKIP_LONG, aliases=['s', 'pular', 'next'])
+    async def skip(self, ctx: Context) -> None:
+        controller = SkipHandler(ctx, self.__bot)
+
+        response = await controller.run()
+        if response.success:
+            view = EmoteView(response)
+        else:
+            view = EmbedView(response)
+
+        await view.run()
+
+    @commands.command(name='stop', help=helper.HELP_STOP, description=helper.HELP_STOP_LONG, aliases=['parar'])
+    async def stop(self, ctx: Context) -> None:
+        controller = StopHandler(ctx, self.__bot)
+
+        response = await controller.run()
+        if response.success:
+            view = EmoteView(response)
+        else:
+            view = EmbedView(response)
+
+        await view.run()
+
+    @commands.command(name='pause', help=helper.HELP_PAUSE, description=helper.HELP_PAUSE_LONG, aliases=['pausar', 'pare'])
+    async def pause(self, ctx: Context) -> None:
+        controller = PauseHandler(ctx, self.__bot)
+
+        response = await controller.run()
+        view1 = EmoteView(response)
+        view2 = EmbedView(response)
+        await view1.run()
+        await view2.run()
+
+    @commands.command(name='resume', help=helper.HELP_RESUME, description=helper.HELP_RESUME_LONG, aliases=['soltar', 'despausar'])
+    async def resume(self, ctx: Context) -> None:
+        controller = ResumeHandler(ctx, self.__bot)
+
+        response = await controller.run()
+        view1 = EmoteView(response)
+        view2 = EmbedView(response)
+        await view1.run()
+        await view2.run()
+
+    @commands.command(name='prev', help=helper.HELP_PREV, description=helper.HELP_PREV_LONG, aliases=['anterior', 'return', 'previous'])
+    async def prev(self, ctx: Context) -> None:
+        controller = PrevHandler(ctx, self.__bot)
+
+        response = await controller.run()
+        if response is not None:
+            view1 = EmbedView(response)
+            view2 = EmoteView(response)
+            await view1.run()
+            await view2.run()
+
+    @commands.command(name='history', help=helper.HELP_HISTORY, description=helper.HELP_HISTORY_LONG, aliases=['historico', 'h'])
+    async def history(self, ctx: Context) -> None:
+        controller = HistoryHandler(ctx, self.__bot)
+
+        response = await controller.run()
+        view1 = EmbedView(response)
+        view2 = EmoteView(response)
+        await view1.run()
+        await view2.run()
+
+    @commands.command(name='loop', help=helper.HELP_LOOP, description=helper.HELP_LOOP_LONG, aliases=['l', 'repeat'])
+    async def loop(self, ctx: Context, args='') -> None:
+        controller = LoopHandler(ctx, self.__bot)
+
+        response = await controller.run(args)
+        view1 = EmoteView(response)
+        view2 = EmbedView(response)
+        await view1.run()
+        await view2.run()
+
+    @commands.command(name='clear', help=helper.HELP_CLEAR, description=helper.HELP_CLEAR_LONG, aliases=['c', 'limpar'])
+    async def clear(self, ctx: Context) -> None:
+        controller = ClearHandler(ctx, self.__bot)
+
+        response = await controller.run()
+        view = EmoteView(response)
+        await view.run()
+
+    @commands.command(name='np', help=helper.HELP_NP, description=helper.HELP_NP_LONG, aliases=['playing', 'now', 'this'])
+    async def now_playing(self, ctx: Context) -> None:
+        controller = NowPlayingHandler(ctx, self.__bot)
+
+        response = await controller.run()
+        view1 = EmbedView(response)
+        view2 = EmoteView(response)
+        await view1.run()
+        await view2.run()
+
+    @commands.command(name='shuffle', help=helper.HELP_SHUFFLE, description=helper.HELP_SHUFFLE_LONG, aliases=['aleatorio'])
+    async def shuffle(self, ctx: Context) -> None:
+        controller = ShuffleHandler(ctx, self.__bot)
+
+        response = await controller.run()
+        view1 = EmbedView(response)
+        view2 = EmoteView(response)
+        await view1.run()
+        await view2.run()
+
+    @commands.command(name='move', help=helper.HELP_MOVE, description=helper.HELP_MOVE_LONG, aliases=['m', 'mover'])
+    async def move(self, ctx: Context, pos1, pos2='1') -> None:
+        controller = MoveHandler(ctx, self.__bot)
+
+        response = await controller.run(pos1, pos2)
+        view1 = EmbedView(response)
+        view2 = EmoteView(response)
+        await view1.run()
+        await view2.run()
+
+    @commands.command(name='remove', help=helper.HELP_REMOVE, description=helper.HELP_REMOVE_LONG, aliases=['remover'])
+    async def remove(self, ctx: Context, position) -> None:
+        controller = RemoveHandler(ctx, self.__bot)
+
+        response = await controller.run(position)
+        view1 = EmbedView(response)
+        view2 = EmoteView(response)
+        await view1.run()
+        await view2.run()
+
+    @commands.command(name='reset', help=helper.HELP_RESET, description=helper.HELP_RESET_LONG, aliases=['resetar'])
+    async def reset(self, ctx: Context) -> None:
+        controller = ResetHandler(ctx, self.__bot)
+
+        response = await controller.run()
+        view1 = EmbedView(response)
+        view2 = EmoteView(response)
+        await view1.run()
+        await view2.run()
+
+
+def setup(bot):
+    bot.add_cog(MusicCog(bot))

DiscordCogs/RandomCog.py

@@ -0,0 +1,64 @@
+from random import randint, random
+from discord import Client
+from discord.ext.commands import Context, command, Cog
+from Config.Helper import Helper
+from Views.Embeds import Embeds
+
+helper = Helper()
+
+
+class RandomCog(Cog):
+    """Class to listen to commands of type Random"""
+
+    def __init__(self, bot: Client):
+        self.__embeds = Embeds()
+
+    @command(name='random', help=helper.HELP_RANDOM, description=helper.HELP_RANDOM_LONG, aliases=['rand', 'aleatorio'])
+    async def random(self, ctx: Context, arg: str) -> None:
+        try:
+            arg = int(arg)
+
+        except:
+            embed = self.__embeds.ERROR_NUMBER()
+            await ctx.send(embed=embed)
+            return None
+
+        if arg < 1:
+            a = arg
+            b = 1
+        else:
+            a = 1
+            b = arg
+
+        x = randint(a, b)
+        embed = self.__embeds.RANDOM_NUMBER(a, b, x)
+        await ctx.send(embed=embed)
+
+    @command(name='cara', help=helper.HELP_CARA, description=helper.HELP_CARA_LONG, aliases=['coroa'])
+    async def cara(self, ctx: Context) -> None:
+        x = random()
+        if x < 0.5:
+            result = 'cara'
+        else:
+            result = 'coroa'
+
+        embed = self.__embeds.CARA_COROA(result)
+        await ctx.send(embed=embed)
+
+    @command(name='choose', help=helper.HELP_CHOOSE, description=helper.HELP_CHOOSE_LONG, aliases=['escolha', 'pick'])
+    async def choose(self, ctx, *args: str) -> None:
+        try:
+            user_input = " ".join(args)
+            itens = user_input.split(sep=',')
+
+            index = randint(0, len(itens)-1)
+
+            embed = self.__embeds.CHOSEN_THING(itens[index])
+            await ctx.send(embed=embed)
+        except:
+            embed = self.__embeds.BAD_CHOOSE_USE()
+            await ctx.send(embed=embed)
+
+
+def setup(bot):
+    bot.add_cog(RandomCog(bot))