Removed multi langs

Powers/plugins/admin.py

@@ -18,7 +18,6 @@ from Powers import DEV_USERS, LOGGER, OWNER_ID, SUPPORT_GROUP, SUPPORT_STAFF
 from Powers.bot_class import Gojo
 from Powers.database.approve_db import Approve
 from Powers.database.reporting_db import Reporting
-from Powers.tr_engine import tlang
 from Powers.utils.caching import ADMIN_CACHE, TEMP_ADMIN_CACHE_BLOCK, admin_cache_reload
 from Powers.utils.custom_filters import (
     DEV_LEVEL,
@@ -37,19 +36,17 @@ async def adminlist_show(_, m: Message):
     global ADMIN_CACHE
     if m.chat.type != "supergroup":
         return await m.reply_text(
-            "This command is made to be used in groups only!",
+            text="This command is made to be used in groups only!",
         )
     try:
         try:
             admin_list = ADMIN_CACHE[m.chat.id]
-            note = tlang(m, "admin.adminlist.note_cached")
+            note = "<i>Note:</i> These are cached values!"
         except KeyError:
             admin_list = await admin_cache_reload(m, "adminlist")
-            note = tlang(m, "admin.adminlist.note_updated")
-
-        adminstr = (tlang(m, "admin.adminlist.adminstr")).format(
-            chat_title=m.chat.title,
-        ) + "\n\n"
+            note = "<i>Note:</i> These are up-to-date values!"
+            
+        adminstr = f"Admins in <b>{m.chat.title}</b>:"+ "\n\n"
 
         bot_admins = [i for i in admin_list if (i[1].lower()).endswith("bot")]
         user_admins = [i for i in admin_list if not (i[1].lower()).endswith("bot")]
@@ -86,14 +83,11 @@ async def adminlist_show(_, m: Message):
 
     except Exception as ef:
         if str(ef) == str(m.chat.id):
-            await m.reply_text(tlang(m, "admin.adminlist.use_admin_cache"))
+            await m.reply_text(text="Use /admincache to reload admins!")
         else:
             ef = str(ef) + f"{admin_list}\n"
             await m.reply_text(
-                (tlang(m, "general.some_error")).format(
-                    SUPPORT_GROUP=SUPPORT_GROUP,
-                    ef=ef,
-                ),
+                text=f"Some error occured, report to @{SUPPORT_GROUP} \n <b>Error:</b> <code>{ef}</code>"
             )
         LOGGER.error(ef)
         LOGGER.error(format_exc())
@@ -119,7 +113,7 @@ async def zombie_clean(c: Gojo, m: Message):
     if zombie == 0:
         return await wait.edit_text("Group is clean!")
     return await wait.edit_text(
-        f"<b>{zombie}</b> Zombies found and has been banned!",
+        text=f"<b>{zombie}</b> Zombies found and has been banned!",
     )
 
 
@@ -143,14 +137,11 @@ async def reload_admins(_, m: Message):
     try:
         await admin_cache_reload(m, "admincache")
         TEMP_ADMIN_CACHE_BLOCK[m.chat.id] = "manualblock"
-        await m.reply_text(tlang(m, "admin.adminlist.reloaded_admins"))
+        await m.reply_text(text="Reloaded all admins in this chat!")
         LOGGER.info(f"Admincache cmd use in {m.chat.id} by {m.from_user.id}")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text=f"Some error occured, report to @{SUPPORT_GROUP} \n <b>Error:</b> <code>{ef}</code>"
         )
         LOGGER.error(ef)
         LOGGER.error(format_exc())
@@ -185,7 +176,7 @@ async def fullpromote_usr(c: Gojo, m: Message):
     global ADMIN_CACHE
 
     if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "admin.promote.no_target"))
+        await m.reply_text(text="I can't promote nothing! Give me an username or user id or atleast reply to that user")
         return
 
     try:
@@ -241,6 +232,8 @@ async def fullpromote_usr(c: Gojo, m: Message):
             title = m.text.split()[1]
         if title and len(title) > 16:
             title = title[0:16]  # trim title to 16 characters
+        elif not title:
+            title = "Gojo"
 
         try:
             await c.set_administrator_title(m.chat.id, user_id, title)
@@ -250,14 +243,15 @@ async def fullpromote_usr(c: Gojo, m: Message):
         LOGGER.info(
             f"{m.from_user.id} fullpromoted {user_id} in {m.chat.id} with title '{title}'",
         )
+        
 
         await m.reply_text(
-            (tlang(m, "admin.promote.promoted_user")).format(
+            ("{promoter} promoted {promoted} in chat <b>{chat_title}</b>!").format(
                 promoter=(await mention_html(m.from_user.first_name, m.from_user.id)),
                 promoted=(await mention_html(user_first_name, user_id)),
                 chat_title=f"{escape(m.chat.title)} title set to {title}"
                 if title
-                else f"{escape(m.chat.title)} title set to Admin",
+                else f"{escape(m.chat.title)} title set to Gojo",
             ),
         )
 
@@ -275,17 +269,14 @@ async def fullpromote_usr(c: Gojo, m: Message):
             await admin_cache_reload(m, "promote_key_error")
 
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights......")
     except RightForbidden:
-        await m.reply_text(tlang(m, "admin.promote.bot_no_right"))
+        await m.reply_text(text = "I don't have enough rights to promote this user.")
     except UserAdminInvalid:
-        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+        await m.reply_text(text="Cannot act on this user, maybe I wasn't the one who changed their permissions.")
     except RPCError as e:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=e,
-            ),
+            text=f"Some error occured, report to @{SUPPORT_GROUP} \n <b>Error:</b> <code>{e}</code>"
         )
         LOGGER.error(e)
         LOGGER.error(format_exc())
@@ -298,7 +289,7 @@ async def promote_usr(c: Gojo, m: Message):
     global ADMIN_CACHE
 
     if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "admin.promote.no_target"))
+        await m.reply_text(text="I can't promote nothing!......reply to user to promote him/her....")
         return
 
     try:
@@ -338,18 +329,19 @@ async def promote_usr(c: Gojo, m: Message):
             can_delete_messages=bot.can_delete_messages,
             can_restrict_members=bot.can_restrict_members,
             can_pin_messages=bot.can_pin_messages,
-            # can_promote_members=bot.can_promote_members,
             can_manage_chat=bot.can_manage_chat,
             can_manage_voice_chats=bot.can_manage_voice_chats,
         )
 
-        title = "Itadori"  # Deafult title
+        title = ""  # Deafult title
         if len(m.text.split()) == 3 and not m.reply_to_message:
             title = m.text.split()[2]
         elif len(m.text.split()) == 2 and m.reply_to_message:
             title = m.text.split()[1]
         if title and len(title) > 16:
             title = title[0:16]  # trim title to 16 characters
+        if not title:
+            title="Itadori"
 
         try:
             await c.set_administrator_title(m.chat.id, user_id, title)
@@ -361,122 +353,12 @@ async def promote_usr(c: Gojo, m: Message):
         )
 
         await m.reply_text(
-            (tlang(m, "admin.promote.promoted_user")).format(
-                promoter=(await mention_html(m.from_user.first_name, m.from_user.id)),
-                promoted=(await mention_html(user_first_name, user_id)),
-                chat_title=f"{escape(m.chat.title)} title set to {title}"
-                if title
-                else f"{escape(m.chat.title)} title set to Admin",
-            ),
-        )
-
-        # If user is approved, disapprove them as they willbe promoted and get even more rights
-        if Approve(m.chat.id).check_approve(user_id):
-            Approve(m.chat.id).remove_approve(user_id)
-
-        # ----- Add admin to temp cache -----
-        try:
-            inp1 = user_name or user_first_name
-            admins_group = ADMIN_CACHE[m.chat.id]
-            admins_group.append((user_id, inp1))
-            ADMIN_CACHE[m.chat.id] = admins_group
-        except KeyError:
-            await admin_cache_reload(m, "promote_key_error")
-
-    except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
-    except RightForbidden:
-        await m.reply_text(tlang(m, "admin.promote.bot_no_right"))
-    except UserAdminInvalid:
-        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
-    except RPCError as e:
-        await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=e,
-            ),
-        )
-        LOGGER.error(e)
-        LOGGER.error(format_exc())
-    return
-
-
-
-@Gojo.on_message(command("spromote") & promote_filter)
-async def superpromote_usr(c: Gojo, m: Message):
-
-    global ADMIN_CACHE
-
-    if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "admin.promote.no_target"))
-        return
-
-    try:
-        user_id, user_first_name, user_name = await extract_user(c, m)
-    except Exception:
-        return
-
-    bot = await c.get_chat_member(m.chat.id, Config.BOT_ID)
-
-    if user_id == Config.BOT_ID:
-        await m.reply_text("Huh, how can I even promote myself?")
-        return
-
-    if not bot.can_promote_members:
-        return await m.reply_text(
-            "I don't have enough permissions",
-        )  # This should be here
-    # If user is alreay admin
-    try:
-        admin_list = {i[0] for i in ADMIN_CACHE[m.chat.id]}
-    except KeyError:
-        admin_list = {
-            i[0] for i in (await admin_cache_reload(m, "promote_cache_update"))
-        }
-
-    if user_id in admin_list:
-        await m.reply_text(
-            "This user is already an admin, how am I supposed to re-promote them?",
-        )
-        return
-
-    try:
-        await m.chat.promote_member(
-            user_id=user_id,
-            can_change_info=bot.can_change_info,
-            can_invite_users=bot.can_invite_users,
-            can_delete_messages=bot.can_delete_messages,
-            can_restrict_members=bot.can_restrict_members,
-            can_pin_messages=bot.can_pin_messages,
-            can_promote_members=bot.can_promote_members,
-            can_manage_chat=bot.can_manage_chat,
-            can_manage_voice_chats=bot.can_manage_voice_chats,
-        )
-
-        title = "Gojo"  # Deafult title
-        if len(m.text.split()) == 3 and not m.reply_to_message:
-            title = m.text.split()[2]
-        elif len(m.text.split()) == 2 and m.reply_to_message:
-            title = m.text.split()[1]
-        if title and len(title) > 16:
-            title = title[0:16]  # trim title to 16 characters
-
-        try:
-            await c.set_administrator_title(m.chat.id, user_id, title)
-        except RPCError as e:
-            LOGGER.error(e)
-
-        LOGGER.info(
-            f"{m.from_user.id} super promoted {user_id} in {m.chat.id} with title '{title}'",
-        )
-
-        await m.reply_text(
-            (tlang(m, "admin.promote.promoted_user")).format(
+            ("{promoter} promoted {promoted} in chat <b>{chat_title}</b>!").format(
                 promoter=(await mention_html(m.from_user.first_name, m.from_user.id)),
                 promoted=(await mention_html(user_first_name, user_id)),
                 chat_title=f"{escape(m.chat.title)} title set to {title}"
                 if title
-                else f"{escape(m.chat.title)} title set to Admin",
+                else f"{escape(m.chat.title)} title set to Itadori",
             ),
         )
 
@@ -494,112 +376,20 @@ async def superpromote_usr(c: Gojo, m: Message):
             await admin_cache_reload(m, "promote_key_error")
 
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights.")
     except RightForbidden:
-        await m.reply_text(tlang(m, "admin.promote.bot_no_right"))
+        await m.reply_text(text="I don't have enough rights to promote this user.")
     except UserAdminInvalid:
-        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+        await m.reply_text(text="Cannot act on this user, maybe I wasn't the one who changed their permissions.")
     except RPCError as e:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=e,
-            ),
+            text=f"Some error occured, report to @{SUPPORT_GROUP} \n <b>Error:</b> <code>{e}</code>"
         )
         LOGGER.error(e)
         LOGGER.error(format_exc())
     return
 
 
-@Gojo.on_message(command("demote") & promote_filter)
-async def demote_usr(c: Gojo, m: Message):
-
-    global ADMIN_CACHE
-
-    if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "admin.demote.no_target"))
-        return
-
-    try:
-        user_id, user_first_name, _ = await extract_user(c, m)
-    except Exception:
-        return
-
-    if user_id == Config.BOT_ID:
-        await m.reply_text("Get an admin to demote me!")
-        return
-
-    # If user not alreay admin
-    try:
-        admin_list = {i[0] for i in ADMIN_CACHE[m.chat.id]}
-    except KeyError:
-        admin_list = {
-            i[0] for i in (await admin_cache_reload(m, "demote_cache_update"))
-        }
-
-    if user_id not in admin_list:
-        await m.reply_text(
-            "This user is not an admin, how am I supposed to re-demote them?",
-        )
-        return
-
-    try:
-        await m.chat.promote_member(
-            user_id=user_id,
-            can_change_info=False,
-            can_invite_users=False,
-            can_delete_messages=False,
-            can_restrict_members=False,
-            can_pin_messages=False,
-            can_promote_members=False,
-            can_manage_chat=False,
-            can_manage_voice_chats=False,
-        )
-        LOGGER.info(f"{m.from_user.id} demoted {user_id} in {m.chat.id}")
-
-        # ----- Remove admin from cache -----
-        try:
-            admin_list = ADMIN_CACHE[m.chat.id]
-            user = next(user for user in admin_list if user[0] == user_id)
-            admin_list.remove(user)
-            ADMIN_CACHE[m.chat.id] = admin_list
-        except (KeyError, StopIteration):
-            await admin_cache_reload(m, "demote_key_stopiter_error")
-
-        await m.reply_text(
-            (tlang(m, "admin.demote.demoted_user")).format(
-                demoter=(
-                    await mention_html(
-                        m.from_user.first_name,
-                        m.from_user.id,
-                    )
-                ),
-                demoted=(await mention_html(user_first_name, user_id)),
-                chat_title=m.chat.title,
-            ),
-        )
-
-    except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
-    except RightForbidden:
-        await m.reply_text(tlang(m, "admin.demote.bot_no_right"))
-    except UserAdminInvalid:
-        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
-    except RPCError as ef:
-        await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
-        )
-        LOGGER.error(ef)
-        LOGGER.error(format_exc())
-
-    return
-
-
-
-
 @Gojo.on_message(command("invitelink"))
 async def get_invitelink(c: Gojo, m: Message):
     # Bypass the bot devs, sudos and owner
@@ -607,31 +397,26 @@ async def get_invitelink(c: Gojo, m: Message):
         user = await m.chat.get_member(m.from_user.id)
 
         if not user.can_invite_users and user.status != "creator":
-            await m.reply_text(tlang(m, "admin.no_user_invite_perm"))
+            await m.reply_text(text="You don't have rights to invite users....")
             return False
 
     try:
         link = await c.export_chat_invite_link(m.chat.id)
         await m.reply_text(
-            (tlang(m, "admin.invitelink")).format(
-                chat_name=m.chat.id,
-                link=link,
-            ),
+            text=f"Invite Link for Chat <b>{m.chat.id}</b>: {link}",
+                
             disable_web_page_preview=True,
         )
         LOGGER.info(f"{m.from_user.id} exported invite link in {m.chat.id}")
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights.")
     except ChatAdminInviteRequired:
-        await m.reply_text(tlang(m, "admin.no_invite_perm"))
+        await m.reply_text(text="I don't have permission for invite link!")
     except RightForbidden:
-        await m.reply_text(tlang(m, "admin.no_user_invite_perm"))
+        await m.reply_text(text="You don't have permissions to invite users.")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text = f"Some error occured, report to @{SUPPORT_GROUP} \n <b>Error:</b> <code>{ef}</code>"
         )
         LOGGER.error(ef)
         LOGGER.error(format_exc())
@@ -756,7 +541,6 @@ __PLUGIN__ = "admin"
 __alt_name__ = [
     "admins",
     "promote",
-    "spromote",
     "demote",
     "adminlist",
     "setgpic",

Powers/plugins/antispam.py

@@ -9,7 +9,6 @@ from Powers import LOGGER, MESSAGE_DUMP, SUPPORT_GROUP, SUPPORT_STAFF
 from Powers.bot_class import Gojo
 from Powers.database.antispam_db import GBan
 from Powers.database.users_db import Users
-from Powers.tr_engine import tlang
 from Powers.utils.clean_file import remove_markdown_and_html
 from Powers.utils.custom_filters import command
 from Powers.utils.extract_user import extract_user
@@ -23,11 +22,11 @@ db = GBan()
 @Gojo.on_message(command(["gban", "globalban"], sudo_cmd=True))
 async def gban(c: Gojo, m: Message):
     if len(m.text.split()) == 1:
-        await m.reply_text(tlang(m, "antispam.gban.how_to"))
+        await m.reply_text(text ="<b>How to gban?</b> \n <b>Answer:</b> <code>/gban user_id reason</code>")
         return
 
     if len(m.text.split()) == 2 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "antispam.gban.enter_reason"))
+        await m.reply_text(text="Please enter a reason to gban user!")
         return
 
     user_id, user_first_name, _ = await extract_user(c, m)
@@ -38,45 +37,33 @@ async def gban(c: Gojo, m: Message):
         gban_reason = m.text.split(None, 2)[2]
 
     if user_id in SUPPORT_STAFF:
-        await m.reply_text(tlang(m, "antispam.part_of_support"))
+        await m.reply_text(text="This user is part of my Support!, Can't ban our own!")
         return
 
     if user_id == Config.BOT_ID:
-        await m.reply_text(tlang(m, "antispam.gban.not_self"))
+        await m.reply_text(text="You don't dare use that command on me again nigga! \n Go straight and fuck your self......")
         return
 
     if db.check_gban(user_id):
         db.update_gban_reason(user_id, gban_reason)
         await m.reply_text(
-            (tlang(m, "antispam.gban.updated_reason")).format(
-                gban_reason=gban_reason,
-            ),
+            text="Updated Gban reason to: <code>{gban_reason}</code>."
         )
         return
 
     db.add_gban(user_id, gban_reason, m.from_user.id)
     await m.reply_text(
-        (tlang(m, "antispam.gban.added_to_watch")).format(
-            first_name=user_first_name,
-        ),
+        (f"Added {user_first_name} to GBan List. \n They will now be banned in all groups where I'm admin!")
     )
     LOGGER.info(f"{m.from_user.id} gbanned {user_id} from {m.chat.id}")
-    log_msg = (tlang(m, "antispam.gban.log_msg")).format(
-        chat_id=m.chat.id,
-        ban_admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
-        gbanned_user=(await mention_html(user_first_name, user_id)),
-        gban_user_id=user_id,
-        time=(datetime.utcnow().strftime("%H:%M - %d-%m-%Y")),
-    )
+    date = (datetime.utcnow().strftime("%H:%M - %d-%m-%Y"))
+    log_msg = f"#GBAN \n <b>Originated from:</b> {m.chat.id} \n <b>Admin:</b> {await mention_html(m.from_user.first_name, m.from_user.id)} \n <b>Gbanned User:</b> {await mention_html(user_first_name, user_id)} \n <b>Gbanned User ID:</b> {user_id} \ n<b>Event Stamp:</b> {date}"
     await c.send_message(MESSAGE_DUMP, log_msg)
     try:
         # Send message to user telling that he's gbanned
         await c.send_message(
             user_id,
-            (tlang(m, "antispam.gban.user_added_to_watch")).format(
-                gban_reason=gban_reason,
-                SUPPORT_GROUP=SUPPORT_GROUP,
-            ),
+            f"You have been added to my global ban list! \n <b>Reason:</b> <code>{gban_reason}</code> \n <b>Appeal Chat:</b> @{SUPPORT_GROUP}"
         )
     except UserIsBlocked:
         LOGGER.error("Could not send PM Message, user blocked bot")
@@ -95,47 +82,46 @@ async def gban(c: Gojo, m: Message):
 )
 async def ungban(c: Gojo, m: Message):
     if len(m.text.split()) == 1:
-        await m.reply_text(tlang(m, "antispam.pass_user_id"))
+        await m.reply_text(text= "Pass a user id or username as an argument!")
         return
 
     user_id, user_first_name, _ = await extract_user(c, m)
 
     if user_id in SUPPORT_STAFF:
-        await m.reply_text(tlang(m, "antispam.part_of_support"))
+        await m.reply_text(text="This user is part of my Support!, Can't ban our own!")
         return
 
     if user_id == Config.BOT_ID:
-        await m.reply_text(tlang(m, "antispam.ungban.not_self"))
+        await m.reply_text(text= """You can't gban me nigga!
+        Fuck yourself.......!""")
         return
 
     if db.check_gban(user_id):
         db.remove_gban(user_id)
         await m.reply_text(
-            (tlang(m, "antispam.ungban.removed_from_list")).format(
-                first_name=user_first_name,
-            ),
+            text=f"Removed {user_first_name} from Global Ban List."
         )
+        time=(datetime.utcnow().strftime("%H:%M - %d-%m-%Y")),
         LOGGER.info(f"{m.from_user.id} ungbanned {user_id} from {m.chat.id}")
-        log_msg = (tlang(m, "amtispam.ungban.log_msg")).format(
-            chat_id=m.chat.id,
-            ungban_admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
-            ungbaned_user=(await mention_html(user_first_name, user_id)),
-            ungbanned_user_id=user_id,
-            time=(datetime.utcnow().strftime("%H:%M - %d-%m-%Y")),
-        )
+        log_msg = (f"""#UNGBAN
+        <b>Originated from:</b> {m.chat.id}
+        <b>Admin:</b> {(await mention_html(m.from_user.first_name, m.from_user.id))}
+        <b>UnGbanned User:</b> {(await mention_html(user_first_name, user_id))}
+        <b>UnGbanned User ID:</b> {user_id}
+        <b>Event Stamp:</b> {time}""")
         await c.send_message(MESSAGE_DUMP, log_msg)
         try:
             # Send message to user telling that he's ungbanned
             await c.send_message(
                 user_id,
-                (tlang(m, "antispam.ungban.user_removed_from_list")),
+                text="You have been removed from my global ban list!.....Be careful it takes few seconds to add you again..."
             )
         except Exception as ef:  # TODO: Improve Error Detection
             LOGGER.error(ef)
             LOGGER.error(format_exc())
         return
 
-    await m.reply_text(tlang(m, "antispam.ungban.non_gbanned"))
+    await m.reply_text(text="User is not gbanned!")
     return
 
 
@@ -144,8 +130,7 @@ async def ungban(c: Gojo, m: Message):
 )
 async def gban_count(_, m: Message):
     await m.reply_text(
-        (tlang(m, "antispam.num_gbans")).format(count=(db.count_gbans())),
-    )
+        text=f"Number of people gbanned: <code>{(db.count_gbans())}</code>")
     LOGGER.info(f"{m.from_user.id} counting gbans in {m.chat.id}")
     return
 
@@ -157,10 +142,10 @@ async def gban_list(_, m: Message):
     banned_users = db.load_from_db()
 
     if not banned_users:
-        await m.reply_text(tlang(m, "antispam.none_gbanned"))
+        await m.reply_text(text="There aren't any gbanned users...!")
         return
 
-    banfile = tlang(m, "antispam.here_gbanned_start")
+    banfile = "Here are all the globally banned geys!\n\n"
     for user in banned_users:
         banfile += f"[x] <b>{Users.get_user_info(user['_id'])['name']}</b> - <code>{user['_id']}</code>\n"
         if user["reason"]:
@@ -173,7 +158,7 @@ async def gban_list(_, m: Message):
             f.name = "gbanlist.txt"
             await m.reply_document(
                 document=f,
-                caption=tlang(m, "antispam.here_gbanned_start"),
+                caption="Here are all the globally banned geys!\n\n"
             )
 
     LOGGER.info(f"{m.from_user.id} exported gbanlist in {m.chat.id}")

Powers/plugins/bans.py

@@ -19,7 +19,6 @@ from pyrogram.types import (
 from Powers import LOGGER, OWNER_ID, SUPPORT_GROUP, SUPPORT_STAFF
 from Powers.bot_class import Gojo
 from Powers.utils.fun_strings import BAN_GIFS, KICK_GIFS
-from Powers.tr_engine import tlang
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
 from Powers.utils.custom_filters import command, restrict_filter
 from Powers.utils.extract_user import extract_user
@@ -34,7 +33,7 @@ KICK_MEDIA = random.choice(KICK_GIFS)
 @Gojo.on_message(command("tban") & restrict_filter)
 async def tban_usr(c: Gojo, m: Message):
     if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "admin.ban.no_target"))
+        await m.reply_text(text="I can't ban nothing!")
         await m.stop_propagation()
 
     try:
@@ -50,7 +49,7 @@ async def tban_usr(c: Gojo, m: Message):
         await m.stop_propagation()
 
     if user_id in SUPPORT_STAFF:
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text="This user is in my support staff, cannot restrict them.")
         LOGGER.info(
             f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
@@ -85,17 +84,18 @@ async def tban_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "ban")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.ban.admin_cannot_ban"))
+        await m.reply_text(text="This user is an admin, I cannot ban them!")
         await m.stop_propagation()
 
     try:
+        admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+        banned=(await mention_html(user_first_name, user_id)),
+        chat_title=m.chat.title,
         LOGGER.info(f"{m.from_user.id} tbanned {user_id} in {m.chat.id}")
