Stylish update

vulkan/commands/Control.py

@@ -15,7 +15,7 @@ class Control(commands.Cog):
             'WARFRAME': ['warframe'],
             'RANDOM': ['escolha', 'cara', 'random'],
             'HELP': ['help'],
-            'OTHERS': ['frase', 'drop']
+            'OTHERS': ['frase']
         }
 
     @commands.Cog.listener()
@@ -27,21 +27,36 @@ class Control(commands.Cog):
     @commands.Cog.listener()
     async def on_command_error(self, ctx, error):
         if isinstance(error, MissingRequiredArgument):
-            await ctx.channel.send(f'Falta argumentos. Digite {config.BOT_PREFIX}help para ver todos os comandos\n\nOu tente {config.BOT_PREFIX}command help para mais informações')
-        elif isinstance(error, CommandNotFound):
-            await ctx.channel.send(f'O comando não existe')
-        else:
-            await ctx.channel.send(f'Teve um erro aí bicho')
-            raise error
+            embed = discord.Embed(
+                title=config.ERROR_TITLE,
+                description=config.ERROR_MISSING_ARGUMENTS,
+                colour=config.COLOURS['red']
+            )
+            await ctx.send(embed=embed)
 
-    @commands.command(name="help", alisases=['ajuda'], help=config.HELP_HELP)
+        elif isinstance(error, CommandNotFound):
+            embed = discord.Embed(
+                title=config.ERROR_TITLE,
+                description=config.COMMAND_NOT_FOUND,
+                colour=config.COLOURS['red']
+            )
+            await ctx.send(embed=embed)
+        else:
+            embed = discord.Embed(
+                title=config.ERROR_TITLE,
+                description=config.UNKNOWN_ERROR,
+                colour=config.COLOURS['red']
+            )
+            await ctx.send(embed=embed)
+
+    @commands.command(name="help", help=config.HELP_HELP, alisases=['h', 'ajuda'])
     async def help_msg(self, ctx):
         helptxt = ''
-        help_music = '-- MUSIC\n'
-        help_random = '-- RANDOM\n'
-        help_warframe = '-- WARFRAME\n'
-        help_help = '-- HELP\n'
-        help_others = '-- OTHERS\n'
+        help_music = '🎧 `MUSIC`\n'
+        help_random = '🎲 `RANDOM`\n'
+        help_warframe = '🎮 `WARFRAME`\n'
+        help_help = '👾 `HELP`\n'
+        help_others = '🕹️ `OTHERS`\n'
 
         for command in self.__bot.commands:
             if command.name in self.__comandos['MUSIC']:
@@ -58,9 +73,9 @@ class Control(commands.Cog):
         helptxt = f'{help_music}\n{help_warframe}\n{help_random}\n{help_others}\n{help_help}'
 
         embedhelp = discord.Embed(
-            colour=config.COLOURS['grey'],
-            title=f'Comandos do {self.__bot.user.name}',
-            description=helptxt
+            title=f'**Available Commands of {self.__bot.user.name}**',
+            description=helptxt,
+            colour=config.COLOURS['blue']
         )
 
         embedhelp.set_thumbnail(url=self.__bot.user.avatar_url)

vulkan/commands/Music.py

@@ -7,35 +7,35 @@ from vulkan.music.utils import *
 
 
 class Music(commands.Cog):
-    def __init__(self, bot):
+    def __init__(self, bot) -> None:
         self.__guilds = {}
         self.__bot: discord.Client = bot
 
     @commands.Cog.listener()
-    async def on_ready(self):
+    async def on_ready(self) -> None:
         for guild in self.__bot.guilds:
             self.__guilds[guild] = Player(self.__bot, guild)
 
     @commands.command(name="play", help=config.HELP_PLAY, aliases=['p', 'tocar'])
-    async def play(self, ctx, *args):
-        user_input = " ".join(args)
+    async def play(self, ctx, *args) -> None:
+        track = " ".join(args)
         requester = ctx.author.name
 
         player = self.__get_player(ctx)
         if player == None:
