Added ytdl

wbb/modules/misc.py

@@ -26,10 +26,9 @@ import string
 
 import aiohttp
 from cryptography.fernet import Fernet
-from googletrans import Translator
 from pyrogram import filters
 
-from wbb import FERNET_ENCRYPTION_KEY, app
+from wbb import FERNET_ENCRYPTION_KEY, app, arq
 from wbb.core.decorators.errors import capture_err
 from wbb.utils import random_line
 from wbb.utils.fetch import fetch
@@ -259,19 +258,13 @@ async def tr(_, message):
         return
     if message.reply_to_message.text:
         text = message.reply_to_message.text
-        try:
-            i = Translator().translate(text, dest=lang)
-        except ValueError:
-            await message.reply_text("[ERROR]: LANGUAGE NOT FOUND")
-            return
-        await message.reply_text(i.text)
     elif message.reply_to_message.caption:
         text = message.reply_to_message.caption
-        i = Translator().translate(text, dest=lang)
-        await message.reply_text(i.text)
-
-
-fetch_limit = 0
+    result = await arq.translate(text, lang)
+    if not result.ok:
+        await message.reply_text(result.result)
+        return
+    await message.reply_text(result.result.translatedText)
 
 
 @app.on_message(filters.command("json") & ~filters.edited)
@@ -281,9 +274,6 @@ async def json_fetch(_, message):
     if len(message.command) != 2:
         await message.reply_text("/json [URL]")
         return
-    elif fetch_limit > 500:
-        await message.reply_text("Today's Quota Exceeded!, lol")
-        return
     url = message.text.split(None, 1)[1]
     try:
         data = await fetch(url)

wbb/modules/ytdl.py

@@ -0,0 +1,116 @@
+from asyncio import gather
+from os import remove
+from random import randint
+
+from pykeyboard import InlineKeyboard
+from pyrogram import filters
+from pyrogram.types import InlineKeyboardButton
+
+from wbb import app, arq
+from wbb.core.decorators.errors import capture_err
+from wbb.utils.formatter import convert_seconds_to_minutes as timeFormat
+from wbb.utils.functions import downloader
+
+__MODULE__ = "YoutubeDL"
+__HELP__ = "/ytdl [VIDEO_LINK] - Download a youtube video."
+
+
+VIDEO_DATA = {}
+
+
+@app.on_message(filters.command("ytdl"))
+async def ytdl_func(_, message):
+    if len(message.command) != 2:
+        await message.reply_text("**Usage:**/ytdl [VIDEO_LINK]")
+        return
+    m = await message.reply_text("Processing")
+    url = message.text.split(None, 1)[1]
+    results = await arq.ytdl(url)
+    if not results.ok:
+        await message.reply_text(results.result)
+        return
+    result = results.result
+    title = result.title
+    thumbnail = result.thumbnail
+    duration = result.duration
+    video = result.video
+    buttons = InlineKeyboard(row_width=3)
+    keyboard = []
+    for media in video:
+        quality = media.quality
+        size = media.size
+        url = media.url
+        format = media.format
+        data = str(randint(999, 9999999))
+        VIDEO_DATA[data] = {
+            "url": url,
+            "title": title,
+            "size": size,
+            "quality": quality,
+            "duration": duration,
+            "format": format,
+            "thumbnail": thumbnail,
+        }
+        keyboard.append(
+            InlineKeyboardButton(
+                text=f"{quality} | {size}", callback_data=f"ytdl {data}"
+            )
+        )
+    buttons.add(*keyboard)
+    caption = f"""
+**Title:** {title}
+**Duration:** {await timeFormat(duration)}
+**Size:** {size}
+"""
+    await message.reply_photo(thumbnail, caption=caption, reply_markup=buttons)
+    await m.delete()
+
+
+@app.on_callback_query(filters.regex(r"^ytdl"))
+async def ytdlCallback(_, cq):
+    await cq.message.edit("Downloading")
+    data_ = cq.data.split()[1]
+    try:
+        data = VIDEO_DATA[data_]
+        url = data["url"]
+        title = data["title"]
+        duration = data["duration"]
+        format = data["format"]
+        size = data["size"]
+        thumbnail = data["thumbnail"]
+        caption = f"""
+    **Title:** {title}
+    **Size:** {size}
+    **Format:** {format}
+    **Duration:** {await timeFormat(duration)}
+        """
+        media, thumb = await gather(
+            downloader.download(url), downloader.download(thumbnail)
+        )
+        await cq.message.edit("Uploading")
+        if format == "mp3":
+            await cq.message.reply_audio(
+                media,
+                quote=False,
+                caption=caption,
+                duration=duration,
+                thumb=thumb,
+                title=title,
+            )
+        else:
+            await cq.message.reply_video(
+                media,
+                caption=caption,
+                quote=False,
+                duration=duration,
+                supports_streaming=True,
+            )
+        del VIDEO_DATA[data_]
+        remove(thumb)
+        remove(media)
+        await cq.message.delete()
+    except Exception as e:
+        e = traceback.format_exc()
+        print(e)
+        del VIDEO_DATA[data_]
+        await cq.message.delete()