-        await m.chat.ban_member(user_id, until_date=int(bantime))
-        txt = (tlang(m, "admin.ban.banned_user")).format(
-            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
-            banned=(await mention_html(user_first_name, user_id)),
-            chat_title=m.chat.title,
+        await m.chat.ban_member(user_id, until_date=int(bantime),
+        text = f"{admin} banned {banned} in <b>{chat_title}</b>!"
         )
+        
         txt += f"\n<b>Reason</b>: {reason}" if reason else ""
         keyboard = InlineKeyboardMarkup(
             [
@@ -110,21 +110,20 @@ async def tban_usr(c: Gojo, m: Message):
         await m.reply_animation(reply_to_message_id = r_id, animation = BAN_MEDIA, caption = txt,  reply_markup=keyboard, parse_mode="html")
        # await m.reply_text(txt, reply_markup=keyboard, reply_to_message_id=r_id)
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights.")
     except PeerIdInvalid:
         await m.reply_text(
             "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
         )
     except UserAdminInvalid:
-        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+        await m.reply_text(text="Cannot act on this user, maybe I wasn't the one who changed their permissions.")
     except RightForbidden:
-        await m.reply_text(tlang(m, tlang(m, "admin.ban.bot_no_right")))
+        await m.reply_text(text="I don't have enough rights to ban this user.")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            (f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>""")
         )
         LOGGER.error(ef)
         LOGGER.error(format_exc())
@@ -134,7 +133,7 @@ async def tban_usr(c: Gojo, m: Message):
 @Gojo.on_message(command("stban") & restrict_filter)
 async def stban_usr(c: Gojo, m: Message):
     if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "admin.ban.no_target"))
+        await m.reply_text(text="I can't ban nothing!")
         await m.stop_propagation()
 
     try:
@@ -150,7 +149,7 @@ async def stban_usr(c: Gojo, m: Message):
         await m.stop_propagation()
 
     if user_id in SUPPORT_STAFF:
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text="This user is in my support staff, cannot restrict them.")
         LOGGER.info(
             f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
@@ -183,7 +182,7 @@ async def stban_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "ban")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.ban.admin_cannot_ban"))
+        await m.reply_text(text="This user is an admin, I cannot ban them!")
         await m.stop_propagation()
 
     try:
@@ -195,21 +194,20 @@ async def stban_usr(c: Gojo, m: Message):
             return
         return
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights.")
     except PeerIdInvalid:
         await m.reply_text(
             "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
         )
     except UserAdminInvalid:
-        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+        await m.reply_text(text="Cannot act on this user, maybe I wasn't the one who changed their permissions.")
     except RightForbidden:
-        await m.reply_text(tlang(m, tlang(m, "admin.ban.bot_no_right")))
+        await m.reply_text(text="I don't have enough rights to ban this user.")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
         LOGGER.error(format_exc())
@@ -219,7 +217,7 @@ async def stban_usr(c: Gojo, m: Message):
 @Gojo.on_message(command("dtban") & restrict_filter)
 async def dtban_usr(c: Gojo, m: Message):
     if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "admin.ban.no_target"))
+        await m.reply_text(text="I can't ban nothing!")
         await m.stop_propagation()
 
     if not m.reply_to_message:
@@ -239,7 +237,7 @@ async def dtban_usr(c: Gojo, m: Message):
         await m.stop_propagation()
 
     if user_id in SUPPORT_STAFF:
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text="I am not going to ban one of my support staff")
         LOGGER.info(
             f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
@@ -272,18 +270,19 @@ async def dtban_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "ban")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.ban.admin_cannot_ban"))
+        await m.reply_text(text="This user is an admin, I cannot ban them!")
         await m.stop_propagation()
 
     try:
+        admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+        banned=(await mention_html(user_first_name, user_id)),
+        chat_title=m.chat.title,
         LOGGER.info(f"{m.from_user.id} dtbanned {user_id} in {m.chat.id}")
         await m.chat.ban_member(user_id, until_date=int(bantime))
         await m.reply_to_message.delete()
-        txt = (tlang(m, "admin.ban.banned_user")).format(
-            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
-            banned=(await mention_html(user_first_name, user_id)),
-            chat_title=m.chat.title,
-        )
+        txt = f"{admin} banned {banned} in <b>{chat_title}</b>!"
+            
+        
         txt += f"\n<b>Reason</b>: {reason}" if reason else ""
         keyboard = InlineKeyboardMarkup(
             [
@@ -298,21 +297,20 @@ async def dtban_usr(c: Gojo, m: Message):
         await c.send_animation(chat_id = m.chat.id, animation = BAN_MEDIA, caption = txt,  reply_markup=keyboard, parse_mode="html")
         # await c.send_message(m.chat.id, txt, reply_markup=keyboard)
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights.")
     except PeerIdInvalid:
         await m.reply_text(
             "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
         )
     except UserAdminInvalid:
-        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+        await m.reply_text(text="Cannot act on this user, maybe I wasn't the one who changed their permissions.")
     except RightForbidden:
-        await m.reply_text(tlang(m, tlang(m, "admin.ban.bot_no_right")))
+        await m.reply_text(text="I don't have enough rights to ban this user.")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
         LOGGER.error(format_exc())
@@ -322,7 +320,7 @@ async def dtban_usr(c: Gojo, m: Message):
 @Gojo.on_message(command("kick") & restrict_filter)
 async def kick_usr(c: Gojo, m: Message):
     if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "admin.kick.no_target"))
+        await m.reply_text(text="I can't kick nothing!")
         return
 
     reason = None
@@ -349,7 +347,7 @@ async def kick_usr(c: Gojo, m: Message):
         await m.stop_propagation()
 
     if user_id in SUPPORT_STAFF:
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text="This user is in my support staff, cannot restrict them.")
         LOGGER.info(
             f"{m.from_user.id} trying to kick {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
@@ -361,37 +359,35 @@ async def kick_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "kick")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.kick.admin_cannot_kick"))
+        await m.reply_text(text="This user is an admin, I cannot kick them!")
         await m.stop_propagation()
 
     try:
+        admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+        kicked=(await mention_html(user_first_name, user_id)),
+        chat_title=m.chat.title,
         LOGGER.info(f"{m.from_user.id} kicked {user_id} in {m.chat.id}")
         await m.chat.ban_member(user_id)
-        txt = (tlang(m, "admin.kick.kicked_user")).format(
-            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
-            kicked=(await mention_html(user_first_name, user_id)),
-            chat_title=m.chat.title,
-        )
+        txt = f"{admin} kicked {kicked} in <b>{chat_title}</b>!"
         txt += f"\n<b>Reason</b>: {reason}" if reason else ""
        # await m.reply_text(txt, reply_to_message_id=r_id)
         await m.reply_animation(reply_to_message_id = r_id, animation = KICK_MEDIA, caption = txt,  parse_mode="html")
         await m.chat.unban_member(user_id)
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights.")
     except PeerIdInvalid:
         await m.reply_text(
             "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
         )
     except UserAdminInvalid:
-        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+        await m.reply_text(text="Cannot act on this user, maybe I wasn't the one who changed their permissions.")
     except RightForbidden:
-        await m.reply_text(tlang(m, "admin.kick.bot_no_right"))
+        await m.reply_text(text="I don't have enough rights to ban this user.")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
         LOGGER.error(format_exc())
@@ -402,7 +398,7 @@ async def kick_usr(c: Gojo, m: Message):
 @Gojo.on_message(command("skick") & restrict_filter)
 async def skick_usr(c: Gojo, m: Message):
     if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "admin.kick.no_target"))
+        await m.reply_text(text="I can't kick nothing!")
         return
 
     try:
@@ -419,7 +415,7 @@ async def skick_usr(c: Gojo, m: Message):
         await m.stop_propagation()
 
     if user_id in SUPPORT_STAFF:
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text="This user is in my support staff, cannot restrict them.")
         LOGGER.info(
             f"{m.from_user.id} trying to skick {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
@@ -431,7 +427,7 @@ async def skick_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "kick")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.kick.admin_cannot_kick"))
+        await m.reply_text(text="This user is an admin, I cannot kick them!")
         await m.stop_propagation()
 
     try:
@@ -442,21 +438,20 @@ async def skick_usr(c: Gojo, m: Message):
             await m.reply_to_message.delete()
         await m.chat.unban_member(user_id)
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights.")
     except PeerIdInvalid:
         await m.reply_text(
             "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
         )
     except UserAdminInvalid:
-        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+        await m.reply_text(text="Cannot act on this user, maybe I wasn't the one who changed their permissions.")
     except RightForbidden:
-        await m.reply_text(tlang(m, "admin.kick.bot_no_right"))
+        await m.reply_text(text="I don't have enough rights to kick this user.")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
         LOGGER.error(format_exc())
@@ -467,7 +462,7 @@ async def skick_usr(c: Gojo, m: Message):
 @Gojo.on_message(command("dkick") & restrict_filter)
 async def dkick_usr(c: Gojo, m: Message):
     if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "admin.kick.no_target"))
+        await m.reply_text(text="I can't ban nothing!")
         return
     if not m.reply_to_message:
         return await m.reply_text("Reply to a message to delete it and kick the user!")
@@ -486,7 +481,7 @@ async def dkick_usr(c: Gojo, m: Message):
         await m.stop_propagation()
 
     if user_id in SUPPORT_STAFF:
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text="This user is in my support staff, cannot restrict them.")
         LOGGER.info(
             f"{m.from_user.id} trying to dkick {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
@@ -498,38 +493,36 @@ async def dkick_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "kick")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.kick.admin_cannot_kick"))
+        await m.reply_text(text="This user is an admin, I cannot kick them!")
         await m.stop_propagation()
 
     try:
         LOGGER.info(f"{m.from_user.id} dkicked {user_id} in {m.chat.id}")
         await m.reply_to_message.delete()
         await m.chat.ban_member(user_id)
-        txt = (tlang(m, "admin.kick.kicked_user")).format(
-            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
-            kicked=(await mention_html(user_first_name, user_id)),
-            chat_title=m.chat.title,
-        )
+        admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+        kicked=(await mention_html(user_first_name, user_id)),
+        chat_title=m.chat.title,
+        txt = f"{admin} kicked {kicked} in <b>{chat_title}</b>!"
         txt += f"\n<b>Reason</b>: {reason}" if reason else ""
         await c.send_message(m.chat.id, txt)
         await c.send_animation(chat_id = m.chat.id, animation = KICK_MEDIA, caption = txt,  parse_mode="html")
         await m.chat.unban_member(user_id)
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights.")
     except PeerIdInvalid:
         await m.reply_text(
             "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
         )
     except UserAdminInvalid:
-        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+        await m.reply_text(text="Cannot act on this user, maybe I wasn't the one who changed their permissions.")
     except RightForbidden:
-        await m.reply_text(tlang(m, "admin.kick.bot_no_right"))
+        await m.reply_text(text="I don't have enough rights to kick this user.")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
         LOGGER.error(format_exc())
@@ -540,7 +533,7 @@ async def dkick_usr(c: Gojo, m: Message):
 @Gojo.on_message(command("unban") & restrict_filter)
 async def unban_usr(c: Gojo, m: Message):
     if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "admin.unban.no_target"))
+        await m.reply_text(text="I can't unban nothing!")
         await m.stop_propagation()
 
     if m.reply_to_message and not m.reply_to_message.from_user:
@@ -563,23 +556,21 @@ async def unban_usr(c: Gojo, m: Message):
 
     try:
         await m.chat.unban_member(user_id)
-        txt = (tlang(m, "admin.unban.unbanned_user")).format(
-            admin=m.from_user.mention,
-            unbanned=(await mention_html(user_first_name, user_id)),
-            chat_title=m.chat.title,
-        )
+        admin=m.from_user.mention,
+        unbanned=(await mention_html(user_first_name, user_id)),
+        chat_title=m.chat.title,
+        txt = f"{admin} unbanned {unbanned} in chat <b>{chat_title}</b>!"
         txt += f"\n<b>Reason</b>: {reason}" if reason else ""
         await m.reply_text(txt)
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights.")
     except RightForbidden:
-        await m.reply_text(tlang(m, tlang(m, "admin.unban.bot_no_right")))
+        await m.reply_text(text="I don't have enough rights to unban this user.")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+           text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
         LOGGER.error(format_exc())
@@ -590,7 +581,7 @@ async def unban_usr(c: Gojo, m: Message):
 @Gojo.on_message(command("sban") & restrict_filter)
 async def sban_usr(c: Gojo, m: Message):
     if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "admin.ban.no_target"))
+        await m.reply_text(text="I can't ban nothing!")
         await m.stop_propagation()
 
     if m.reply_to_message and not m.reply_to_message.from_user:
@@ -612,7 +603,7 @@ async def sban_usr(c: Gojo, m: Message):
         await m.stop_propagation()
 
     if user_id in SUPPORT_STAFF:
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text="This user is in my support staff, cannot restrict them.")
         LOGGER.info(
             f"{m.from_user.id} trying to sban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
@@ -624,7 +615,7 @@ async def sban_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "ban")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.ban.admin_cannot_ban"))
+        await m.reply_text(text="This user is an admin, I cannot ban them!")
         await m.stop_propagation()
 
     try:
@@ -634,21 +625,20 @@ async def sban_usr(c: Gojo, m: Message):
         if m.reply_to_message:
             await m.reply_to_message.delete()
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights.")
     except PeerIdInvalid:
         await m.reply_text(
             "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
         )
     except UserAdminInvalid:
-        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+        await m.reply_text(text="Cannot act on this user, maybe I wasn't the one who changed their permissions.")
     except RightForbidden:
-        await m.reply_text(tlang(m, tlang(m, "admin.ban.bot_no_right")))
+        await m.reply_text(text="I don't have enough rights to ban this user.")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
         LOGGER.error(format_exc())
@@ -658,7 +648,7 @@ async def sban_usr(c: Gojo, m: Message):
 @Gojo.on_message(command("dban") & restrict_filter)
 async def dban_usr(c: Gojo, m: Message):
     if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "admin.ban.no_target"))
+        await m.reply_text(text="I can't ban nothing!")
         await m.stop_propagation()
 
     if not m.reply_to_message:
@@ -686,7 +676,7 @@ async def dban_usr(c: Gojo, m: Message):
         await m.stop_propagation()
 
     if user_id in SUPPORT_STAFF:
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text="This user is in my support staff, cannot restrict them.")
         LOGGER.info(
             f"{m.from_user.id} trying to dban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
@@ -698,7 +688,7 @@ async def dban_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "ban")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.ban.admin_cannot_ban"))
+        await m.reply_text(text="This user is an admin, I cannot ban them!")
         await m.stop_propagation()
 
     reason = None
@@ -709,11 +699,7 @@ async def dban_usr(c: Gojo, m: Message):
         LOGGER.info(f"{m.from_user.id} dbanned {user_id} in {m.chat.id}")
         await m.reply_to_message.delete()
         await m.chat.ban_member(user_id)
-        txt = (tlang(m, "admin.ban.banned_user")).format(
-            admin=m.from_user.mention,
-            banned=m.reply_to_message.from_user.mention,
-            chat_title=m.chat.title,
-        )
+        txt =f"{m.from_user.mention} banned {m.reply_to_message.from_user.mention} in <b>{m.chat.title}</b>!"
         txt += f"\n<b>Reason</b>: {reason}" if reason else ""
         keyboard = InlineKeyboardMarkup(
             [
@@ -727,21 +713,20 @@ async def dban_usr(c: Gojo, m: Message):
         )
         await c.send_message(m.chat.id, txt, reply_markup=keyboard)
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights.")
     except PeerIdInvalid:
         await m.reply_text(
             "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
         )
     except UserAdminInvalid:
-        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+        await m.reply_text(text="Cannot act on this user, maybe I wasn't the one who changed their permissions.")
     except RightForbidden:
-        await m.reply_text(tlang(m, tlang(m, "admin.ban.bot_no_right")))
+        await m.reply_text(text="I don't have enough rights to ban this user.")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
         LOGGER.error(format_exc())
@@ -751,7 +736,7 @@ async def dban_usr(c: Gojo, m: Message):
 @Gojo.on_message(command("ban") & restrict_filter)
 async def ban_usr(c: Gojo, m: Message):
     if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text(tlang(m, "admin.ban.no_target"))
+        await m.reply_text(text="I can't ban nothing!")
         await m.stop_propagation()
 
     if m.reply_to_message and not m.reply_to_message.from_user:
@@ -776,7 +761,7 @@ async def ban_usr(c: Gojo, m: Message):
         await m.stop_propagation()
 
     if user_id in SUPPORT_STAFF:
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text="This user is in my support staff, cannot restrict them.")
         LOGGER.info(
             f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
@@ -788,7 +773,7 @@ async def ban_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "ban")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.ban.admin_cannot_ban"))
+        await m.reply_text(text="This user is an admin, I cannot ban them!")
         await m.stop_propagation()
 
     reason = None
@@ -804,11 +789,8 @@ async def ban_usr(c: Gojo, m: Message):
     try:
         LOGGER.info(f"{m.from_user.id} banned {user_id} in {m.chat.id}")
         await m.chat.ban_member(user_id)
-        txt = (tlang(m, "admin.ban.banned_user")).format(
-            admin=m.from_user.mention,
-            banned=(await mention_html(user_first_name, user_id)),
-            chat_title=m.chat.title,
-        )
+        banned=(await mention_html(user_first_name, user_id))
+        txt = f"{m.from_user.mention} banned {banned} in <b>{m.chat.title}</b>!"
         txt += f"\n<b>Reason</b>: {reason}" if reason else ""
         keyboard = InlineKeyboardMarkup(
             [
@@ -822,21 +804,20 @@ async def ban_usr(c: Gojo, m: Message):
         )
         await m.reply_text(txt, reply_markup=keyboard, reply_to_message_id=r_id)
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights.")
     except PeerIdInvalid:
         await m.reply_text(
             "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
         )
     except UserAdminInvalid:
-        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+        await m.reply_text(text="Cannot act on this user, maybe I wasn't the one who changed their permissions.")
     except RightForbidden:
-        await m.reply_text(tlang(m, tlang(m, "admin.ban.bot_no_right")))
+        await m.reply_text(text="I don't have enough rights to ban this user.")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
         LOGGER.error(format_exc())
@@ -876,14 +857,13 @@ async def kickme(_, m: Message):
         await m.chat.ban_member(m.from_user.id)
         txt = "Why not let me help you!"
         txt += f"\n<b>Reason</b>: {reason}" if reason else ""
-        await m.reply_text(txt)
+        await m.reply_animation(animation=KICK_MEDIA, caption=txt)
         await m.chat.unban_member(m.from_user.id)
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
     return
 

Powers/plugins/blacklist.py

@@ -6,7 +6,6 @@ from pyrogram.types import CallbackQuery, Message
 from Powers import LOGGER
 from Powers.bot_class import Gojo
 from Powers.database.blacklist_db import Blacklist
-from Powers.tr_engine import tlang
 from Powers.utils.custom_filters import command, owner_filter, restrict_filter
 from Powers.utils.kbhelpers import ikb
 
@@ -18,16 +17,12 @@ async def view_blacklist(_, m: Message):
     LOGGER.info(f"{m.from_user.id} checking blacklists in {m.chat.id}")
 
     chat_title = m.chat.title
-    blacklists_chat = (tlang(m, "blacklist.curr_blacklist_initial")).format(
-        chat_title=chat_title,
-    )
+    blacklists_chat = f"Current Blacklisted words in <b>{chat_title}</b>:\n\n"
     all_blacklisted = db.get_blacklists()
 
     if not all_blacklisted:
         await m.reply_text(
-            (tlang(m, "blacklist.no_blacklist")).format(
-                chat_title=chat_title,
-            ),
+            text=f"There are no blacklisted messages in <b>{chat_title}</b>!"
         )
         return
 
@@ -44,7 +39,7 @@ async def add_blacklist(_, m: Message):
     db = Blacklist(m.chat.id)
 
     if len(m.text.split()) < 2:
-        await m.reply_text(tlang(m, "general.check_help"))
+        await m.reply_text(text="Please check help on how to use this this command.")
         return
 
     bl_words = ((m.text.split(None, 1)[1]).lower()).split()
@@ -63,11 +58,9 @@ async def add_blacklist(_, m: Message):
             + " already added in blacklist, skipped them!"
         )
     LOGGER.info(f"{m.from_user.id} added new blacklists ({bl_words}) in {m.chat.id}")
+    trigger=", ".join(f"<code>{i}</code>" for i in bl_words)
     await m.reply_text(
-        (tlang(m, "blacklist.added_blacklist")).format(
-            trigger=", ".join(f"<code>{i}</code>" for i in bl_words),
-        )
-        + (f"\n{rep_text}" if rep_text else ""),
+        text=f"Added <code>{trigger}</code> in blacklist words!" + (f"\n{rep_text}" if rep_text else ""),
     )
 
     await m.stop_propagation()
@@ -100,7 +93,7 @@ async def rm_blacklist(_, m: Message):
     db = Blacklist(m.chat.id)
 
     if len(m.text.split()) < 2:
-        await m.reply_text(tlang(m, "general.check_help"))
+        await m.reply_text(text="Please check help on how to use this this command.")
         return
 
     chat_bl = db.get_blacklists()
@@ -122,11 +115,9 @@ async def rm_blacklist(_, m: Message):
         ) + " in blcklisted words, skipped them."
 
     LOGGER.info(f"{m.from_user.id} removed blacklists ({bl_words}) in {m.chat.id}")
+    bl_words=", ".join(f"<code>{i}</code>" for i in bl_words)
     await m.reply_text(
-        (tlang(m, "blacklist.rm_blacklist")).format(
-            bl_words=", ".join(f"<code>{i}</code>" for i in bl_words),
-        )
-        + (f"\n{rep_text}" if rep_text else ""),
+        text=f"Removed <b>{bl_words}</b> from blacklist words!" + (f"\n{rep_text}" if rep_text else ""),
     )
 
     await m.stop_propagation()
@@ -155,16 +146,17 @@ async def set_bl_action(_, m: Message):
             f"{m.from_user.id} set blacklist action to '{action}' in {m.chat.id}",
         )
         await m.reply_text(
-            (tlang(m, "blacklist.action_set")).format(action=action),
+            text=f"Set action for blacklist for this to <b>{action}</b>"
         )
     elif len(m.text.split()) == 1:
         action = db.get_action()
         LOGGER.info(f"{m.from_user.id} checking blacklist action in {m.chat.id}")
         await m.reply_text(
-            (tlang(m, "blacklist.action_get")).format(action=action),
+           text= f"""The current action for blacklists in this chat is <i><b>{action}</b></i>
+      All blacklist modes delete the message containing blacklist word."""
         )
     else:
-        await m.reply_text(tlang(m, "general.check_help"))
+        await m.reply_text(text="Please check help on how to use this this command.")
 
     return
 

Powers/plugins/dev.py

@@ -14,12 +14,11 @@ from pyrogram.errors import (
     RPCError,
 )
 from pyrogram.types import Message
-from speedtest import Speedtest
+
 
 from Powers import LOGFILE, LOGGER, MESSAGE_DUMP, UPTIME
 from Powers.bot_class import Gojo
 from Powers.database.chats_db import Chats
-from Powers.tr_engine import tlang
 from Powers.utils.clean_file import remove_markdown_and_html
 from Powers.utils.custom_filters import command
 from Powers.utils.http_helper import HTTPx
@@ -32,7 +31,7 @@ from Powers.vars import Config
 async def ping(_, m: Message):
     LOGGER.info(f"{m.from_user.id} used ping cmd in {m.chat.id}")
     start = time()
-    replymsg = await m.reply_text((tlang(m, "utils.ping.pinging")), quote=True)
+    replymsg = await m.reply_text(text="Pinging...", quote=True)
     delta_ping = time() - start
     await replymsg.edit_text(f"<b>Pong!</b>\n{delta_ping * 1000:.3f} ms")
     return
@@ -78,29 +77,6 @@ async def group_info(c: Gojo, m: Message):
     await replymsg.edit_text(msg)
     return
 
-
-@Gojo.on_message(command("speedtest", dev_cmd=True))
-async def test_speed(c: Gojo, m: Message):
-    await c.send_message(
-        MESSAGE_DUMP,
-        f"#SPEEDTEST\n\n**User:** {(await mention_markdown(m.from_user.first_name, m.from_user.id))}",
-    )
-    sent = await m.reply_text(tlang(m, "dev.speedtest.start_speedtest"))
-    s = Speedtest()
-    bs = s.get_best_server()
-    dl = round(s.download() / 1024 / 1024, 2)
-    ul = round(s.upload() / 1024 / 1024, 2)
-    await sent.edit_text(
-        (tlang(m, "dev.speedtest.speedtest_txt")).format(
-            host=bs["sponsor"],
-            ping=int(bs["latency"]),
-            download=dl,
-            upload=ul,
-        ),
-    )
-    return
-
-
 @Gojo.on_message(command("neofetch", dev_cmd=True))
 async def neofetch_stats(_, m: Message):
     cmd = "neofetch --stdout"
@@ -131,7 +107,7 @@ async def neofetch_stats(_, m: Message):
 @Gojo.on_message(command(["eval", "py"], dev_cmd=True))
 async def evaluate_code(c: Gojo, m: Message):
     if len(m.text.split()) == 1:
-        await m.reply_text(tlang(m, "dev.execute_cmd_err"))
+        await m.reply_text(text="Please execute the code correctly!")
         return
     sm = await m.reply_text("`Processing...`")
     cmd = m.text.split(None, maxsplit=1)[1]
@@ -193,7 +169,7 @@ async def aexec(code, c, m):
 @Gojo.on_message(command(["exec", "sh"], dev_cmd=True))
 async def execution(_, m: Message):
     if len(m.text.split()) == 1:
-        await m.reply_text(tlang(m, "dev.execute_cmd_err"))
+        await m.reply_text(text="Please execute the code correctly!")
         return
     sm = await m.reply_text("`Processing...`")
     cmd = m.text.split(maxsplit=1)[1]
@@ -243,7 +219,8 @@ async def public_ip(c: Gojo, m: Message):
         f"#IP\n\n**User:** {(await mention_markdown(m.from_user.first_name, m.from_user.id))}",
     )
     await m.reply_text(
-        (tlang(m, "dev.bot_ip")).format(ip=f"<code>{ip.text}</code>"),
+        text=f"""<b>Bot IP Address:</b>
+      <code>{ip.text}</code>""",
         quote=True,
     )
     return
@@ -251,13 +228,15 @@ async def public_ip(c: Gojo, m: Message):
 
 @Gojo.on_message(command("chatlist", dev_cmd=True))
 async def chats(c: Gojo, m: Message):
-    exmsg = await m.reply_text(tlang(m, "dev.chatlist.exporting"))
+    exmsg = await m.reply_text(text="Exporting Charlist...")
     await c.send_message(
         MESSAGE_DUMP,
         f"#CHATLIST\n\n**User:** {(await mention_markdown(m.from_user.first_name, m.from_user.id))}",
     )
     all_chats = (Chats.list_chats_full()) or {}
-    chatfile = tlang(m, "dev.chatlist.header")
+    chatfile = """List of chats in my database.
+
+        <b>Chat name | Chat ID | Members count</b>"""
     P = 1
     for chat in all_chats:
         try:
@@ -287,7 +266,7 @@ async def chats(c: Gojo, m: Message):
         f.name = "chatlist.txt"
         await m.reply_document(
             document=f,
-            caption=(tlang(m, "dev.chatlist.chats_in_db")),
+            caption="Here is the list of chats in my Database.",
         )
     await exmsg.delete()
     return
@@ -296,7 +275,7 @@ async def chats(c: Gojo, m: Message):
 @Gojo.on_message(command("uptime", dev_cmd=True))
 async def uptime(_, m: Message):
     up = strftime("%Hh %Mm %Ss", gmtime(time() - UPTIME))
-    await m.reply_text((tlang(m, "dev.uptime")).format(uptime=up), quote=True)
+    await m.reply_text(text=f"<b>Uptime:</b> <code>{up}</code>", quote=True)
     return
 
 

Powers/plugins/formatting.py

@@ -3,7 +3,6 @@ from pyrogram.types import CallbackQuery, Message
 
 from Powers import LOGGER
 from Powers.bot_class import Gojo
-from Powers.tr_engine import tlang
 from Powers.utils.custom_filters import command
 from Powers.utils.kbhelpers import ikb
 
@@ -16,7 +15,7 @@ async def gen_formatting_kb(m):
                 ("Fillings", "formatting.fillings"),
             ],
             [("Random Content", "formatting.random_content")],
-            [(("« " + (tlang(m, "general.back_btn"))), "commands")],
+            [("« " + "Back", "commands")],
         ],
     )
 
@@ -26,7 +25,7 @@ async def gen_formatting_kb(m):
 )
 async def markdownhelp(_, m: Message):
     await m.reply_text(
-        tlang(m, f"plugins.{__PLUGIN__}.help"),
+        text=f"plugins.{__PLUGIN__}.help",
         quote=True,
         reply_markup=(await gen_formatting_kb(m)),
     )
@@ -37,23 +36,74 @@ async def markdownhelp(_, m: Message):
 @Gojo.on_callback_query(filters.regex("^formatting."))
 async def get_formatting_info(_, q: CallbackQuery):
     cmd = q.data.split(".")[1]
-    kb = ikb([[((tlang(q, "general.back_btn")), "back.formatting")]])
+    kb = ikb([[("Back", "back.formatting")]])
 
     if cmd == "md_formatting":
         await q.message.edit_text(
-            tlang(q, "formatting.md_help"),
+            text="""<b>Markdown Formatting</b>
+      You can format your message using <b>bold</b>, <i>italic</i>, <u>underline</u>, <strike>strike</strike> and much more. Go ahead and experiment!
+
+      **Note**: It supports telegram user based formatting as well as html and markdown formattings.
+      <b>Supported markdown</b>:
+      - <code>`code words`</code>: Backticks are used for monospace fonts. Shows as: <code>code words</code>.
+      - <code>__italic__</code>: Underscores are used for italic fonts. Shows as: <i>italic words</i>.
+      - <code>**bold**</code>: Asterisks are used for bold fonts. Shows as: <b>bold words</b>.
+      - <code>```pre```</code>: To make the formatter ignore other formatting characters inside the text formatted with '```', like: <code>**bold** | *bold*</code>.
+      - <code>--underline--</code>: To make text <u>underline</u>.
+      - <code>~~strike~~</code>: Tildes are used for strikethrough. Shows as: <strike>strike</strike>.
+      - <code>||spoiler||</code>: Double vertical bars are used for spoilers. Shows as: <spoiler>Spoiler</spoiler>.
+      - <code>[hyperlink](example.com)</code>: This is the formatting used for hyperlinks. Shows as: <a href="https://example.com/">hyperlink</a>.
+      - <code>[My Button](buttonurl://example.com)</code>: This is the formatting used for creating buttons. This example will create a button named "My button" which opens <code>example.com</code> when clicked.
+      If you would like to send buttons on the same row, use the <code>:same</code> formatting.
+      <b>Example:</b>
+      <code>[button 1](buttonurl:example.com)</code>
+      <code>[button 2](buttonurl://example.com:same)</code>
+      <code>[button 3](buttonurl://example.com)</code>
+      This will show button 1 and 2 on the same line, while 3 will be underneath.""",
             reply_markup=kb,
             parse_mode="html",
         )
     elif cmd == "fillings":
         await q.message.edit_text(
-            tlang(q, "formatting.filling_help"),
+            text="""<b>Fillings</b>
+
+      You can also customise the contents of your message with contextual data. For example, you could mention a user by name in the welcome message, or mention them in a filter!
+      You can use these to mention a user in notes too!
+
+      <b>Supported fillings:</b>
+      - <code>{first}</code>: The user's first name.
+      - <code>{last}</code>: The user's last name.
+      - <code>{fullname}</code>: The user's full name.
+      - <code>{username}</code>: The user's username. If they don't have one, mentions the user instead.
+      - <code>{mention}</code>: Mentions the user with their firstname.
+      - <code>{id}</code>: The user's ID.
+      - <code>{chatname}</code>: The chat's name.""",
             reply_markup=kb,
             parse_mode="html",
         )
     elif cmd == "random_content":
         await q.message.edit_text(
-            tlang(q, "formatting.random_help"),
+            text="""<b>Random Content</b>
+
+      Another thing that can be fun, is to randomise the contents of a message. Make things a little more personal by changing welcome messages, or changing notes!
+
+      How to use random contents:
+      - %%%: This separator can be used to add "random" replies to the bot.
+      For example:
+      <code>hello
+      %%%
+      how are you</code>
+      This will randomly choose between sending the first message, "hello", or the second message, "how are you".
+      Use this to make Alita feel a bit more customised! (only works in filters/notes)
+
+      Example welcome message::
+      - Every time a new user joins, they'll be presented with one of the three messages shown here.
+      -> /filter "hey"
+      hello there <code>{first}</code>!
+      %%%
+      Ooooh, <code>{first}</code> how are you?
+      %%%
+      Sup? <code>{first}</code>""",
             reply_markup=kb,
             parse_mode="html",
         )
@@ -65,7 +115,9 @@ async def get_formatting_info(_, q: CallbackQuery):
 @Gojo.on_callback_query(filters.regex("^back."))
 async def send_mod_help(_, q: CallbackQuery):
     await q.message.edit_text(
-        (tlang(q, "plugins.formatting.help")),
+        text="""Formatting
+
+        Alita supports a large number of formatting options to make your messages more expressive. Take a look by clicking the buttons below!""",
         reply_markup=(await gen_formatting_kb(q.message)),
     )
     await q.answer()

Powers/plugins/fun.py

@@ -7,7 +7,6 @@ from pyrogram.types import Message
 
 from Powers import LOGGER, DEV_USERS
 from Powers.bot_class import Gojo
-from Powers.tr_engine import tlang
 from Powers.utils import fun_strings
 from Powers.utils.custom_filters import command
 from Powers.utils.extract_user import extract_user
@@ -18,7 +17,7 @@ from Powers.utils.extract_user import extract_user
 async def fun_shout(_, m: Message):
     if len(m.text.split()) == 1:
         await m.reply_text(
-            (tlang(m, "general.check_help")),
+            text="Please check help on how to use this this command.",
             quote=True,
         )
         return
@@ -157,7 +156,7 @@ async def weebify(_, m: Message):
         )
         return
     if not args:
-        await m.reply_text(tlang(m, "utils.weebify.weebify_what"))
+        await m.reply_text(text="What am I supposed to Weebify?")
         return
 
     # Use split to convert to list
@@ -172,7 +171,8 @@ async def weebify(_, m: Message):
             string = string.replace(normiecharacter, weebycharacter)
 
     await m.reply_text(
-        (tlang(m, "utils.weebify.weebified_string").format(string=string)),
+       text=f"""<b>Weebified String:</b>
+        <code>{string}</code>"""
     )
     LOGGER.info(f"{m.from_user.id} weebified '{args}' in {m.chat.id}")
     return

Powers/plugins/initial.py

@@ -10,7 +10,6 @@ from Powers.database.chats_db import Chats
 from Powers.database.disable_db import Disabling
 from Powers.database.filters_db import Filters
 from Powers.database.greetings_db import Greetings
-from Powers.database.lang_db import Langs
 from Powers.database.notes_db import Notes, NotesSettings
 from Powers.database.pins_db import Pins
 from Powers.database.reporting_db import Reporting
@@ -85,7 +84,6 @@ async def initial_works(_, m: Message):
 
 async def migrate_chat(m: Message, new_chat: int) -> None:
     LOGGER.info(f"Migrating from {m.chat.id} to {new_chat}...")
-    langdb = Langs(m.chat.id)
     notedb = Notes()
     gdb = Greetings(m.chat.id)
     ruledb = Rules(m.chat.id)
@@ -102,7 +100,6 @@ async def migrate_chat(m: Message, new_chat: int) -> None:
     gdb.migrate_chat(new_chat)
     chatdb.migrate_chat(new_chat)
     userdb.migrate_chat(new_chat)
-    langdb.migrate_chat(new_chat)
     ruledb.migrate_chat(new_chat)
     bldb.migrate_chat(new_chat)
     notedb.migrate_chat(m.chat.id, new_chat)

Powers/plugins/langs.py

@@ -6,7 +6,6 @@ from pyrogram.types import CallbackQuery, Message
 from Powers import LOGGER
 from Powers.bot_class import Gojo
 from Powers.database.lang_db import Langs
-from Powers.tr_engine import lang_dict, tlang
 from Powers.utils.custom_filters import admin_filter, command
 from Powers.utils.kbhelpers import ikb
 

Powers/plugins/locks.py

@@ -6,7 +6,6 @@ from pyrogram.types import ChatPermissions, Message
 from Powers import LOGGER
 from Powers.bot_class import Gojo
 from Powers.database.approve_db import Approve
-from Powers.tr_engine import tlang
 from Powers.utils.custom_filters import command, restrict_filter
 
 
@@ -41,7 +40,7 @@ async def lock_perm(c: Gojo, m: Message):
     chat_id = m.chat.id
 
     if not lock_type:
-        await m.reply_text(tlang(m, "locks.locks_perm_sp"))
+        await m.reply_text(text="Specify a permission to lock!")
         return
 
     get_perm = m.chat.permissions
@@ -62,8 +61,8 @@ async def lock_perm(c: Gojo, m: Message):
         except ChatNotModified:
             pass
         except ChatAdminRequired:
-            await m.reply_text(tlang(m, "general.no_perm_admin"))
-        await m.reply_text("🔒 " + (tlang(m, "locks.lock_all")))
+            await m.reply_text(text="I don't have permission to do that")
+        await m.reply_text("🔒 " + "Locked <b>all</b> permission from this Chat!")
         await prevent_approved(m)
         return
 
@@ -112,7 +111,9 @@ async def lock_perm(c: Gojo, m: Message):
         perm = "pin"
 
     else:
-        await m.reply_text(tlang(m, "locks.invalid_lock"))
+        await m.reply_text(text=""" Invalid Lock Type!
+
+      Use /locktypes to get the lock types""")
         return
 
     try:
@@ -133,9 +134,9 @@ async def lock_perm(c: Gojo, m: Message):
     except ChatNotModified:
         pass
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "general.no_perm_admin"))
+        await m.reply_text(text="I don't have permission to do that")
     await m.reply_text(
-        "🔒 " + (tlang(m, "locks.locked_perm").format(perm=perm)),
+        "🔒 " + f"Locked <b>{perm}</b> for this Chat.",
     )
     await prevent_approved(m)
     return
@@ -143,7 +144,7 @@ async def lock_perm(c: Gojo, m: Message):
 
 @Gojo.on_message(command("locks") & restrict_filter)
 async def view_locks(_, m: Message):
-    chkmsg = await m.reply_text(tlang(m, "locks.check_perm_msg"))
+    chkmsg = await m.reply_text(text="Checking Chat permissions...")
     v_perm = m.chat.permissions
 
     async def convert_to_emoji(val: bool):
@@ -162,21 +163,24 @@ async def view_locks(_, m: Message):
 
     if v_perm is not None:
         try:
-            permission_view_str = (tlang(m, "locks.view_perm")).format(
-                vmsg=vmsg,
-                vmedia=vmedia,
-                vother=vother,
-                vwebprev=vwebprev,
-                vpolls=vpolls,
-                vinfo=vinfo,
-                vinvite=vinvite,
-                vpin=vpin,
-            )
+            permission_view_str = f"""<b>Chat Permissions:</b>
+
+      <b>Send Messages:</b> {vmsg}
+      <b>Send Media:</b> {vmedia}
+      <b>Send Stickers:</b> {vother}
+      <b>Send Animations:</b> {vother}
+      <b>Can Play Games:</b> {vother}
+      <b>Can Use Inline Bots:</b> {vother}
+      <b>Webpage Preview:</b> {vwebprev}
+      <b>Send Polls:</b> {vpolls}
+      <b>Change Info:</b> {vinfo}
+      <b>Invite Users:</b> {vinvite}
+      <b>Pin Messages:</b> {vpin}"""
             LOGGER.info(f"{m.from_user.id} used locks cmd in {m.chat.id}")
             await chkmsg.edit_text(permission_view_str)
 
         except RPCError as e_f:
-            await chkmsg.edit_text(tlang(m, "general.something_wrong"))
+            await chkmsg.edit_text(text="Something went wrong!")
             await m.reply_text(e_f)
     return
 
@@ -190,7 +194,7 @@ async def unlock_perm(c: Gojo, m: Message):
     chat_id = m.chat.id
 
     if not unlock_type:
-        await m.reply_text(tlang(m, "locks.unlocks_perm_sp"))
+        await m.reply_text(text="Specify a permission to unlock!")
         return
 
     if unlock_type == "all":
@@ -212,8 +216,8 @@ async def unlock_perm(c: Gojo, m: Message):
         except ChatNotModified:
             pass
         except ChatAdminRequired:
-            await m.reply_text(tlang(m, "general.no_perm_admin"))
-        await m.reply_text("🔓 " + (tlang(m, "locks.unlock_all")))
+            await m.reply_text(text="I don't have permission to do that")
+        await m.reply_text("🔓 " + "Unlocked <b>all</b> permission from this Chat!")
         await prevent_approved(m)
         return
 
@@ -273,7 +277,9 @@ async def unlock_perm(c: Gojo, m: Message):
         uperm = "pin"
 
     else:
-        await m.reply_text(tlang(m, "locks.invalid_lock"))
+        await m.reply_text(text="""Invalid Lock Type!
+
+      Use /locktypes to get the lock types""")
         return
 
     try:
@@ -296,9 +302,9 @@ async def unlock_perm(c: Gojo, m: Message):
     except ChatNotModified:
         pass
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "general.no_perm_admin"))
+        await m.reply_text(text="I don't have permission to do that")
     await m.reply_text(
-        "🔓 " + (tlang(m, "locks.unlocked_perm").format(uperm=uperm)),
+        "🔓 " + f"Unlocked <b>{uperm}</b> for this Chat.",
     )
     await prevent_approved(m)
     return

Powers/plugins/muting.py

@@ -15,7 +15,6 @@ from pyrogram.types import (
 
 from Powers import LOGGER, OWNER_ID, SUPPORT_GROUP, SUPPORT_STAFF
 from Powers.bot_class import Gojo
-from Powers.tr_engine import tlang
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
 from Powers.utils.custom_filters import command, restrict_filter
 from Powers.utils.extract_user import extract_user
@@ -46,7 +45,7 @@ async def tmute_usr(c: Gojo, m: Message):
         LOGGER.info(
             f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text="This user is in my support staff, cannot restrict them.")
         return
 
     try:
@@ -55,7 +54,7 @@ async def tmute_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "mute")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.mute.admin_cannot_mute"))
+        await m.reply_text(text="This user is an admin, I cannot mute them!")
         return
 
     r_id = m.reply_to_message.message_id if m.reply_to_message else m.message_id
@@ -89,10 +88,9 @@ async def tmute_usr(c: Gojo, m: Message):
             mutetime,
         )
         LOGGER.info(f"{m.from_user.id} tmuted {user_id} in {m.chat.id}")