-            await self.__send_embed(ctx, description=config.NO_GUILD, colour_name='red')
+            await self.__send_embed(ctx, config.ERROR_TITLE, config.NO_GUILD, 'red')
             return
 
         if is_connected(ctx) == None:
-            result = await player.connect(ctx)
-            if result['success'] == False:
-                await self.__send_embed(ctx, description=result['reason'], colour_name='red')
+            success = await player.connect(ctx)
+            if success == False:
+                await self.__send_embed(ctx, config.ERROR_TITLE, config.NO_CHANNEL, 'red')
                 return
 
-        await player.play(ctx, user_input, requester)
+        await player.play(ctx, track, requester)
 
     @commands.command(name="queue", help=config.HELP_QUEUE, aliases=['q', 'fila'])
-    async def queue(self, ctx):
+    async def queue(self, ctx) -> None:
         player = self.__get_player(ctx)
         if player == None:
             return
@@ -43,8 +43,8 @@ class Music(commands.Cog):
         embed = await player.queue()
         await ctx.send(embed=embed)
 
-    @commands.command(name="skip", help=config.HELP_SKIP, aliases=['pular'])
-    async def skip(self, ctx):
+    @commands.command(name="skip", help=config.HELP_SKIP, aliases=['s', 'pular'])
+    async def skip(self, ctx) -> None:
         player = self.__get_player(ctx)
         if player == None:
             return
@@ -52,7 +52,7 @@ class Music(commands.Cog):
             await player.skip()
 
     @commands.command(name='stop', help=config.HELP_STOP, aliases=['parar'])
-    async def stop(self, ctx):
+    async def stop(self, ctx) -> None:
         player = self.__get_player(ctx)
         if player == None:
             return
@@ -60,37 +60,36 @@ class Music(commands.Cog):
             await player.stop()
 
     @commands.command(name='pause', help=config.HELP_PAUSE, aliases=['pausar'])
-    async def pause(self, ctx):
+    async def pause(self, ctx) -> None:
         player = self.__get_player(ctx)
         if player == None:
-            print('No player')
             return
         else:
             success = await player.pause()
             if success:
-                await self.__send_embed(ctx, description='Song paused', colour_name='blue')
+                await self.__send_embed(ctx, config.SONG_PLAYER, config.SONG_PAUSED, 'blue')
 
     @commands.command(name='resume', help=config.HELP_RESUME, aliases=['soltar'])
-    async def resume(self, ctx):
+    async def resume(self, ctx) -> None:
         player = self.__get_player(ctx)
         if player == None:
             return
         else:
             success = await player.resume()
             if success:
-                await self.__send_embed(ctx, description='Song Playing', colour_name='blue')
+                await self.__send_embed(ctx, config.SONG_PLAYER, config.SONG_RESUMED, 'blue')
 
-    @commands.command(name='loop', help=config.HELP_LOOP, aliases=['repeat'])
-    async def loop(self, ctx, args: str):
+    @commands.command(name='loop', help=config.HELP_LOOP, aliases=['l', 'repeat'])
+    async def loop(self, ctx, args: str) -> None:
         player = self.__get_player(ctx)
         if player == None:
             return
         else:
-            result = await player.loop(args)
-            await self.__send_embed(ctx, description=result, colour_name='blue')
+            description = await player.loop(args)
+            await self.__send_embed(ctx, config.SONG_PLAYER, description, 'blue')
 
-    @commands.command(name='clear', help=config.HELP_CLEAR, aliases=['limpar'])
-    async def clear(self, ctx):
+    @commands.command(name='clear', help=config.HELP_CLEAR, aliases=['c', 'limpar'])
+    async def clear(self, ctx) -> None:
         player = self.__get_player(ctx)
         if player == None:
             return
@@ -98,7 +97,7 @@ class Music(commands.Cog):
             await player.clear()
 
     @commands.command(name='np', help=config.HELP_NP, aliases=['playing', 'now'])
-    async def now_playing(self, ctx):
+    async def now_playing(self, ctx) -> None:
         player = self.__get_player(ctx)
         if player == None:
             return
@@ -108,45 +107,44 @@ class Music(commands.Cog):
             await ctx.send(embed=embed)
 
     @commands.command(name='shuffle', help=config.HELP_SHUFFLE, aliases=['aleatorio'])
-    async def shuffle(self, ctx):
+    async def shuffle(self, ctx) -> None:
         player = self.__get_player(ctx)
         if player == None:
             return
         else:
-            result = await player.shuffle()
-            await self.__send_embed(ctx, description=result, colour_name='blue')
+            description = await player.shuffle()
+            await self.__send_embed(ctx, config.SONG_PLAYER, description, 'blue')
 
-    @commands.command(name='move', help=config.HELP_MOVE, aliases=['mover'])
-    async def move(self, ctx, pos1, pos2='1'):
+    @commands.command(name='move', help=config.HELP_MOVE, aliases=['m', 'mover'])
+    async def move(self, ctx, pos1, pos2='1') -> None:
         player = self.__get_player(ctx)
         if player == None:
             return
         else:
-            result = await player.move(pos1, pos2)
-            await self.__send_embed(ctx, description=result, colour_name='blue')
+            description = await player.move(pos1, pos2)
+            await self.__send_embed(ctx, config.SONG_PLAYER, description, 'blue')
 
     @commands.command(name='remove', help=config.HELP_REMOVE, aliases=['remover'])
-    async def remove(self, ctx, position):
-        """Remove a song from the queue in the position"""
+    async def remove(self, ctx, position) -> None:
         player = self.__get_player(ctx)
         if player == None:
             return
         else:
-            result = await player.remove(position)
-            await self.__send_embed(ctx, description=result, colour_name='blue')
+            description = await player.remove(position)
+            await self.__send_embed(ctx, config.SONG_PLAYER, description, 'blue')
 
     @commands.command(name='reset', help=config.HELP_RESET, aliases=['resetar'])
-    async def reset(self, ctx):
+    async def reset(self, ctx) -> None:
         player = self.__get_player(ctx)
         if player != None:
             await player.stop()
 
         self.__guilds[ctx.guild] = Player(self.__bot, ctx.guild)
 
-    async def __send_embed(self, ctx, title='', description='', colour_name='grey'):
+    async def __send_embed(self, ctx, title='', description='', colour='grey') -> None:
         try:
-            colour = config.COLOURS[colour_name]
-        except Exception as e:
+            colour = config.COLOURS[colour]
+        except:
             colour = config.COLOURS['grey']
 
         embedvc = discord.Embed(
@@ -156,8 +154,7 @@ class Music(commands.Cog):
         )
         await ctx.send(embed=embedvc)
 
-    async def __clean_messages(self, ctx):
-        """Clear Bot messages if send recently"""
+    async def __clean_messages(self, ctx) -> None:
         last_messages = await ctx.channel.history(limit=5).flatten()
 
         for message in last_messages:
@@ -165,12 +162,12 @@ class Music(commands.Cog):
                 if message.author == self.__bot.user:
                     if len(message.embeds) > 0:
                         embed = message.embeds[0]
-                        if embed.title == 'Song Playing Now' or embed.title == 'Song Looping Now':
+                        if embed.title in config.SONGS_PLAYING_TITLES:
                             await message.delete()
             except:
                 continue
 
-    def __get_player(self, ctx):
+    def __get_player(self, ctx) -> Player:
         try:
             return self.__guilds[ctx.guild]
         except:

vulkan/commands/Phrases.py

@@ -36,6 +36,7 @@ class Phrases(commands.Cog):
         while True:
             tries += 1
             if tries > config.MAX_API_PHRASES_TRIES:
+                return config.ERROR_WHILE_REQUEST
                 return 'O banco de dados dos cara tá off, bando de vagabundo, tenta depois aí bicho'
 
             try:
@@ -51,7 +52,7 @@ class Phrases(commands.Cog):
                 text = f'{phrase} \nBy: {author}'
 
                 return text
-            except Exception as e:
+            except:
                 continue
 
 

vulkan/music/Downloader.py

@@ -64,7 +64,6 @@ class Downloader():
                 except (ExtractorError, DownloadError) as e:
                     return None
         else:
-            print('Invalid type of playlist URL')
             return None
 
     async def preload(self, songs: list) -> None:

vulkan/music/Interfaces.py

@@ -24,10 +24,6 @@ class IPlaylist(ABC):
     def next_song(self):
         pass
 
-    @abstractmethod
-    def prev_song(self):
-        pass
-
     @abstractmethod
     def add_song(self, identifier: str) -> None:
         pass

vulkan/music/Player.py

@@ -1,4 +1,5 @@
 import discord
+from discord import colour
 from discord.ext import commands
 from config import config
 import datetime
@@ -25,41 +26,53 @@ class Player(commands.Cog):
         self.FFMPEG_OPTIONS = {'before_options': '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5',
                                'options': '-vn'}
 
-    async def connect(self, ctx):
+    async def connect(self, ctx) -> None:
         if not ctx.author.voice:
-            return {'success': False, 'reason': config.NO_CHANNEL}
+            return False
 
         if self.__guild.voice_client == None:
             await ctx.author.voice.channel.connect(reconnect=True, timeout=None)
-            return {'success': True, 'reason': ''}
+            return True
+
+    def __play_next(self, error, ctx) -> None:
+        if error != None:
+            return
 
-    def __play_next(self, error, ctx):
         song = self.__playlist.next_song()
-        if song != None:  # If there is not a song for the song
+        if song != None:
             coro = self.__play_music(ctx, song)
             self.__bot.loop.create_task(coro)
         else:
             self.__playing = False
 
-    async def __play_music(self, ctx, song):
-        self.__playing = True
+    async def __play_music(self, ctx, song) -> None:
+        try:
+            self.__playing = True
 
-        player = discord.FFmpegPCMAudio(song.source, **self.FFMPEG_OPTIONS)
-        self.__guild.voice_client.play(
-            player, after=lambda e: self.__play_next(e, ctx))
+            player = discord.FFmpegPCMAudio(song.source, **self.FFMPEG_OPTIONS)
+            self.__guild.voice_client.play(
+                player, after=lambda e: self.__play_next(e, ctx))
 
-        self.__timer.cancel()
-        self.__timer = Timer(self.__timeout_handler)
+            self.__timer.cancel()
+            self.__timer = Timer(self.__timeout_handler)
 
-        await ctx.invoke(self.__bot.get_command('np'))
+            await ctx.invoke(self.__bot.get_command('np'))
 
-        songs = self.__playlist.songs_to_preload
-        await self.__down.preload(songs)
+            songs = self.__playlist.songs_to_preload
+            await self.__down.preload(songs)
+        except:
+            embed = discord.Embed(
+                title=config.ERROR_TITLE,
+                description=config.ERROR_PLAYING,
+                colour=config.COLOURS['red']
+            )
+            await ctx.send(embed=embed)
+            return
 
-    async def play(self, ctx, track, requester) -> str:
+    async def play(self, ctx, track=str, requester=str) -> str:
         try:
             songs_names, provider = self.__searcher.search(track)
