Api key (#65)

* Added api key

* Inline funcs

* Inline funcs

.gitignore

@@ -1,4 +1,5 @@
 *.m4a
+__pycache__
 *.opus
 nsfw.py
 unknown_errors.txt

app.json

@@ -70,6 +70,10 @@
         "MESSAGE_DUMP_CHAT": {
             "description": "Chat_id of the group where useless things will go",
             "required": true
+        },
+        "ARQ_API_KEY": {
+            "description": "Get this from @ARQRoboto.",
+            "required": true
         }
     }
 }

sample_config.py

@@ -15,8 +15,8 @@ if HEROKU:
     FERNET_ENCRYPTION_KEY = environ.get("FERNET_ENCRYPTION_KEY", None)
     WELCOME_DELAY_KICK_SEC = int(environ.get("WELCOME_DELAY_KICK_SEC", None))
     MONGO_DB_URI = environ.get("MONGO_DB_URI", None)
-    ARQ_API_BASE_URL = environ.get("ARQ_API_BASE_URL", None)
-
+    ARQ_API_URL = environ.get("ARQ_API_URL", None)
+    ARQ_API_KEY = environ.get("ARQ_API_KEY", None)
 else:
     BOT_TOKEN = "467677575:YZfaakjwd545dfg-N6JStihhuw5gQeZHntc"
     API_ID = 123456
@@ -35,5 +35,6 @@ else:
     )
     WELCOME_DELAY_KICK_SEC = 300
     MONGO_DB_URI = "mongodb+srv://username:password@cluster0.ksiis.mongodb.net/YourDataBaseName?retryWrites=true&w=majority"
+    ARQ_API_KEY = "Get this from @ARQRobot"
     # NOTE Don't make changes below this line
     ARQ_API_BASE_URL = "http://thearq.tech"

wbb/__init__.py

@@ -89,8 +89,8 @@ print("[INFO]: LOADING BOT CLIENT")
 app = Client("wbb", bot_token=BOT_TOKEN, api_id=API_ID, api_hash=API_HASH)
 # ARQ client
 print("[INFO]: LOADING ARQ")
-arq = ARQ(ARQ_API_BASE_URL)
-# Telegram client
+arq = ARQ(ARQ_API_URL, ARQ_API_KEY)
+# Telegraph client
 print("[INFO]: LOADING TELEGRAPH")
 telegraph = Telegraph()
 telegraph.create_account(short_name="wbb")

wbb/__main__.py

@@ -69,12 +69,6 @@ async def start_bot():
 @app.on_message(filters.command(["help", "start"]))
 async def help_command(_, message):
     if message.chat.type != "private":
