Many many fixes, infact fixed everything, fuck you (#36)

* various admin fixes

* Fixed many things in search.py

* Fixed wallpaper shit

* many fixes

* many fixes 2

wbb/modules/admin.py

@@ -94,18 +94,15 @@ async def purge(client, message: Message):
 
 @app.on_message(cust_filter.command(commands=("kick")) & ~filters.edited)
 async def kick(_, message: Message):
-    try:
-        username = (message.text.split(None, 2)[1])
-    except IndexError:
-        username = ""
     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 username != "":
-            if username in SUDO or (await app.get_users(username)).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 \
@@ -117,9 +114,8 @@ async def kick(_, message: Message):
                     await message.reply_text("This user isn't here,"
                                              " consider kicking yourself.")
 
-        else:
-            if username in SUDO or message.reply_to_message.from_user.id \
-                    in SUDO:
+        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 \
@@ -127,106 +123,77 @@ async def kick(_, message: Message):
                     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(f"Kicked {username}")
+                    await message.reply_text("Kicked!")
                 else:
-                    await message.reply_text("This user isn't here,"
-                                             " consider kicking yourself.")
+                    await message.reply_text("This user isn't here.")
 
 # Ban members
 
 
 @app.on_message(cust_filter.command(commands=("ban")) & ~filters.edited)
 async def ban(_, message: Message):
-    try:
-        username = (message.text.split(None, 2)[1])
-    except IndexError:
-        username = ""
     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 username != "":
-            if username in SUDO or (await app.get_users(username)).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}")
+                    await message.reply_text(f"Banned! {username}")
                 else:
                     await message.reply_text("This user isn't here,"
                                              " consider banning yourself.")
-        else:
-            if username in SUDO or message.reply_to_message.from_user.id \
-                    in SUDO:
+
+        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 (await app.get_users(username)).id in \
+                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(f"Banned {username}")
+                    await message.reply_text("Banned!")
                 else:
-                    await message.reply_text("This user isn't here,"
-                                             " consider kicking yourself.")
+                    await message.reply_text("This user isn't here.")
+
 
 # Unban members
 
 
 @app.on_message(cust_filter.command(commands=("unban")) & ~filters.edited)
 async def unban(_, message: Message):
-    try:
-        username = (message.text.split(None, 2)[1])
-    except IndexError:
-        username = ""
     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 username != "":
+        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}")
+                await message.reply_text(f"Unbanned! {username}")
             else:
                 await message.reply_text("This user is already here,"
-                                         " don't bully me!")
-        else:
-            if (await app.get_users(username)).id not in \
+                                         " 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.reply_to_message.chat.unban_member(user_id)
-                await message.reply_text(f"Unbanned {username}")
+                await message.chat.unban_member(user_id)
+                await message.reply_text("Unbanned!")
             else:
-                await message.reply_text("This user is already here,"
-                                         " don't bully me!")
+                await message.reply_text("This user is already here.")
 
-# Kick members on their own call
-
-
-@app.on_message(cust_filter.command(commands=("kickme")) & ~filters.edited)
-async def kickme(_, message: Message):
-    if message.from_user.id not in SUDO:
-        await message.chat.kick_member(message.from_user.id)
-        await message.chat.unban_member(message.from_user.id)
-        await message.reply_text("Kicked!, Joke's on you, I'm into that shit!")
-    else:
-        await message.reply_text("It doesn't works that way mate.")
-
-# Ban members on their own call
-
-
-@app.on_message(cust_filter.command(commands=("banme")))
-async def banme(_, message: Message):
-    if message.from_user.id not in SUDO:
-        await message.chat.kick_member(message.from_user.id)
-        await message.reply_text("Banned!, Joke's on you, I'm into that shit!")
-    else:
-        await message.reply_text("It doesn't works that way mate.")
 
 # Delete messages
 
@@ -276,10 +243,7 @@ async def promote(_, message: Message):
                         user_id=user_id,
                         can_change_info=True,
                         can_invite_users=True,
-                        can_restrict_members=True,
-                        can_delete_messages=True,
-                        can_pin_messages=True,
-                        can_promote_members=True)
+                        can_delete_messages=True)
                     await message.reply_text('Promoted!')
 
                 else:
@@ -288,10 +252,7 @@ async def promote(_, message: Message):
                         user_id=user_id,
                         can_change_info=True,
                         can_invite_users=True,
-                        can_restrict_members=True,
-                        can_delete_messages=True,
-                        can_pin_messages=True,
-                        can_promote_members=True)
+                        can_delete_messages=True)
                     await message.reply_text('Promoted!')
 
             else:
@@ -321,29 +282,10 @@ async def pin(_, message: Message):
             == 'creator' \
                 or message.from_user.id in SUDO:
 
-            await message.reply_to_message.pin()
+            await message.reply_to_message.pin(disable_notification=True)
     else:
         await message.reply_text("You're Not An Admin, Stop Spamming!")
 
-# Unpin Messages
-
-
-@app.on_message(cust_filter.command(commands=("unpin")) & ~filters.edited)
-async def unpin(_, message: Message):
-    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' \
-                or message.from_user.id in SUDO:
-            await app.unpin_all_chat_messages(chat_id)
-    else:
-        await message.reply_text("You're Not An Admin, Stop Spamming!")
 
 # Mute members
 
@@ -351,15 +293,17 @@ async def unpin(_, message: Message):
 @app.on_message(cust_filter.command(commands=("mute")) & ~filters.edited)
 async def mute(_, message: Message):
     chat_id = message.chat.id
-    admins = await list_admins(chat_id)
     from_user_id = message.from_user.id
-    username = message.text.replace("/mute", "")
+    if not message.reply_to_message:
+        await message.reply_text("Reply To A User's Message!")
+        return
 
-    if from_user_id in admins or from_user_id in SUDO:
-        if username != "":
-            victim = username
-        else:
-            victim = message.reply_to_message.from_user.id
+    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!")
@@ -372,15 +316,16 @@ async def mute(_, message: Message):
 @app.on_message(cust_filter.command(commands=("unmute")) & ~filters.edited)
 async def unmute(_, message: Message):
     chat_id = message.chat.id
-    admins = await list_admins(chat_id)
     from_user_id = message.from_user.id
-    username = message.text.replace("/unmute", "")
-
-    if from_user_id in admins or from_user_id in SUDO:
-        if username != "":
-            victim = username
-        else:
-            victim = message.reply_to_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:

wbb/modules/images.py

@@ -41,19 +41,19 @@ async def dog(_, message: Message):
 
 @app.on_message(cust_filter.command(commands=("wall")) & ~filters.edited)
 async def wall(_, message: Message):
-    app.set_parse_mode("markdown")
-    if len(message.command) > 2:
+    if len(message.command) < 2:
         await message.reply_text("/wall needs an argument")
         return
-    m = await message.reply_text("Searching!")
     initial_term = message.text.split(None, 1)[1]
+    m = await message.reply_text("Searching!")
+
     term = initial_term.replace(' ', '%20')
     api = "https://wall.alphacoders.com/api2.0/get.php?auth=" + \
         "{}&method=search&term={}".format(WALL_API_KEY, term)
 
     json_rep = r.get(api).json()
     if not json_rep.get("success"):
-        await m.edit("`\"/wall\"` Needs A Keyword Argument!")
+        await m.edit("Something happened! Shit.")
     else:
         wallpapers = json_rep.get("wallpapers")
         if not wallpapers:
@@ -69,4 +69,4 @@ async def wall(_, message: Message):
         wallpaper = wallpaper.get("url_image")
         wallpaper = wallpaper.replace("\\", "")
         await message.reply_document(wallpaper)
-    await delete_message_with_delay(5, m)
+        await m.delete()

wbb/modules/misc.py

@@ -6,7 +6,6 @@ from pyrogram import filters
 from pyrogram.types import Message
 from googletrans import Translator
 from cryptography.fernet import Fernet
-from wbb.utils.botinfo import BOT_ID
 from wbb import app, FERNET_ENCRYPTION_KEY
 from wbb.utils import cust_filter, random_line
 
@@ -43,99 +42,73 @@ async def quote(_, message: Message):
 
 @app.on_message(cust_filter.command(commands=("id")) & ~filters.edited)
 async def get_id(_, message: Message):
