From d237c2f0ec7c28c9688b21e50c573c2b6d649567 Mon Sep 17 00:00:00 2001
From: Choco <94597336+ChocoMeow@users.noreply.github.com>
Date: Tue, 20 Feb 2024 11:37:01 +0800
Subject: [PATCH] Optimized code

---
 cogs/basic.py       | 264 +++++++++++++++++++++++---------------------
 cogs/effect.py      |  31 +++---
 cogs/playlist.py    | 110 +++++++++---------
 cogs/settings.py    |  36 +++---
 function.py         |  48 ++++++--
 main.py             |   3 +-
 views/controller.py | 138 ++++++++++-------------
 views/list.py       |  29 ++---
 views/playlist.py   |  33 +++---
 views/search.py     |  12 +-
 voicelink/player.py |  11 +-
 web/ipc/methods.py  |   8 +-
 12 files changed, 378 insertions(+), 345 deletions(-)

diff --git a/cogs/basic.py b/cogs/basic.py
index 3e5be6f..162ffd7 100644
--- a/cogs/basic.py
+++ b/cogs/basic.py
@@ -27,6 +27,7 @@ from io import StringIO
 from discord import app_commands
 from discord.ext import commands
 from function import (
+    send,
     time as ctime,
     formatTime,
     get_source,
@@ -50,10 +51,12 @@ searchPlatform = {
 async def nowplay(ctx: commands.Context, player: voicelink.Player):
     track = player.current
     if not track:
-        return await ctx.send(player.get_msg('noTrackPlaying'), ephemeral=True)
+        return await send(ctx, 'noTrackPlaying', ephemeral=True)
 
+    texts = await get_lang(ctx.guild.id, "nowplayingDesc", "nowplayingField", "nowplayingLink")
     upnext = "\n".join(f"`{index}.` `[{track.formatted_length}]` [{track.title[:30]}]({track.uri})" for index, track in enumerate(player.queue.tracks()[:2], start=2))
-    embed = discord.Embed(description=player.get_msg('nowplayingDesc').format(track.title), color=settings.embed_color)
+    
+    embed = discord.Embed(description=texts[0].format(track.title), color=settings.embed_color)
     embed.set_author(
         name=track.requester,
         icon_url=track.requester.display_avatar.url
@@ -61,13 +64,13 @@ async def nowplay(ctx: commands.Context, player: voicelink.Player):
     embed.set_thumbnail(url=track.thumbnail)
 
     if upnext:
-        embed.add_field(name=player.get_msg('nowplayingField'), value=upnext)
+        embed.add_field(name=texts[1], value=upnext)
 
     pbar = "".join(":radio_button:" if i == round(player.position // round(track.length // 15)) else "▬" for i in range(15))
     icon = ":red_circle:" if track.is_stream else (":pause_button:" if player.is_paused else ":arrow_forward:")
     embed.add_field(name="\u2800", value=f"{icon} {pbar} **[{ctime(player.position)}/{track.formatted_length}]**", inline=False)
 
-    return await ctx.send(embed=embed, view=LinkView(player.get_msg('nowplayingLink').format(track.source), track.emoji, track.uri))
+    return await ctx.send(embed=embed, view=LinkView(texts[2].format(track.source), track.emoji, track.uri))
 
 class Basic(commands.Cog):
     def __init__(self, bot: commands.Bot) -> None:
@@ -103,9 +106,9 @@ class Basic(commands.Cog):
         try:
             player = await voicelink.connect_channel(ctx, channel)
         except discord.errors.ClientException:
-            return await ctx.send(get_lang(ctx.guild.id, "alreadyConnected"))
+            return await send(ctx, "alreadyConnected")
 
-        await ctx.send(player.get_msg('connect').format(player.channel))
+        await send(ctx, 'connect', player.channel)
                 
     @commands.hybrid_command(name="play", aliases=get_aliases("play"))
     @app_commands.describe(query="Input a query or a searchable link.")
@@ -118,19 +121,20 @@ class Basic(commands.Cog):
             player = await voicelink.connect_channel(ctx)
 
         if not player.is_user_join(ctx.author):
-            return await ctx.send(player.get_msg('notInChannel').format(ctx.author.mention, player.channel.mention), ephemeral=True)
+            return await send(ctx, "notInChannel", ctx.author.mention, player.channel.mention, ephemeral=True)
 
         tracks = await player.get_tracks(query, requester=ctx.author)
         if not tracks:
-            return await ctx.send(player.get_msg('noTrackFound'))
+            return await send(ctx, "noTrackFound")
 
         try:
             if isinstance(tracks, voicelink.Playlist):
                 index = await player.add_track(tracks.tracks)
-                await ctx.send(player.get_msg('playlistLoad').format(tracks.name, index))
+                await send(ctx, "playlistLoad", tracks.name, index)
             else:
                 position = await player.add_track(tracks[0])
-                await ctx.send((f"`{player.get_msg('live')}`" if tracks[0].is_stream else "") + (player.get_msg('trackLoad_pos').format(tracks[0].title, tracks[0].uri, tracks[0].author, tracks[0].formatted_length, position) if position >= 1 and player.is_playing else player.get_msg('trackLoad').format(tracks[0].title, tracks[0].uri, tracks[0].author, tracks[0].formatted_length)), allowed_mentions=False)
+                texts = await get_lang(ctx.guild.id, "live", "trackLoad_pos", "trackLoad")
+                await ctx.send((f"`{texts[0]}`" if tracks[0].is_stream else "") + (texts[1].format(tracks[0].title, tracks[0].uri, tracks[0].author, tracks[0].formatted_length, position) if position >= 1 and player.is_playing else texts[2].format(tracks[0].title, tracks[0].uri, tracks[0].author, tracks[0].formatted_length)), allowed_mentions=False)
         except voicelink.QueueFull as e:
             await ctx.send(e)
         finally:
@@ -151,26 +155,27 @@ class Basic(commands.Cog):
             query = message.attachments[0].url
 
         if not query:
-            return await interaction.response.send_message(get_lang(interaction.guild.id, key="noPlaySource"), ephemeral=True)
+            return await send(interaction, "noPlaySource", ephemeral=True)
 
         player: voicelink.Player = interaction.guild.voice_client
         if not player:
             player = await voicelink.connect_channel(interaction)
 
         if not player.is_user_join(interaction.user):
-            return await interaction.response.send_message(player.get_msg('notInChannel').format(interaction.user.mention, player.channel.mention), ephemeral=True)
+            return await send(interaction, "notInChannel", interaction.user.mention, player.channel.mention, ephemeral=True)
 
         tracks = await player.get_tracks(query, requester=interaction.user)
         if not tracks:
-            return await interaction.response.send_message(player.get_msg('noTrackFound'))
+            return await send(interaction, "noTrackFound")
 
         try:
             if isinstance(tracks, voicelink.Playlist):
                 index = await player.add_track(tracks.tracks)
-                await interaction.response.send_message(player.get_msg('playlistLoad').format(tracks.name, index))
+                await send(interaction, "playlistLoad", tracks.name, index)
             else:
                 position = await player.add_track(tracks[0])
-                await interaction.response.send_message((f"`{player.get_msg('live')}`" if tracks[0].is_stream else "") + (player.get_msg('trackLoad_pos').format(tracks[0].title, tracks[0].uri, tracks[0].author, tracks[0].formatted_length, position) if position >= 1 and player.is_playing else player.get_msg('trackLoad').format(tracks[0].title, tracks[0].uri, tracks[0].author, tracks[0].formatted_length)), allowed_mentions=False)
+                texts = await get_lang(interaction.guild.id, "live", "trackLoad_pos", "trackLoad")
+                await interaction.response.send_message((f"`{texts[0]}`" if tracks[0].is_stream else "") + (texts[1].format(tracks[0].title, tracks[0].uri, tracks[0].author, tracks[0].formatted_length, position) if position >= 1 and player.is_playing else texts[2].format(tracks[0].title, tracks[0].uri, tracks[0].author, tracks[0].formatted_length)), allowed_mentions=False)
         except voicelink.QueueFull as e:
             await interaction.response.send_message(e)
         
@@ -201,10 +206,10 @@ class Basic(commands.Cog):
             player = await voicelink.connect_channel(ctx)
 
         if not player.is_user_join(ctx.author):
-            return await ctx.send(player.get_msg('notInChannel').format(ctx.author.mention, player.channel.mention), ephemeral=True)
+            return await send(ctx, "notInChannel", ctx.author.mention, player.channel.mention, ephemeral=True)
 
         if url(query):
-            return await ctx.send(player.get_msg('noLinkSupport'), ephemeral=True)
+            return await send(ctx, "noLinkSupport", ephemeral=True)
 
         platform = platform.lower()
         if platform != 'spotify':
@@ -214,13 +219,12 @@ class Basic(commands.Cog):
             tracks = await player.node.spotifySearch(query=query, requester=ctx.author)
 
         if not tracks:
-            return await ctx.send(player.get_msg('noTrackFound'))
+            return await send(ctx, "noTrackFound")
 
-        query_track = "\n".join(
-            f"`{index}.` `[{track.formatted_length}]` **{track.title[:35]}**" for index, track in enumerate(tracks[0:10], start=1))
-        embed = discord.Embed(title=player.get_msg('searchTitle').format(query), description=player.get_msg(
-            'searchDesc').format(get_source(platform, "emoji"), platform, len(tracks[0:10]), query_track), color=settings.embed_color)
-        view = SearchView(tracks=tracks[0:10], lang=player.get_msg)
+        texts = await get_lang(ctx.guild.id, "searchTitle", "searchDesc", "live", "trackLoad_pos", "trackLoad", "searchWait", "searchSuccess")
+        query_track = "\n".join(f"`{index}.` `[{track.formatted_length}]` **{track.title[:35]}**" for index, track in enumerate(tracks[0:10], start=1))
+        embed = discord.Embed(title=texts[0].format(query), description=texts[1].format(get_source(platform, "emoji"), platform, len(tracks[0:10]), query_track), color=settings.embed_color)
+        view = SearchView(tracks=tracks[0:10], texts=[texts[5], texts[6]])
         view.response = await ctx.send(embed=embed, view=view, ephemeral=True)
 
         await view.wait()
@@ -229,8 +233,7 @@ class Basic(commands.Cog):
             for value in view.values:
                 track = tracks[int(value.split(". ")[0]) - 1]
                 position = await player.add_track(track)
-                msg += ((f"`{player.get_msg('live')}`" if track.is_stream else "") + (player.get_msg('trackLoad_pos').format(track.title, track.uri, track.author, track.formatted_length,
-                        position) if position >= 1 else player.get_msg('trackLoad').format(track.title, track.uri, track.author, track.formatted_length)))
+                msg += (f"`{texts[2]}`" if track.is_stream else "") + (texts[3].format(track.title, track.uri, track.author, track.formatted_length, position) if position >= 1 else texts[4].format(track.title, track.uri, track.author, track.formatted_length))
             await ctx.send(msg, allowed_mentions=False)
 
             if not player.is_playing:
@@ -246,19 +249,20 @@ class Basic(commands.Cog):
             player = await voicelink.connect_channel(ctx)
 
         if not player.is_user_join(ctx.author):
-            return await ctx.send(player.get_msg('notInChannel').format(ctx.author.mention, player.channel.mention), ephemeral=True)
+            return await send(ctx, "notInChannel", ctx.author.mention, player.channel.mention, ephemeral=True)
             
         tracks = await player.get_tracks(query, requester=ctx.author)
         if not tracks:
-            return await ctx.send(player.get_msg('noTrackFound'))
+            return await send(ctx, "noTrackFound")
         
         try:
             if isinstance(tracks, voicelink.Playlist):
                 index = await player.add_track(tracks.tracks, at_font=True)
-                await ctx.send(player.get_msg('playlistLoad').format(tracks.name, index))
+                await send(ctx, "playlistLoad", tracks.name, index)
             else:
                 position = await player.add_track(tracks[0], at_font=True)
-                await ctx.send((f"`{player.get_msg('live')}`" if tracks[0].is_stream else "") + (player.get_msg('trackLoad_pos').format(tracks[0].title, tracks[0].uri, tracks[0].author, tracks[0].formatted_length, position) if position >= 1 and player.is_playing else player.get_msg('trackLoad').format(tracks[0].title, tracks[0].uri, tracks[0].author, tracks[0].formatted_length)), allowed_mentions=False)
+                texts = await get_lang(ctx.guild.id, "live", "trackLoad_pos", "trackLoad")
+                await ctx.send((f"`{texts[0]}`" if tracks[0].is_stream else "") + (texts[1].format(tracks[0].title, tracks[0].uri, tracks[0].author, tracks[0].formatted_length, position) if position >= 1 and player.is_playing else texts[2].format(tracks[0].title, tracks[0].uri, tracks[0].author, tracks[0].formatted_length)), allowed_mentions=False)
         
         except voicelink.QueueFull as e:
             await ctx.send(e)
@@ -277,19 +281,20 @@ class Basic(commands.Cog):
             player = await voicelink.connect_channel(ctx)
 
         if not player.is_privileged(ctx.author):
-            return await ctx.send(player.get_msg('missingPerms_function'), ephemeral=True)
+            return await send(ctx, "missingPerms_function", ephemeral=True)
             
         tracks = await player.get_tracks(query, requester=ctx.author)
         if not tracks:
-            return await ctx.send(player.get_msg('noTrackFound'))
+            return await send(ctx, "noTrackFound")
         
         try:
             if isinstance(tracks, voicelink.Playlist):
                 index = await player.add_track(tracks.tracks, at_font=True)
-                await ctx.send(player.get_msg('playlistLoad').format(tracks.name, index))
+                await send(ctx, "playlistLoad", tracks.name, index)
             else:
+                texts = await get_lang(ctx.guild.id, "live", "trackLoad")
                 await player.add_track(tracks[0], at_font=True)
-                await ctx.send((f"`{player.get_msg('live')}`" if tracks[0].is_stream else "") + player.get_msg('trackLoad').format(tracks[0].title, tracks[0].uri, tracks[0].author, tracks[0].formatted_length), allowed_mentions=False)
+                await ctx.send((f"`{texts[0]}`" if tracks[0].is_stream else "") + texts[1].format(tracks[0].title, tracks[0].uri, tracks[0].author, tracks[0].formatted_length), allowed_mentions=False)
 
         except voicelink.QueueFull as e:
             await ctx.send(e)
@@ -306,24 +311,24 @@ class Basic(commands.Cog):
         "Pause the music."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if player.is_paused:
-            return await ctx.send(player.get_msg('pauseError'))
+            return await send(ctx, "pauseError", ephemeral=True)
 
         if not player.is_privileged(ctx.author):
             if ctx.author in player.pause_votes:
-                return await ctx.send(player.get_msg('voted'), ephemeral=True)
+                return await send(ctx, "voted", ephemeral=True)
             else:
                 player.pause_votes.add(ctx.author)
                 if len(player.pause_votes) >= (required := player.required()):
                     pass
                 else:
-                    return await ctx.send(player.get_msg('pauseVote').format(ctx.author, len(player.pause_votes), required))
+                    return await send(ctx, "pauseVote", ctx.author, len(player.pause_votes), required)
 
         await player.set_pause(True, ctx.author)
         player.pause_votes.clear()
-        await ctx.send(player.get_msg('paused').format(ctx.author))
+        await send(ctx, "paused", ctx.author)
 
     @commands.hybrid_command(name="resume", aliases=get_aliases("resume"))
     @commands.dynamic_cooldown(cooldown_check, commands.BucketType.guild)
@@ -331,24 +336,24 @@ class Basic(commands.Cog):
         "Resume the music."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_paused:
-            return await ctx.send(player.get_msg('resumeError'))
+            return await send(ctx, "resumeError")
 
         if not player.is_privileged(ctx.author):
             if ctx.author in player.resume_votes:
-                return await ctx.send(player.get_msg('voted'), ephemeral=True)
+                return await send(ctx, "voted", ephemeral=True)
             else:
                 player.resume_votes.add(ctx.author)
                 if len(player.resume_votes) >= (required := player.required()):
                     pass
                 else:
-                    return await ctx.send(player.get_msg('resumeVote').format(ctx.author, len(player.resume_votes), required))
+                    return await send(ctx, "resumeVote", ctx.author, len(player.resume_votes), required)
 
         await player.set_pause(False, ctx.author)
         player.resume_votes.clear()
-        await ctx.send(player.get_msg('resumed').format(ctx.author))
+        await send(ctx, "resumed", ctx.author)
 
     @commands.hybrid_command(name="skip", aliases=get_aliases("skip"))
     @app_commands.describe(index="Enter a index that you want to skip to.")
@@ -357,30 +362,30 @@ class Basic(commands.Cog):
         "Skips to the next song or skips to the specified song."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_playing:
-            return await ctx.send(player.get_msg('skipError'), ephemeral=True)
+            return await send(ctx, "skipError", ephemeral=True)
 
         if not player.is_privileged(ctx.author):
             if ctx.author == player.current.requester:
                 pass
             elif ctx.author in player.skip_votes:
-                return await ctx.send(player.get_msg('voted'), ephemeral=True)
+                return await send(ctx, "voted", ephemeral=True)
             else:
                 player.skip_votes.add(ctx.author)
                 if len(player.skip_votes) >= (required := player.required()):
                     pass
                 else:
-                    return await ctx.send(player.get_msg('skipVote').format(ctx.author, len(player.skip_votes), required))
+                    return await send(ctx, "skipVote", ctx.author, len(player.skip_votes), required)
 
         if not player.node._available:
-            return await ctx.send(player.get_msg('nodeReconnect'))
+            return await send(ctx, "nodeReconnect")
 
         if index:
             player.queue.skipto(index)
 
-        await ctx.send(player.get_msg('skipped').format(ctx.author))
+        await send(ctx, "skipped", ctx.author)
 
         if player.queue._repeat.mode == voicelink.LoopType.track:
             await player.set_repeat(voicelink.LoopType.off.name)
@@ -394,20 +399,20 @@ class Basic(commands.Cog):
         "Skips back to the previous song or skips to the specified previous song."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_privileged(ctx.author):
             if ctx.author in player.previous_votes:
-                return await ctx.send(player.get_msg('voted'), ephemeral=True)
+                return await send(ctx, "voted", ephemeral=True)
             else:
                 player.previous_votes.add(ctx.author)
                 if len(player.previous_votes) >= (required := player.required()):
                     pass
                 else:
-                    return await ctx.send(player.get_msg('backVote').format(ctx.author, len(player.previous_votes), required))
+                    return await send(ctx, "backVote", ctx.author, len(player.previous_votes), required)
 
         if not player.node._available:
-            return await ctx.send(player.get_msg('nodeReconnect'))
+            return await send(ctx, "nnodeReconnectode")
 
         if not player.is_playing:
             player.queue.backto(index)
@@ -416,7 +421,7 @@ class Basic(commands.Cog):
             player.queue.backto(index + 1)
             await player.stop()
 
-        await ctx.send(player.get_msg('backed').format(ctx.author))
+        await send(ctx, "backed", ctx.author)
 
         if player.queue._repeat.mode == voicelink.LoopType.track:
             await player.set_repeat(voicelink.LoopType.off.name)
@@ -428,20 +433,20 @@ class Basic(commands.Cog):
         "Change the player position."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_privileged(ctx.author):
-            return await ctx.send(player.get_msg('missingPerms_pos'), ephemeral=True)
+            return await send(ctx, "missingPerms_pos", ephemeral=True)
 
         if not player.current or player.position == 0:
-            return await ctx.send(player.get_msg('noTrackPlaying'), ephemeral=True)
+            return await send(ctx, "noTrackPlaying", ephemeral=True)
 
         num = formatTime(position)
         if num is None:
-            return await ctx.send(player.get_msg('timeFormatError'), ephemeral=True)
+            return await send(ctx, "timeFormatError", ephemeral=True)
 
         await player.seek(num, ctx.author)
-        await ctx.send(player.get_msg('seek').format(position))
+        await send(ctx, "seek", position)
 
     @commands.hybrid_group(
         name="queue", 
@@ -454,10 +459,10 @@ class Basic(commands.Cog):
         "Display the players queue songs in your queue."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_user_join(ctx.author):
-            return await ctx.send(player.get_msg('notInChannel').format(ctx.author.mention, player.channel.mention), ephemeral=True)
+            return await send(ctx, "notInChannel", ctx.author.mention, player.channel.mention, ephemeral=True)
 
         if player.queue.is_empty:
             return await nowplay(ctx, player)
@@ -470,13 +475,13 @@ class Basic(commands.Cog):
         "Exports the entire queue to a text file"
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, "noPlayer"), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
         
         if not player.is_user_join(ctx.author):
-            return await ctx.send(player.get_msg('notInChannel').format(ctx.author.mention, player.channel.mention), ephemeral=True)
+            return await send(ctx, "notInChannel", ctx.author.mention, player.channel.mention, ephemeral=True)
         
         if player.queue.is_empty and not player.current:
-            return await ctx.send(player.get_msg('noTrackPlaying'), ephemeral=True)
+            return await send(ctx, "noTrackPlaying", ephemeral=True)
 
         await ctx.defer()
 
@@ -510,7 +515,7 @@ class Basic(commands.Cog):
             player = await voicelink.connect_channel(ctx)
 
         if not player.is_user_join(ctx.author):
-            return await ctx.send(player.get_msg('notInChannel').format(ctx.author.mention, player.channel.mention), ephemeral=True)
+            return await send(ctx, "notInChannel", ctx.author.mention, player.channel.mention, ephemeral=True)
 
         try:
             bytes = await attachment.read()
@@ -519,16 +524,16 @@ class Basic(commands.Cog):
             
             tracks = (voicelink.Track(track_id=track_id, info=voicelink.decode(track_id), requester=ctx.author) for track_id in track_ids)
             if not tracks:
-                return await ctx.send(player.get_msg('noTrackFound'))
+                return await send(ctx, "noTrackFound")
 
             index = await player.add_track(tracks)
-            await ctx.send(player.get_msg('playlistLoad').format(attachment.filename, index))
+            await send(ctx, "playlistLoad", attachment.filename, index)
                 
         except voicelink.QueueFull as e:
             return await ctx.send(e, ephemeral=True)
 
         except:
-            return await ctx.send(player.get_msg("decodeError"), ephemeral=True)
+            return await send(ctx, "decodeError", ephemeral=True)
 
         finally:
             if not player.is_playing:
@@ -540,10 +545,10 @@ class Basic(commands.Cog):
         "Display the players queue songs in your history queue."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_user_join(ctx.author):
-            return await ctx.send(player.get_msg('notInChannel').format(ctx.author.mention, player.channel.mention), ephemeral=True)
+            return await send(ctx, "notInChannel", ctx.author.mention, player.channel.mention, ephemeral=True)
 
         if not player.queue.history():
             return await nowplay(ctx, player)
@@ -557,19 +562,19 @@ class Basic(commands.Cog):
         "Disconnects the bot from your voice channel and chears the queue."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_privileged(ctx.author):
             if ctx.author in player.stop_votes:
-                return await ctx.send(player.get_msg('voted'), ephemeral=True)
+                return await send(ctx, "voted", ephemeral=True)
             else:
                 player.stop_votes.add(ctx.author)
                 if len(player.stop_votes) >= (required := player.required(leave=True)):
                     pass
                 else:
-                    return await ctx.send(player.get_msg('leaveVote').format(ctx.author, len(player.stop_votes), required))
+                    return await send(ctx, "leaveVote", ctx.author, len(player.stop_votes), required)
 
-        await ctx.send(player.get_msg('left').format(ctx.author))
+        await send(ctx, "left", ctx.author)
         await player.teardown()
 
     @commands.hybrid_command(name="nowplaying", aliases=get_aliases("nowplaying"))
@@ -578,10 +583,10 @@ class Basic(commands.Cog):
         "Shows details of the current track."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_user_join(ctx.author):
-            return await ctx.send(player.get_msg('notInChannel').format(ctx.author.mention, player.channel.mention), ephemeral=True)
+            return await send(ctx, "notInChannel", ctx.author.mention, player.channel.mention, ephemeral=True)
 
         await nowplay(ctx, player)
 
@@ -597,13 +602,13 @@ class Basic(commands.Cog):
         "Changes Loop mode."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_privileged(ctx.author):
-            return await ctx.send(player.get_msg('missingPerms_mode'), ephemeral=True)
+            return await send(ctx, "missingPerms_mode", ephemeral=True)
 
         await player.set_repeat(mode)
-        await ctx.send(player.get_msg('repeat').format(mode.capitalize()))
+        await send(ctx, "repeat", mode.capitalize())
 
     @commands.hybrid_command(name="clear", aliases=get_aliases("clear"))
     @app_commands.describe(queue="Choose a queue that you want to clear.")
@@ -616,10 +621,10 @@ class Basic(commands.Cog):
         "Remove all the tracks in your queue or history queue."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_privileged(ctx.author):
-            return await ctx.send(player.get_msg('missingPerms_queue'), ephemeral=True)
+            return await send(ctx, "missingPerms_queue", ephemeral=True)
 
         queue = queue.lower()
         if queue == 'history':
@@ -628,7 +633,7 @@ class Basic(commands.Cog):
             queue = "queue"
             player.queue.clear()
 
-        await ctx.send(player.get_msg('cleared').format(queue.capitalize()))
+        await send(ctx, "cleared", queue.capitalize())
 
     @commands.hybrid_command(name="remove", aliases=get_aliases("remove"))
     @app_commands.describe(
@@ -641,10 +646,10 @@ class Basic(commands.Cog):
         "Removes specified track or a range of tracks from the queue."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_privileged(ctx.author):
-            return await ctx.send(player.get_msg('missingPerms_queue'), ephemeral=True)
+            return await send(ctx, "missingPerms_queue", ephemeral=True)
 
         removedTrack = player.queue.remove(position1, position2, member=member)
 
@@ -656,7 +661,7 @@ class Basic(commands.Cog):
                 "current_queue_position": player.queue._position
             }, requester=ctx.author)
 
-        await ctx.send(player.get_msg('removed').format(len(removedTrack)))
+        await send(ctx, "removed", len(removedTrack))
 
     @commands.hybrid_command(name="forward", aliases=get_aliases("forward"))
     @app_commands.describe(position="Input a amount that you to forward to. Exmaple: 1:20")
@@ -665,20 +670,20 @@ class Basic(commands.Cog):
         "Forwards by a certain amount of time in the current track. The default is 10 seconds."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_privileged(ctx.author):
-            return await ctx.send(player.get_msg('missingPerms_pos'), ephemeral=True)
+            return await send(ctx, "missingPerms_pos", ephemeral=True)
 
         if not player.current:
-            return await ctx.send(player.get_msg('noTrackPlaying'), ephemeral=True)
+            return await send(ctx, "noTrackPlaying", ephemeral=True)
         
         num = formatTime(position)
         if num is None:
-            return await ctx.send(player.get_msg('timeFormatError'), ephemeral=True)
+            return await send(ctx, "timeFormatError", ephemeral=True)
 
         await player.seek(int(player.position + num))
-        await ctx.send(player.get_msg('forward').format(ctime(player.position + num)))
+        await send(ctx, "forward", ctime(player.position + num))
 
     @commands.hybrid_command(name="rewind", aliases=get_aliases("rewind"))
     @app_commands.describe(position="Input a amount that you to rewind to. Exmaple: 1:20")
@@ -687,20 +692,20 @@ class Basic(commands.Cog):
         "Rewind by a certain amount of time in the current track. The default is 10 seconds."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_privileged(ctx.author):
-            return await ctx.send(player.get_msg('missingPerms_pos'), ephemeral=True)
+            return await send(ctx, "missingPerms_pos", ephemeral=True)
 
         if not player.current:
-            return await ctx.send(player.get_msg('noTrackPlaying'), ephemeral=True)
+            return await send(ctx, "noTrackPlaying", ephemeral=True)
         
         num = formatTime(position)
         if num is None:
-            return await ctx.send(player.get_msg('timeFormatError'), ephemeral=True)
+            return await send(ctx, "timeFormatError", ephemeral=True)
 
         await player.seek(int(player.position - num))
-        await ctx.send(player.get_msg('rewind').format(ctime(player.position - num)))
+        await send(ctx, "rewind", ctime(player.position - num))
 
     @commands.hybrid_command(name="replay", aliases=get_aliases("replay"))
     @commands.dynamic_cooldown(cooldown_check, commands.BucketType.guild)
@@ -708,16 +713,16 @@ class Basic(commands.Cog):
         "Reset the progress of the current song."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_privileged(ctx.author):
-            return await ctx.send(player.get_msg('missingPerms_pos'), ephemeral=True)
+            return await send(ctx, "missingPerms_pos", ephemeral=True)
 
         if not player.current:
-            return await ctx.send(player.get_msg('noTrackPlaying'), ephemeral=True)
+            return await send(ctx, "noTrackPlaying", ephemeral=True)
         
         await player.seek(0)
-        await ctx.send(player.get_msg('replay'))
+        await send(ctx, "replay")
 
     @commands.hybrid_command(name="shuffle", aliases=get_aliases("shuffle"))
     @commands.dynamic_cooldown(cooldown_check, commands.BucketType.guild)
@@ -725,20 +730,20 @@ class Basic(commands.Cog):
         "Randomizes the tracks in the queue."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_privileged(ctx.author):
             if ctx.author in player.shuffle_votes:
-                return await ctx.send(player.get_msg('voted'), ephemeral=True)
+                return await send(ctx, "voted", ephemeral=True)
             else:
                 player.shuffle_votes.add(ctx.author)
                 if len(player.shuffle_votes) >= (required := player.required()):
                     pass
                 else:
-                    return await ctx.send(player.get_msg('shuffleVote').format(ctx.author, len(player.skip_votes), required))
+                    return await send(ctx, "shuffleVote", ctx.author, len(player.skip_votes), required)
         
         await player.shuffle("queue", ctx.author)
-        await ctx.send(player.get_msg('shuffled'))
+        await send(ctx, "shuffled")
 
     @commands.hybrid_command(name="swap", aliases=get_aliases("swap"))
     @app_commands.describe(
@@ -750,10 +755,10 @@ class Basic(commands.Cog):
         "Swaps the specified song to the specified song."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_privileged(ctx.author):
-            return await ctx.send(player.get_msg('missingPerms_pos'), ephemeral=True)
+            return await send(ctx, "missingPerms_pos", ephemeral=True)
 
         track1, track2 = player.queue.swap(position1, position2)
         await player.send_ws({
@@ -761,7 +766,7 @@ class Basic(commands.Cog):
             "position1": {"index": position1, "track_id": track1.track_id},
             "position2": {"index": position2, "track_id": track2.track_id}
         }, requester=ctx.author)
-        await ctx.send(player.get_msg('swapped').format(track1.title, track2.title))
+        await send(ctx, "swapped", track1.title, track2.title)
 
     @commands.hybrid_command(name="move", aliases=get_aliases("move"))
     @app_commands.describe(
@@ -773,10 +778,10 @@ class Basic(commands.Cog):
         "Moves the specified song to the specified position."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
         
         if not player.is_privileged(ctx.author):
-            return await ctx.send(player.get_msg('missingPerms_pos'), ephemeral=True)
+            return await send(ctx, "missingPerms_pos", ephemeral=True)
 
         moved_track = player.queue.move(target, to)
         await player.send_ws({
@@ -784,7 +789,7 @@ class Basic(commands.Cog):
             "position": {"index": target, "track_id": moved_track.track_id},
             "newPosition": {"index": to}
         }, requester=ctx.author)
-        await ctx.send(player.get_msg('moved').format(moved_track.title, to))
+        await send(ctx, "moved", moved_track, to)
 
     @commands.hybrid_command(name="lyrics", aliases=get_aliases("lyrics"))
     @app_commands.describe(name="Searches for your query and displays the reutned lyrics.")
@@ -795,13 +800,13 @@ class Basic(commands.Cog):
 
         if not name:
             if not player or not player.is_playing:
-                return await ctx.send(get_lang(ctx.guild.id, 'noTrackPlaying'), ephemeral=True)
+                return await send(ctx, "noTrackPlaying", ephemeral=True)
             name = player.current.title + " " + player.current.author
         await ctx.defer()
 
         song: dict[str, str] = await lyricsPlatform.get(settings.lyrics_platform)().getLyrics(name)
         if not song:
-            return await ctx.send(get_lang(ctx.guild.id, 'lyricsNotFound'), ephemeral=True)
+            return await send(ctx, "lyricsNotFound", ephemeral=True)
 
         view = LyricsView(name=name, source={_: re.findall(r'.*\n(?:.*\n){,22}', v) for _, v in song.items()}, author=ctx.author)
         view.response = await ctx.send(embed=view.build_embed(), view=view)
@@ -813,22 +818,22 @@ class Basic(commands.Cog):
         "Transfer dj to another."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_user_join(ctx.author):
-            return await ctx.send(player.get_msg('notInChannel').format(ctx.author.mention, player.channel.mention), ephemeral=True)
+            return await send(ctx, "notInChannel", ctx.author.mention, player.channel.mention, ephemeral=True)
 
         if player.dj.id != ctx.author.id or player.settings.get('dj', False):
-            return await ctx.send(player.get_msg('notdj').format(f"<@&{player.settings['dj']}>" if player.settings.get('dj') else player.dj.mention), ephemeral=True)
+            return await send(ctx, "notdj", f"<@&{player.settings['dj']}>" if player.settings.get('dj') else player.dj.mention, ephemeral=True)
 
         if player.dj.id == member.id or member.bot:
-            return await ctx.send(player.get_msg('djToMe'), ephemeral=True)
+            return await send(ctx, "djToMe", ephemeral=True)
 
         if member not in player.channel.members:
-            return await ctx.send(player.get_msg('djnotinchannel').format(member), ephemeral=True)
+            return await send(ctx, "djnotinchannel", member, ephemeral=True)
 
         player.dj = member
-        await ctx.send(player.get_msg('djswap').format(member))
+        await send(ctx, "djswap", member)
 
     @commands.hybrid_command(name="autoplay", aliases=get_aliases("autoplay"))
     @commands.dynamic_cooldown(cooldown_check, commands.BucketType.guild)
@@ -836,14 +841,14 @@ class Basic(commands.Cog):
         "Toggles autoplay mode, it will automatically queue the best songs to play."
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlayer'), ephemeral=True)
+            return await send(ctx, "noPlayer", ephemeral=True)
 
         if not player.is_privileged(ctx.author):
-            return await ctx.send(player.get_msg('missingPerms_autoplay'), ephemeral=True)
+            return await send(ctx, "missingPerms_autoplay", ephemeral=True)
 
         check = not player.settings.get("autoplay", False)
         player.settings['autoplay'] = check
-        await ctx.send(player.get_msg('autoplay').format(player.get_msg('enabled') if check else player.get_msg('disabled')))
+        await send(ctx, "autoplay", await get_lang(ctx.guild.id, "enabled" if check else "disabled"))
 
         if not player.is_playing:
             await player.do_next()
@@ -864,12 +869,23 @@ class Basic(commands.Cog):
     async def ping(self, ctx: commands.Context):
         "Test if the bot is alive, and see the delay between your commands and my response."
         player: voicelink.Player = ctx.guild.voice_client
+
+        value = await get_lang(ctx.guild.id, "pingTitle1", "pingfield1", "pingTitle2", "pingfield2")
+        
         embed = discord.Embed(color=settings.embed_color)
-        embed.add_field(name=get_lang(ctx.guild.id, 'pingTitle1'), value=get_lang(ctx.guild.id, 'pingfield1').format(
-            "0", "0", self.bot.latency, '😭' if self.bot.latency > 5 else ('😨' if self.bot.latency > 1 else '👌'), "St Louis, MO, United States"))
+        embed.add_field(
+            name=value[0],
+            value=value[1].format(
+                "0", "0", self.bot.latency, '😭' if self.bot.latency > 5 else ('😨' if self.bot.latency > 1 else '👌'), "St Louis, MO, United States"
+        ))
+
         if player:
-            embed.add_field(name=get_lang(ctx.guild.id, 'pingTitle2'), value=get_lang(ctx.guild.id, 'pingfield2').format(
-                player.node._identifier, player.ping, player.node.player_count, player.channel.rtc_region), inline=False)
+            embed.add_field(
+                name=value[2],
+                value=value[3].format(
+                    player.node._identifier, player.ping, player.node.player_count, player.channel.rtc_region),
+                    inline=False
+            )
 
         await ctx.send(embed=embed)
 
diff --git a/cogs/effect.py b/cogs/effect.py
index 607d56a..cd4a2b1 100644
--- a/cogs/effect.py
+++ b/cogs/effect.py
@@ -25,6 +25,7 @@ import discord
 import voicelink
 
 from function import (
+    send,
     get_lang,
     get_aliases,
     cooldown_check
@@ -36,15 +37,16 @@ from discord.ext import commands
 async def check_access(ctx: commands.Context):
     player: voicelink.Player = ctx.guild.voice_client
     if not player:
-        raise voicelink.VoicelinkException(get_lang(ctx.guild.id, 'noPlayer'))
+        text = await get_lang(ctx.guild.id, "noPlayer")
+        raise voicelink.exceptions.VoicelinkException(text)
 
     if ctx.author not in player.channel.members:
         if not ctx.author.guild_permissions.manage_guild:
-            return await ctx.send(player.get_msg('notInChannel').format(ctx.author.mention, player.channel.mention), ephemeral=True)
+            text = await get_lang(ctx.guild.id, "notInChannel")
+            raise voicelink.exceptions.VoicelinkException(text.format(ctx.author.mention, player.channel.mention))
 
     return player
 
-
 class Effect(commands.Cog):
     def __init__(self, bot: commands.Bot) -> None:
         self.bot = bot
@@ -85,7 +87,7 @@ class Effect(commands.Cog):
         if player.filters.has_filter(filter_tag="karaoke"):
             player.filters.remove_filter(filter_tag="karaoke")
         await player.add_filter(voicelink.Karaoke(tag="karaoke", level=level, mono_level=monolevel, filter_band=filterband, filter_width=filterwidth))
-        await ctx.send(player.get_msg('karaoke').format(level, monolevel, filterband, filterwidth))
+        await send(ctx, "karaoke", level, monolevel, filterband, filterwidth)
 
     @commands.hybrid_command(name="tremolo", aliases=get_aliases("tremolo"))
     @app_commands.describe(
@@ -100,7 +102,7 @@ class Effect(commands.Cog):
         if player.filters.has_filter(filter_tag="tremolo"):
             player.filters.remove_filter(filter_tag="tremolo")
         await player.add_filter(voicelink.Tremolo(tag="tremolo", frequency=frequency, depth=depth))
-        await ctx.send(player.get_msg('tremolo&vibrato').format(frequency, depth))
+        await send(ctx, "tremolo&vibrato", frequency, depth)
 
     @commands.hybrid_command(name="vibrato", aliases=get_aliases("vibrato"))
     @app_commands.describe(
@@ -115,7 +117,7 @@ class Effect(commands.Cog):
         if player.filters.has_filter(filter_tag="vibrato"):
             player.filters.remove_filter(filter_tag="vibrato")
         await player.add_filter(voicelink.Vibrato(tag="vibrato", frequency=frequency, depth=depth))
-        await ctx.send(player.get_msg('tremolo&vibrato').format(frequency, depth))
+        await send(ctx, "tremolo&vibrato", frequency, depth)
 
     @commands.hybrid_command(name="rotation", aliases=get_aliases("rotation"))
     @app_commands.describe(hertz="The hertz of the rotation. Default is `0.2`")
@@ -127,7 +129,7 @@ class Effect(commands.Cog):
         if player.filters.has_filter(filter_tag="rotation"):
             player.filters.remove_filter(filter_tag="rotation")
         await player.add_filter(voicelink.Rotation(tag="rotation", rotation_hertz=hertz))
-        await ctx.send(player.get_msg('rotation').format(hertz))
+        await send(ctx, "rotation", hertz)
 
     @commands.hybrid_command(name="distortion", aliases=get_aliases("distortion"))
     @commands.dynamic_cooldown(cooldown_check, commands.BucketType.guild)
@@ -138,7 +140,7 @@ class Effect(commands.Cog):
         if player.filters.has_filter(filter_tag="distortion"):
             player.filters.remove_filter(filter_tag="distortion")
         await player.add_filter(voicelink.Distortion(tag="distortion", sin_offset=0.0, sin_scale=1.0, cos_offset=0.0, cos_scale=1.0, tan_offset=0.0, tan_scale=1.0, offset=0.0, scale=1.0))
-        await ctx.send(player.get_msg('distortion'))
+        await send(ctx, "distortion")
 
     @commands.hybrid_command(name="lowpass", aliases=get_aliases("lowpass"))
     @app_commands.describe(smoothing="The level of the lowPass. Default is `20.0`")
@@ -150,7 +152,7 @@ class Effect(commands.Cog):
         if player.filters.has_filter(filter_tag="lowpass"):
             player.filters.remove_filter(filter_tag="lowpass")
         await player.add_filter(voicelink.LowPass(tag="lowpass", smoothing=smoothing))
-        await ctx.send(player.get_msg('lowpass').format(smoothing))
+        await send(ctx, "lowpass", smoothing)
 
     @commands.hybrid_command(name="channelmix", aliases=get_aliases("channelmix"))
     @app_commands.describe(
@@ -167,7 +169,7 @@ class Effect(commands.Cog):
         if player.filters.has_filter(filter_tag="channelmix"):
             player.filters.remove_filter(filter_tag="channelmix")
         await player.add_filter(voicelink.ChannelMix(tag="channelmix", left_to_left=left_to_left, right_to_right=right_to_right, left_to_right=left_to_right, right_to_left=right_to_left))
-        await ctx.send(player.get_msg('channelmix').format(left_to_left, right_to_right, left_to_right, right_to_left))
+        await send(ctx, "channelmix", left_to_left, right_to_right, left_to_right, right_to_left)
 
     @commands.hybrid_command(name="nightcore", aliases=get_aliases("nightcore"))
     @commands.dynamic_cooldown(cooldown_check, commands.BucketType.guild)
@@ -176,7 +178,7 @@ class Effect(commands.Cog):
         player = await check_access(ctx)
 
         await player.add_filter(voicelink.Timescale.nightcore())
-        await ctx.send(player.get_msg('nightcore'))
+        await send(ctx, "nightcore")
 
     @commands.hybrid_command(name="8d", aliases=get_aliases("8d"))
     @commands.dynamic_cooldown(cooldown_check, commands.BucketType.guild)
@@ -185,7 +187,7 @@ class Effect(commands.Cog):
         player = await check_access(ctx)
 
         await player.add_filter(voicelink.Rotation.nightD())
-        await ctx.send(player.get_msg('8d'))
+        await send(ctx, "8d")
 
     @commands.hybrid_command(name="vaporwave", aliases=get_aliases("vaporwave"))
     @commands.dynamic_cooldown(cooldown_check, commands.BucketType.guild)
@@ -194,7 +196,7 @@ class Effect(commands.Cog):
         player = await check_access(ctx)
 
         await player.add_filter(voicelink.Timescale.vaporwave())
-        await ctx.send(player.get_msg('vaporwave'))
+        await send(ctx, "vaporwave")
 
     @commands.hybrid_command(name="cleareffect", aliases=get_aliases("cleareffect"))
     @app_commands.describe(effect="Remove a specific sound effects.")
@@ -209,8 +211,7 @@ class Effect(commands.Cog):
         else:
             await player.reset_filter()
             
-        await ctx.send(player.get_msg('cleareffect'))
-
+        await send(ctx, "cleareffect")
 
 async def setup(bot: commands.Bot) -> None:
     await bot.add_cog(Effect(bot))
diff --git a/cogs/playlist.py b/cogs/playlist.py
index 665e397..7d256ec 100644
--- a/cogs/playlist.py
+++ b/cogs/playlist.py
@@ -27,6 +27,7 @@ from io import StringIO
 from discord import app_commands
 from discord.ext import commands
 from function import (
+    send,
     time as ctime,
     get_user,
     update_user,
@@ -120,10 +121,10 @@ class Playlists(commands.Cog, name="playlist"):
         result = await check_playlist(ctx, name.lower() if name else None)
 
         if not result['playlist']:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistNotFound').format(name), ephemeral=True)
+            return await send(ctx, 'playlistNotFound', name, ephemeral=True)
         rank, max_p, max_t = check_roles()
         if result['position'] > max_p:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistNotAccess'), ephemeral=True)
+            return await send(ctx, 'playlistNotAccess', ephemeral=True)
 
         player: voicelink.Player = ctx.guild.voice_client
         if not player:
@@ -133,7 +134,7 @@ class Playlists(commands.Cog, name="playlist"):
             tracks = await search_playlist(result['playlist']['uri'], ctx.author, timeNeed=False)
         else:
             if not result['playlist']['tracks']:
-                return await ctx.send(get_lang(ctx.guild.id, 'playlistNoTrack').format(result['playlist']['name']), ephemeral=True)
+                return await send(ctx, 'playlistNoTrack', result['playlist']['name'], ephemeral=True)
 
             playtrack = []
             for track in result['playlist']['tracks'][:max_t]:
@@ -142,12 +143,12 @@ class Playlists(commands.Cog, name="playlist"):
             tracks = {"name": result['playlist']['name'], "tracks": playtrack}
 
         if not tracks:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistNoTrack').format(result['playlist']['name']), ephemeral=True)
+            return await send(ctx, 'playlistNoTrack', result['playlist']['name'], ephemeral=True)
 
         if value and 0 < value <= (len(tracks['tracks'])):
             tracks['tracks'] = [tracks['tracks'][value - 1]]
         await player.add_track(tracks['tracks'])
-        await ctx.send(get_lang(ctx.guild.id, 'playlistPlay').format(result['playlist']['name'], len(tracks['tracks'][:max_t])))
+        await send(ctx, 'playlistPlay', result['playlist']['name'], len(tracks['tracks'][:max_t]))
 
         if not player.is_playing:
             await player.do_next()
@@ -191,11 +192,10 @@ class Playlists(commands.Cog, name="playlist"):
             except:
                 results.append({'emoji': '⛔', 'id': data, 'time': '--:--', 'name': 'Error', 'tracks': [], 'type': 'error'})
 
-        title = get_lang(ctx.guild.id, 'playlistViewHeaders').split(",")
-
+        text = await get_lang(ctx.guild.id, "playlistViewTitle", "playlistViewHeaders", "playlistFooter")
         embed = discord.Embed(
-            title=get_lang(ctx.guild.id, 'playlistViewTitle').format(ctx.author.display_name),
-            description='```prolog\n   %4s %10s %10s %10s\n' % tuple(title),
+            title=text[0].format(ctx.author.display_name),
+            description='```prolog\n   %4s %10s %10s %10s\n' % tuple(text[1].split(",")),
             color=settings.embed_color
         )
         
@@ -209,7 +209,7 @@ class Playlists(commands.Cog, name="playlist"):
             embed.description += '%0s %3s. %10s %10s %10s\n' % track_info
             
         embed.description += "```"
-        embed.set_footer(text=get_lang(ctx.guild.id, 'playlistFooter'))
+        embed.set_footer(text=text[2])
 
         view = PlaylistView(embed, results, ctx.author)
         view.response = await ctx.send(embed=embed, view=view, ephemeral=True)
@@ -223,25 +223,25 @@ class Playlists(commands.Cog, name="playlist"):
     async def create(self, ctx: commands.Context, name: str, link: str = None):
         "Create your custom playlist."
         if len(name) > 10:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistOverText'), ephemeral=True)
+            return await send(ctx, 'playlistOverText', ephemeral=True)
         
         rank, max_p, max_t = check_roles()
         user = await check_playlist(ctx, full=True)
 
         if len(user) >= max_p:
-            return await ctx.send(get_lang(ctx.guild.id, 'overPlaylistCreation').format(max_p), ephemeral=True)
+            return await send(ctx, 'overPlaylistCreation', max_p, ephemeral=True)
         
         for data in user:
             if user[data]['name'].lower() == name.lower():
-                return await ctx.send(get_lang(ctx.guild.id, 'playlistExists').format(name), ephemeral=True)
+                return await send(ctx, 'playlistExists', name, ephemeral=True)
         if link:
             tracks = await voicelink.NodePool.get_node().get_tracks(link, requester=ctx.author)
             if not isinstance(tracks, voicelink.Playlist):
-                return await ctx.send(get_lang(ctx.guild.id, 'playlistNotInvaildUrl'), ephemeral=True)
+                return await send(ctx, "playlistNotInvaildUrl", ephemeral=True)
 
         data = {'uri': link, 'perms': {'read': []}, 'name': name, 'type': 'link'} if link else {'tracks': [], 'perms': {'read': [], 'write': [], 'remove': []}, 'name': name, 'type': 'playlist'}
         await update_user(ctx.author.id, {"$set": {f"playlist.{assign_playlistId([data for data in user])}": data}})
-        await ctx.send(get_lang(ctx.guild.id, 'playlistCreated').format(name))
+        await send(ctx, "playlistCreated", name)
 
     @playlist.command(name="delete", aliases=get_aliases("delete"))
     @app_commands.describe(name="The name of the playlist.")
@@ -251,15 +251,15 @@ class Playlists(commands.Cog, name="playlist"):
         "Delete your custom playlist."
         result = await check_playlist(ctx, name.lower(), share=False)
         if not result['playlist']:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistNotFound').format(name), ephemeral=True)
+            return await ctx(ctx, "playlistNotFound", name, ephemeral=True)
         if result['id'] == "200":
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistDeleteError'), ephemeral=True)
+            return await send(ctx, "playlistDeleteError", ephemeral=True)
 
         if result['playlist']['type'] == 'share':
             await update_user(result['playlist']['user'], {"$pull": {f"playlist.{result['playlist']['referId']}.perms.read": ctx.author.id}})
 
         await update_user(ctx.author.id, {"$unset": {f"playlist.{result['id']}": 1}})
-        return await ctx.send(get_lang(ctx.guild.id, 'playlistRemove').format(result['playlist']['name']))
+        return await send(ctx, "playlistRemove", result["playlist"]["name"])
 
     @playlist.command(name="share", aliases=get_aliases("share"))
     @app_commands.describe(
@@ -271,26 +271,26 @@ class Playlists(commands.Cog, name="playlist"):
     async def share(self, ctx: commands.Context, member: discord.Member, name: str):
         "Share your custom playlist with your friends."
         if member.id == ctx.author.id:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistSendErrorPlayer'), ephemeral=True)
+            return await send(ctx, 'playlistSendErrorPlayer', ephemeral=True)
         if member.bot:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistSendErrorBot'), ephemeral=True)
+            return await send(ctx, 'playlistSendErrorBot', ephemeral=True)
         result = await check_playlist(ctx, name.lower(), share=False)
         if not result['playlist']:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistNotFound').format(name), ephemeral=True)
+            return await send(ctx, 'playlistNotFound', name, ephemeral=True)
 
         if result['playlist']['type'] == 'share':
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistBelongs').format(result['playlist']['user']), ephemeral=True)
+            return await send(ctx, 'playlistBelongs', result['playlist']['user'], ephemeral=True)
         if member.id in result['playlist']['perms']['read']:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistShare').format(member), ephemeral=True)
+            return await send(ctx, 'playlistShare', member, ephemeral=True)
 
         receiver = await get_user(member.id)
         if not receiver:
-            return await ctx.send(get_lang(ctx.guild.id, 'noPlaylistAcc').format(member))
+            return await send(ctx, 'noPlaylistAcc', member)
         for mail in receiver['inbox']:
             if mail['sender'] == ctx.author.id and mail['referId'] == result['id']:
-                return await ctx.send(get_lang(ctx.guild.id, 'playlistSent'), ephemeral=True)
+                return await send(ctx, 'playlistSent', ephemeral=True)
         if len(receiver['inbox']) >= 10:
-            return await ctx.send(get_lang(ctx.guild.id, 'inboxFull').format(member), ephemeral=True)
+            return await send(ctx.guild.id, 'inboxFull', member, ephemeral=True)
 
         await update_user(
             member.id, 
@@ -303,7 +303,7 @@ class Playlists(commands.Cog, name="playlist"):
                 'type': 'invite'
             }}}
         )
-        return await ctx.send(get_lang(ctx.guild.id, 'invitationSent').format(member))
+        return await send(ctx, "invitationSent", member)
 
     @playlist.command(name="rename", aliases=get_aliases("rename"))
     @app_commands.describe(
@@ -315,22 +315,22 @@ class Playlists(commands.Cog, name="playlist"):
     async def rename(self, ctx: commands.Context, name: str, newname: str) -> None:
         "Rename your custom playlist."
         if len(newname) > 10:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistOverText'), ephemeral=True)
+            return await send(ctx, 'playlistOverText', ephemeral=True)
         if name.lower() == newname.lower():
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistSameName'), ephemeral=True)
+            return await send(ctx, 'playlistSameName', ephemeral=True)
         user = await check_playlist(ctx, full=True)
         found, id = False, 0
         for data in user:
             if user[data]['name'].lower() == name.lower():
                 found, id = True, data
             if user[data]['name'].lower() == newname.lower():
-                return await ctx.send(get_lang(ctx.guild.id, 'playlistExists'), ephemeral=True)
+                return await send(ctx, 'playlistExists', ephemeral=True)
 
         if not found:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistNotFound').format(name), ephemeral=True)
+            return await send(ctx.guild.id, 'playlistNotFound', name, ephemeral=True)
 
         await update_user(ctx.author.id, {"$set": {f'playlist.{id}.name': newname}})
-        await ctx.send(get_lang(ctx.guild.id, 'playlistRenamed').format(name, newname))
+        await send(ctx, 'playlistRenamed', name, newname)
 
     @playlist.command(name="inbox", aliases=get_aliases("inbox"))
     @commands.dynamic_cooldown(cooldown_check, commands.BucketType.guild)
@@ -340,7 +340,7 @@ class Playlists(commands.Cog, name="playlist"):
         rank, max_p, max_t = check_roles()
 
         if not user['inbox']:
-            return await ctx.send(get_lang(ctx.guild.id, 'inboxNoMsg'), ephemeral=True)
+            return await send(ctx, 'inboxNoMsg', ephemeral=True)
 
         inbox = user['inbox'].copy()
         view = InboxView(ctx.author, user['inbox'])
@@ -375,26 +375,26 @@ class Playlists(commands.Cog, name="playlist"):
         "Add tracks in to your custom playlist."
         result = await check_playlist(ctx, name.lower(), share=False)
         if not result['playlist']:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistNotFound').format(name), ephemeral=True)
+            return await send(ctx, 'playlistNotFound', name, ephemeral=True)
         if result['playlist']['type'] in ['share', 'link']:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistNotAllow'), ephemeral=True)
+            return await send(ctx, 'playlistNotAllow', ephemeral=True)
         
         rank, max_p, max_t = check_roles()
         if len(result['playlist']['tracks']) >= max_t:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistLimitTrack').format(max_t), ephemeral=True)
+            return await send(ctx, 'playlistLimitTrack', max_t, ephemeral=True)
 
         results = await voicelink.NodePool.get_node().get_tracks(query, requester=ctx.author)
         if not results:
-            return await ctx.send(get_lang(ctx.guild.id, 'noTrackFound'))
+            return await send(ctx, 'noTrackFound')
         
         if isinstance(results, voicelink.Playlist):
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistPlaylistLink'), ephemeral=True)
+            return await send(ctx, 'playlistPlaylistLink', ephemeral=True)
         
         if results[0].is_stream:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistStream'), ephemeral=True)
+            return await send(ctx, 'playlistStream', ephemeral=True)
 
         await update_user(ctx.author.id, {"$push": {f'playlist.{result["id"]}.tracks': results[0].track_id}})
-        await ctx.send(get_lang(ctx.guild.id, 'playlistAdded').format(results[0].title, ctx.author, result['playlist']['name']))
+        await send(ctx, 'playlistAdded', results[0].title, ctx.author, result['playlist']['name'])
 
     @playlist.command(name="remove", aliases=get_aliases("remove"))
     @commands.dynamic_cooldown(cooldown_check, commands.BucketType.guild)
@@ -407,16 +407,16 @@ class Playlists(commands.Cog, name="playlist"):
         "Remove song from your favorite playlist."
         result = await check_playlist(ctx, name.lower(), share=False)
         if not result['playlist']:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistNotFound').format(name), ephemeral=True)
+            return await send(ctx, 'playlistNotFound', name, ephemeral=True)
         if result['playlist']['type'] in ['link', 'share']:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistNotAllow'), ephemeral=True)
+            return await send(ctx, 'playlistNotAllow', ephemeral=True)
         if not 0 < position <= len(result['playlist']['tracks']):
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistPositionNotFound').format(position, name))
+            return await send(ctx, 'playlistPositionNotFound', position, name)
 
         await update_user(ctx.author.id, {"$pull": {f'playlist.{result["id"]}.tracks': result['playlist']['tracks'][position - 1]}})
         
         track = voicelink.decode(result['playlist']['tracks'][position - 1])
-        await ctx.send(get_lang(ctx.guild.id, 'playlistRemoved').format(track.get("title"), ctx.author, name))
+        await send(ctx, 'playlistRemoved', track.get("title"), ctx.author, name)
 
     @playlist.command(name="clear", aliases=get_aliases("clear"))
     @commands.dynamic_cooldown(cooldown_check, commands.BucketType.guild)
@@ -425,13 +425,13 @@ class Playlists(commands.Cog, name="playlist"):
         "Remove all songs from your favorite playlist."
         result = await check_playlist(ctx, name.lower(), share=False)
         if not result['playlist']:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistNotFound').format(name), ephemeral=True)
+            return await send(ctx, 'playlistNotFound', name, ephemeral=True)
 
         if result['playlist']['type'] in ['link', 'share']:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistNotAllow'), ephemeral=True)
+            return await send(ctx, 'playlistNotAllow', ephemeral=True)
 
         await update_user(ctx.author.id, {"$set": {f'playlist.{result["id"]}.tracks': []}})
-        await ctx.send(get_lang(ctx.guild.id, 'playlistClear').format(name))
+        await send(ctx, 'playlistClear', name)
 
     @playlist.command(name="export", aliases=get_aliases("export"))
     @commands.dynamic_cooldown(cooldown_check, commands.BucketType.guild)
@@ -440,13 +440,13 @@ class Playlists(commands.Cog, name="playlist"):
         "Exports the entire playlist to a text file"
         result = await check_playlist(ctx, name.lower())
         if not result['playlist']:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistNotFound').format(name), ephemeral=True)
+            return await send(ctx, 'playlistNotFound', name, ephemeral=True)
         
         if result['playlist']['type'] == 'link':
             tracks = await search_playlist(result['playlist']['uri'], ctx.author, timeNeed=False)
         else:
             if not result['playlist']['tracks']:
-                return await ctx.send(get_lang(ctx.guild.id, 'playlistNoTrack').format(result['playlist']['name']), ephemeral=True)
+                return await send(ctx, 'playlistNoTrack', result['playlist']['name'], ephemeral=True)
 
             playtrack = []
             for track in result['playlist']['tracks']:
@@ -455,7 +455,7 @@ class Playlists(commands.Cog, name="playlist"):
             tracks = {"name": result['playlist']['name'], "tracks": playtrack}
 
         if not tracks:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistNoTrack').format(result['playlist']['name']), ephemeral=True)
+            return await send(ctx, 'playlistNoTrack', result['playlist']['name'], ephemeral=True)
 
         temp = ""
         raw = "----------->Raw Info<-----------\n"
@@ -483,17 +483,17 @@ class Playlists(commands.Cog, name="playlist"):
     async def _import(self, ctx: commands.Context, name: str, attachment: discord.Attachment):
         "Create your custom playlist."
         if len(name) > 10:
-            return await ctx.send(get_lang(ctx.guild.id, 'playlistOverText'), ephemeral=True)
+            return await send(ctx, 'playlistOverText', ephemeral=True)
         
         rank, max_p, max_t = check_roles()
         user = await check_playlist(ctx, full=True)
 
         if len(user) >= max_p:
-            return await ctx.send(get_lang(ctx.guild.id, 'overPlaylistCreation').format(max_p), ephemeral=True)
+            return await send(ctx, 'overPlaylistCreation', max_p, ephemeral=True)
         
         for data in user:
             if user[data]['name'].lower() == name.lower():
-                return await ctx.send(get_lang(ctx.guild.id, 'playlistExists').format(name), ephemeral=True)
+                return await send(ctx, 'playlistExists', name, ephemeral=True)
 
         try:
             bytes = await attachment.read()
@@ -502,10 +502,10 @@ class Playlists(commands.Cog, name="playlist"):
 
             data = {'tracks': track_ids, 'perms': {'read': [], 'write': [], 'remove': []}, 'name': name, 'type': 'playlist'}
             await update_user(ctx.author.id, {"$set": {f"playlist.{assign_playlistId([data for data in user])}": data}})
-            await ctx.send(get_lang(ctx.guild.id, 'playlistCreated').format(name))
+            await send(ctx, 'playlistCreated', name)
 
         except:
-            return await ctx.send(get_lang(ctx.guild.id, "decodeError"), ephemeral=True)
+            return await send(ctx, "decodeError", ephemeral=True)
 
 async def setup(bot: commands.Bot) -> None:
     await bot.add_cog(Playlists(bot))
diff --git a/cogs/settings.py b/cogs/settings.py
index f92fb54..3b918a3 100644
--- a/cogs/settings.py
+++ b/cogs/settings.py
@@ -31,6 +31,7 @@ from discord import app_commands
 from discord.ext import commands
 from function import (
     LANGS,
+    send,
     update_settings,
     get_settings,
     get_lang,
@@ -68,7 +69,7 @@ class Settings(commands.Cog, name="settings"):
     async def prefix(self, ctx: commands.Context, prefix: str):
         "Change the default prefix for message commands."
         await update_settings(ctx.guild.id, {"$set": {"prefix": prefix}})
-        await ctx.send(get_lang(ctx.guild.id, "setPrefix").format(ctx.prefix, prefix))
+        await send(ctx, "setPrefix", ctx.prefix, prefix)
 
     @settings.command(name="language", aliases=get_aliases("language"))
     @commands.has_permissions(manage_guild=True)
@@ -77,10 +78,10 @@ class Settings(commands.Cog, name="settings"):
         "You can choose your preferred language, the bot message will change to the language you set."
         language = language.upper()
         if language not in LANGS:
-            return await ctx.send(get_lang(ctx.guild.id, "languageNotFound"))
+            return await send(ctx, "languageNotFound")
 
         await update_settings(ctx.guild.id, {"$set": {'lang': language}})
-        await ctx.send(get_lang(ctx.guild.id, 'changedLanguage').format(language))
+        await send(ctx, 'changedLanguage', language)
 
     @language.autocomplete('language')
     async def autocomplete_callback(self, interaction: discord.Interaction, current: str) -> list:
@@ -94,7 +95,7 @@ class Settings(commands.Cog, name="settings"):
     async def dj(self, ctx: commands.Context, role: discord.Role = None):
         "Set a DJ role or remove DJ role."
         await update_settings(ctx.guild.id, {"$set": {'dj': role.id}} if role else {"$unset": {'dj': None}})
-        await ctx.send(get_lang(ctx.guild.id, 'setDJ').format(f"<@&{role.id}>" if role else "None"), allowed_mentions=discord.AllowedMentions.none())
+        await send(ctx, 'setDJ', f"<@&{role.id}>" if role else "None")
 
     @settings.command(name="queue", aliases=get_aliases("queue"))
     @app_commands.choices(mode=[
@@ -107,7 +108,7 @@ class Settings(commands.Cog, name="settings"):
         "Change to another type of queue mode."
         mode = "FairQueue" if mode.lower() == "fairqueue" else "Queue"
         await update_settings(ctx.guild.id, {"$set": {"queueType": mode}})
-        await ctx.send(get_lang(ctx.guild.id, "setqueue").format(mode))
+        await send(ctx, "setqueue", mode)
 
     @settings.command(name="247", aliases=get_aliases("247"))
     @commands.has_permissions(manage_guild=True)
@@ -117,7 +118,7 @@ class Settings(commands.Cog, name="settings"):
         settings = await get_settings(ctx.guild.id)
         toggle = settings.get('24/7', False)
         await update_settings(ctx.guild.id, {"$set": {'24/7': not toggle}})
-        await ctx.send(get_lang(ctx.guild.id, '247').format(get_lang(ctx.guild.id, "enabled" if not toggle else "disabled")))
+        await send(ctx, '247', await get_lang(ctx.guild.id, "enabled" if not toggle else "disabled"))
 
     @settings.command(name="bypassvote", aliases=get_aliases("bypassvote"))
     @commands.has_permissions(manage_guild=True)
@@ -127,7 +128,7 @@ class Settings(commands.Cog, name="settings"):
         settings = await get_settings(ctx.guild.id)
         toggle = settings.get('votedisable', True)
         await update_settings(ctx.guild.id, {"$set": {'votedisable': not toggle}})
-        await ctx.send(get_lang(ctx.guild.id, 'bypassVote').format(get_lang(ctx.guild.id, "enabled" if not toggle else "disabled")))
+        await send(ctx, 'bypassVote', await get_lang(ctx.guild.id, "enabled" if not toggle else "disabled"))
 
     @settings.command(name="view", aliases=get_aliases("view"))
     @commands.has_permissions(manage_guild=True)
@@ -135,12 +136,14 @@ class Settings(commands.Cog, name="settings"):
     async def view(self, ctx: commands.Context):
         "Show all the bot settings in your server."
         settings = await get_settings(ctx.guild.id)
+
+        texts = await get_lang(ctx.guild.id, "settingsMenu", "settingsTitle", "settingsValue", "settingsTitle2", "settingsValue2", "settingsPermTitle", "settingsPermValue")
         embed = discord.Embed(color=func.settings.embed_color)
-        embed.set_author(name=get_lang(ctx.guild.id, 'settingsMenu').format(ctx.guild.name), icon_url=self.bot.user.display_avatar.url)
+        embed.set_author(name=texts[0].format(ctx.guild.name), icon_url=self.bot.user.display_avatar.url)
         if ctx.guild.icon:
             embed.set_thumbnail(url=ctx.guild.icon.url)
 
-        embed.add_field(name=get_lang(ctx.guild.id, 'settingsTitle'), value=get_lang(ctx.guild.id, 'settingsValue').format(
+        embed.add_field(name=texts[1], value=texts[2].format(
             settings.get('prefix', func.settings.bot_prefix) or "None",
             settings.get('lang', 'EN'),
             settings.get('controller', True),
@@ -151,15 +154,14 @@ class Settings(commands.Cog, name="settings"):
             ctime(settings.get('playTime', 0) * 60 * 1000),
             inline=True)
         )
-        embed.add_field(name=get_lang(ctx.guild.id, 'settingsTitle2'), value=get_lang(ctx.guild.id, 'settingsValue2').format(
+        embed.add_field(name=texts[3], value=texts[4].format(
             settings.get("queueType", "Queue"),
             func.settings.max_queue,
             settings.get("duplicateTrack", True)
-        )
-        )
+        ))
 
         perms = ctx.guild.me.guild_permissions
-        embed.add_field(name=get_lang(ctx.guild.id, 'settingsPermTitle'), value=get_lang(ctx.guild.id, 'settingsPermValue').format(
+        embed.add_field(name=texts[5], value=texts[6].format(
             '<a:Check:941206936651706378>' if perms.administrator else '<a:Cross:941206918255497237>',
             '<a:Check:941206936651706378>' if perms.manage_guild else '<a:Cross:941206918255497237>',
             '<a:Check:941206936651706378>' if perms.manage_channels else '<a:Cross:941206918255497237>',
@@ -178,7 +180,7 @@ class Settings(commands.Cog, name="settings"):
             await player.set_volume(value, ctx.author)
 
         await update_settings(ctx.guild.id, {"$set": {'volume': value}})
-        await ctx.send(get_lang(ctx.guild.id, 'setVolume').format(value))
+        await send(ctx, 'setVolume', value)
 
     @settings.command(name="togglecontroller", aliases=get_aliases("togglecontroller"))
     @commands.has_permissions(manage_guild=True)
@@ -196,7 +198,7 @@ class Settings(commands.Cog, name="settings"):
                 discord.ui.View.from_message(player.controller).stop()
 
         await update_settings(ctx.guild.id, {"$set": {'controller': toggle}})
-        await ctx.send(get_lang(ctx.guild.id, 'togglecontroller').format(get_lang(ctx.guild.id, "enabled" if toggle else "disabled")))
+        await send(ctx, 'togglecontroller', await get_lang(ctx.guild.id, "enabled" if toggle else "disabled"))
 
     @settings.command(name="duplicatetrack", aliases=get_aliases("duplicatetrack"))
     @commands.has_permissions(manage_guild=True)
@@ -210,7 +212,7 @@ class Settings(commands.Cog, name="settings"):
             player.queue._allow_duplicate = toggle
 
         await update_settings(ctx.guild.id, {"$set": {'duplicateTrack': toggle}})
-        return await ctx.send(get_lang(ctx.guild.id, "toggleDuplicateTrack").format(get_lang(ctx.guild.id, "disabled" if toggle else "enabled")))
+        return await send(ctx, "toggleDuplicateTrack", await get_lang(ctx.guild.id, "disabled" if toggle else "enabled"))
     
     @settings.command(name="customcontroller", aliases=get_aliases("customcontroller"))
     @commands.has_permissions(manage_guild=True)
@@ -232,7 +234,7 @@ class Settings(commands.Cog, name="settings"):
         toggle = not settings.get('controller_msg', True)
 
         await update_settings(ctx.guild.id, {"$set": {'controller_msg': toggle}})
-        await ctx.send(get_lang(ctx.guild.id, 'toggleControllerMsg').format(get_lang(ctx.guild.id, "enabled" if toggle else "disabled")))
+        await send(ctx, 'toggleControllerMsg', await get_lang(ctx.guild.id, "enabled" if toggle else "disabled"))
 
     @app_commands.command(name="debug")
     async def debug(self, interaction: discord.Interaction):
diff --git a/function.py b/function.py
index 191cabc..c9564e6 100644
--- a/function.py
+++ b/function.py
@@ -4,7 +4,7 @@ from discord.ext import commands
 from datetime import datetime
 from time import strptime
 from io import BytesIO
-from typing import Optional, Dict, Any
+from typing import Optional, Union, Dict, Any
 from addons import Settings, TOKENS
 
 from motor.motor_asyncio import (
@@ -62,13 +62,6 @@ def update_json(path: str, new_data: dict) -> None:
     with open(os.path.join(ROOT_DIR, path), "w") as json_file:
         json.dump(data, json_file, indent=4)
 
-def get_lang(guild_id:int, key:str) -> str:
-    lang = SETTINGS_BUFFER.get(guild_id, {}).get("lang", "EN")
-    if lang in LANGS and not LANGS[lang]:
-        LANGS[lang] = open_json(os.path.join("langs", f"{lang}.json"))
-
-    return LANGS.get(lang, {}).get(key, "Language pack not found!")
-
 def langs_setup() -> None:
     for language in os.listdir(os.path.join(ROOT_DIR, "langs")):
         if language.endswith('.json'):
@@ -136,6 +129,45 @@ def get_aliases(name: str) -> list:
 def check_roles() -> tuple[str, int, int]:
     return 'Normal', 5, 500
 
+def truncate_string(text: str, length: int = 30) -> str:
+    return text[:length - 3] + "..." if len(text) > length else text
+    
+def get_lang_non_async(guild_id: int, *keys) -> Union[list[str], str]:
+    settings = SETTINGS_BUFFER.get(guild_id, {})
+    lang = settings.get("lang", "EN")
+    if lang in LANGS and not LANGS[lang]:
+        LANGS[lang] = open_json(os.path.join("langs", f"{lang}.json"))
+
+    if len(keys) == 1:
+        return LANGS.get(lang, {}).get(keys[0], "Language pack not found!")
+    return [LANGS.get(lang, {}).get(key, "Language pack not found!") for key in keys]
+
+async def get_lang(guild_id:int, *keys) -> Union[list[str], str]:
+    settings = await get_settings(guild_id)
+    lang = settings.get("lang", "EN")
+    if lang in LANGS and not LANGS[lang]:
+        LANGS[lang] = open_json(os.path.join("langs", f"{lang}.json"))
+
+    if len(keys) == 1:
+        return LANGS.get(lang, {}).get(keys[0], "Language pack not found!")
+    return [LANGS.get(lang, {}).get(key, "Language pack not found!") for key in keys]
+
+async def send(ctx: Union[commands.Context, discord.Interaction], key: str, *params, delete_after: float = None, ephemeral: bool = False) -> Optional[discord.Message]:
+    text = await get_lang(ctx.guild.id, key)
+    text = text.format(*params)
+
+    message = None
+
+    if isinstance(ctx, commands.Context):
+        message = await ctx.send(text, delete_after=delete_after, ephemeral=ephemeral, allowed_mentions=discord.AllowedMentions.none())
+    else:
+        if ctx.response.is_done():
+            await ctx.followup.send(text, delete_after=delete_after, ephemeral=ephemeral, allowed_mentions=discord.AllowedMentions.none())
+        else:
+            await ctx.response.send_message(text, delete_after=delete_after, ephemeral=ephemeral, allowed_mentions=discord.AllowedMentions.none())
+
+    return message
+
 async def update_db(db: AsyncIOMotorCollection, tempStore: dict, filter: dict, data: dict) -> bool:
     for mode, action in data.items():
         for key, value in action.items():
diff --git a/main.py b/main.py
index ddc7afb..6945f4f 100644
--- a/main.py
+++ b/main.py
@@ -53,7 +53,7 @@ class Vocard(commands.Bot):
             raise Exception("MONGODB_NAME and MONGODB_URL can't not be empty in settings.json")
 
         try:
-            func.MONGO_DB = AsyncIOMotorClient(host=db_url, serverSelectionTimeoutMS=5000)
+            func.MONGO_DB = AsyncIOMotorClient(host=db_url)
             await func.MONGO_DB.server_info()
             print("Successfully connected to MongoDB!")
 
@@ -123,6 +123,7 @@ class Vocard(commands.Bot):
 
         elif not issubclass(error.__class__, VoicelinkException):
             error = func.get_lang(ctx.guild.id, "unknownException") + func.settings.invite_link
+            error = await func.get_lang(ctx.guild.id, "unknownException") + func.settings.invite_link
             if (guildId := ctx.guild.id) not in func.ERROR_LOGS:
                 func.ERROR_LOGS[guildId] = {}
             func.ERROR_LOGS[guildId][round(datetime.timestamp(datetime.now()))] = "".join(traceback.format_exception(type(exception), exception, exception.__traceback__))
diff --git a/views/controller.py b/views/controller.py
index a504c74..a002f74 100644
--- a/views/controller.py
+++ b/views/controller.py
@@ -50,10 +50,10 @@ class ControlButton(discord.ui.Button):
         disable_button_text = not func.settings.controller.get("disableButtonText", False)
         super().__init__(label=player.get_msg(label) if label and disable_button_text else None, **kwargs)
 
-    async def send(self, interaction: discord.Interaction, content: str, *, ephemeral: bool = False) -> None:
+    async def send(self, interaction: discord.Interaction, key:str, *params, ephemeral: bool = False) -> None:
         stay = self.player.settings.get("controller_msg", True)
-        return await interaction.response.send_message(
-            content,
+        return await func.send(
+            interaction, key, *params,
             delete_after=None if ephemeral or stay is True else 10,
             ephemeral=ephemeral
         )
@@ -70,13 +70,13 @@ class Back(ControlButton):
     async def callback(self, interaction: discord.Interaction):
         if not self.player.is_privileged(interaction.user):
             if interaction.user in self.player.previous_votes:
-                return await self.send(interaction, self.player.get_msg("voted"), ephemeral=True)
+                return await self.send(interaction, "voted", ephemeral=True)
             else:
                 self.player.previous_votes.add(interaction.user)
                 if len(self.player.previous_votes) >= (required := self.player.required()):
                     pass
                 else:
-                    return await self.send(interaction, self.player.get_msg("backVote").format(interaction.user, len(self.player.previous_votes), required))
+                    return await self.send(interaction, "backVote".format(interaction.user, len(self.player.previous_votes), required))
 
         if not self.player.is_playing:
             self.player.queue.backto(1)
@@ -85,7 +85,7 @@ class Back(ControlButton):
             self.player.queue.backto(2)
             await self.player.stop()
 
-        await self.send(interaction, self.player.get_msg("backed").format(interaction.user))
+        await self.send(interaction, "backed", interaction.user)
 
         if self.player.queue._repeat.mode == voicelink.LoopType.track:
             await self.player.set_repeat(voicelink.LoopType.off.name)
@@ -100,37 +100,24 @@ class Resume(ControlButton):
         )
     
     async def callback(self, interaction: discord.Interaction):
-        if self.player.is_paused:
-            if not self.player.is_privileged(interaction.user):
-                if interaction.user in self.player.resume_votes:
-                    return await self.send(interaction, self.player.get_msg("voted"), ephemeral=True)
-                else:
-                    self.player.resume_votes.add(interaction.user)
-                    if len(self.player.resume_votes) >= (required := self.player.required()):
-                        pass
-                    else:
-                        return await self.send(interaction, self.player.get_msg("resumeVote").format(interaction.user, len(self.player.resume_votes), required))
+        is_paused = self.player.is_paused
+        vote_type = "resume" if is_paused else "pause"
+        votes = getattr(self.player, f"{vote_type}_votes")
+        emoji = "⏸️" if is_paused else "▶️"
+        button = "buttonPause" if is_paused else "buttonResume"
 
-            self.player.resume_votes.clear()
-            self.emoji = "⏸️"
-            self.label = self.player.get_msg("buttonPause")
-            await self.player.set_pause(False, interaction.user)
-        
-        else:
-            if not self.player.is_privileged(interaction.user):
-                if interaction.user in self.player.pause_votes:
-                    return await self.send(interaction, self.player.get_msg("voted"), ephemeral=True)
-                else:
-                    self.player.pause_votes.add(interaction.user)
-                    if len(self.player.pause_votes) >= (required := self.player.required()):
-                        pass
-                    else:
-                        return await self.send(interaction, self.player.get_msg("pauseVote").format(interaction.user, len(self.player.pause_votes), required))
+        if not self.player.is_privileged(interaction.user):
+            if interaction.user in votes:
+                return await self.send(interaction, "voted", ephemeral=True)
+            else:
+                votes.add(interaction.user)
+                if len(votes) < (required := self.player.required()):
+                    return await self.send(interaction, f"{vote_type}Vote", interaction.user, len(votes), required)
 
-            self.player.pause_votes.clear()
-            self.emoji = "▶️"
-            self.label = self.player.get_msg("buttonResume")
-            await self.player.set_pause(True, interaction.user)  
+        votes.clear()
+        self.emoji = emoji
+        self.label = await func.get_lang(interaction.guild.id, button)
+        await self.player.set_pause(is_paused, interaction.user)
         await interaction.response.edit_message(view=self.view)
 
 class Skip(ControlButton):
@@ -148,15 +135,15 @@ class Skip(ControlButton):
             if interaction.user == self.player.current.requester:
                 pass 
             elif interaction.user in self.player.skip_votes:
-                return await self.send(interaction, self.player.get_msg("voted"), ephemeral=True)
+                return await self.send(interaction, "voted", ephemeral=True)
             else:
                 self.player.skip_votes.add(interaction.user)
                 if len(self.player.skip_votes) >= (required := self.player.required()):
                     pass
                 else:
-                    return await self.send(interaction, self.player.get_msg("skipVote").format(interaction.user, len(self.player.skip_votes), required))
+                    return await self.send(interaction, "skipVote", interaction.user, len(self.player.skip_votes), required)
 
-        await self.send(interaction, self.player.get_msg("skipped").format(interaction.user))
+        await self.send(interaction, "skipped", interaction.user)
 
         if self.player.queue._repeat.mode == voicelink.LoopType.track:
             await self.player.set_repeat(voicelink.LoopType.off.name)
@@ -173,15 +160,15 @@ class Stop(ControlButton):
     async def callback(self, interaction: discord.Interaction):
         if not self.player.is_privileged(interaction.user):
             if interaction.user in self.player.stop_votes:
-                return await self.send(interaction, self.player.get_msg("voted"), ephemeral=True)
+                return await self.send(interaction, "voted", ephemeral=True)
             else:
                 self.player.stop_votes.add(interaction.user)
                 if len(self.player.stop_votes) >= (required := self.player.required(leave=True)):
                     pass
                 else:
-                    return await self.send(interaction, self.player.get_msg("leaveVote").format(interaction.user, len(self.player.stop_votes), required))
+                    return await self.send(interaction, "leaveVote", interaction.user, len(self.player.stop_votes), required)
         
-        await self.send(interaction, self.player.get_msg("left").format(interaction.user))
+        await self.send(interaction, "left", interaction.user)
         await self.player.teardown()
 
 class Add(ControlButton):
@@ -195,21 +182,21 @@ class Add(ControlButton):
     async def callback(self, interaction: discord.Interaction):
         track = self.player.current
         if not track:
-            return await self.send(interaction, self.player.get_msg("noTrackPlaying"))
+            return await self.send(interaction, "noTrackPlaying")
         if track.is_stream:
-            return await self.send(interaction, self.player.get_msg("playlistAddError"))
+            return await self.send(interaction, "playlistAddError")
         user = await get_user(interaction.user.id, 'playlist')
         rank, max_p, max_t = check_roles()
         if len(user['200']['tracks']) >= max_t:
-            return await self.send(interaction, self.player.get_msg("playlistlimited").format(max_t), ephemeral=True)
+            return await self.send(interaction, "playlistlimited", max_t, ephemeral=True)
 
         if track.track_id in user['200']['tracks']:
-            return await self.send(interaction, self.player.get_msg("playlistrepeated"), ephemeral=True)
+            return await self.send(interaction, "playlistrepeated", ephemeral=True)
         respond = await update_user(interaction.user.id, {"$push": {'playlist.200.tracks': track.track_id}})
         if respond:
-            await self.send(interaction, self.player.get_msg("playlistAdded").format(track.title, interaction.user.mention, user['200']['name']), ephemeral=True)
+            await self.send(interaction, "playlistAdded", track.title, interaction.user.mention, user['200']['name'], ephemeral=True)
         else:
-            await self.send(interaction, self.player.get_msg("playlistAddError2"), ephemeral=True)
+            await self.send(interaction, "playlistAddError2", ephemeral=True)
 
 class Loop(ControlButton):
     def __init__(self, **kwargs):
@@ -221,10 +208,10 @@ class Loop(ControlButton):
     
     async def callback(self, interaction: discord.Interaction):
         if not self.player.is_privileged(interaction.user):
-            return await self.send(interaction, self.player.get_msg('missingPerms_mode'), ephemeral=True)
+            return await self.send(interaction, 'missingPerms_mode', ephemeral=True)
 
         mode = await self.player.set_repeat()
-        await self.send(interaction, self.player.get_msg('repeat').format(mode.capitalize()))
+        await self.send(interaction, 'repeat', mode.capitalize())
 
 class VolumeUp(ControlButton):
     def __init__(self, **kwargs):
@@ -236,12 +223,12 @@ class VolumeUp(ControlButton):
     
     async def callback(self, interaction: discord.Interaction):
         if not self.player.is_privileged(interaction.user):
-            return await self.send(interaction, self.player.get_msg("missingPerms_function"))
+            return await self.send(interaction, "missingPerms_function")
 
         value = value if (value := self.player.volume + 20) <= 150 else 150
         await self.player.set_volume(value, interaction.user)
 
-        await self.send(interaction, self.player.get_msg('setVolume').format(value), ephemeral=True)
+        await self.send(interaction, 'setVolume', value, ephemeral=True)
 
 class VolumeDown(ControlButton):
     def __init__(self, **kwargs):
@@ -253,12 +240,12 @@ class VolumeDown(ControlButton):
     
     async def callback(self, interaction: discord.Interaction):
         if not self.player.is_privileged(interaction.user):
-            return await self.send(interaction, self.player.get_msg("missingPerms_function"))
+            return await self.send(interaction, "missingPerms_function")
 
         value = value if (value := self.player.volume - 20) >= 0 else 0
         await self.player.set_volume(value, interaction.user)
 
-        await self.send(interaction, self.player.get_msg('setVolume').format(value), ephemeral=True)
+        await self.send(interaction, 'setVolume', value, ephemeral=True)
 
 class VolumeMute(ControlButton):
     def __init__(self, **kwargs):
@@ -270,19 +257,14 @@ class VolumeMute(ControlButton):
     
     async def callback(self, interaction: discord.Interaction):
         if not self.player.is_privileged(interaction.user):
-            return await self.send(interaction, self.player.get_msg("missingPerms_function"))
+            return await self.send(interaction, "missingPerms_function")
 
-        if self.player.volume != 0:
-            value = 0
-            self.emoji = "🔈"
-            self.label = self.player.get_msg("buttonVolumeUnmute")
-        else:
-            value = self.player.settings.get("volume", 100)
-            self.emoji = "🔇"
-            self.label = self.player.get_msg("buttonVolumeMute")
+        is_muted = self.player.volume != 0
+        value = 0 if is_muted else self.player.settings.get("volume", 100)
+        self.emoji = "🔈" if is_muted else "🔇"
+        self.label = await func.get_lang(interaction.guild_id, "buttonVolumeUnmute" if is_muted else "buttonVolumeMute")
 
         await self.player.set_volume(value, interaction.user)
-
         await interaction.response.edit_message(view=self.view)
 
 class AutoPlay(ControlButton):
@@ -295,11 +277,11 @@ class AutoPlay(ControlButton):
     
     async def callback(self, interaction: discord.Interaction):
         if not self.player.is_privileged(interaction.user):
-            return await self.send(interaction, self.player.get_msg("missingPerms_autoplay"), ephemeral=True)
+            return await self.send(interaction, "missingPerms_autoplay", ephemeral=True)
 
         check = not self.player.settings.get("autoplay", False)
         self.player.settings['autoplay'] = check
-        await self.send(interaction, self.player.get_msg('autoplay').format(self.player.get_msg('enabled') if check else self.player.get_msg('disabled')))
+        await self.send(interaction, 'autoplay', await func.get_lang(interaction.guild_id, 'enabled' if check else "disabled"))
 
         if not self.player.is_playing:
             await self.player.do_next()
@@ -315,16 +297,16 @@ class Shuffle(ControlButton):
     async def callback(self, interaction: discord.Interaction):
         if not self.player.is_privileged(interaction.user):
             if interaction.user in self.player.shuffle_votes:
-                return await self.send(interaction, self.player.get_msg('voted'), ephemeral=True)
+                return await self.send(interaction, 'voted', ephemeral=True)
             else:
                 self.player.shuffle_votes.add(interaction.user)
                 if len(self.player.shuffle_votes) >= (required := self.player.required()):
                     pass
                 else:
-                    return await self.send(interaction, self.player.get_msg('shuffleVote').format(interaction.user, len(self.player.skip_votes), required))
+                    return await self.send(interaction, 'shuffleVote', interaction.user, len(self.player.skip_votes), required)
         
         await self.player.shuffle("queue", interaction.user)
-        await self.send(interaction, self.player.get_msg('shuffled'))
+        await self.send(interaction, 'shuffled')
 
 class Forward(ControlButton):
     def __init__(self, **kwargs):
@@ -337,15 +319,15 @@ class Forward(ControlButton):
         
     async def callback(self, interaction: discord.Interaction):
         if not self.player.is_privileged(interaction.user):
-            return await self.send(interaction, self.player.get_msg('missingPerms_pos'), ephemeral=True)
+            return await self.send(interaction, 'missingPerms_pos', ephemeral=True)
 
         if not self.player.current:
-            return await self.send(interaction, self.player.get_msg('noTrackPlaying'), ephemeral=True)
+            return await self.send(interaction, 'noTrackPlaying', ephemeral=True)
 
         position = int(self.player.position + 10000)
 
         await self.player.seek(position)
-        await self.send(interaction, self.player.get_msg('forward').format(func.time(position)))
+        await self.send(interaction, 'forward', func.time(position))
 
 class Rewind(ControlButton):
     def __init__(self, **kwargs):
@@ -358,15 +340,15 @@ class Rewind(ControlButton):
         
     async def callback(self, interaction: discord.Interaction):
         if not self.player.is_privileged(interaction.user):
-            return await self.send(interaction, self.player.get_msg('missingPerms_pos'), ephemeral=True)
+            return await self.send(interaction, 'missingPerms_pos', ephemeral=True)
 
         if not self.player.current:
-            return await self.send(interaction, self.player.get_msg('noTrackPlaying'), ephemeral=True)
+            return await self.send(interaction, 'noTrackPlaying', ephemeral=True)
 
         position = 0 if (value := int(self.player.position - 30000)) <= 0 else value
         
         await self.player.seek(position)
-        await self.send(interaction, self.player.get_msg('rewind').format(func.time(position)))
+        await self.send(interaction, 'rewind', func.time(position))
 
 class Tracks(discord.ui.Select):
     def __init__(self, player, style, row):
@@ -388,13 +370,13 @@ class Tracks(discord.ui.Select):
 
     async def callback(self, interaction: discord.Interaction):
         if not self.player.is_privileged(interaction.user):
-            return await interaction.response.send_message(self.player.get_msg("missingPerms_function"), ephemeral=True)
+            return await func.send(interaction, "missingPerms_function", ephemeral=True)
         
         self.player.queue.skipto(int(self.values[0].split(". ")[0]))
         await self.player.stop()
 
         if self.player.settings.get("controller_msg", True):
-            await interaction.response.send_message(self.player.get_msg("skipped").format(interaction.user))
+            await func.send(interaction, "skipped", interaction.user)
 
 btnType = {
     "back": Back,
@@ -441,7 +423,7 @@ class InteractiveController(discord.ui.View):
             
     async def interaction_check(self, interaction: discord.Interaction):
         if not self.player.node._available:
-            await interaction.response.send_message(self.player.get_msg("nodeReconnect"), ephemeral=True)
+            await func.send(interaction, "nodeReconnect", ephemeral=True)
             return False
 
         if interaction.user.id in func.settings.bot_access_user:
@@ -453,7 +435,7 @@ class InteractiveController(discord.ui.View):
                 raise ButtonOnCooldown(retry_after)
             return True
         else:
-            await interaction.response.send_message(self.player.get_msg("notInChannel").format(interaction.user.mention, self.player.channel.mention), ephemeral=True)
+            await func.send(interaction, "notInChannel", interaction.user.mention, self.player.channel.mention, ephemeral=True)
             return False
 
     async def on_error(self, interaction: discord.Interaction, error: Exception, item: discord.ui.Item):
diff --git a/views/list.py b/views/list.py
index 9b60eb0..004358c 100644
--- a/views/list.py
+++ b/views/list.py
@@ -35,16 +35,16 @@ class ListView(discord.ui.View):
         self,
         player: "Player",
         author: discord.Member, 
-        isQueue = True
+        is_queue: bool = True
     ) -> None:
         super().__init__(timeout=60)
         self.player: Player = player
 
-        self.name: str = player.get_msg('queueTitle') if isQueue else player.get_msg('historyTitle')
-        self.tracks: list[Track] = player.queue.tracks() if isQueue else player.queue.history()
+        self.is_queue: bool = is_queue
+        self.tracks: list[Track] = player.queue.tracks() if is_queue else player.queue.history()
         self.response: discord.Message = None
 
-        if not isQueue:
+        if not is_queue:
             self.tracks.reverse()
         self.author: discord.Member = author
 
@@ -70,19 +70,20 @@ class ListView(discord.ui.View):
     async def interaction_check(self, interaction: discord.Interaction) -> bool:
         return interaction.user == self.author
 
-    def build_embed(self) -> discord.Embed:
+    async def build_embed(self) -> discord.Embed:
         offset: int = self.current_page * 7
         tracks: list[Track] = self.tracks[(offset-7):offset]
+        texts = await func.get_lang(self.author.guild.id, "viewTitle", "viewDesc", "nowplayingDesc", "live", "queueTitle", "historyTitle", "viewFooter")
 
-        embed = discord.Embed(title=self.player.get_msg('viewTitle'), color=func.settings.embed_color)
-        embed.description=self.player.get_msg('viewDesc').format(self.player.current.uri, f"```{self.player.current.title}```") if self.player.current else self.player.get_msg('nowplayingDesc').format("None")
+        embed = discord.Embed(title=texts[0], color=func.settings.embed_color)
+        embed.description=texts[1].format(self.player.current.uri, f"```{self.player.current.title}```") if self.player.current else texts[2].format("None")
         
         queueText = "\n".join([
-            f"{track.emoji} `{i}.` `[" + (self.player.get_msg("live") if track.is_stream else func.time(track.length)) + f'`] **{track.title[:30]}** ' + (track.requester.mention)
+            f"{track.emoji} `{i}.` `[" + (texts[3] if track.is_stream else func.time(track.length)) + f'`] **{track.title[:30]}** ' + (track.requester.mention)
             for i, track in enumerate(tracks, start=offset-6)
         ])
-        embed.add_field(name=self.name, value=queueText) 
-        embed.set_footer(text=self.player.get_msg('viewFooter').format(self.current_page, self.page, self.time))
+        embed.add_field(name=texts[4] if self.is_queue else texts[5], value=queueText) 
+        embed.set_footer(text=texts[6].format(self.current_page, self.page, self.time))
 
         return embed
 
@@ -90,28 +91,28 @@ class ListView(discord.ui.View):
     async def fast_back_button(self, interaction: discord.Interaction, button: discord.ui.Button) -> None:
         if self.current_page != 1:
             self.current_page = 1
-            return await interaction.response.edit_message(embed=self.build_embed())
+            return await interaction.response.edit_message(embed=await self.build_embed())
         await interaction.response.defer()
 
     @discord.ui.button(label='Back', style=discord.ButtonStyle.blurple)
     async def back_button(self, interaction: discord.Interaction, button: discord.ui.Button) -> None:
         if self.current_page > 1:
             self.current_page -= 1
-            return await interaction.response.edit_message(embed=self.build_embed())
+            return await interaction.response.edit_message(embed=await self.build_embed())
         await interaction.response.defer()
 
     @discord.ui.button(label='Next', style=discord.ButtonStyle.blurple)
     async def next_button(self, interaction: discord.Interaction, button: discord.ui.Button) -> None:
         if self.current_page < self.page:
             self.current_page += 1
-            return await interaction.response.edit_message(embed=self.build_embed())
+            return await interaction.response.edit_message(embed=await self.build_embed())
         await interaction.response.defer()
 
     @discord.ui.button(label='>>', style=discord.ButtonStyle.grey)
     async def fast_next_button(self, interaction: discord.Interaction, button: discord.ui.Button) -> None:
         if self.current_page != self.page:
             self.current_page = self.page
-            return await interaction.response.edit_message(embed=self.build_embed())
+            return await interaction.response.edit_message(embed=await self.build_embed())
         await interaction.response.defer()
         
     @discord.ui.button(emoji='🗑️', style=discord.ButtonStyle.red)
diff --git a/views/playlist.py b/views/playlist.py
index e78fd4f..fc61f0d 100644
--- a/views/playlist.py
+++ b/views/playlist.py
@@ -55,7 +55,7 @@ class Select_playlist(discord.ui.Select):
         self.view.page = ceil(len(self.view.current['tracks']) / 7)
         self.view.current_page = 1
         self.view.toggle_btn(False)
-        await interaction.response.edit_message(embed=self.view.build_embed(), view=self.view)
+        await interaction.response.edit_message(embed=await self.view.build_embed(), view=self.view)
 
 class PlaylistView(discord.ui.View):
     def __init__(
@@ -88,32 +88,29 @@ class PlaylistView(discord.ui.View):
             if child.custom_id not in ("delete", "selector"):
                 child.disabled = action
         
-    def build_embed(self) -> discord.Embed:
+    async def build_embed(self) -> discord.Embed:
         offset: int = self.current_page * 7
         tracks: list[Track] = self.current['tracks'][(offset-7):offset]
-        guild_id = self.author.id
+        texts = await func.get_lang(self.author.guild.id, "playlistView", "playlistViewDesc", "settingsPermTitle", "playlistViewPermsValue", "playlistViewPermsValue2", "playlistViewTrack", "playlistNoTrack", "playlistViewPage")
 
-        embed = discord.Embed(title=func.get_lang(guild_id, 'playlistView'), color=func.settings.embed_color)
-
-        embed.description= func.get_lang(guild_id, 'playlistViewDesc').format(self.current['name'], self.current['id'], len(self.current['tracks']), owner if (owner := self.current.get('owner')) else f"{self.author.id} (You)", self.current['type'])
+        embed = discord.Embed(title=texts[0], color=func.settings.embed_color)
+        embed.description= texts[1].format(self.current['name'], self.current['id'], len(self.current['tracks']), owner if (owner := self.current.get('owner')) else f"{self.author.id} (You)", self.current['type'])
         
         perms = self.current['perms']
-        permsStr = func.get_lang(guild_id, 'settingsPermTitle')
         if self.current['type'] == 'share':
-            embed.add_field(name=permsStr, value=func.get_lang(guild_id, 'playlistViewPermsValue').format('✓' if 'write' in perms and self.author.id in perms['write'] else '✘', '✓' if 'remove' in perms and self.author.id in perms['remove'] else '✘'))
+            embed.add_field(name=texts[2], value=texts[3].format('✓' if 'write' in perms and self.author.id in perms['write'] else '✘', '✓' if 'remove' in perms and self.author.id in perms['remove'] else '✘'))
         else:
-            embed.add_field(name=permsStr, value=func.get_lang(guild_id, 'playlistViewPermsValue2').format(', '.join(f'<@{user}>' for user in perms['read'])))
+            embed.add_field(name=texts[2], value=texts[4].format(', '.join(f'<@{user}>' for user in perms['read'])))
 
-        trackStr = func.get_lang(guild_id, 'playlistViewTrack')
         if tracks:
             if self.current.get("type") == "playlist":    
-                embed.add_field(name=trackStr, value="\n".join(f"{func.get_source(track['sourceName'], 'emoji')} `{index}.` `[{func.time(track['length'])}]` **{track['title'][:30]}**" for index, track in enumerate(tracks, start=offset - 6)), inline=False)
+                embed.add_field(name=texts[5], value="\n".join(f"{func.get_source(track['sourceName'], 'emoji')} `{index}.` `[{func.time(track['length'])}]` **{track['title'][:30]}**" for index, track in enumerate(tracks, start=offset - 6)), inline=False)
             else:
-                embed.add_field(name=trackStr, value='\n'.join(f"{func.get_source(extract(track.info['uri']).domain, 'emoji')} `{index}.` `[{func.time(track.length)}]` **{track.title[:30]}** " for index, track in enumerate(tracks, start=offset - 6)), inline=False)
+                embed.add_field(name=texts[5], value='\n'.join(f"{func.get_source(extract(track.info['uri']).domain, 'emoji')} `{index}.` `[{func.time(track.length)}]` **{track.title[:30]}** " for index, track in enumerate(tracks, start=offset - 6)), inline=False)
         else:
-            embed.add_field(name=trackStr, value=func.get_lang(guild_id, 'playlistNoTrack').format(self.current['name']), inline=False)
+            embed.add_field(name=texts[5], value=texts[6].format(self.current['name']), inline=False)
 
-        embed.set_footer(text=func.get_lang(guild_id, 'playlistViewPage').format(self.current_page, self.page, self.current['time']))
+        embed.set_footer(text=texts[7].format(self.current_page, self.page, self.current['time']))
 
         return embed
 
@@ -131,7 +128,7 @@ class PlaylistView(discord.ui.View):
             return 
         if self.current_page != 1:
             self.current_page = 1
-            return await interaction.response.edit_message(embed=self.build_embed())
+            return await interaction.response.edit_message(embed=await self.build_embed())
         await interaction.response.defer()
 
     @discord.ui.button(label='Back', style=discord.ButtonStyle.blurple, disabled=True)
@@ -140,7 +137,7 @@ class PlaylistView(discord.ui.View):
             return 
         if self.current_page > 1:
             self.current_page -= 1
-            return await interaction.response.edit_message(embed=self.build_embed())
+            return await interaction.response.edit_message(embed=await self.build_embed())
         await interaction.response.defer()
 
     @discord.ui.button(label='Next', style=discord.ButtonStyle.blurple, disabled=True)
@@ -149,7 +146,7 @@ class PlaylistView(discord.ui.View):
             return 
         if self.current_page < self.page:
             self.current_page += 1
-            return await interaction.response.edit_message(embed=self.build_embed())
+            return await interaction.response.edit_message(embed=await self.build_embed())
         await interaction.response.defer()
 
     @discord.ui.button(label='>>', style=discord.ButtonStyle.grey, disabled=True)
@@ -158,7 +155,7 @@ class PlaylistView(discord.ui.View):
             return 
         if self.current_page != self.page:
             self.current_page = self.page
-            return await interaction.response.edit_message(embed=self.build_embed())
+            return await interaction.response.edit_message(embed=await self.build_embed())
         await interaction.response.defer()
 
     @discord.ui.button(emoji='🗑️', custom_id="delete", style=discord.ButtonStyle.red)
diff --git a/views/search.py b/views/search.py
index dbab80e..3a77cb8 100644
--- a/views/search.py
+++ b/views/search.py
@@ -29,12 +29,12 @@ if TYPE_CHECKING:
     from voicelink import Track
 
 class SearchDropdown(discord.ui.Select):
-    def __init__(self, tracks: list[Track], get_msg: callable) -> None:
+    def __init__(self, tracks: list[Track], texts: list[str]) -> None:
         self.view: SearchView
-        self.get_msg: callable = get_msg
+        self.texts: list[str] = texts
         
         super().__init__(
-            placeholder=get_msg('searchWait'),
+            placeholder=texts[0],
             min_values=1, max_values=len(tracks),
             options=[
                 discord.SelectOption(label=f"{i}. {track.title[:50]}", description=f"{track.author[:50]} · {track.formatted_length}")
@@ -44,18 +44,18 @@ class SearchDropdown(discord.ui.Select):
         
     async def callback(self, interaction: discord.Interaction) -> None:
         self.disabled = True
-        self.placeholder = self.get_msg('searchSuccess')
+        self.placeholder = self.texts[1]
         await interaction.response.edit_message(view=self.view)
         self.view.values = self.values          
         self.view.stop()
 
 class SearchView(discord.ui.View):
-    def __init__(self, tracks: list[Track], lang: callable) -> None:
+    def __init__(self, tracks: list[Track], texts: list[str]) -> None:
         super().__init__(timeout=60)
 
         self.response: discord.Message = None
         self.values: list[str] = None
-        self.add_item(SearchDropdown(tracks, lang))
+        self.add_item(SearchDropdown(tracks, texts))
 
     async def on_error(self, error, item, interaction):
         return
diff --git a/voicelink/player.py b/voicelink/player.py
index c261d61..f24c4a5 100644
--- a/voicelink/player.py
+++ b/voicelink/player.py
@@ -59,14 +59,15 @@ from .placeholders import Placeholders, build_embed
 from random import shuffle, choice
 
 async def connect_channel(ctx: Union[commands.Context, Interaction], channel: VoiceChannel = None):
+    texts = await func.get_lang(ctx.guild.id, "noChannel", "noPermission")
     try:
         channel = channel or ctx.author.voice.channel if isinstance(ctx, commands.Context) else ctx.user.voice.channel
     except:
-        raise VoicelinkException(func.get_lang(ctx.guild.id, 'noChannel'))
+        raise VoicelinkException(texts[0])
 
     check = channel.permissions_for(ctx.guild.me)
     if check.connect == False or check.speak == False:
-        raise VoicelinkException(func.get_lang(ctx.guild.id, 'noPermission'))
+        raise VoicelinkException(texts[1])
 
     settings = await func.get_settings(channel.guild.id)
     player: Player = await channel.connect(
@@ -220,9 +221,9 @@ class Player(VoiceProtocol):
     @property
     def ping(self) -> float:
         return round(self._ping / 1000, 2)
-    
-    def get_msg(self, key: str) -> str:
-        return func.get_lang(self.guild.id, key)
+
+    def get_msg(self, *keys) -> Union[list[str], str]:
+        return func.get_lang_non_async(self.guild.id, *keys)
 
     def required(self, leave=False):
         if self.settings.get('votedisable'):
diff --git a/web/ipc/methods.py b/web/ipc/methods.py
index 9fab211..573c163 100644
--- a/web/ipc/methods.py
+++ b/web/ipc/methods.py
@@ -65,13 +65,13 @@ async def skipTo(player: Player, member: Member, data: dict):
             pass
 
         elif member in player.skip_votes:
-            return error_msg(player.get_msg('voted', 'EN'), user_id=member.id)
+            return error_msg(player.get_msg('voted'), user_id=member.id)
         else:
             player.skip_votes.add(member)
             if len(player.skip_votes) >= (required := player.required()):
                 pass
             else:
-                return error_msg(player.get_msg('skipVote', 'EN').format(member, len(player.skip_votes), required), guild_id=player.guild.id)
+                return error_msg(player.get_msg('skipVote').format(member, len(player.skip_votes), required), guild_id=player.guild.id)
 
     index = data.get("index", 1)
     if index > 1:
@@ -87,13 +87,13 @@ async def backTo(player: Player, member: Member, data: dict):
             pass
 
         elif member in player.skip_votes:
-            return error_msg(player.get_msg('voted', 'EN'), user_id=member.id)
+            return error_msg(player.get_msg('voted'), user_id=member.id)
         else:
             player.skip_votes.add(member)
             if len(player.skip_votes) >= (required := player.required()):
                 pass
             else:
-                return error_msg(player.get_msg('backVote', 'EN').format(member, len(player.skip_votes), required), guild_id=player.guild.id)
+                return error_msg(player.get_msg('backVote').format(member, len(player.skip_votes), required), guild_id=player.guild.id)
     
     index = data.get("index", 1)
     if not player.is_playing: