Merge pull request #123 from Edwinexd/i18n-guilds

Add language setting per server

bot.py

@@ -28,7 +28,9 @@
 import disnake
 from disnake.ext import commands
 from cogs.utils import database, activity, version, config, schema
-from cogs.utils.i18n import response
+from cogs.utils.i18n import Response, StaticResponse
+
+static_response = StaticResponse()
 
 extensions = (
     "cogs.admin",
@@ -50,6 +52,7 @@ def __init__(self):
         self.activities = activity.Activities(f"{self.directory}/files/activities.csv")
         self.db = database.Database(f"{self.directory}/files/reactionlight.db")
         self.version = version.get(self.directory)
+        self.response = Response(self, f"{self.directory}/i18n", self.config.language)
         intents = disnake.Intents(message_content=True, guild_messages=True, guild_reactions=True, guilds=True)
         super().__init__(intents=intents)
 
@@ -61,7 +64,7 @@ def isadmin(self, member, guild_id):
         try:
             admins = self.db.get_admins(guild_id)
         except DatabaseError as error:
-            print(response.get("db-error-admin-check").format(exception=error))
+            print(self.response.get("db-error-admin-check").format(exception=error))
             return False
 
         try:
@@ -104,13 +107,16 @@ async def database_updates(self):
         if handler.version == 4:
             handler.four_to_five()
 
+        if handler.version == 5:
+            handler.five_to_six()
+
     async def report(self, text, guild_id=None, embed=None):
         # Send a message to the system channel (if set)
         if guild_id:
             try:
                 server_channel = self.db.fetch_systemchannel(guild_id)
             except DatabaseError as error:
-                await self.report(response.get("db-error-fetching-systemchannels-server").format(exception=error, text=text))
+                await self.report(self.response.get("db-error-fetching-systemchannels-server").format(exception=error, text=text))
                 return
 
             if server_channel:
@@ -138,9 +144,9 @@ async def report(self, text, guild_id=None, embed=None):
                 else:
                     await target_channel.send(text)
             except disnake.NotFound:
-                print(response.get("systemchannel-404"))
+                print(self.response.get("systemchannel-404"))
             except disnake.Forbidden:
-                print(response.get("systemchannel-403"))
+                print(self.response.get("systemchannel-403"))
         else:
             print(text)
 
@@ -175,6 +181,6 @@ async def getmember(self, guild, user_id):
 try:
     rl.run(rl.config.token, reconnect=True)
 except disnake.PrivilegedIntentsRequired:
-    print(response.get("login-failure-intents"))
+    print(static_response.get("login-failure-intents"))
 except disnake.errors.LoginFailure:
-    print(response.get("login-failure-token"))
+    print(static_response.get("login-failure-token"))

cogs/admin.py

@@ -25,28 +25,33 @@
 from sqlite3 import Error as DatabaseError
 import disnake
 from disnake.ext import commands
-from cogs.utils.i18n import response
+from cogs.utils.i18n import StaticResponse
+
+static_response = StaticResponse()
 
 
 class Admin(commands.Cog):
     def __init__(self, bot):
         self.bot = bot
 
-    @commands.slash_command(name="admin", description=response.get("brief-admin"))
+    @commands.slash_command(name="admin", description=static_response.get("brief-admin"))
     @commands.has_permissions(administrator=True)
     async def admin(
         self,
         inter,
-        action: str = commands.Param(description=response.get("admin-option-action"), choices=("add", "remove", "list")),
-        role: disnake.Role = commands.Param(description=response.get("admin-option-role"), default=None),
+        action: str = commands.Param(description=static_response.get("admin-option-action"), choices=("add", "remove", "list")),
+        role: disnake.Role = commands.Param(description=static_response.get("admin-option-role"), default=None),
     ):
         await inter.response.defer()
         if role is None or action == "list":
             # Lists all admin IDs in the database, mentioning them if possible
             try:
                 admin_ids = self.bot.db.get_admins(inter.guild.id)
             except DatabaseError as error:
-                await self.bot.report(response.get("db-error-fetching-admins").format(exception=error), inter.guild.id)
+                await self.bot.report(
+                    self.bot.response.get("db-error-fetching-admins", guild_id=inter.guild.id).format(exception=error),
+                    inter.guild.id,
+                )
                 return
 
             adminrole_objects = []
@@ -55,30 +60,37 @@ async def admin(
 
             if adminrole_objects:
                 await inter.edit_original_message(
-                    content=response.get("adminlist-local").format(admin_list="\n- ".join(adminrole_objects))
+                    content=self.bot.response.get("adminlist-local", guild_id=inter.guild.id).format(
+                        admin_list="\n- ".join(adminrole_objects)
+                    )
                 )
             else:
-                await inter.edit_original_message(content=response.get("adminlist-local-empty"))
+                await inter.edit_original_message(content=self.bot.response.get("adminlist-local-empty", guild_id=inter.guild.id))
 
         elif action == "add":
             # Adds an admin role ID to the database
             try:
                 self.bot.db.add_admin(role.id, inter.guild.id)
             except DatabaseError as error:
-                await self.bot.report(response.get("db-error-admin-add").format(exception=error), inter.guild.id)
+                await self.bot.report(
+                    self.bot.response.get("db-error-admin-add", guild_id=inter.guild.id).format(exception=error), inter.guild.id
+                )
                 return
 
-            await inter.edit_original_message(content=response.get("admin-add-success"))
+            await inter.edit_original_message(content=self.bot.response.get("admin-add-success", guild_id=inter.guild.id))
 
         elif action == "remove":
             # Removes an admin role ID from the database
             try:
                 self.bot.db.remove_admin(role.id, inter.guild.id)
             except DatabaseError as error:
-                await self.bot.report(response.get("db-error-admin-remove").format(exception=error), inter.guild.id)
+                await self.bot.report(
+                    self.bot.response.get("db-error-admin-remove", guild_id=inter.guild.id).format(exception=error),
+                    inter.guild.id,
+                )
                 return
 
-            await inter.edit_original_message(content=response.get("admin-remove-success"))
+            await inter.edit_original_message(content=self.bot.response.get("admin-remove-success", guild_id=inter.guild.id))
 
 
 def setup(bot):

cogs/cleaner.py

@@ -26,7 +26,6 @@
 from sqlite3 import Error as DatabaseError
 import disnake
 from disnake.ext import commands, tasks
-from cogs.utils.i18n import response
 
 
 class Cleaner(commands.Cog):
@@ -40,7 +39,7 @@ async def on_guild_remove(self, guild):
         try:
             self.bot.db.add_cleanup_guild(guild.id, round(datetime.utcnow().timestamp()))
         except DatabaseError as error:
-            await self.bot.report(response.get("db-error-add-cleanup-removal").format(exception=error))
+            await self.bot.report(self.bot.response.get("db-error-add-cleanup-removal").format(exception=error))
             return
 
     @tasks.loop(hours=24)
@@ -50,7 +49,7 @@ async def cleandb(self):
             # Cleans the database by deleting rows of reaction role messages that don't exist anymore
             messages = self.bot.db.fetch_all_messages()
         except DatabaseError as error:
-            await self.bot.report(response.get("db-error-fetching-cleaning").format(exception=error))
+            await self.bot.report(self.bot.response.get("db-error-fetching-cleaning").format(exception=error))
             return
 
         for message in messages:
@@ -70,12 +69,12 @@ async def cleandb(self):
                         self.bot.db.delete(message[0])
                     except DatabaseError as error:
                         await self.bot.report(
-                            response.get("db-error-fetching-cleaning").format(exception=error), channel.guild.id
+                            self.bot.response.get("db-error-fetching-cleaning").format(exception=error), channel.guild.id
                         )
                         return
 
                     await self.bot.report(
-                        response.get("db-message-delete-success").format(
+                        self.bot.response.get("db-message-delete-success").format(
                             message_id=message_id,
                             channel_id=channel_id,
                             guild_id=guild_id,
@@ -86,7 +85,7 @@ async def cleandb(self):
             except disnake.Forbidden:
                 # If we can't fetch the channel due to the bot not being in the guild or permissions we usually cant mention it or get the guilds id using the channels object
                 await self.bot.report(
-                    response.get("db-forbidden-message").format(
+                    self.bot.response.get("db-forbidden-message").format(
                         message_id=message_id, channel_id=channel_id, guild_id=guild_id, limit_to_one_status=limit_to_one_status
                     ),
                     guild_id,
@@ -97,7 +96,7 @@ async def cleandb(self):
             # Get the cleanup queued guilds
             cleanup_guild_ids = self.bot.db.fetch_cleanup_guilds(guild_ids_only=True)
         except DatabaseError as error:
-            await self.bot.report(response.get("db-error-fetching-cleaning-guild").format(exception=error))
+            await self.bot.report(self.bot.response.get("db-error-fetching-cleaning-guild").format(exception=error))
             return
 
         for guild_id in guilds:
@@ -107,7 +106,7 @@ async def cleandb(self):
                     try:
                         self.bot.db.remove_cleanup_guild(guild_id)
                     except DatabaseError as error:
-                        await self.bot.report(response.get("db-error-removing-cleanup").format(exception=error))
+                        await self.bot.report(self.bot.response.get("db-error-removing-cleanup").format(exception=error))
                         return
             except disnake.Forbidden:
                 # If unknown guild
@@ -117,16 +116,16 @@ async def cleandb(self):
                     try:
                         self.bot.db.add_cleanup_guild(guild_id, round(datetime.utcnow().timestamp()))
                     except DatabaseError as error:
-                        await self.bot.report(response.get("db-error-add-cleanup").format(exception=error))
+                        await self.bot.report(self.bot.response.get("db-error-add-cleanup").format(exception=error))
                         return
             except DatabaseError as error:
-                await self.bot.report(response.get("db-error-fetching-guild").format(exception=error))
+                await self.bot.report(self.bot.response.get("db-error-fetching-guild").format(exception=error))
                 return
 
         try:
             cleanup_guilds = self.bot.db.fetch_cleanup_guilds()
         except DatabaseError as error:
-            await self.bot.report(response.get("db-error-fetching-cleanup-guild").format(exception=error))
+            await self.bot.report(self.bot.response.get("db-error-fetching-cleanup-guild").format(exception=error))
             return
 
         current_timestamp = round(datetime.utcnow().timestamp())
@@ -142,15 +141,15 @@ async def cleandb(self):
                     try:
                         self.bot.db.remove_guild(guild[0])
                     except DatabaseError as error:
-                        await self.bot.report(response.get("db-error-deleting-cleaning-guild").format(exception=error))
+                        await self.bot.report(self.bot.response.get("db-error-deleting-cleaning-guild").format(exception=error))
                         return
                     try:
                         self.bot.db.remove_cleanup_guild(guild[0])
                     except DatabaseError as error:
-                        await self.bot.report(response.get("db-error-deleting-cleaning-guild").format(exception=error))
+                        await self.bot.report(self.bot.response.get("db-error-deleting-cleaning-guild").format(exception=error))
                         return
                 except DatabaseError as error:
-                    await self.bot.report(response.get("db-error-removing-cleanup").format(exception=error))
+                    await self.bot.report(self.bot.response.get("db-error-removing-cleanup").format(exception=error))
                     return
 
     @tasks.loop(hours=6)
@@ -160,7 +159,7 @@ async def check_cleanup_queued_guilds(self):
         try:
             cleanup_guild_ids = self.bot.db.fetch_cleanup_guilds(guild_ids_only=True)
         except DatabaseError as error:
-            await self.bot.report(response.get("db-error-fetching-cleaning-guild").format(exception=error))
+            await self.bot.report(self.bot.response.get("db-error-fetching-cleaning-guild").format(exception=error))
             return
         for guild_id in cleanup_guild_ids:
             try:
@@ -169,7 +168,7 @@ async def check_cleanup_queued_guilds(self):
             except disnake.Forbidden:
                 continue
             except DatabaseError as error:
-                await self.bot.report(response.get("db-error-removing-cleanup").format(exception=error))
+                await self.bot.report(self.bot.response.get("db-error-removing-cleanup").format(exception=error))
                 return
 
 

cogs/control.py

@@ -27,13 +27,16 @@
 from shutil import copy
 import disnake
 from disnake.ext import commands, tasks
-from cogs.utils.i18n import response
 from cogs.utils import github
+from cogs.utils.i18n import StaticResponse
+
+static_response = StaticResponse()
 
 
 class Control(commands.Cog):
     def __init__(self, bot):
         self.bot = bot
+        # pylint: disable=no-member
         self.updates.start()
 
     def restart(self):
@@ -55,63 +58,66 @@ async def updates(self):
                 title=f"Reaction Light v{new_version} - Changes", description=changelog, colour=self.bot.config.botcolour
             )
             em.set_footer(text=f"{self.bot.config.botname}", icon_url=self.bot.config.logo)
-            await self.bot.report(response.get("update-notification").format(new_version=new_version), embed=em)
+            await self.bot.report(self.bot.response.get("update-notification").format(new_version=new_version), embed=em)
 
     @commands.slash_command(name="bot")
     async def controlbot_group(self, inter):
         pass
 
-    @controlbot_group.sub_command(name="version", description=response.get("brief-version"))
+    @controlbot_group.sub_command(name="version", description=static_response.get("brief-version"))
     async def print_version(self, inter):
         await inter.response.defer()
         if not self.bot.isadmin(inter.author, inter.guild.id):
-            await inter.edit_original_message(content=response.get("not-admin"))
+            await inter.edit_original_message(content=self.bot.response.get("not-admin", guild_id=inter.guild.id))
             return
 
         latest = await github.get_latest()
         changelog = await github.latest_changelog()
         em = disnake.Embed(title=f"Reaction Light v{latest} - Changes", description=changelog, colour=self.bot.config.botcolour)
         em.set_footer(text=f"{self.bot.config.botname}", icon_url=self.bot.config.logo)
         await inter.edit_original_message(
-            content=response.get("version").format(version=self.bot.version, latest_version=latest), embed=em
+            content=self.bot.response.get("version", guild_id=inter.guild.id).format(
+                version=self.bot.version, latest_version=latest
+            ),
+            embed=em,
         )
 
     @commands.is_owner()
-    @controlbot_group.sub_command(name="kill", description=response.get("brief-kill"))
+    @controlbot_group.sub_command(name="kill", description=static_response.get("brief-kill"))
     async def kill(self, inter):
         await inter.response.defer()
-        await inter.edit_original_message(content=response.get("shutdown"))
+        await inter.edit_original_message(content=self.bot.response.get("shutdown", guild_id=inter.guild.id))
         await self.bot.close()
 
     @commands.is_owner()
-    @controlbot_group.sub_command(name="restart", description=response.get("brief-restart"))
+    @controlbot_group.sub_command(name="restart", description=static_response.get("brief-restart"))
     async def restart_cmd(self, inter):
         if platform != "win32":
             self.restart()
             await inter.response.defer()
-            await inter.edit_original_message(content=response.get("restart"))
+            await inter.edit_original_message(content=self.bot.response.get("restart", guild_id=inter.guild.id))
             await self.bot.close()
         else:
-            await inter.send(response.get("windows-error"))
+            await inter.send(self.bot.response.get("windows-error", guild_id=inter.guild.id))
 
     @commands.is_owner()
-    @controlbot_group.sub_command(name="update", description=response.get("brief-update"))
+    @controlbot_group.sub_command(name="update", description=static_response.get("brief-update"))
     async def update(self, inter):
         if platform != "win32":
             await inter.response.defer()
-            await inter.edit_original_message(content=response.get("attempting-update"))
+            await inter.edit_original_message(content=self.bot.response.get("attempting-update", guild_id=inter.guild.id))
             os.chdir(self.bot.directory)
             cmd = os.popen("git fetch")
             cmd.close()
             cmd = os.popen("git pull")
             cmd.close()
-            await inter.channel.send(response.get("database-backup"))
+            await inter.channel.send(self.bot.response.get("database-backup", guild_id=inter.guild.id))
             copy(f"{self.bot.directory}/files/reactionlight.db", f"{self.bot.directory}/files/reactionlight.db.bak")
             self.restart()
-            await inter.channel.send(response.get("restart"))
+            await inter.channel.send(self.bot.response.get("restart", guild_id=inter.guild.id))
             await self.bot.close()
         else:
-            await inter.send(response.get("windows-error"))
+            await inter.send(self.bot.response.get("windows-error", guild_id=inter.guild.id))
 
 
 def setup(bot):

cogs/errors.py

@@ -25,7 +25,6 @@
 
 import traceback
 from disnake.ext import commands
-from cogs.utils.i18n import response
 
 
 class Errors(commands.Cog):
@@ -35,7 +34,7 @@ def __init__(self, bot):
     @commands.Cog.listener()
     async def on_command_error(self, inter, error):
         if isinstance(error, commands.NotOwner):
-            await inter.send(response.get("not-owner"))
+            await inter.send(self.bot.response.get("not-owner", guild_id=inter.guild.id))
         else:
             traceback.print_tb(error.__traceback__)
             print(error)