-    app.set_parse_mode("markdown")
-    if message.text != '/id':
-        username = message.text.replace('/id', '')
+    if len(message.command) != 1:
+        username = message.text.split(None, 1)[1]
         user_id = (await app.get_users(username)).id
         msg = f"{username}'s ID is `{user_id}`"
         await message.reply_text(msg)
 
-    elif message.text == '/id' and not bool(message.reply_to_message):
+    elif len(message.command) == 1 and not message.reply_to_message:
         chat_id = message.chat.id
         msg = f"{message.chat.title}'s ID is `{chat_id}`"
         await message.reply_text(msg)
 
-    elif message.text == '/id' and bool(message.reply_to_message):
+    elif len(message.command) == 1 and message.reply_to_message:
         from_user_id = message.reply_to_message.from_user.id
         from_user_mention = message.reply_to_message.from_user.mention
         msg = f"{from_user_mention}'s ID is `{from_user_id}`"
         await message.reply_text(msg)
 
-
-@app.on_message(cust_filter.command(commands=("dev")) & ~filters.edited)
-async def dev(_, message: Message):
-    app.set_parse_mode("markdown")
-    if (await app.get_chat_member(
-            message.chat.id,
-            BOT_ID)).can_restrict_members:
-
-        await message.reply_to_message.forward('TheHamkerChat')
-        await app.send_message("TheHamkerChat",
-                               "Forwarded By: `{}` | {}\n"
-                               "Forwarded From: `{}` | {}"
-                               .format(message.from_user.id,
-                                       message.from_user.mention,
-                                       message.chat.id,
-                                       message.chat.title))
-        await message.reply_text("Your Message Has Been Forward To Devs,"
-                                 + " Any Missuse Of This Feature Will Not"
-                                 + " Be Tolerated And You Will Be"
-                                 + " Gbanned instantaneously!")
-    else:
-        await message.reply_text("To Use This Feature You Have To Make Me"
-                                 + " Admin")
-# Password
+# Random
 
 
 @app.on_message(cust_filter.command(commands=('random')) & ~filters.edited)
 async def random(_, message: Message):
-    app.set_parse_mode('markdown')
-    if message.text != "/random":
-        length = message.text.replace('/random', '')
-        try:
-            if 1 < int(length) < 1000:
-                alphabet = string.ascii_letters + string.digits
-                password = ''.join(secrets.choice(alphabet) for i in
-                                   range(int(length)))
-                await message.reply_text(f"`{password}`")
-            else:
-                await message.reply_text('Specify A Length Between 1-1000')
-        except ValueError:
-            await message.reply_text("Strings Won't Work!, Pass A"
-                                     + " Positive Integer Between 1-1000")
-    else:
+    if len(message.command) != 2:
         await message.reply_text('"/random" Needs An Argurment.'
                                  ' Ex: `/random 5`')
+        random
+    length = message.text.split(None, 1)[1]
+
+    try:
+        if 1 < int(length) < 1000:
+            alphabet = string.ascii_letters + string.digits
+            password = ''.join(secrets.choice(alphabet) for i in
+                               range(int(length)))
+            await message.reply_text(f"`{password}`")
+        else:
+            await message.reply_text('Specify A Length Between 1-1000')
+    except ValueError:
+        await message.reply_text("Strings Won't Work!, Pass A"
+                                 + " Positive Integer Between 1-1000")
 
 # http cat search
 
 
 @app.on_message(cust_filter.command(commands=('http')) & ~filters.edited)
 async def http(_, message: Message):
-    if message.text != "/http":
-        code = message.text.replace('/http', '')
-        url = f"https://http.cat/{code}"
-        final = url.replace(' ', '')
-        await message.reply_photo(final)
-    else:
+    if len(message.command) != 2:
         await message.reply_text('"/http" Needs An Argument. Ex: `/http 404`')
-
+        return
+    code = message.text.split(None, 1)[1]
+    url = f"https://http.cat/{code}"
+    final = url.replace(' ', '')
+    await message.reply_photo(final)
 
 # Encrypt
 
 
 @app.on_message(cust_filter.command(commands=('encrypt')) & ~filters.edited)
 async def encrypt(_, message: Message):
-    app.set_parse_mode('markdown')
     if not message.reply_to_message:
         await message.reply_text('Reply To A Message To Encrypt It.')