-        if len(message.command) >= 2 and message.command[1] == "help":
-            text, keyboard = await help_parser(message)
-            await message.reply(
-                text, reply_markup=keyboard, disable_web_page_preview=True
-            )
-            return
         keyboard = InlineKeyboardMarkup(
             [
                 [

wbb/modules/arq.py

@@ -23,12 +23,16 @@ SOFTWARE.
 """
 from pyrogram import filters
 
-from wbb import ARQ_API_BASE_URL, app, arq
+from wbb import ARQ_API_URL, app, arq
 
 
 @app.on_message(filters.command("arq"))
 async def arq_stats(_, message):
     data = await arq.stats()
+    if not data.ok:
+        await message.reply_text(data.result)
+        return
+    data = data.result
     uptime = data.uptime
     requests = data.requests
     cpu = data.cpu
@@ -37,6 +41,7 @@ async def arq_stats(_, message):
     disk = data.disk
     platform = data.platform
     python_version = data.python
+    users = data.users
     statistics = f"""
 **Uptime:** `{uptime}`
 **Requests:** `{requests}`
@@ -47,6 +52,7 @@ async def arq_stats(_, message):
 **Disk:** `{disk}`
 **Platform:** `{platform}`
 **Python:** `{python_version}`
-**Address:** {ARQ_API_BASE_URL}
+**Users:** `{users}`
+**Address:** {ARQ_API_URL}
 """
     await message.reply_text(statistics)

wbb/modules/chatbot.py

@@ -72,6 +72,11 @@ async def chatbot_status(_, message):
         await message.reply_text("**Usage**\n/chatbot [ON|OFF]")
 
 
+async def lunaQuery(query):
+    luna = await arq.luna(query)
+    return luna.result
+
+
 @app.on_message(
     filters.text & filters.reply & ~filters.bot & ~filters.via_bot & ~filters.forwarded,
     group=chatbot_group,
@@ -85,8 +90,7 @@ async def chatbot_talk(_, message):
     if message.reply_to_message.from_user.id != BOT_ID:
         return
     query = message.text
-    luna = await arq.luna(query)
-    response = luna.response
+    response = await lunaQuery(query)
     await message.reply_text(response)
 
 
@@ -145,8 +149,7 @@ async def chatbot_talk_ubot(_, message):
     else:
         if username not in query:
             return
-    luna = await arq.luna(query)
-    response = luna.response
+    response = await lunaQuery(query)
     await message.reply_text(response)
 
 
@@ -160,7 +163,6 @@ async def chatbot_talk_ubot_pm(_, message):
         return
     query = message.text
     await app2.send_chat_action(message.chat.id, "typing")
-    luna = await arq.luna(query)
-    response = luna.response
+    response = await lunaQuery(query)
     await message.reply_text(response)
     await app2.send_chat_action(message.chat.id, "cancel")

wbb/modules/music.py

@@ -157,9 +157,12 @@ async def jssong(_, message):
     m = await message.reply_text("Searching...")
     try:
         songs = await arq.saavn(query)
-        sname = songs[0].song
-        slink = songs[0].media_url
-        ssingers = songs[0].singers
+        if not songs.ok:
+            await message.reply_text(songs.result)
+            return
+        sname = songs.result[0].song
+        slink = songs.result[0].media_url
+        ssingers = songs.result[0].singers
         await m.edit("Downloading")
         song = await download_song(slink)
         await m.edit("Uploading")
@@ -198,9 +201,12 @@ async def deezsong(_, message):
     m = await message.reply_text("Searching...")
     try:
         songs = await arq.deezer(query, 1)
-        title = songs[0].title
-        url = songs[0].url
-        artist = songs[0].artist
+        if not songs.ok:
+            await message.reply_text(songs.result)
+            return
+        title = songs.result[0].title
+        url = songs.result[0].url
+        artist = songs.result[0].artist
         await m.edit("Downloading")
         song = await download_song(url)
         await m.edit("Uploading")
@@ -229,7 +235,7 @@ async def lyrics_func(_, message):
     m = await message.reply_text("**Searching**")
     query = message.text.strip().split(None, 1)[1]
     song = await arq.lyrics(query)
-    lyrics = song.lyrics
+    lyrics = song.result
     if len(lyrics) < 4095:
         await m.edit(f"__{lyrics}__")
         return

wbb/modules/ocr.py

@@ -86,7 +86,7 @@ async def image_ocr(_, message):
     os.remove(file)
     data = await arq.ocr(url)
     try:
-        await m.edit(data.ocr)
+        await m.edit(data.result)
     except MessageEmpty:
         await m.edit("There's no text in that image.")
         return

wbb/modules/reddit.py

@@ -37,16 +37,16 @@ async def reddit(_, message):
         await message.reply_text("/reddit needs an argument")
         return
     subreddit = message.text.split(None, 1)[1]
-    try:
-        reddit = await arq.reddit(subreddit)
-        sreddit = reddit.subreddit
-        title = reddit.title
-        image = reddit.url
-        link = reddit.postLink
-        caption = f"""**Title:** `{title}`
+    reddit = await arq.reddit(subreddit)
+    if not reddit.ok:
+        await message.reply_text(reddit.result)
+        return
+    reddit = reddit.result
+    sreddit = reddit.subreddit
+    title = reddit.title
+    image = reddit.url
+    link = reddit.postLink
+    caption = f"""**Title:** `{title}`
 **Subreddit:** {sreddit}
 **PostLink:** {link}"""
-        await message.reply_photo(photo=image, caption=caption)
-    except Exception as e:
-        print(str(e))
-        await message.reply_text(str(e))
+    await message.reply_photo(photo=image, caption=caption)

wbb/utils/inlinefuncs.py

@@ -171,28 +171,35 @@ __**Translated from {i.src} to {lang}**__
 
 async def urban_func(answers, text):
     results = await arq.urbandict(text)
+    if not results.ok:
+        answers.append(
+            InlineQueryResultArticle(
+                title="Error",
+                description=results.result,
+                input_message_content=InputTextMessageContent(results.result),
+            )
+        )
+        return answers
+    results = results.result
     limit = 0
     for i in results:
         if limit > 48:
             break
         limit += 1
-        try:
-            msg = f"""
+        msg = f"""
 **Query:** {text}
 
-**Definition:** __{results[i].definition}__
+**Definition:** __{i.definition}__
 
-**Example:** __{results[i].example}__"""
+**Example:** __{i.example}__"""
 
-            answers.append(
-                InlineQueryResultArticle(
-                    title=results[i].word,
-                    description=results[i].definition,
-                    input_message_content=InputTextMessageContent(msg),
-                )
+        answers.append(
+            InlineQueryResultArticle(
+                title=i.word,
+                description=i.definition,
+                input_message_content=InputTextMessageContent(msg),
             )
-        except KeyError:
-            pass
+        )
     return answers
 
 
@@ -225,87 +232,108 @@ async def google_search_func(answers, text):
 
 async def wall_func(answers, text):
     results = await arq.wall(text)
+    if not results.ok:
+        answers.append(
+            InlineQueryResultArticle(
+                title="Error",
+                description=results.result,
+                input_message_content=InputTextMessageContent(results.result),
+            )
+        )
+        return answers
     limit = 0
+    results = results.result
     for i in results:
         if limit > 48:
             break
         limit += 1
-        try:
-            answers.append(
-                InlineQueryResultPhoto(
-                    photo_url=results[i].url_image,
-                    thumb_url=results[i].url_thumb,
-                    caption=f"[Source]({results[i].url_image})",
-                )
+        answers.append(
+            InlineQueryResultPhoto(
+                photo_url=i.url_image,
+                thumb_url=i.url_thumb,
+                caption=f"[Source]({i.url_image})",
             )
-        except KeyError:
-            pass
+        )
     return answers
 
 
 async def saavn_func(answers, text):
     buttons_list = []
     results = await arq.saavn(text)
-    for i in results:
+    if not results.ok:
+        answers.append(
+            InlineQueryResultArticle(
+                title="Error",
+                description=results.result,
+                input_message_content=InputTextMessageContent(results.result),
+            )
+        )
+        return answers
+    results = results.result
+    for count, i in enumerate(results):
         buttons = InlineKeyboard(row_width=1)
-        buttons.add(InlineKeyboardButton("Download | Play", url=results[i].media_url))
+        buttons.add(InlineKeyboardButton("Download | Play", url=i.media_url))
         buttons_list.append(buttons)
-        duration = await time_convert(results[i].duration)
+        duration = await time_convert(i.duration)
         caption = f"""
-**Title:** {results[i].song}
-**Album:** {results[i].album}
+**Title:** {i.song}
+**Album:** {i.album}
 **Duration:** {duration}
-**Release:** {results[i].year}
-**Singers:** {results[i].singers}"""
+**Release:** {i.year}
+**Singers:** {i.singers}"""
         description = (
-            f"{results[i].album} | {duration} "
-            + f"| {results[i].singers} ({results[i].year})"
+            f"{i.album} | {duration} "
+            + f"| {i.singers} ({i.year})"
         )
-        try:
-            answers.append(
-                InlineQueryResultArticle(
-                    title=results[i].song,
-                    input_message_content=InputTextMessageContent(
-                        caption, disable_web_page_preview=True
-                    ),
-                    description=description,
-                    thumb_url=results[i].image,
-                    reply_markup=buttons_list[i],
-                )
+        answers.append(
+            InlineQueryResultArticle(
+                title=i.song,
+                input_message_content=InputTextMessageContent(
+                    caption, disable_web_page_preview=True
+                ),
+                description=description,
+                thumb_url=i.image,
+                reply_markup=buttons_list[count],
             )
-        except (KeyError, ValueError):
-            pass
+        )
     return answers
 
 
 async def deezer_func(answers, text):
     buttons_list = []
     results = await arq.deezer(text, 5)
-    for i in results:
+    if not results.ok:
+        answers.append(
+            InlineQueryResultArticle(
+                title="Error",
+                description=results.result,
+                input_message_content=InputTextMessageContent(results.result),
+            )
+        )
+        return answers
+    results = results.result
+    for count, i in enumerate(results):
         buttons = InlineKeyboard(row_width=1)
-        buttons.add(InlineKeyboardButton("Download | Play", url=results[i].url))
+        buttons.add(InlineKeyboardButton("Download | Play", url=i.url))
         buttons_list.append(buttons)
-        duration = await time_convert(results[i].duration)
+        duration = await time_convert(i.duration)
         caption = f"""
-**Title:** {results[i].title}
-**Artist:** {results[i].artist}
+**Title:** {i.title}
+**Artist:** {i.artist}
 **Duration:** {duration}
-**Source:** [Deezer]({results[i].source})"""
-        description = f"{results[i].artist} | {duration}"
-        try:
-            answers.append(
-                InlineQueryResultArticle(
-                    title=results[i].title,
-                    thumb_url=results[i].thumbnail,
-                    description=description,
-                    input_message_content=InputTextMessageContent(
-                        caption, disable_web_page_preview=True
-                    ),
-                    reply_markup=buttons_list[i],
-                )
+**Source:** [Deezer]({i.source})"""
+        description = f"{i.artist} | {duration}"
+        answers.append(
+            InlineQueryResultArticle(
+                title=i.title,
+                thumb_url=i.thumbnail,
+                description=description,
+                input_message_content=InputTextMessageContent(
+                    caption, disable_web_page_preview=True
+                ),
+                reply_markup=buttons_list[count],
             )
-        except (KeyError, ValueError):
-            pass
+        )
     return answers
 
 
@@ -339,16 +367,26 @@ async def shortify(url):
 
 async def torrent_func(answers, text):
     results = await arq.torrent(text)
+    if not results.ok:
+        answers.append(
+            InlineQueryResultArticle(
+                title="Error",
+                description=results.result,
+                input_message_content=InputTextMessageContent(results.result),
+            )
+        )
+        return answers
     limit = 0
+    results = results.result
     for i in results:
         if limit > 48:
             break
-        title = results[i].name
-        size = results[i].size
-        seeds = results[i].seeds
-        leechs = results[i].leechs
-        upload_date = results[i].uploaded + " Ago"
-        magnet = results[i].magnet
+        title = i.name
+        size = i.size
+        seeds = i.seeds
+        leechs = i.leechs
+        upload_date = i.uploaded + " Ago"
+        magnet = i.magnet
         caption = f"""
 **Title:** __{title}__
 **Size:** __{size}__
@@ -358,63 +396,77 @@ async def torrent_func(answers, text):
 **Magnet:** `{magnet}`"""
 
         description = f"{size} | {upload_date} | Seeds: {seeds}"
-        try:
-            answers.append(
-                InlineQueryResultArticle(
-                    title=title,
-                    description=description,
-                    input_message_content=InputTextMessageContent(
-                        caption, disable_web_page_preview=True
-                    ),
-                )
+        answers.append(
+            InlineQueryResultArticle(
+                title=title,
+                description=description,
+                input_message_content=InputTextMessageContent(
+                    caption, disable_web_page_preview=True
+                ),
             )
-            limit += 1
-        except (KeyError, ValueError):
-            pass
+        )
+        limit += 1
+        pass
     return answers
 
 
 async def youtube_func(answers, text):
     results = await arq.youtube(text)
+    if not results.ok:
+        answers.append(
+            InlineQueryResultArticle(
+                title="Error",
+                description=results.result,
+                input_message_content=InputTextMessageContent(results.result),
+            )
+        )
+        return answers
     limit = 0
+    results = results.result
     for i in results:
         if limit > 48:
             break
         limit += 1
         buttons = InlineKeyboard(row_width=1)
-        video_url = f"https://youtube.com{results[i].url_suffix}"
+        video_url = f"https://youtube.com{i.url_suffix}"
         buttons.add(InlineKeyboardButton("Watch", url=video_url))
         caption = f"""
-**Title:** {results[i].title}
-**Views:** {results[i].views}
-**Channel:** {results[i].channel}
-**Duration:** {results[i].duration}
-**Uploaded:** {results[i].publish_time}
-**Description:** {results[i].long_desc}"""
+**Title:** {i.title}
+**Views:** {i.views}
+**Channel:** {i.channel}
+**Duration:** {i.duration}
+**Uploaded:** {i.publish_time}
+**Description:** {i.long_desc}"""
         description = (
-            f"{results[i].views} | {results[i].channel} | "
-            + f"{results[i].duration} | {results[i].publish_time}"
+            f"{i.views} | {i.channel} | "
+            + f"{i.duration} | {i.publish_time}"
         )
-        try:
-            answers.append(
-                InlineQueryResultArticle(
-                    title=results[i].title,
-                    thumb_url=results[i].thumbnails[0],
-                    description=description,
-                    input_message_content=InputTextMessageContent(
-                        caption, disable_web_page_preview=True
-                    ),
-                    reply_markup=buttons,
-                )
+        answers.append(
+            InlineQueryResultArticle(
+                title=i.title,
+                thumb_url=i.thumbnails[0],
+                description=description,
+                input_message_content=InputTextMessageContent(
+                    caption, disable_web_page_preview=True
+                ),
+                reply_markup=buttons,
             )
-        except (KeyError, ValueError):
-            pass
+        )
     return answers
 
 
 async def lyrics_func(answers, text):
     song = await arq.lyrics(text)
-    lyrics = song.lyrics
+    if not song.ok:
+        answers.append(
+            InlineQueryResultArticle(
+                title="Error",
+                description=song.result,
+                input_message_content=InputTextMessageContent(song.result),
+            )
+        )
+        return answers
+    lyrics = song.result
     song = lyrics.splitlines()
     song_name = song[0]
     artist = song[1]
@@ -610,16 +662,26 @@ async def music_inline_func(answers, query):
 
 async def wiki_func(answers, text):
     data = await arq.wiki(text)
+    if not data.ok:
+        answers.append(
+            InlineQueryResultArticle(
+                title="Error",
+                description=data.result,
+                input_message_content=InputTextMessageContent(data.result),
+            )
+        )
+        return answers
+    data = data.result
     msg = f"""
 **QUERY:**
-{data['title']}
+{data.title}
 
 **ANSWER:**
-__{data['answer']}__"""
+__{data.answer}__"""
     answers.append(
         InlineQueryResultArticle(
-            title=data["title"],
-            description=data["answer"],
+            title=data.title,
+            description=data.answer,
             input_message_content=InputTextMessageContent(msg),
         )
     )
@@ -748,7 +810,7 @@ async def ping_func(answers):
     ping = Ping(ping_id=randint(696969, 6969696))
     await app.send(ping)
     t2 = time()
-    ping = f"{str(round((t2 - t1), 6)) * 100} ms"
+    ping = f"{str(round((t2 - t1), 6) * 100)} ms"
     answers.append(
         InlineQueryResultArticle(
             title=ping, input_message_content=InputTextMessageContent(f"__**{ping}**__")
@@ -759,9 +821,19 @@ async def ping_func(answers):
 
 async def nsfw_scan_func(answers, url: str):
     t1 = time()
-    data = (await arq.nsfw_scan(url)).data
+    data = await arq.nsfw_scan(url)
+    if not data.ok:
+        answers.append(
+            InlineQueryResultArticle(
+                title="Error",
+                description=data.result,
+                input_message_content=InputTextMessageContent(data.result),
+            )
+        )
+        return answers
     t2 = time()
     tt = round(t2 - t1, 4)
+    data = data.result
     content = f"""
 **Scanned [Image]({url}) In {tt} Seconds.**
 
@@ -793,7 +865,7 @@ async def yt_music_func(answers, url, user_id):
         )
         return answers
     if "http" not in url:
-        url = (await arq.youtube(url))[0]
+        url = (await arq.youtube(url)).result[0]
         url = f"https://youtube.com{url.url_suffix}"
     title, performer, duration, audio, thumbnail = await download_youtube_audio(url)
     m = await app.send_audio(