Exceptions go brr

wbb/modules/admin.py

@@ -91,74 +91,81 @@ async def purge(client, message: Message):
 
 @app.on_message(cust_filter.command(commands=("kick")) & ~filters.edited)
 async def kick(_, message: Message):
-    if (await app.get_chat_member(
-        message.chat.id, message.from_user.id)).status == 'creator' \
-        or (await app.get_chat_member(
-            message.chat.id, message.from_user.id)).can_restrict_members \
-            is True or message.from_user.id in SUDO:
-
-        if len(message.command) == 2:
-            username = (message.text.split(None, 1)[1])
-            if (await app.get_users(username)).id in SUDO:
-                await message.reply_text("You Wanna Kick The Elevated One?")
-            else:
-                if (await app.get_users(username)).id in \
-                        await list_members(message.chat.id):
-                    await message.chat.kick_member(username)
-                    await message.chat.unban_member(username)
-                    await message.reply_text(f"Kicked {username}")
+    try:
+        if (await app.get_chat_member(
+            message.chat.id, message.from_user.id)).status == 'creator' \
+            or (await app.get_chat_member(
+                message.chat.id, message.from_user.id)).can_restrict_members \
+                is True or message.from_user.id in SUDO:
+
+            if len(message.command) == 2:
+                username = (message.text.split(None, 1)[1])
+                if (await app.get_users(username)).id in SUDO:
+                    await message.reply_text("You Wanna Kick The Elevated One?")
                 else:
-                    await message.reply_text("This user isn't here,"
-                                             " consider kicking yourself.")
-
-        if len(message.command) == 1 and message.reply_to_message:
-            if message.reply_to_message.from_user.id in SUDO:
-                await message.reply_text("You Wanna Kick The Elevated One?")
-            else:
-                if message.reply_to_message.from_user.id in \
-                        await list_members(message.chat.id):
-                    user_id = message.reply_to_message.from_user.id
-                    await message.reply_to_message.chat.kick_member(user_id)
-                    await message.reply_to_message.chat.unban_member(user_id)
-                    await message.reply_text("Kicked!")
+                    if (await app.get_users(username)).id in \
+                            await list_members(message.chat.id):
+                        await message.chat.kick_member(username)
+                        await message.chat.unban_member(username)
+                        await message.reply_text(f"Kicked {username}")
+                    else:
+                        await message.reply_text("This user isn't here,"
+                                                 " consider kicking yourself.")
+
+            if len(message.command) == 1 and message.reply_to_message:
+                if message.reply_to_message.from_user.id in SUDO:
+                    await message.reply_text("You Wanna Kick The Elevated One?")
                 else:
-                    await message.reply_text("This user isn't here.")
+                    if message.reply_to_message.from_user.id in \
+                            await list_members(message.chat.id):
+                        user_id = message.reply_to_message.from_user.id
+                        await message.reply_to_message.chat.kick_member(user_id)
+                        await message.reply_to_message.chat.unban_member(user_id)
+                        await message.reply_text("Kicked!")
+                    else:
+                        await message.reply_text("This user isn't here.")
+    
+    except Exception as e:
+        await message.reply_text(str(e))
 
 # Ban members
 
 
 @app.on_message(cust_filter.command(commands=("ban")) & ~filters.edited)
 async def ban(_, message: Message):
-    if (await app.get_chat_member(
-        message.chat.id, message.from_user.id)).status == 'creator' \
-        or (await app.get_chat_member(
-            message.chat.id, message.from_user.id)).can_restrict_members \
-            is True or message.from_user.id in SUDO:
-
-        if len(message.command) == 2:
-            username = (message.text.split(None, 1)[1])
-            if (await app.get_users(username)).id in SUDO:
-                await message.reply_text("You Wanna Ban The Elevated One?")
-            else:
-                if (await app.get_users(username)).id in \
-                        await list_members(message.chat.id):
-                    await message.chat.kick_member(username)
-                    await message.reply_text(f"Banned! {username}")
+    try:
+        if (await app.get_chat_member(
+            message.chat.id, message.from_user.id)).status == 'creator' \
+            or (await app.get_chat_member(
+                message.chat.id, message.from_user.id)).can_restrict_members \
+                is True or message.from_user.id in SUDO:
+
+            if len(message.command) == 2:
+                username = (message.text.split(None, 1)[1])
+                if (await app.get_users(username)).id in SUDO:
+                    await message.reply_text("You Wanna Ban The Elevated One?")
                 else:
-                    await message.reply_text("This user isn't here,"
-                                             " consider banning yourself.")
-
-        if len(message.command) == 1 and message.reply_to_message:
-            if message.reply_to_message.from_user.id in SUDO:
-                await message.reply_text("You Wanna Ban The Elevated One?")
-            else:
-                if message.reply_to_message.from_user.id in \
-                        await list_members(message.chat.id):
-                    user_id = message.reply_to_message.from_user.id
-                    await message.reply_to_message.chat.kick_member(user_id)
-                    await message.reply_text("Banned!")
+                    if (await app.get_users(username)).id in \
+                            await list_members(message.chat.id):
+                        await message.chat.kick_member(username)
+                        await message.reply_text(f"Banned! {username}")
+                    else:
+                        await message.reply_text("This user isn't here,"
+                                                 " consider banning yourself.")
+
+            if len(message.command) == 1 and message.reply_to_message:
+                if message.reply_to_message.from_user.id in SUDO:
+                    await message.reply_text("You Wanna Ban The Elevated One?")
                 else:
-                    await message.reply_text("This user isn't here.")
+                    if message.reply_to_message.from_user.id in \
+                            await list_members(message.chat.id):
+                        user_id = message.reply_to_message.from_user.id
+                        await message.reply_to_message.chat.kick_member(user_id)
+                        await message.reply_text("Banned!")
+                    else:
+                        await message.reply_text("This user isn't here.")
+    except Exception as e:
+        await message.reply_text(str(e))
 
 
 # Unban members
@@ -166,30 +173,33 @@ async def ban(_, message: Message):
 
 @app.on_message(cust_filter.command(commands=("unban")) & ~filters.edited)
 async def unban(_, message: Message):
-    if (await app.get_chat_member(
-        message.chat.id, message.from_user.id)).status == 'creator' \
-        or (await app.get_chat_member(
-            message.chat.id, message.from_user.id)).can_restrict_members \
-            is True or message.from_user.id in SUDO:
-
-        if len(message.command) == 2:
-            username = (message.text.split(None, 1)[1])
-            if (await app.get_users(username)).id not in \
-                    await list_members(message.chat.id):
-                await message.chat.unban_member(username)
-                await message.reply_text(f"Unbanned! {username}")
-            else:
-                await message.reply_text("This user is already here,"
-                                         " consider banning yourself.")
-
-        if len(message.command) == 1 and message.reply_to_message:
-            if message.reply_to_message.from_user.id not in \
-                    await list_members(message.chat.id):
-                user_id = message.reply_to_message.from_user.id
-                await message.chat.unban_member(user_id)
-                await message.reply_text("Unbanned!")
-            else:
-                await message.reply_text("This user is already here.")
+    try:
+        if (await app.get_chat_member(
+            message.chat.id, message.from_user.id)).status == 'creator' \
+            or (await app.get_chat_member(
+                message.chat.id, message.from_user.id)).can_restrict_members \
+                is True or message.from_user.id in SUDO:
+
+            if len(message.command) == 2:
+                username = (message.text.split(None, 1)[1])
+                if (await app.get_users(username)).id not in \
+                        await list_members(message.chat.id):
+                    await message.chat.unban_member(username)
+                    await message.reply_text(f"Unbanned! {username}")
+                else:
+                    await message.reply_text("This user is already here,"
+                                             " consider banning yourself.")
+
+            if len(message.command) == 1 and message.reply_to_message:
+                if message.reply_to_message.from_user.id not in \
+                        await list_members(message.chat.id):
+                    user_id = message.reply_to_message.from_user.id
+                    await message.chat.unban_member(user_id)
+                    await message.reply_text("Unbanned!")
+                else:
+                    await message.reply_text("This user is already here.")
+    except Exception as e:
+        await message.reply_text(str(e))
 
 
 # Delete messages
@@ -197,91 +207,99 @@ async def unban(_, message: Message):
 
 @app.on_message(cust_filter.command(commands=("del")))
 async def delete(_, message: Message):
-    admins = await list_admins(message.chat.id)
-    chat_id = message.chat.id
-    from_user_id = message.from_user.id
+    try:
+        admins = await list_admins(message.chat.id)
+        chat_id = message.chat.id
+        from_user_id = message.from_user.id
 
-    if message.from_user.id in admins \
-            or message.from_user.id in SUDO:
-        if (await app.get_chat_member(chat_id,
-                                      from_user_id)).can_delete_messages \
-            or (await app.get_chat_member(chat_id, from_user_id)).status \
-            == 'creator' \
+        if message.from_user.id in admins \
                 or message.from_user.id in SUDO:
-            await message.reply_to_message.delete()
-            await message.delete()
-    else:
-        await message.reply_text("You Don't Have Enough Permissions,"
-                                 + " Consider Deleting Yourself!")
+            if (await app.get_chat_member(chat_id,
+                                          from_user_id)).can_delete_messages \
+                or (await app.get_chat_member(chat_id, from_user_id)).status \
+                == 'creator' \
+                    or message.from_user.id in SUDO:
+                await message.reply_to_message.delete()
+                await message.delete()
+        else:
+            await message.reply_text("You Don't Have Enough Permissions,"
+                                     + " Consider Wiping Yourself Off The Existence!")
+    except Exception as e:
+        await message.reply_text(str(e))
 
 # Promote Members
 
 
 @app.on_message(cust_filter.command(commands=("promote")) & ~filters.edited)
 async def promote(_, message: Message):
-    admins = await list_admins(message.chat.id)
-    chat_id = message.chat.id
-    from_user_id = message.from_user.id
+    try:
+        admins = await list_admins(message.chat.id)
+        chat_id = message.chat.id
+        from_user_id = message.from_user.id
 
-    if (await app.get_chat_member(chat_id,
-                                  BOT_ID)).can_promote_members:
-        if message.from_user.id in admins \
-                or message.from_user.id in SUDO:
-            if (await app.get_chat_member(chat_id,
-                                          from_user_id)).can_promote_members \
-                or (await app.get_chat_member(chat_id, from_user_id)).status \
-                == 'creator' \
+        if (await app.get_chat_member(chat_id,
+                                      BOT_ID)).can_promote_members:
+            if message.from_user.id in admins \
                     or message.from_user.id in SUDO:
-
-                if message.text != '/promote':
-                    username = message.text.replace('/promote', '')
-                    user_id = (await app.get_users(username)).id
-                    await message.chat.promote_member(
-                        user_id=user_id,
-                        can_change_info=True,
-                        can_invite_users=True,
-                        can_delete_messages=True)
-                    await message.reply_text('Promoted!')
-
+                if (await app.get_chat_member(chat_id,
+                                              from_user_id)).can_promote_members \
+                    or (await app.get_chat_member(chat_id, from_user_id)).status \
+                    == 'creator' \
+                        or message.from_user.id in SUDO:
+
+                    if message.text != '/promote':
+                        username = message.text.replace('/promote', '')
+                        user_id = (await app.get_users(username)).id
+                        await message.chat.promote_member(
+                            user_id=user_id,
+                            can_change_info=True,
+                            can_invite_users=True,
+                            can_delete_messages=True)
+                        await message.reply_text('Promoted!')
+
+                    else:
+                        user_id = message.reply_to_message.from_user.id
+                        await message.chat.promote_member(
+                            user_id=user_id,
+                            can_change_info=True,
+                            can_invite_users=True,
+                            can_delete_messages=True)
+                        await message.reply_text('Promoted!')
                 else:
-                    user_id = message.reply_to_message.from_user.id
-                    await message.chat.promote_member(
-                        user_id=user_id,
-                        can_change_info=True,
-                        can_invite_users=True,
-                        can_delete_messages=True)
-                    await message.reply_text('Promoted!')
-
+                    await message.reply_text("Yeah, I Can See You're An Admin,"
+                                             + " But You Don't Have Permissions"
+                                             + " To Promote Someone.")
             else:
-                await message.reply_text("Yeah, I Can See You're An Admin,"
-                                         + " But You Don't Have Permissions"
-                                         + " To Promote Someone.")
+                await message.reply_text("You're Not An Admin, Want A Good Ban?")
         else:
-            await message.reply_text("You're Not An Admin, Want A Good Ban?")
-    else:
-        await message.reply_text("Well, Your Know What?, I'M NOT AN ADMIN!"
-                                 + " MAKE ME ADMIN!")
+            await message.reply_text("Well, Your Know What?, I'M NOT AN ADMIN!"
+                                     + " MAKE ME ADMIN!")
+    except Exception as e:
+        await message.reply_text(str(e))
 
 # Pin Messages
 
 
 @app.on_message(cust_filter.command(commands=("pin")) & ~filters.edited)
 async def pin(_, message: Message):
-    admins = await list_admins(message.chat.id)
-    chat_id = message.chat.id
-    from_user_id = message.from_user.id
+    try:
+        admins = await list_admins(message.chat.id)
+        chat_id = message.chat.id
+        from_user_id = message.from_user.id
 
-    if message.from_user.id in admins \
-            or message.from_user.id in SUDO:
-        if (await app.get_chat_member(chat_id,
-                                      from_user_id)).can_pin_messages \
-            or (await app.get_chat_member(chat_id, from_user_id)).status \
-            == 'creator' \
+        if message.from_user.id in admins \
                 or message.from_user.id in SUDO:
+            if (await app.get_chat_member(chat_id,
+                                          from_user_id)).can_pin_messages \
+                or (await app.get_chat_member(chat_id, from_user_id)).status \
+                == 'creator' \
+                    or message.from_user.id in SUDO:
 
-            await message.reply_to_message.pin(disable_notification=True)
-    else:
-        await message.reply_text("You're Not An Admin, Stop Spamming!")
+                await message.reply_to_message.pin(disable_notification=True)
+        else:
+            await message.reply_text("You're Not An Admin, Stop Spamming!")
+    except Exception as e:
+        await message.reply_text(str(e))
 
 
 # Mute members
@@ -289,41 +307,47 @@ async def pin(_, message: Message):
 
 @app.on_message(cust_filter.command(commands=("mute")) & ~filters.edited)
 async def mute(_, message: Message):
-    chat_id = message.chat.id
-    from_user_id = message.from_user.id
-    if not message.reply_to_message:
-        await message.reply_text("Reply To A User's Message!")
-        return
+    try:
+        chat_id = message.chat.id
+        from_user_id = message.from_user.id
+        if not message.reply_to_message:
+            await message.reply_text("Reply To A User's Message!")
+            return
 
-    if (await app.get_chat_member(chat_id,
-                                  from_user_id)).can_restrict_members \
-        or (await app.get_chat_member(chat_id, from_user_id)).status \
-        == 'creator' \
-            or message.from_user.id in SUDO:
-        victim = message.reply_to_message.from_user.id
-        await message.chat.restrict_member(victim,
-                                           permissions=ChatPermissions())
-        await message.reply_text("Muted!")
-    else:
-        await message.reply_text("Get Yourself An Admin Tag!")
+        if (await app.get_chat_member(chat_id,
+                                      from_user_id)).can_restrict_members \
+            or (await app.get_chat_member(chat_id, from_user_id)).status \
+            == 'creator' \
+                or message.from_user.id in SUDO:
+            victim = message.reply_to_message.from_user.id
+            await message.chat.restrict_member(victim,
+                                               permissions=ChatPermissions())
+            await message.reply_text("Muted!")
+        else:
+            await message.reply_text("Get Yourself An Admin Tag!")
+    except Exception as e:
+        await message.reply_text(str(e))
 
 # Unmute members
 
 
 @app.on_message(cust_filter.command(commands=("unmute")) & ~filters.edited)
 async def unmute(_, message: Message):
-    chat_id = message.chat.id
-    from_user_id = message.from_user.id
-    if not message.reply_to_message:
-        await message.reply_text("Reply To A User's Message!")
-        return
-    if (await app.get_chat_member(chat_id,
-                                  from_user_id)).can_restrict_members \
-        or (await app.get_chat_member(chat_id, from_user_id)).status \
-        == 'creator' \
-            or message.from_user.id in SUDO:
-        victim = message.reply_to_message.from_user.id
-        await message.chat.unban_member(victim)
-        await message.reply_text("Unmuted!")
-    else:
-        await message.reply_text("Get Yourself An Admin Tag!")
+    try:
+        chat_id = message.chat.id
+        from_user_id = message.from_user.id
+        if not message.reply_to_message:
+            await message.reply_text("Reply To A User's Message!")
+            return
+        if (await app.get_chat_member(chat_id,
+                                      from_user_id)).can_restrict_members \
+            or (await app.get_chat_member(chat_id, from_user_id)).status \
+            == 'creator' \
+                or message.from_user.id in SUDO:
+            victim = message.reply_to_message.from_user.id
+            await message.chat.unban_member(victim)
+            await message.reply_text("Unmuted!")
+        else:
+            await message.reply_text("Get Yourself An Admin Tag!")
+    except Exception as e:
+        await message.reply_text(str(e))

wbb/modules/search.py

@@ -45,22 +45,25 @@ async def urbandict(_, message: Message):
 
 @app.on_message(cust_filter.command(commands=("google")) & ~filters.edited)
 async def google(_, message: Message):
-    if len(message.command) < 2:
-        await message.reply_text('"/google" Needs An Argument')
-        return
-    text = message.text.split(None, 1)[1]
-    gresults = await GoogleSearch().async_search(text, 1)
-    result = ""
-    for i in range(4):
-        try:
-            title = gresults["titles"][i].replace("\n", " ")
-            source = gresults["links"][i]
-            description = gresults["descriptions"][i]
-            result += f"[{title}]({source})\n"
-            result += f"`{description}`\n\n"
-        except IndexError:
-            pass
-    await message.reply_text(result, disable_web_page_preview=True)
+    try:
+        if len(message.command) < 2:
+            await message.reply_text('"/google" Needs An Argument')
+            return
+        text = message.text.split(None, 1)[1]
+        gresults = await GoogleSearch().async_search(text, 1)
+        result = ""
+        for i in range(4):
+            try:
+                title = gresults["titles"][i].replace("\n", " ")
+                source = gresults["links"][i]
+                description = gresults["descriptions"][i]
+                result += f"[{title}]({source})\n"
+                result += f"`{description}`\n\n"
+            except IndexError:
+                pass
+        await message.reply_text(result, disable_web_page_preview=True)
+    except Exception as e:
+        await message.reply_text(str(e))
 
 
 # StackOverflow [This is also a google search with some added args]
@@ -92,23 +95,26 @@ async def stack(_, message: Message):
 
 @app.on_message(cust_filter.command(commands=("gh")) & ~filters.edited)
 async def github(_, message: Message):