-            if provider == Provider.Unknown:
+            if provider == Provider.Unknown or songs_names == None:
                 embed = discord.Embed(
                     title=config.ERROR_TITLE,
                     description=config.INVALID_INPUT,
@@ -78,7 +91,7 @@ class Player(commands.Cog):
             songs_preload = self.__playlist.songs_to_preload
             await self.__down.preload(songs_preload)
 
-        except:
+        except Exception as e:
             embed = discord.Embed(
                 title=config.ERROR_TITLE,
                 description=config.DOWNLOADING_ERROR,
@@ -98,16 +111,16 @@ class Player(commands.Cog):
                 return
             elif not self.__playing:
                 embed = discord.Embed(
-                    title=config.SONG_QUEUE_TITLE,
+                    title=config.SONG_PLAYER,
                     description=config.SONG_ADDED.format(song.title),
                     colour=config.COLOURS['blue'])
                 await ctx.send(embed=embed)
             else:
-                embed = self.__format_embed(song.info, config.SONG_ADDED)
+                embed = self.__format_embed(song.info, config.SONG_ADDED_TWO)
                 await ctx.send(embed=embed)
         else:
             embed = discord.Embed(
-                title=config.SONG_QUEUE_TITLE,
+                title=config.SONG_PLAYER,
                 description=config.SONGS_ADDED.format(songs_quant),
                 colour=config.COLOURS['blue'])
             await ctx.send(embed=embed)
@@ -115,7 +128,7 @@ class Player(commands.Cog):
         if not self.__playing:
             try_another = True
 
-            while try_another:  # This will ensure the first song source to be ready
+            while try_another:  # will ensure the first song source to be ready
                 first_song = self.__playlist.next_song()
                 if first_song == None:
                     embed = discord.Embed(
@@ -139,26 +152,32 @@ class Player(commands.Cog):
     async def queue(self) -> discord.Embed:
         if self.__playlist.looping_one:
             info = self.__playlist.current.info
-            title = 'Song Looping Now'
+            title = config.ONE_SONG_LOOPING
             return self.__format_embed(info, title)
 
         songs_preload = self.__playlist.songs_to_preload
-        await self.__down.preload(songs_preload)
-        total_time = format_time(sum([int(song.duration if song.duration else 0)
-                                 for song in songs_preload]))  # Sum the duration
-        total_songs = len(self.__playlist)
-        text = f'Total musics: {total_songs} | Duration: `{total_time}` downloaded  \n\n'
 
-        for pos, song in enumerate(songs_preload, start=1):
-            title = song.title if song.title else 'Downloading...'
-            text += f"**`{pos}` - ** {title} - `{format_time(song.duration)}`\n"
+        if len(songs_preload) == 0:
+            title = config.SONG_PLAYER
+            text = config.EMPTY_QUEUE
 
-        title = 'Songs in Queue'
-        if len(songs_preload) > 0:
-            if self.__playlist.looping_all:
-                title = 'Repeating All'
         else:
-            text = 'There is no musics in queue'
+            if self.__playlist.looping_all:
+                title = config.ALL_SONGS_LOOPING
+            else:
+                title = config.QUEUE_TITLE
+
+            await self.__down.preload(songs_preload)
+
+            total_time = format_time(sum([int(song.duration if song.duration else 0)
+                                          for song in songs_preload]))
+            total_songs = len(self.__playlist)
+
+            text = f'📜 Queue length: {total_songs} | ⌛ Duration: `{total_time}` downloaded  \n\n'
+
+            for pos, song in enumerate(songs_preload, start=1):
+                song_name = song.title if song.title else config.SONG_DOWNLOADING
+                text += f"**`{pos}` - ** {song_name} - `{format_time(song.duration)}`\n"
 
         embed = discord.Embed(
             title=title,
@@ -202,7 +221,7 @@ class Player(commands.Cog):
             self.__guild.voice_client.resume()
             return True
 
-    async def loop(self, args: str):
+    async def loop(self, args: str) -> str:
         args = args.lower()
         if args == 'one':
             description = self.__playlist.loop_one()
@@ -211,7 +230,7 @@ class Player(commands.Cog):
         elif args == 'off':
             description = self.__playlist.loop_off()
         else:
-            description = 'Comando Loop\nOne - Repete a música atual\nAll - Repete as músicas atuais\nOff - Desativa o loop'
+            description = config.HELP_LONG_LOOP
 
         return description
 
@@ -220,9 +239,9 @@ class Player(commands.Cog):
 
     async def now_playing(self) -> discord.Embed:
         if self.__playlist.looping_one:
-            title = 'Song Looping Now'
+            title = config.ONE_SONG_LOOPING
         else:
-            title = 'Song Playing Now'
+            title = config.SONG_PLAYING
 
         current_song = self.__playlist.current
         embed = self.__format_embed(current_song.info, title)
@@ -235,9 +254,9 @@ class Player(commands.Cog):
             songs = self.__playlist.songs_to_preload
 
             await self.__down.preload(songs)
-            return 'Musics shuffled successfully'
+            return config.SONGS_SHUFFLED
         except:
-            return 'An error ocurred :/'
+            return config.ERROR_SHUFFLING
 
     async def move(self, pos1, pos2='1') -> str:
         try:
@@ -245,7 +264,7 @@ class Player(commands.Cog):
             pos2 = int(pos2)
 
         except:
-            return 'This command require a number'
+            return config.ERROR_NUMBER
 
         result = self.__playlist.move_songs(pos1, pos2)
 
@@ -259,12 +278,12 @@ class Player(commands.Cog):
             position = int(position)
 
         except:
-            return 'This command require a number'
+            return config.ERROR_NUMBER
 
         result = self.__playlist.remove_song(position)
         return result
 
-    def __format_embed(self, info, title='') -> discord.Embed:
+    def __format_embed(self, info=dict, title='') -> discord.Embed:
         """Configure the embed to show the song information"""
         embedvc = discord.Embed(
             title=title,

vulkan/music/Playlist.py

@@ -41,42 +41,27 @@ class Playlist(IPlaylist):
     def next_song(self) -> Song:
         """Return the next song to play"""
         if self.__current == None and len(self.__queue) == 0:
-            # If not playing and nothing to play
             return None
 
-        # If playing
         played_song = self.__current
 
-        # Check if need to repeat the played song
         if self.__looping_one:  # Insert the current song to play again
             self.__queue.appendleft(played_song)
 
         if self.__looping_all:  # Insert the current song in the end of queue
             self.__queue.append(played_song)
 
-        while True:  # Try to get the source of next song
-            if len(self.__queue) == 0:  # If no more song to play, return None
+        while True:
+            if len(self.__queue) == 0:
                 return None
 
-            # Att the current with the first one
             self.__current = self.__queue[0]
-            self.__queue.popleft()  # Remove the current from queue
-            self.__name_history.append(
-                self.__current.identifier)  # Add to name history
-            self.__songs_history.append(self.__current)  # Add to song history
+            self.__queue.popleft()
+            self.__name_history.append(self.__current.identifier)
+            self.__songs_history.append(self.__current)
 
             return self.__current
 
-    def prev_song(self) -> Song:
-        """Return the source of the last song played
-
-        Return None or the source of the prev song
-        """
-        if len(self.__songs_history) == 0:
-            return None
-        else:
-            return self.__songs_history[0].source
-
     def add_song(self, identifier: str, requester: str) -> Song:
         """Create a song object, add to queue and return it"""
         song = Song(identifier=identifier, playlist=self, requester=requester)
@@ -102,12 +87,13 @@ class Playlist(IPlaylist):
         Return: Embed descrition to show to user
         """
         if self.__looping_all == True:
-            return 'Vulkan already looping one music, disable loop first'
+            return config.LOOP_ALL_ON
+
         elif self.__looping_one == True:
-            return "I'm already doing this, you dumb ass"
+            return config.LOOP_ONE_ALREADY_ON
         else:
             self.__looping_one = True
-            return 'Repeating the current song'
+            return config.LOOP_ONE_ACTIVATE
 
     def loop_all(self) -> str:
         """Try to start the loop of all songs
@@ -115,21 +101,23 @@ class Playlist(IPlaylist):
         Return: Embed descrition to show to user
         """
         if self.__looping_one == True:
-            return 'Vulkan already looping one music, disable loop first'
+            return config.LOOP_ONE_ON
+
         elif self.__looping_all == True:
-            return "I'm already doing this, you dumb ass"
+            return config.LOOP_ALL_ALREADY_ON
+
         else:
             self.__looping_all = True
-            return 'Repeating all songs in queue'
+            return config.LOOP_ALL_ACTIVATE
 
     def loop_off(self) -> str:
         """Disable both types of loop"""
         if self.__looping_all == False and self.__looping_one == False:
-            return "The loop is already off, you fucking dick head"
+            return config.LOOP_ALREADY_DISABLE
 
         self.__looping_all = False
         self.__looping_one = False
-        return 'Loop disable'
+        return config.LOOP_DISABLE
 
     def destroy_song(self, song_destroy: Song) -> None:
         """Destroy a song object from the queue"""
@@ -150,7 +138,7 @@ class Playlist(IPlaylist):
             pos2 = len(self.__queue)
 
         if pos2 not in range(1, len(self.__queue) + 1) or pos1 not in range(1, len(self.__queue) + 1):
-            return 'Numbers must be between 1 and queue length, or -1 for the last song'
+            return config.LENGTH_ERROR
 
         try:
             song1 = self.__queue[pos1-1]
@@ -162,18 +150,17 @@ class Playlist(IPlaylist):
             song1_name = song1.title if song1.title else song1.identifier
             song2_name = song2.title if song2.title else song2.identifier
 
-            return f'Song `{song1_name}` in position `{pos1}` moved with `{song2_name}` in position `{pos2}` successfully'
-        except Exception as e:
-            print(e)
-            return 'There was a problem with the moving of songs'
+            return config.SONG_MOVED_SUCCESSFULLY.format(song1_name, pos1, song2_name, pos2)
+        except:
+            return config.ERROR_MOVING
 
-    def remove_song(self, position) -> tuple:
+    def remove_song(self, position) -> str:
         if position not in range(1, len(self.__queue) + 1) and position != -1:
-            return 'Numbers must be between 1 and queue length, or -1 for the last song'
+            return config.LENGTH_ERROR
         else:
             song = self.__queue[position-1]
             self.__queue.remove(song)
 
             song_name = song.title if song.title else song.identifier
 
-            return f'Song `{song_name}` removed successfully'
+            return config.SONG_REMOVED_SUCCESSFULLY.format(song_name)

vulkan/music/Spotify.py

@@ -24,7 +24,7 @@ class SpotifySearch():
         except:
             return False
 
-    def search(self, music) -> list:
+    def search(self, music=str) -> list:
         """Search and return the title of musics on Spotify"""
         type = music.split('/')[3].split('?')[0]
         code = music.split('/')[4].split('?')[0]
@@ -39,14 +39,13 @@ class SpotifySearch():
 
         return musics
 
-    def __get_album(self, code) -> list:
+    def __get_album(self, code=str) -> list:
         """Get the externals urls of a album
 
-            ARG: Spotify Code of the Album
+        ARG: Spotify Code of the Album
         """
         if self.__connected == True:
             try:
-                # Load all music objects
                 results = self.__api.album_tracks(code)
                 musics = results['items']
 
@@ -66,10 +65,10 @@ class SpotifySearch():
             except Exception as e:
                 raise e
 
-    def __get_playlist(self, code) -> list:
+    def __get_playlist(self, code=str) -> list:
         """Get the externals urls of a playlist
 
-            Arg: Spotify Code of the Playlist
+        Arg: Spotify Code of the Playlist
         """
         try:
             results = self.__api.playlist_items(code)
@@ -96,10 +95,10 @@ class SpotifySearch():
         except Exception as e:
             raise e
 
-    def __get_track(self, code) -> list:
+    def __get_track(self, code=str) -> list:
         """Convert a external_url track to the title of the music
 
-            ARG: Spotify Code of the Music
+        ARG: Spotify Code of the Music
         """
         results = self.__api.track(code)
         name = results['name']
@@ -112,7 +111,7 @@ class SpotifySearch():
     def __extract_title(self, music: dict) -> str:
         """Receive a spotify music object and return his title
 
-            ARG: music dict returned by Spotify
+        ARG: music dict returned by Spotify
         """
         title = f'{music["name"]} '
         for artist in music['artists']:

vulkan/music/utils.py

@@ -11,7 +11,7 @@ def is_connected(ctx):
         return None
 
 
-def format_time(duration):
+def format_time(duration) -> str:
     if not duration:
         return "00:00"