-        txt = (tlang(m, "admin.mute.muted_user")).format(
-            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
-            muted=(await mention_html(user_first_name, user_id)),
-        )
+        admin=(await mention_html(m.from_user.first_name, m.from_user.id))
+        muted=(await mention_html(user_first_name, user_id))
+        txt =f"Admin {admin} muted {muted}!"
         if reason:
             txt += f"\n<b>Reason</b>: {reason}"
         keyboard = InlineKeyboardMarkup(
@@ -107,17 +105,16 @@ async def tmute_usr(c: Gojo, m: Message):
         )
         await m.reply_text(txt, reply_markup=keyboard, reply_to_message_id=r_id)
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights.")
     except RightForbidden:
-        await m.reply_text(tlang(m, "admin.mute.bot_no_right"))
+        await m.reply_text(text="I don't have enough rights to ban this user.")
     except UserNotParticipant:
         await m.reply_text("How can I mute a user who is not a part of this chat?")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
 
@@ -148,7 +145,7 @@ async def dtmute_usr(c: Gojo, m: Message):
         LOGGER.info(
             f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text = "This user is in my support staff, cannot restrict them.")
         return
 
     try:
@@ -157,7 +154,7 @@ async def dtmute_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "mute")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.mute.admin_cannot_mute"))
+        await m.reply_text(text = "This user is an admin, I cannot mute them!")
         return
 
     if m.reply_to_message and len(m.text.split()) >= 2:
@@ -189,10 +186,9 @@ async def dtmute_usr(c: Gojo, m: Message):
         )
         LOGGER.info(f"{m.from_user.id} dtmuted {user_id} in {m.chat.id}")
         await m.reply_to_message.delete()
-        txt = (tlang(m, "admin.mute.muted_user")).format(
-            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
-            muted=(await mention_html(user_first_name, user_id)),
-        )
+        admin=(await mention_html(m.from_user.first_name, m.from_user.id))
+        muted=(await mention_html(user_first_name, user_id))
+        txt = f"Admin {admin} muted {muted}!"
         if reason:
             txt += f"\n<b>Reason</b>: {reason}"
         keyboard = InlineKeyboardMarkup(
@@ -207,17 +203,16 @@ async def dtmute_usr(c: Gojo, m: Message):
         )
         await c.send_message(m.chat.id, txt, reply_markup=keyboard)
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text = "I'm not admin or I don't have rights.")
     except RightForbidden:
-        await m.reply_text(tlang(m, "admin.mute.bot_no_right"))
+        await m.reply_text(text = "I don't have enough rights to ban this user.")
     except UserNotParticipant:
         await m.reply_text("How can I mute a user who is not a part of this chat?")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text = f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
 
@@ -246,7 +241,7 @@ async def stmute_usr(c: Gojo, m: Message):
         LOGGER.info(
             f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text = "This user is in my support staff, cannot restrict them.")
         return
 
     try:
@@ -255,7 +250,7 @@ async def stmute_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "mute")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.mute.admin_cannot_mute"))
+        await m.reply_text(text = "This user is an admin, I cannot mute them!")
         return
 
     if m.reply_to_message and len(m.text.split()) >= 2:
@@ -290,17 +285,16 @@ async def stmute_usr(c: Gojo, m: Message):
         if m.reply_to_message:
             await m.reply_to_message.delete()
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text = "I'm not admin or I don't have rights.")
     except RightForbidden:
-        await m.reply_text(tlang(m, "admin.mute.bot_no_right"))
+        await m.reply_text(text = "I don't have enough rights to ban this user.")
     except UserNotParticipant:
         await m.reply_text("How can I mute a user who is not a part of this chat?")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text = f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
 
@@ -338,7 +332,7 @@ async def mute_usr(c: Gojo, m: Message):
         LOGGER.info(
             f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text = "This user is in my support staff, cannot restrict them.")
         return
 
     try:
@@ -347,7 +341,7 @@ async def mute_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "mute")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.mute.admin_cannot_mute"))
+        await m.reply_text(text = "This user is an admin, I cannot mute them!")
         return
 
     try:
@@ -356,10 +350,9 @@ async def mute_usr(c: Gojo, m: Message):
             ChatPermissions(),
         )
         LOGGER.info(f"{m.from_user.id} muted {user_id} in {m.chat.id}")
-        txt = (tlang(m, "admin.mute.muted_user")).format(
-            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
-            muted=(await mention_html(user_first_name, user_id)),
-        )
+        admin=(await mention_html(m.from_user.first_name, m.from_user.id))
+        muted=(await mention_html(user_first_name, user_id))
+        txt = f"Admin {admin} muted {muted}!"
         if reason:
             txt += f"\n<b>Reason</b>: {reason}"
         keyboard = InlineKeyboardMarkup(
@@ -374,17 +367,16 @@ async def mute_usr(c: Gojo, m: Message):
         )
         await m.reply_text(txt, reply_markup=keyboard, reply_to_message_id=r_id)
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text = "I'm not admin or I don't have rights.")
     except RightForbidden:
-        await m.reply_text(tlang(m, "admin.mute.bot_no_right"))
+        await m.reply_text(text = "I don't have enough rights to ban this user.")
     except UserNotParticipant:
         await m.reply_text("How can I mute a user who is not a part of this chat?")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text = f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
 
@@ -413,7 +405,7 @@ async def smute_usr(c: Gojo, m: Message):
         LOGGER.info(
             f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text = "This user is in my support staff, cannot restrict them.")
         return
 
     try:
@@ -422,7 +414,7 @@ async def smute_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "mute")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.mute.admin_cannot_mute"))
+        await m.reply_text(text = "This user is an admin, I cannot mute them!")
         return
 
     try:
@@ -437,17 +429,16 @@ async def smute_usr(c: Gojo, m: Message):
             return
         return
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text = "I'm not admin or I don't have rights.")
     except RightForbidden:
-        await m.reply_text(tlang(m, "admin.mute.bot_no_right"))
+        await m.reply_text(text = "I don't have enough rights to ban this user.")
     except UserNotParticipant:
         await m.reply_text("How can I mute a user who is not a part of this chat?")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text = f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
 
@@ -483,7 +474,7 @@ async def dmute_usr(c: Gojo, m: Message):
         LOGGER.info(
             f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text = "This user is in my support staff, cannot restrict them.")
         return
 
     try:
@@ -492,7 +483,7 @@ async def dmute_usr(c: Gojo, m: Message):
         admins_group = await admin_cache_reload(m, "mute")
 
     if user_id in admins_group:
-        await m.reply_text(tlang(m, "admin.mute.admin_cannot_mute"))
+        await m.reply_text(text = "This user is an admin, I cannot mute them!")
         return
 
     try:
@@ -502,10 +493,9 @@ async def dmute_usr(c: Gojo, m: Message):
         )
         LOGGER.info(f"{m.from_user.id} dmuted {user_id} in {m.chat.id}")
         await m.reply_to_message.delete()
-        txt = (tlang(m, "admin.mute.muted_user")).format(
-            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
-            muted=(await mention_html(user_first_name, user_id)),
-        )
+        admin=(await mention_html(m.from_user.first_name, m.from_user.id))
+        muted=(await mention_html(user_first_name, user_id))
+        txt = f"Admin {admin} muted {muted}!"
         if reason:
             txt += f"\n<b>Reason</b>: {reason}"
         keyboard = InlineKeyboardMarkup(
@@ -520,17 +510,16 @@ async def dmute_usr(c: Gojo, m: Message):
         )
         await c.send_message(m.chat.id, txt, reply_markup=keyboard)
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text = "I'm not admin or I don't have rights.")
     except RightForbidden:
-        await m.reply_text(tlang(m, "admin.mute.bot_no_right"))
+        await m.reply_text(text = "I don't have enough rights to ban this user.")
     except UserNotParticipant:
         await m.reply_text("How can I mute a user who is not a part of this chat?")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text = f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
 
@@ -555,24 +544,22 @@ async def unmute_usr(c: Gojo, m: Message):
     try:
         await m.chat.unban_member(user_id)
         LOGGER.info(f"{m.from_user.id} unmuted {user_id} in {m.chat.id}")
+        admin=(await mention_html(m.from_user.first_name, m.from_user.id))
+        unmuted=(await mention_html(user_first_name, user_id))
         await m.reply_text(
-            (tlang(m, "admin.unmute.unmuted_user")).format(
-                admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
-                unmuted=(await mention_html(user_first_name, user_id)),
-            ),
+            text=f"Admin {admin} unmuted {unmuted}!"
         )
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text = "I'm not admin or I don't have rights.")
     except UserNotParticipant:
         await m.reply_text("How can I unmute a user who is not a part of this chat?")
     except RightForbidden:
-        await m.reply_text(tlang(m, "admin.unmute.bot_no_right"))
+        await m.reply_text(text="I don't have enough rights to ban this user.")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text = f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
     return

Powers/plugins/pin.py

@@ -7,7 +7,6 @@ from pyrogram.types import CallbackQuery, Message
 from Powers import LOGGER, SUPPORT_GROUP
 from Powers.bot_class import Gojo
 from Powers.database.pins_db import Pins
-from Powers.tr_engine import tlang
 from Powers.utils.custom_filters import admin_filter, command
 from Powers.utils.kbhelpers import ikb
 from Powers.utils.string import build_keyboard, parse_button
@@ -43,20 +42,19 @@ async def pin_message(_, m: Message):
                     f"https://t.me/c/{link_chat_id}/{m.reply_to_message.message_id}"
                 )
             await m.reply_text(
-                tlang(m, "pin.pinned_msg").format(message_link=message_link),
+                text=f"I have Pinned [this message]({message_link})!",
                 disable_web_page_preview=True,
             )
 
         except ChatAdminRequired:
-            await m.reply_text(tlang(m, "admin.not_admin"))
+            await m.reply_text(text="I'm not admin or I don't have rights.")
         except RightForbidden:
-            await m.reply_text(tlang(m, "pin.no_rights_pin"))
+            await m.reply_text(text="I don't have enough rights to pin messages.")
         except RPCError as ef:
             await m.reply_text(
-                (tlang(m, "general.some_error")).format(
-                    SUPPORT_GROUP=SUPPORT_GROUP,
-                    ef=ef,
-                ),
+                text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
             )
             LOGGER.error(ef)
     else:
@@ -73,20 +71,19 @@ async def unpin_message(c: Gojo, m: Message):
             LOGGER.info(
                 f"{m.from_user.id} unpinned msgid: {m.reply_to_message.message_id} in {m.chat.id}",
             )
-            await m.reply_text(tlang(m, "pin.unpinned_last_msg"))
+            await m.reply_text(text="Unpinned last message.")
         else:
             await c.unpin_chat_message(m.chat.id)
-            await m.reply_text(tlang(m, "Unpinned last pinned message!"))
+            await m.reply_text(text="Unpinned last pinned message!")
     except ChatAdminRequired:
-        await m.reply_text(tlang(m, "admin.not_admin"))
+        await m.reply_text(text="I'm not admin or I don't have rights.")
     except RightForbidden:
-        await m.reply_text(tlang(m, "pin.no_rights_unpin"))
+        await m.reply_text(text="I don't have enough rights to unpin messages.")
     except RPCError as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+            text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
 
@@ -121,17 +118,16 @@ async def unpinall_calllback(c: Gojo, q: CallbackQuery):
     try:
         await c.unpin_all_chat_messages(q.message.chat.id)
         LOGGER.info(f"{q.from_user.id} unpinned all messages in {q.message.chat.id}")
-        await q.message.edit_text(tlang(q, "pin.unpinned_all_msg"))
+        await q.message.edit_text(text="Unpinned all messages in this chat.")
     except ChatAdminRequired:
-        await q.message.edit_text(tlang(q, "admin.notadmin"))
+        await q.message.edit_text(text="I'm not admin or I don't have rights.")
     except RightForbidden:
-        await q.message.edit_text(tlang(q, "pin.no_rights_unpin"))
+        await q.message.edit_text(text="I don't have enough rights to unpin messages.")
     except RPCError as ef:
         await q.message.edit_text(
-            (tlang(q, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+           text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
         )
         LOGGER.error(ef)
     return
@@ -144,9 +140,7 @@ async def anti_channel_pin(_, m: Message):
     if len(m.text.split()) == 1:
         status = pinsdb.get_settings()["antichannelpin"]
         await m.reply_text(
-            tlang(m, "pin.antichannelpin.current_status").format(
-                status=status,
-            ),
+            text=f"Current AntiChannelPin status: {status}"
         )
         return
 
@@ -154,13 +148,13 @@ async def anti_channel_pin(_, m: Message):
         if m.command[1] in ("yes", "on", "true"):
             pinsdb.antichannelpin_on()
             LOGGER.info(f"{m.from_user.id} enabled antichannelpin in {m.chat.id}")
-            msg = tlang(m, "pin.antichannelpin.turned_on")
+            msg = "Turned on AntiChannelPin, now all message pinned by channel will be unpinned automtically!"
         elif m.command[1] in ("no", "off", "false"):
             pinsdb.antichannelpin_off()
             LOGGER.info(f"{m.from_user.id} disabled antichannelpin in {m.chat.id}")
-            msg = tlang(m, "pin.antichannelpin.turned_off")
+            msg = "Turned off AntiChannelPin, now all message pinned by channel will stay pinned!"
         else:
-            await m.reply_text(tlang(m, "general.check_help"))
+            await m.reply_text(text="Please check help on how to use this this command.")
             return
 
     await m.reply_text(msg)
@@ -198,9 +192,7 @@ async def clean_linked(_, m: Message):
     if len(m.text.split()) == 1:
         status = pinsdb.get_settings()["cleanlinked"]
         await m.reply_text(
-            tlang(m, "pin.antichannelpin.current_status").format(
-                status=status,
-            ),
+           text=f"Current AntiChannelPin status: {status}"
         )
         return
 
@@ -214,7 +206,7 @@ async def clean_linked(_, m: Message):
             LOGGER.info(f"{m.from_user.id} disabled CleanLinked in {m.chat.id}")
             msg = "Turned off CleanLinked! Messages from linked channel will not be deleted!"
         else:
-            await m.reply_text(tlang(m, "general.check_help"))
+            await m.reply_text(text="Please check help on how to use this this command.")
             return
 
     await m.reply_text(msg)

Powers/plugins/purge.py

@@ -5,14 +5,13 @@ from pyrogram.types import Message
 
 from Powers import SUPPORT_GROUP
 from Powers.bot_class import Gojo
-from Powers.tr_engine import tlang
 from Powers.utils.custom_filters import admin_filter, command
 
 
 @Gojo.on_message(command("purge") & admin_filter)
 async def purge(c: Gojo, m: Message):
     if m.chat.type != "supergroup":
-        await m.reply_text(tlang(m, "purge.err_basic"))
+        await m.reply_text(text="Cannot purge messages in a basic group")
         return
 
     if m.reply_to_message:
@@ -34,22 +33,20 @@ async def purge(c: Gojo, m: Message):
                 )
             await m.delete()
         except MessageDeleteForbidden:
-            await m.reply_text(tlang(m, "purge.old_msg_err"))
+            await m.reply_text(text="Cannot delete all messages. The messages may be too old, I might not have delete rights, or this might not be a supergroup.")
             return
         except RPCError as ef:
             await m.reply_text(
-                (tlang(m, "general.some_error")).format(
-                    SUPPORT_GROUP=SUPPORT_GROUP,
-                    ef=ef,
-                ),
+                text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
             )
 
         count_del_msg = len(message_ids)
 
         z = await m.reply_text(
-            (tlang(m, "purge.purge_msg_count")).format(
-                msg_count=count_del_msg,
-            ),
+            text=f"Deleted <i>{count_del_msg}</i> messages"
+                
         )
         await sleep(3)
         await z.delete()
@@ -61,7 +58,7 @@ async def purge(c: Gojo, m: Message):
 @Gojo.on_message(command("spurge") & admin_filter)
 async def spurge(c: Gojo, m: Message):
     if m.chat.type != "supergroup":
-        await m.reply_text(tlang(m, "purge.err_basic"))
+        await m.reply_text(text="Cannot purge messages in a basic group")
         return
 
     if m.reply_to_message:
@@ -83,14 +80,13 @@ async def spurge(c: Gojo, m: Message):
                 )
             await m.delete()
         except MessageDeleteForbidden:
-            await m.reply_text(tlang(m, "purge.old_msg_err"))
+            await m.reply_text(text="Cannot delete all messages. The messages may be too old, I might not have delete rights, or this might not be a supergroup.")
             return
         except RPCError as ef:
             await m.reply_text(
-                (tlang(m, "general.some_error")).format(
-                    SUPPORT_GROUP=SUPPORT_GROUP,
-                    ef=ef,
-                ),
+                text=f"""Some error occured, report to @{SUPPORT_GROUP}
+
+      <b>Error:</b> <code>{ef}</code>"""
             )
         return
     await m.reply_text("Reply to a message to start spurge !")
@@ -112,7 +108,7 @@ async def del_msg(c: Gojo, m: Message):
             message_ids=m.reply_to_message.message_id,
         )
     else:
-        await m.reply_text(tlang(m, "purge.what_del"))
+        await m.reply_text(text="What do you wanna delete?")
     return
 
 

Powers/plugins/rules.py

@@ -4,7 +4,6 @@ from pyrogram.types import CallbackQuery, Message
 from Powers import LOGGER
 from Powers.bot_class import Gojo
 from Powers.database.rules_db import Rules
-from Powers.tr_engine import tlang
 from Powers.utils.custom_filters import admin_filter, command
 from Powers.utils.kbhelpers import ikb
 from Powers.vars import Config
@@ -22,7 +21,7 @@ async def get_rules(_, m: Message):
 
     if not rules:
         await m.reply_text(
-            (tlang(m, "rules.no_rules")),
+            text="The Admins for this group have not setup rules! That doesn't mean you can break the DECORUM of this group !",
             quote=True,
         )
         return