wbb/utils/aiodownloader/downloader.py

@@ -28,7 +28,7 @@ class DownloadJob:
         self._session = session
         self._chunk_size = chunk_size
 
-        self.file_name = file_url.split("/")[~0]
+        self.file_name = file_url.split("/")[~0][0:230]
         self.file_path = (
             os.path.join(save_path, self.file_name)
             if save_path
@@ -143,5 +143,6 @@ class Handler:
 
         await task
         file_name = url.split("/")[-1]
+        file_name = file_name[0:230] if len(file_name) > 230 else file_name
         path = os.getcwd() + "/" + file_name if not save_path else save_path
         return path

wbb/utils/inlinefuncs.py

@@ -31,7 +31,6 @@ from time import ctime, time
 
 import aiofiles
 import aiohttp
-from googletrans import Translator
 from motor import version as mongover
 from pykeyboard import InlineKeyboard
 from pyrogram import __version__ as pyrover
@@ -148,25 +147,37 @@ async def alive_function(answers):
 
 
 async def translate_func(answers, lang, tex):
-    i = Translator().translate(tex, dest=lang)
+    result = await arq.translate(tex, lang)
+    if not result.ok:
+        answers.append(
+            InlineQueryResultArticle(
+                title="Error",
+                description=result.result,
+                input_message_content=InputTextMessageContent(result.result),
+            )
+        )
+        return answers
+    result = result.result
     msg = f"""
-__**Translated from {i.src} to {lang}**__
+__**Translated from {result.src} to {result.dest}**__
 
 **INPUT:**
 {tex}
 
 **OUTPUT:**
-{i.text}"""
+{result.translatedText}"""
     answers.extend(
         [
             InlineQueryResultArticle(
-                title=f"Translated from {i.src} to {lang}.",
-                description=i.text,
+                title=f"Translated from {result.src} to {result.dest}.",
+                description=result.translatedText,
                 input_message_content=InputTextMessageContent(msg),
             ),
             InlineQueryResultArticle(
-                title=i.text,
-                input_message_content=InputTextMessageContent(i.text),
+                title=result.translatedText,
+                input_message_content=InputTextMessageContent(
+                    result.translatedText
+                ),
             ),
         ]
     )
@@ -425,7 +436,7 @@ async def youtube_func(answers, text):
 **Uploaded:** {i.publish_time}
 **Description:** {i.long_desc}"""
         description = (
-            f"{i.views} | {i.channel} | " + f"{i.duration} | {i.publish_time}"
+            f"{i.views} | {i.channel} | {i.duration} | {i.publish_time}"
         )
         answers.append(
             InlineQueryResultArticle(