-    if len(message.command) < 2:
-        await message.reply_text('"/gh" Needs An Argument')
-        return
-    gett = message.text.split(None, 1)[1]
-    text = gett + ' "site:github.com"'
-    gresults = await GoogleSearch().async_search(text, 1)
-    result = ""
-    for i in range(4):
-        try:
-            title = gresults["titles"][i].replace("\n", " ")
-            source = gresults["links"][i]
-            description = gresults["descriptions"][i]
-            result += f"[{title}]({source})\n"
-            result += f"`{description}`\n\n"
-        except IndexError:
-            pass
-    await message.reply_text(result, disable_web_page_preview=True)
+    try:
+        if len(message.command) < 2:
+            await message.reply_text('"/gh" Needs An Argument')
+            return
+        gett = message.text.split(None, 1)[1]
+        text = gett + ' "site:github.com"'
+        gresults = await GoogleSearch().async_search(text, 1)
+        result = ""
+        for i in range(4):
+            try:
+                title = gresults["titles"][i].replace("\n", " ")
+                source = gresults["links"][i]
+                description = gresults["descriptions"][i]
+                result += f"[{title}]({source})\n"
+                result += f"`{description}`\n\n"
+            except IndexError:
+                pass
+        await message.reply_text(result, disable_web_page_preview=True)
+    except Exception as e:
+        await message.reply_text(str(e))
 
 
 # Wikipedia
@@ -116,40 +122,46 @@ async def github(_, message: Message):
 
 @app.on_message(cust_filter.command(commands=("wiki")) & ~filters.edited)
 async def wiki(_, message: Message):
-    if len(message.command) < 2:
-        await message.reply_text('/wiki Needs An Argument')
-        return
-    query = message.text.split(None, 1)[1]
-    limit = 5
-    wikipedia.set_lang("en")
-    results = wikipedia.search(query)
-    output = "```Found These Topics```"
-    for i, j in enumerate(results, start=1):
-        page = wikipedia.page(j)
-        url = page.url
-        output += f"[{j}]({url})\n"
-        if i == limit:
-            break
-    await message.reply_text(output, disable_web_page_preview=True)
+    try:
+        if len(message.command) < 2:
+            await message.reply_text('/wiki Needs An Argument')
+            return
+        query = message.text.split(None, 1)[1]
+        limit = 5
+        wikipedia.set_lang("en")
+        results = wikipedia.search(query)
+        output = "```Found These Topics```"
+        for i, j in enumerate(results, start=1):
+            page = wikipedia.page(j)
+            url = page.url
+            output += f"[{j}]({url})\n"
+            if i == limit:
+                break
+        await message.reply_text(output, disable_web_page_preview=True)
+    except Exception as e:
+        await message.reply_text(str(e))
 
 # YouTube
 
 
 @app.on_message(cust_filter.command(commands=("yt")) & ~filters.edited)
 async def ytsearch(_, message: Message):
-    if len(message.command) < 2:
-        await message.reply_text("/yt needs an argument")
-        return
-    query = message.text.split(None, 1)[1]
-    m = await message.reply_text("Searching....")
-    results = YoutubeSearch(query, max_results=4).to_dict()
-    i = 0
-    text = ""
-    while i < 4:
-        text += f"Title - {results[i]['title']}\n"
-        text += f"Duration - {results[i]['duration']}\n"
-        text += f"Views - {results[i]['views']}\n"
-        text += f"Channel - {results[i]['channel']}\n"
-        text += f"https://youtube.com{results[i]['url_suffix']}\n\n"
-        i += 1
-    await m.edit(text, disable_web_page_preview=True)
+    try:
+        if len(message.command) < 2:
+            await message.reply_text("/yt needs an argument")
+            return
+        query = message.text.split(None, 1)[1]
+        m = await message.reply_text("Searching....")
+        results = YoutubeSearch(query, max_results=4).to_dict()
+        i = 0
+        text = ""
+        while i < 4:
+            text += f"Title - {results[i]['title']}\n"
+            text += f"Duration - {results[i]['duration']}\n"
+            text += f"Views - {results[i]['views']}\n"
+            text += f"Channel - {results[i]['channel']}\n"
+            text += f"https://youtube.com{results[i]['url_suffix']}\n\n"
+            i += 1
+        await m.edit(text, disable_web_page_preview=True)
+    except Exception as e:
+        await message.reply_text(str(e))