@@ -42,7 +41,7 @@ async def get_rules(_, m: Message):
             ],
         )
         await m.reply_text(
-            (tlang(m, "rules.pm_me")),
+            text="Click on the below button to see this group rules!",
             quote=True,
             reply_markup=pm_kb,
             reply_to_message_id=msg_id,
@@ -52,10 +51,8 @@ async def get_rules(_, m: Message):
     formated = rules
 
     await m.reply_text(
-        (tlang(m, "rules.get_rules")).format(
-            chat=f"<b>{m.chat.title}</b>",
-            rules=formated,
-        ),
+        text=f"""The rules for <b>{m.chat.title} are:</b>
+      {formated}""",
         disable_web_page_preview=True,
         reply_to_message_id=msg_id,
     )
@@ -81,7 +78,7 @@ async def set_rules(_, m: Message):
 
     db.set_rules(rules)
     LOGGER.info(f"{m.from_user.id} set rules in {m.chat.id}")
-    await m.reply_text(tlang(m, "rules.set_rules"))
+    await m.reply_text(text="Successfully set rules for this group.")
     return
 
 
@@ -98,23 +95,21 @@ async def priv_rules(_, m: Message):
         if option in ("on", "yes"):
             db.set_privrules(True)
             LOGGER.info(f"{m.from_user.id} enabled privaterules in {m.chat.id}")
-            msg = tlang(m, "rules.priv_rules.turned_on").format(chat_name=m.chat.title)
+            msg = f"Private Rules have been turned <b>on</b> for chat <b>{m.chat.title}</b>"
         elif option in ("off", "no"):
             db.set_privrules(False)
             LOGGER.info(f"{m.from_user.id} disbaled privaterules in {m.chat.id}")
-            msg = tlang(m, "rules.priv_rules.turned_off").format(chat_name=m.chat.title)
+            msg = f"Private Rules have been turned <b>off</b> for chat <b>{m.chat.title}</b>"
         else:
-            msg = tlang(m, "rules.priv_rules.no_option")
+            msg = "Option not valid, choose from <code>on</code>, <code>yes</code>, <code>off</code>, <code>no</code>"
         await m.reply_text(msg)
     elif len(m.text.split()) == 1:
         curr_pref = db.get_privrules()
-        msg = tlang(m, "rules.priv_rules.current_preference").format(
-            current_option=curr_pref,
-        )
+        msg = f"Current Preference for Private rules in this chat is: <b>{curr_pref}</b>"
         LOGGER.info(f"{m.from_user.id} fetched privaterules preference in {m.chat.id}")
         await m.reply_text(msg)
     else:
-        await m.replt_text(tlang(m, "general.check_help"))
+        await m.reply_text(text="Please check help on how to use this this command.")
 
     return
 
@@ -127,11 +122,11 @@ async def clear_rules(_, m: Message):
 
     rules = db.get_rules()
     if not rules:
-        await m.reply_text(tlang(m, "rules.no_rules"))
+        await m.reply_text(text="The Admins for this group have not setup rules! That doesn't mean you can break the DECORUM of this group !")
         return
 
     await m.reply_text(
-        (tlang(m, "rules.clear_rules")),
+        text="Are you sure you want to clear rules?",
         reply_markup=ikb(
             [[("⚠️ Confirm", "clear_rules"), ("❌ Cancel", "close_admin")]],
         ),
@@ -142,7 +137,7 @@ async def clear_rules(_, m: Message):
 @Gojo.on_callback_query(filters.regex("^clear_rules$"))
 async def clearrules_callback(_, q: CallbackQuery):
     Rules(q.message.chat.id).clear_rules()
-    await q.message.edit_text(tlang(q, "rules.cleared"))
+    await q.message.edit_text(text="Successfully cleared rules for this group!")
     LOGGER.info(f"{q.from_user.id} cleared rules in {q.message.chat.id}")
     await q.answer("Rules for the chat have been cleared!", show_alert=True)
     return

Powers/plugins/start.py

@@ -4,7 +4,6 @@ from pyrogram.types import CallbackQuery, Message
 
 from Powers import HELP_COMMANDS, LOGGER
 from Powers.bot_class import Gojo
-from Powers.tr_engine import tlang
 from Powers.utils.custom_filters import command
 from Powers.utils.kbhelpers import ikb
 from Powers.utils.start_utils import (
@@ -22,7 +21,13 @@ from Powers.vars import Config
 )
 async def donate(_, m: Message):
     LOGGER.info(f"{m.from_user.id} fetched donation text in {m.chat.id}")
-    await m.reply_text(tlang(m, "general.donate_owner"))
+    await m.reply_text(text="""Hey Thanks for your thought of donating me!
+      When you donate, all the fund goes towards my development which makes on fast and responsive.
+      Your donation might also me get me a new feature or two, which I wasn't able to get due to server limitations.
+
+      All the fund would be put into my services such as database, storage and hosting!
+
+      You can donate by contacting my owner: @iamgojoof6eyes""")
     return
 
 
@@ -80,7 +85,11 @@ async def start(c: Gojo, m: Message):
             return
         try:
             await m.reply_text(
-                (tlang(m, "start.private")),
+                text="""Hey there! My name is Alita ✨.
+      I'm here to help you manage your groups!
+      Hit /help to find out more about how to use me in my full potential!
+
+      Join my [News Channel](https://t.me/gojo_updates) to get information on all the latest updates.""",
                 reply_markup=(await gen_start_kb(m)),
                 quote=True,
                 disable_web_page_preview=True,
@@ -89,7 +98,7 @@ async def start(c: Gojo, m: Message):
             LOGGER.warning(f"Bot blocked by {m.from_user.id}")
     else:
         await m.reply_text(
-            (tlang(m, "start.group")),
+            text="I'm alive :3",
             quote=True,
         )
     return
@@ -99,7 +108,11 @@ async def start(c: Gojo, m: Message):
 async def start_back(_, q: CallbackQuery):
     try:
         await q.message.edit_text(
-            (tlang(q, "start.private")),
+            text="""Hey there! My name is Alita ✨.
+      I'm here to help you manage your groups!
+      Hit /help to find out more about how to use me in my full potential!
+
+      Join my [News Channel](http://t.me/gojo_updates) to get information on all the latest updates.""",
             reply_markup=(await gen_start_kb(q.message)),
             disable_web_page_preview=True,
         )
@@ -114,19 +127,27 @@ async def commands_menu(_, q: CallbackQuery):
     keyboard = ikb(
         [
             *(await gen_cmds_kb(q)),
-            [(f"« {(tlang(q, 'general.back_btn'))}", "start_back")],
+            [(f"« Back", "start_back")],
         ],
     )
     try:
         await q.message.edit_text(
-            (tlang(q, "general.commands_available")),
-            reply_markup=keyboard,
+            text="""Hey There! My name is Alita.
+            I'm here to help you manage your groups!
+            Commands available:
+            × /start: Start the bot
+            × /help: Give's you this message.""",
+        reply_markup=keyboard,
         )
     except MessageNotModified:
         pass
     except QueryIdInvalid:
         await q.message.reply_text(
-            (tlang(q, "general.commands_available")),
+            text="""Hey There! My name is Alita.
+            I'm here to help you manage your groups!
+            Commands available:
+            × /start: Start the bot
+            × /help: Give's you this message.""",
             reply_markup=keyboard,
         )
     await q.answer()
@@ -156,7 +177,7 @@ async def help_menu(_, m: Message):
             )
         else:
             await m.reply_text(
-                (tlang(m, "start.public_help").format(help_option=help_option)),
+                text=f"Press the button below to get help for <i>{help_option}</i>",
                 reply_markup=ikb(
                     [
                         [
@@ -174,16 +195,19 @@ async def help_menu(_, m: Message):
             keyboard = ikb(
                 [
                     *(await gen_cmds_kb(m)),
-                    [(f"« {(tlang(m, 'general.back_btn'))}", "start_back")],
+                    [("« Back", "start_back")],
                 ],
             )
-            msg = tlang(m, "general.commands_available")
+            msg = """Hey There! My name is Alita.
+      I'm here to help you manage your groups!
+      Commands available:
+       × /start: Start the bot
+       × /help: Give's you this message."""
         else:
             keyboard = ikb(
                 [[("Help", f"t.me/{Config.BOT_USERNAME}?start=help", "url")]],
             )
-            msg = tlang(m, "start.pm_for_help")
-
+            msg = "Contact me in PM to get the list of possible commands."
         await m.reply_text(
             msg,
             reply_markup=keyboard,
@@ -196,13 +220,10 @@ async def help_menu(_, m: Message):
 async def get_module_info(_, q: CallbackQuery):
     module = q.data.split(".", 1)[1]
 
-    help_msg = f"**{(tlang(q, str(module)))}:**\n\n" + tlang(
-        q,
-        HELP_COMMANDS[module]["help_msg"],
-    )
+    help_msg = f"**{str(module)}:**\n\n" + HELP_COMMANDS[module]["help_msg"],
 
     help_kb = HELP_COMMANDS[module]["buttons"] + [
-        [("« " + (tlang(q, "general.back_btn")), "commands")],
+        [("« " + "Back", "commands")],
     ]
     await q.message.edit_text(
         help_msg,

Powers/plugins/utils.py

@@ -22,7 +22,6 @@ from Powers import (
 from Powers.bot_class import Gojo
 from Powers.database.antispam_db import GBan
 from Powers.database.users_db import Users
-from Powers.tr_engine import tlang
 from Powers.utils.clean_file import remove_markdown_and_html
 from Powers.utils.custom_filters import command
 from Powers.utils.extract_user import extract_user
@@ -39,7 +38,7 @@ async def wiki(_, m: Message):
     LOGGER.info(f"{m.from_user.id} used wiki cmd in {m.chat.id}")
 
     if len(m.text.split()) <= 1:
-        return await m.reply_text(tlang(m, "general.check_help"))
+        return await m.reply_text(text="Please check help on how to use this this command.")
 
     search = m.text.split(None, 1)[1]
     try:
@@ -98,27 +97,26 @@ async def gdpr_remove(_, m: Message):
 )
 async def get_lyrics(_, m: Message):
     if len(m.text.split()) <= 1:
-        await m.reply_text(tlang(m, "general.check_help"))
+        await m.reply_text(text="Please check help on how to use this this command.")
         return
 
     query = m.text.split(None, 1)[1]
     LOGGER.info(f"{m.from_user.id} used lyrics cmd in {m.chat.id}")
     song = ""
     if not query:
-        await m.edit_text(tlang(m, "utils.song.no_song_given"))
+        await m.edit_text(text="You haven't specified which song to look for!")
         return
-
+    song_name=query
     em = await m.reply_text(
-        (tlang(m, "utils.song.searching").format(song_name=query)),
-    )
+        text=f"Finding lyrics for <code>{song_name}<code>...")
     song = Song.find_song(query)
     if song:
         if song.lyrics:
             reply = song.format()
         else:
-            reply = tlang(m, "utils.song.no_lyrics_found")
+            reply = "Couldn't find any lyrics for that song!"
     else:
-        reply = tlang(m, "utils.song.song_not_found")
+        reply = "Song not found!"
     try:
         await em.edit_text(reply)
     except MessageTooLong:
@@ -138,11 +136,11 @@ async def id_info(c: Gojo, m: Message):
     LOGGER.info(f"{m.from_user.id} used id cmd in {m.chat.id}")
 
     if m.chat.type == "supergroup" and not m.reply_to_message:
-        await m.reply_text((tlang(m, "utils.id.group_id")).format(group_id=m.chat.id))
+        await m.reply_text(text=f"This Group's ID is <code>{m.chat.id}</code>")
         return
 
     if m.chat.type == "private" and not m.reply_to_message:
-        await m.reply_text((tlang(m, "utils.id.my_id")).format(my_id=m.chat.id))
+        await m.reply_text(text=f"Your ID is <code>{m.chat.id}</code>.")
         return
 
     user_id, _, _ = await extract_user(c, m)
@@ -150,20 +148,21 @@ async def id_info(c: Gojo, m: Message):
         if m.reply_to_message and m.reply_to_message.forward_from:
             user1 = m.reply_to_message.from_user
             user2 = m.reply_to_message.forward_from
+            orig_sender=(await mention_html(user2.first_name, user2.id)),
+            orig_id=f"<code>{user2.id}</code>",
+            fwd_sender=(await mention_html(user1.first_name, user1.id)),
+            fwd_id=f"<code>{user1.id}</code>",
             await m.reply_text(
-                (tlang(m, "utils.id.id_main")).format(
-                    orig_sender=(await mention_html(user2.first_name, user2.id)),
-                    orig_id=f"<code>{user2.id}</code>",
-                    fwd_sender=(await mention_html(user1.first_name, user1.id)),
-                    fwd_id=f"<code>{user1.id}</code>",
-                ),
+                text=f"""Original Sender - {orig_sender} (<code>{orig_id}</code>)
+        Forwarder - {fwd_sender} (<code>{fwd_id}</code>)""",
                 parse_mode="HTML",
             )
         else:
             try:
                 user = await c.get_users(user_id)
             except PeerIdInvalid:
-                await m.reply_text(tlang(m, "utils.no_user_db"))
+                await m.reply_text(text="""Failed to get user
+      Peer ID invalid, I haven't seen this user anywhere earlier, maybe username would help to know them!""")
                 return
 
             await m.reply_text(
@@ -172,15 +171,11 @@ async def id_info(c: Gojo, m: Message):
             )
     elif m.chat.type == "private":
         await m.reply_text(
-            (tlang(m, "utils.id.my_id")).format(
-                my_id=f"<code>{m.chat.id}</code>",
-            ),
+            text=f"Your ID is <code>{m.chat.id}</code>."    
         )
     else:
         await m.reply_text(
-            (tlang(m, "utils.id.group_id")).format(
-                group_id=f"<code>{m.chat.id}</code>",
-            ),
+            text=f"This Group's ID is <code>{m.chat.id}</code>"
         )
     return
 
@@ -196,7 +191,7 @@ async def get_gifid(_, m: Message):
             parse_mode="html",
         )
     else:
-        await m.reply_text(tlang(m, "utils.gif_id.reply_gif"))
+        await m.reply_text(text="Please reply to a gif to get it's ID.")
     return
 
 
@@ -252,11 +247,11 @@ async def my_info(c: Gojo, m: Message):
     try:
         user_id, name, user_name = await extract_user(c, m)
     except PeerIdInvalid:
-        await m.reply_text(tlang(m, "utils.user_info.peer_id_error"))
+        await m.reply_text(text="I haven't seen this user, mind forwarding one of their messages so I can recognize them?")
         return
     except ValueError as ef:
         if "Peer id invalid" in str(ef):
-            await m.reply_text(tlang(m, "utils.user_info.id_not_found"))
+            await m.reply_text(text="User not found, please check the ID again")
         return
     try:
         user = Users.get_user_info(int(user_id))
@@ -274,45 +269,40 @@ async def my_info(c: Gojo, m: Message):
         user_name = user["username"]
         user_id = user["id"]
     except PeerIdInvalid:
-        await m.reply_text(tlang(m, "utils.no_user_db"))
+        await m.reply_text(text="""Failed to get user
+      Peer ID invalid, I haven't seen this user anywhere earlier, maybe username would help to know them!""")
         return
     except (RPCError, Exception) as ef:
         await m.reply_text(
-            (tlang(m, "general.some_error")).format(
-                SUPPORT_GROUP=SUPPORT_GROUP,
-                ef=ef,
-            ),
+           text=f"""Some error occured, report to @{SUPPORT_GROUP}
+            <b>Error:</b> <code>{ef}</code>"""
         )
         return
 
     gbanned, reason_gban = gban_db.get_gban(user_id)
     LOGGER.info(f"{m.from_user.id} used info cmd for {user_id} in {m.chat.id}")
-
-    text = (tlang(m, "utils.user_info.info_text.main")).format(
-        user_id=user_id,
-        user_name=name,
-    )
+    user_id=user_id,
+    user_name=name,
+    text = f"""<b>Characteristics:</b>
+          <b>ID:</b> <code>{user_id}</code>
+          <b>First Name:</b> {user_name}"""
 
     if user_name:
-        text += (tlang(m, "utils.user_info.info_text.username")).format(
-            username=user_name,
-        )
-
-    text += (tlang(m, "utils.user_info.info_text.perma_link")).format(
-        perma_link=(await mention_html("Click Here", user_id)),
-    )
+        text += f"<b>Username:</b> @{user_name}"
+    perma_link=(await mention_html("Click Here", user_id))
+    text += f"<b>Permanent User Link:</b> {perma_link}"
 
     if gbanned:
         text += f"\nThis user is Globally banned beacuse: {reason_gban}\n"
 
     if user_id == OWNER_ID:
-        text += tlang(m, "utils.user_info.support_user.owner")
+        text += "This person is my Owner, I would never do anything against them!"
     elif user_id in DEV_USERS:
-        text += tlang(m, "utils.user_info.support_user.dev")
+        text += "This member is one of my Developers ⚡️"
     elif user_id in SUDO_USERS:
-        text += tlang(m, "utils.user_info.support_user.sudo")
+        text += "This user is one of my Sudos, he has powers which are approximately same to owner!"
     elif user_id in WHITELIST_USERS:
-        text += tlang(m, "utils.user_info.support_user.whitelist")
+        text += "This person is 'Whitelist User', they cannot be banned!"
 
     await m.reply_text(text, parse_mode="html", disable_web_page_preview=True)
     return
@@ -320,7 +310,7 @@ async def my_info(c: Gojo, m: Message):
 
 @Gojo.on_message(command("paste"))
 async def paste_it(_, m: Message):
-    replymsg = await m.reply_text((tlang(m, "utils.paste.pasting")), quote=True)
+    replymsg = await m.reply_text(text="Pasting...", quote=True)
     try:
         if m.reply_to_message:
             if m.reply_to_message.document:
@@ -336,8 +326,8 @@ async def paste_it(_, m: Message):
         r = await http.post(ur, json={"content": txt})
         url = f"https://hastebin.com/{r.json().get('key')}"
         await replymsg.edit_text(
-            (tlang(m, "utils.paste.pasted_nekobin")),
-            reply_markup=ikb([[((tlang(m, "utils.paste.nekobin_btn")), url, "url")]]),
+            text="Pasted to NekoBin!",
+            reply_markup=ikb([[("NekoBin"), url, "url"]]),
         )
         LOGGER.info(f"{m.from_user.id} used paste cmd in {m.chat.id}")
     except Exception as e:

Powers/plugins/warns.py

@@ -15,7 +15,6 @@ from Powers.bot_class import Gojo
 from Powers.database.rules_db import Rules
 from Powers.database.users_db import Users
 from Powers.database.warns_db import Warns, WarnSettings
-from Powers.tr_engine import tlang
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
 from Powers.utils.custom_filters import admin_filter, command, restrict_filter
 from Powers.utils.extract_user import extract_user
@@ -53,7 +52,7 @@ async def warn(c: Gojo, m: Message):
         return
 
     if user_id in SUPPORT_STAFF:
-        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        await m.reply_text(text="This user is in my support staff, cannot restrict them.")
         LOGGER.info(
             f"{m.from_user.id} trying to warn {user_id} (SUPPORT_STAFF) in {m.chat.id}",
         )

Powers/plugins/watchers.py

@@ -14,7 +14,6 @@ from Powers.database.blacklist_db import Blacklist
 from Powers.database.group_blacklist import BLACKLIST_CHATS
 from Powers.database.pins_db import Pins
 from Powers.database.warns_db import Warns, WarnSettings
-from Powers.tr_engine import tlang
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
 from Powers.utils.parser import mention_html
 from Powers.utils.regex_utils import regex_searcher
@@ -59,7 +58,7 @@ async def bl_watcher(_, m: Message):
         if action == "kick":
             await m.chat.kick_member(m.from_user.id, int(time() + 45))
             await m.reply_text(
-                tlang(m, "blacklist.bl_watcher.action_kick").format(
+                text="Kicked {user} for sending a blacklisted word!".format(
                     user=m.from_user.username or f"<b>{m.from_user.first_name}</b>",
                 ),
             )
@@ -71,7 +70,7 @@ async def bl_watcher(_, m: Message):
                 )
             )
             await m.reply_text(
-                tlang(m, "blacklist.bl_watcher.action_ban").format(
+                text="Banned {user} for sending a blacklisted word!".format(
                     user=m.from_user.username or f"<b>{m.from_user.first_name}</b>",
                 ),
             )
@@ -83,7 +82,7 @@ async def bl_watcher(_, m: Message):
             )
 
             await m.reply_text(
-                tlang(m, "blacklist.bl_watcher.action_mute").format(
+                text="Muted {user} for sending a blacklisted word!".format(
                     user=m.from_user.username or f"<b>{m.from_user.first_name}</b>",
                 ),
             )
@@ -185,13 +184,11 @@ async def gban_watcher(c: Gojo, m: Message):
         try:
             await m.chat.ban_member(m.from_user.id)
             await m.delete(m.message_id)  # Delete users message!
+            user_gbanned=(await mention_html(m.from_user.first_name, m.from_user.id))
             await m.reply_text(
-                (tlang(m, "antispam.watcher_banned")).format(
-                    user_gbanned=(
-                        await mention_html(m.from_user.first_name, m.from_user.id)
-                    ),
-                    SUPPORT_GROUP=SUPPORT_GROUP,
-                ),
+                text=f"""This user ({user_gbanned}) has been banned globally!
+
+      To get unbanned, appeal at @{SUPPORT_GROUP}"""
             )
             LOGGER.info(f"Banned user {m.from_user.id} in {m.chat.id} due to antispam")
             return
@@ -204,10 +201,9 @@ async def gban_watcher(c: Gojo, m: Message):
         except RPCError as ef:
             await c.send_message(
                 MESSAGE_DUMP,
-                tlang(m, "antispam.gban.gban_error_log").format(
-                    chat_id=m.chat.id,
-                    ef=ef,
-                ),
+                text=f"""<b>Gban Watcher Error!</b>
+        <b>Chat:</b> <code>{m.chat.id}</code>
+        <b>Error:</b> <code>{ef}</code>"""
             )
     return