-    else:
-        text = message.reply_to_message.text
-        text_in_bytes = bytes(text, 'utf-8')
-        cipher_suite = Fernet(FERNET_ENCRYPTION_KEY)
-        encrypted_text = cipher_suite.encrypt(text_in_bytes)
-        bytes_in_text = encrypted_text.decode("utf-8")
-        await message.reply_text(bytes_in_text)
+        return
+    text = message.reply_to_message.text
+    text_in_bytes = bytes(text, 'utf-8')
+    cipher_suite = Fernet(FERNET_ENCRYPTION_KEY)
+    encrypted_text = cipher_suite.encrypt(text_in_bytes)
+    bytes_in_text = encrypted_text.decode("utf-8")
+    await message.reply_text(bytes_in_text)
 
 # Decrypt
 
@@ -144,25 +117,27 @@ async def encrypt(_, message: Message):
 async def decrypt(_, message: Message):
     if not message.reply_to_message:
         await message.reply_text('Reply To A Message To Decrypt It.')
-    else:
-        text = message.reply_to_message.text
-        text_in_bytes = bytes(text, 'utf-8')
-        cipher_suite = Fernet(FERNET_ENCRYPTION_KEY)
-        decoded_text = cipher_suite.decrypt(text_in_bytes)
-        bytes_in_text = decoded_text.decode("utf-8")
-        await message.reply_text(bytes_in_text)
+        return
+    text = message.reply_to_message.text
+    text_in_bytes = bytes(text, 'utf-8')
+    cipher_suite = Fernet(FERNET_ENCRYPTION_KEY)
+    decoded_text = cipher_suite.decrypt(text_in_bytes)
+    bytes_in_text = decoded_text.decode("utf-8")
+    await message.reply_text(bytes_in_text)
 
 # Ipinfo
 
 
 @app.on_message(cust_filter.command(commands=('ipinfo')) & ~filters.edited)
 async def ipaddrinfo(_, message: Message):
-    app.set_parse_mode('markdown')
-    ipaddr = message.text.replace("/ipinfo", "")
-    if ipaddr != "":
-        handler = ipinfo.getHandler()
-        details = handler.getDetails(ipaddr)
-        await message.reply_text(f'''`IP - {details.ip}
+    if len(message.command) != 2:
+        await message.reply_text('`/ipinfo` Requires An IP As Argument'
+                                 + '. Ex - `/ipinfo 1.1.1.1`')
+        return
+    ipaddr = message.text.split(None, 1)[1]
+    handler = ipinfo.getHandler()
+    details = handler.getDetails(ipaddr)
+    await message.reply_text(f'''`IP - {details.ip}
 City - {details.city}
 Region - {details.region}
 Country - {details.country}
@@ -171,25 +146,24 @@ ORG - {details.org}
 Postal - {details.postal}
 Timezone - {details.timezone}`''')
 
-    else:
-        await message.reply_text('`/ipinfo` Requires An IP As Argument'
-                                 + '. Ex - `/ipinfo 1.1.1.1`')
 
 # Cheat.sh
 
 
 @app.on_message(cust_filter.command(commands=("cheat")) & ~filters.edited)
 async def cheat(_, message: Message):
-    text = message.text.replace("/cheat ", "")
+    text = message.text.split(None, 1)[1]
     ftext = text.split()
     try:
         language = ftext[0]
     except IndexError:
         await message.reply_text("/cheat [language] [query]")
+        return
     try:
         query = ftext[1]
     except IndexError:
         await message.reply_text("/cheat [language] [query]")
+        return
     r = requests.get(f"http://cht.sh/{language}/{query}?QT")
     reply = r.text
     await message.reply_text(f"`{reply}`")
@@ -199,28 +173,28 @@ async def cheat(_, message: Message):
 
 @app.on_message(cust_filter.command(commands=("weather")) & ~filters.edited)
 async def weather(_, message: Message):
-    city = message.text.replace("/weather ", "")
-    if city != "":
-        r = requests.get(f"https://wttr.in/{city}?mnTC0")
-        data = r.text
-        await message.reply_text(f"`{data}`")
-    else:
+    city = message.text.split(None, 1)[1]
+    if len(message.command) != 2:
         await message.reply_text("/weather [city]")
+        return
+    r = requests.get(f"https://wttr.in/{city}?mnTC0")
+    data = r.text
+    await message.reply_text(f"`{data}`")
 
 # Translate
 
 
 @app.on_message(cust_filter.command(commands=("tr")) & ~filters.edited)
 async def tr(_, message: Message):
-    lang = message.text.replace("/tr", "")
-    flang = lang.replace(" ", "")
-
-    if message.reply_to_message and flang != "":
-        text = message.reply_to_message.text
-        i = Translator().translate(text, dest=flang)
-        await message.reply_text(i.text)
-    else:
-        await message.reply_text("Reply to a message with /tr [language code]"
-                                 + "\nGet supported language list from here -"
-                                 + " https://py-googletrans.readthedocs.io/en"
-                                 + "/latest/#googletrans-languages")
+    lang = message.text.split(None, 1)[1]
+    if not message.reply_to_message or lang == "":
+        await message.reply_text(
+            "Reply to a message with /tr [language code]"
+            + "\nGet supported language list from here -"
+            + " https://py-googletrans.readthedocs.io/en"
+            + "/latest/#googletrans-languages"
+        )
+        return
+    text = message.reply_to_message.text
+    i = Translator().translate(text, dest=lang)
+    await message.reply_text(i.text)

wbb/modules/music.py

@@ -19,8 +19,7 @@ ydl_opts = {
 @app.on_message(cust_filter.command(commands=("music")) & ~filters.edited)
 async def music(_, message: Message):
     if len(message.command) != 2:
-        await message.reply_text(
-            "`/music` needs a link as argument")
+        await message.reply_text("`/music` needs a link as argument")
         return
     link = message.text.split(None, 1)[1]
     m = await message.reply_text(f"Downloading {link}",

wbb/modules/repo.py

@@ -10,7 +10,6 @@ __HELP__ = "/repo - To Get My Github Repository Link " \
 
 @app.on_message(cust_filter.command(commands=("repo")) & ~filters.edited)
 async def repo(_, message: Message):
-    app.set_parse_mode("markdown")
     await message.reply_text(
         "[Github](https://github.com/thehamkercat/WilliamButcherBot)"
         + " | [Group](t.me/TheHamkerChat)", disable_web_page_preview=True)

wbb/modules/search.py

@@ -20,106 +20,107 @@ __HELP__ = '''/ud - Search For Something In Urban Dictionary
 
 @app.on_message(cust_filter.command(commands=("ud")) & ~filters.edited)
 async def urbandict(_, message: Message):
-    text = message.text.replace("/ud ", '')
-    api = "http://api.urbandictionary.com/v0/define?term="
-    if text != '':
-        try:
-            results = get(f"{api}{text}").json()
-            reply_text = f'Definition: {results["list"][0]["definition"]}'
-            reply_text += f'\n\nExample: {results["list"][0]["example"]}'
-        except IndexError:
-            reply_text = ("Sorry could not find any matching results!")
-        ignore_chars = "[]"
-        reply = reply_text
-        for chars in ignore_chars:
-            reply = reply.replace(chars, "")
-        if len(reply) >= 4096:
-            reply = reply[:4096]
-        await message.reply_text(reply)
-
-    else:
+    if len(message.command) < 2:
         await message.reply_text('"/ud" Needs An Argument.')
+        return
+    text = message.text.split(None, 1)[1]
+    api = "http://api.urbandictionary.com/v0/define?term="
+
+    try:
+        results = get(f"{api}{text}").json()
+        reply_text = f'Definition: {results["list"][0]["definition"]}'
+        reply_text += f'\n\nExample: {results["list"][0]["example"]}'
+    except IndexError:
+        reply_text = ("Sorry could not find any matching results!")
+    ignore_chars = "[]"
+    reply = reply_text
+    for chars in ignore_chars:
+        reply = reply.replace(chars, "")
+    if len(reply) >= 4096:
+        reply = reply[:4096]
+    await message.reply_text(reply)
 
 # google
 
 
 @app.on_message(cust_filter.command(commands=("google")) & ~filters.edited)
 async def google(_, message: Message):
-    text = message.text.replace("/google ", '')
-    if text != '':
-        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)
-    else:
+    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)
+
 
 # StackOverflow [This is also a google search with some added args]
 
 
 @app.on_message(cust_filter.command(commands=("so")) & ~filters.edited)
 async def stack(_, message: Message):
-    gett = message.text.replace("/so ", '')
-    text = gett + ' "site:stackoverflow.com"'
-    if gett != '':
-        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)
-    else:
+    if len(message.command) < 2:
         await message.reply_text('"/so" Needs An Argument')
+        return
+    gett = message.text.split(None, 1)[1]
+    text = gett + ' "site:stackoverflow.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)
+
 
 # Github [This is also a google search with some added args]
 
 
 @app.on_message(cust_filter.command(commands=("gh")) & ~filters.edited)
 async def github(_, message: Message):
-    gett = message.text.replace("/gh ", '')
-    text = gett + ' "site:github.com"'
-    if gett != '':
-        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)
-    else:
+    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)
+
 
 # Wikipedia
 
 
 @app.on_message(cust_filter.command(commands=("wiki")) & ~filters.edited)
 async def wiki(_, message: Message):
-    query = message.text.replace("/wiki", '')
-    limit = 5
-    if message.reply_to_message:
-        query = message.reply_to_message.text
-    if not query:
-        await message.reply_text('Reply To A Message Or Give An Argument')
+    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```"
@@ -136,10 +137,11 @@ async def wiki(_, message: Message):
 
 @app.on_message(cust_filter.command(commands=("yt")) & ~filters.edited)
 async def ytsearch(_, message: Message):
-    m = await message.reply_text("Searching....")
-    query = message.text.replace("/yt", '')
-    if query == "":
+    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 = ""

wbb/modules/succ.py

@@ -7,8 +7,12 @@ from wbb.utils import cust_filter
 __MODULE__ = "Succ"
 __HELP__ = "/succ - Sends Succ Image For A Given Argument"
 
-hack = ['https://i.ibb.co/YLLhCtt/i.png', 'https://i.ibb.co/DMzyLMZ/e.jpg',
-        'https://i.ibb.co/sqngHGt/d.jpg', 'https://i.ibb.co/b1Y1rGf/a.jpg']
+hack = [
+    "https://i.ibb.co/YLLhCtt/i.png",
+    "https://i.ibb.co/DMzyLMZ/e.jpg",
+    "https://i.ibb.co/sqngHGt/d.jpg",
+    "https://i.ibb.co/b1Y1rGf/a.jpg",
+]
 
 kemeest = "'https://i.ibb.co/bB4pqNN/i.jpg'"
 educ = "'https://i.ibb.co/LCB3yTX/q.jpg'"
@@ -19,36 +23,48 @@ security = "'https://i.ibb.co/ctf3MGM/c.jpg'"
 
 
 def suck(text):
-    socc = {'komidi': 'message.reply_photo("https://i.ibb.co/mRL3Nnf/j.jpg")',
-            'kemist': f'message.reply_photo({kemeest})',
-            'ejucation': f'message.reply_photo({educ})',
-            'helth': f'message.reply_photo({health})',
-            'nothelth': f'message.reply_photo({nhealth})',
-            'femnnism': f'message.reply_photo({feminism})',
-            'tehc': 'message.reply_photo("https://i.ibb.co/gdSvHSr/n.jpg")',
-            'stonks': 'message.reply_photo("https://i.ibb.co/TtZ144x/h.png")',
-            'sekuriti': f'message.reply_photo({security})',
-            'phijiks': 'message.reply_photo("https://i.ibb.co/Zz4wBnc/g.png")',
-            'welth': 'message.reply_photo("https://i.ibb.co/JxFm4pW/k.jpg")',
-            'smrt': 'message.reply_photo("https://i.ibb.co/7bVkyC7/l.jpg")',
-            'hacc': 'message.reply_photo(random.choice(hack))'}
+    socc = {
+        "komidi": 'message.reply_photo("https://i.ibb.co/mRL3Nnf/j.jpg")',
+        "kemist": f"message.reply_photo({kemeest})",
+        "ejucation": f"message.reply_photo({educ})",
+        "helth": f"message.reply_photo({health})",
+        "nothelth": f"message.reply_photo({nhealth})",
+        "femnnism": f"message.reply_photo({feminism})",
+        "tehc": 'message.reply_photo("https://i.ibb.co/gdSvHSr/n.jpg")',
+        "stonks": 'message.reply_photo("https://i.ibb.co/TtZ144x/h.png")',
+        "sekuriti": f"message.reply_photo({security})",
+        "phijiks": 'message.reply_photo("https://i.ibb.co/Zz4wBnc/g.png")',
+        "welth": 'message.reply_photo("https://i.ibb.co/JxFm4pW/k.jpg")',
+        "smrt": 'message.reply_photo("https://i.ibb.co/7bVkyC7/l.jpg")',
+        "linuks": 'message.reply_photo("https://i.ibb.co/m6b0cB1/image.png")',
+        "hacc": "message.reply_photo(random.choice(hack))",
+    }
     return socc.get(text)
 
 
 @app.on_message(cust_filter.command(commands=("succ")) & ~filters.edited)
 def succ(_, message: Message):
-    result = suck(message.text.replace('/succ ', ''))
+    if len(message.command) != 2:
+        message.reply_text(
+            """"/succ" Needs And Argument
+Args - `komidi, kemist, ejucation, helth, nothelth,
+femnnism, tehc, hacc, stonks, sekuriti,
+phijiks, welth, smrt`"""
+        )
+    result = suck(message.text.split(None, 1)[1])
     if result is None:
-        message.reply_text('''"/succ" Needs And Argument
+        message.reply_text(
+            """"/succ" Needs And Argument
 Args - `komidi, kemist, ejucation, helth, nothelth,
 femnnism, tehc, hacc, stonks, sekuriti,
-phijiks, welth, smrt`''')
+phijiks, welth, smrt`"""
+        )
     exec(result)
 
 
 @app.on_message(cust_filter.command(commands=("reddit")) & ~filters.edited)
 async def reddit(_, message: Message):
-    app.set_parse_mode('html')
+    app.set_parse_mode("html")
     if len(message.command) != 2:
         await message.reply_text("/reddit needs an argument")
     subreddit = message.command[1]

wbb/modules/sudoers.py

@@ -79,8 +79,7 @@ def speed_convert(size):
     filters.user(SUDOERS) & cust_filter.command(commands=("speedtest"))
 )
 async def get_speedtest_result(_, message: Message):
-    app.set_parse_mode("markdown")
-    m = await message.reply_text("```Performing A Speedtest!```")
+    m = await message.reply_text("`Performing A Speedtest!`")
     speed = speedtest.Speedtest()
     i = speed.get_best_server()
     j = speed.download()
@@ -122,7 +121,6 @@ async def get_stats(_, message: Message):
       CPU: {cpu}%
       RAM: {mem}%
       Disk: {disk}%
-
 {neofetch}
 ```''')
     await message.reply_text(stats)
@@ -134,24 +132,24 @@ async def get_stats(_, message: Message):
     filters.user(SUDOERS) & cust_filter.command(commands=("song"))
 )
 async def song(_, message: Message):
-    text = message.text.replace("/song", "")
-    query = text.replace(" ", "")
-    if text != "":
-        m = await message.reply_text("Searching...")
-        r = requests.get(f"{JSMAPI}{query}")
-
-        i = 0
-        while i < 2:
-            sname = r.json()[i]['song']
-            slink = r.json()[i]['media_url']
-            ssingers = r.json()[i]['singers']
-            file = wget.download(slink)
-            ffile = file.replace("mp4", "m4a")
-            os.rename(file, ffile)
-            await message.reply_audio(audio=ffile, title=sname,
-                                      performer=ssingers)
-            i += 1
-            os.remove(ffile)
-        await m.delete()
-    else:
+    if len(message.command) < 2:
         await message.reply_text("/song requires an argument.")
+        return
+    text = message.text.split(None, 1)[1]
+    query = text.replace(" ", "%20")
+    m = await message.reply_text("Searching...")
+    try:
+        r = requests.get(f"{JSMAPI}{query}")
+    except Exception as e:
+        await m.edit(str(e))
+        return
+    sname = r.json()[0]['song']
+    slink = r.json()[0]['media_url']
+    ssingers = r.json()[0]['singers']
+    file = wget.download(slink)
+    ffile = file.replace("mp4", "m4a")
+    os.rename(file, ffile)
+    await message.reply_audio(audio=ffile, title=sname,
+                              performer=ssingers)
+    os.remove(ffile)
+    await m.delete()