Upload 10 files

plugins/admin.py

@@ -0,0 +1,22 @@
+
+# (c) @AbirHasan2005 | Modifieded By : @DC4_WARRIOR
+
+
+from pyrogram import Client as Clinton
+from pyrogram import filters
+from config import Config
+from database.access import clinton
+from plugins.buttons import *
+@Clinton.on_message(filters.private & filters.command('total'))
+async def sts(c, m):
+    if m.from_user.id != Config.OWNER_ID:
+        return 
+    total_users = await clinton.total_users_count()
+    await m.reply_text(text=f"Total user(s) {total_users}", quote=True)
+
+
+@Clinton.on_message(filters.private & filters.command("search"))
+async def serc(bot, update):
+
+      await bot.send_message(chat_id=update.chat.id, text="🔍 TORRENT SEARCH", 
+      parse_mode="html", reply_markup=Button.BUTTONS01)

plugins/broadcast.py

@@ -0,0 +1,109 @@
+
+# (c) @AbirHasan2005 | X-Noid
+
+import traceback, datetime, asyncio, string, random, time, os, aiofiles, aiofiles.os
+from database.access import clinton
+from pyrogram import filters
+from pyrogram import Client as Clinton
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from pyrogram.errors import FloodWait, InputUserDeactivated, UserIsBlocked, PeerIdInvalid
+
+from config import Config
+broadcast_ids = {}
+
+async def send_msg(user_id, message):
+    try:
+        await message.copy(chat_id=user_id)
+        return 200, None
+    except FloodWait as e:
+        await asyncio.sleep(e.x)
+        return send_msg(user_id, message)
+    except InputUserDeactivated:
+        return 400, f"{user_id} : deactivated\n"
+    except UserIsBlocked:
+        return 400, f"{user_id} : blocked the bot\n"
+    except PeerIdInvalid:
+        return 400, f"{user_id} : user id invalid\n"
+    except Exception as e:
+        return 500, f"{user_id} : {traceback.format_exc()}\n"
+        
+
+@Clinton.on_message(filters.private & filters.command('broadcast') & filters.reply)
+async def broadcast_(c, m):
+    if m.from_user.id != Config.OWNER_ID:
+        return
+    all_users = await clinton.get_all_users()
+    
+    broadcast_msg = m.reply_to_message
+    
+    while True:
+        broadcast_id = ''.join([random.choice(string.ascii_letters) for i in range(3)])
+        if not broadcast_ids.get(broadcast_id):
+            break
+    
+    out = await m.reply_text(
+        text = f"Broadcast initiated! You will be notified with log file when all the users are notified."
+    )
+    start_time = time.time()
+    total_users = await clinton.total_users_count()
+    done = 0
+    failed = 0
+    success = 0
+    
+    broadcast_ids[broadcast_id] = dict(
+        total = total_users,
+        current = done,
+        failed = failed,
+        success = success
+    )
+    
+    async with aiofiles.open('broadcast.txt', 'w') as broadcast_log_file:
+        async for user in all_users:
+            
+            sts, msg = await send_msg(
+                user_id = int(user['id']),
+                message = broadcast_msg
+            )
+            if msg is not None:
+                await broadcast_log_file.write(msg)
+            
+            if sts == 200:
+                success += 1
+            else:
+                failed += 1
+            
+            if sts == 400:
+                await clinton.delete_user(user['id'])
+            
+            done += 1
+            if broadcast_ids.get(broadcast_id) is None:
+                break
+            else:
+                broadcast_ids[broadcast_id].update(
+                    dict(
+                        current = done,
+                        failed = failed,
+                        success = success
+                    )
+                )
+    if broadcast_ids.get(broadcast_id):
+        broadcast_ids.pop(broadcast_id)
+    completed_in = datetime.timedelta(seconds=int(time.time()-start_time))
+    
+    await asyncio.sleep(3)
+    
+    await out.delete()
+    
+    if failed == 0:
+        await m.reply_text(
+            text=f"broadcast completed in `{completed_in}`\n\nTotal users {total_users}.\nTotal done {done}, {success} success and {failed} failed.",
+            quote=True
+        )
+    else:
+        await m.reply_document(
+            document='broadcast.txt',
+            caption=f"broadcast completed in `{completed_in}`\n\nTotal users {total_users}.\nTotal done {done}, {success} success and {failed} failed.",
+            quote=True
+        )
+    
+    await aiofiles.os.remove('broadcast.txt')

plugins/buttons.py

@@ -0,0 +1,16 @@
+
+
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+
+
+class Button(object):
+
+      BUTTONS01 = InlineKeyboardMarkup( [ [ InlineKeyboardButton(text="📁 YTS", callback_data='00'),
+                                            InlineKeyboardButton(text="🔍 ꜱᴇᴀʀᴄʜ", switch_inline_query_current_chat="1 ") ],
+                                          [ InlineKeyboardButton(text="📁 Anime", callback_data='00'),
+                                            InlineKeyboardButton(text="🔍 ꜱᴇᴀʀᴄʜ", switch_inline_query_current_chat="2 ") ],
+                                          [ InlineKeyboardButton(text="📁 1337x", callback_data='00'),
+                                            InlineKeyboardButton(text="🔍 ꜱᴇᴀʀᴄʜ", switch_inline_query_current_chat="3 " ) ],
+                                          [ InlineKeyboardButton(text="📁 ThePirateBay", callback_data='00'),
+                                            InlineKeyboardButton(text="🔍 ꜱᴇᴀʀᴄʜ", switch_inline_query_current_chat="4 ") ],
+                                          [ InlineKeyboardButton(text="❌", callback_data="X0") ] ] )

plugins/callback.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# (c) Shrimadhav U K | Modified By > @DC4_WARRIOR
+
+from pyrogram import filters
+from pyrogram import Client as Clinton
+from plugins.youtube_dl_button import youtube_dl_call_back
+from plugins.dl_button import ddl_call_back
+
+@Clinton.on_callback_query(filters.regex('^X0$'))
+async def delt(bot, update):
+          await update.message.delete(True)
+
+
+@Clinton.on_callback_query()
+async def button(bot, update):
+
+    cb_data = update.data
+    if "|" in cb_data:
+        await youtube_dl_call_back(bot, update)
+    elif "=" in cb_data:
+        await ddl_call_back(bot, update)

plugins/custom_thumbnail.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# (c) Shrimadhav U K | Modifieded By : @DC4_WARRIOR
+
+# the logging things
+import logging
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+import random
+import numpy
+import os
+from PIL import Image
+import time
+
+from config import Config
+# the Strings used for this "thing"
+from translation import Translation
+from pyrogram import Client as Clinton
+from database.access import clinton
+from hachoir.metadata import extractMetadata
+from hachoir.parser import createParser
+logging.getLogger("pyrogram").setLevel(logging.WARNING)
+from pyrogram import filters
+from database.adduser import AddUser
+from helper_funcs.help_Nekmo_ffmpeg import take_screen_shot
+
+@Clinton.on_message(filters.private & filters.photo)
+async def save_photo(bot, update):
+    await AddUser(bot, update)
+    await clinton.set_thumbnail(update.from_user.id, thumbnail=update.photo.file_id)
+    await bot.send_message(chat_id=update.chat.id, text=Translation.SAVED_CUSTOM_THUMB_NAIL, reply_to_message_id=update.message_id)
+
+@Clinton.on_message(filters.private & filters.command("delthumbnail"))
+async def delthumbnail(bot, update):
+    await AddUser(bot, update)
+    await clinton.set_thumbnail(update.from_user.id, thumbnail=None)
+    await bot.send_message(chat_id=update.chat.id, text=Translation.DEL_ETED_CUSTOM_THUMB_NAIL, reply_to_message_id=update.message_id)
+
+@Clinton.on_message(filters.private & filters.command("viewthumbnail") )
+async def viewthumbnail(bot, update):
+    await AddUser(bot, update)
+    thumbnail = await clinton.get_thumbnail(update.from_user.id)
+    if thumbnail is not None:
+        await bot.send_photo(
+        chat_id=update.chat.id,
+        photo=thumbnail,
+        caption=f"Your current saved thumbnail 🦠",
+        reply_to_message_id=update.message_id)
+    else:
+        await update.reply_text(text=f"No Thumbnail found 🤒")
+
+async def Gthumb01(bot, update):
+    thumb_image_path = Config.DOWNLOAD_LOCATION + "/" + str(update.from_user.id) + ".jpg"
+    db_thumbnail = await clinton.get_thumbnail(update.from_user.id)
+    if db_thumbnail is not None:
+        thumbnail = await bot.download_media(message=db_thumbnail, file_name=thumb_image_path)
+        Image.open(thumbnail).convert("RGB").save(thumbnail)
+        img = Image.open(thumbnail)
+        img.resize((100, 100))
+        img.save(thumbnail, "JPEG")
+    else:
+        thumbnail = None
+
+    return thumbnail
+
+async def Gthumb02(bot, update, duration, download_directory):
+    thumb_image_path = Config.DOWNLOAD_LOCATION + "/" + str(update.from_user.id) + ".jpg"
+    db_thumbnail = await clinton.get_thumbnail(update.from_user.id)
+    if db_thumbnail is not None:
+        thumbnail = await bot.download_media(message=db_thumbnail, file_name=thumb_image_path)
+    else:
+        thumbnail = await take_screen_shot(download_directory, os.path.dirname(download_directory), random.randint(0, duration - 1))
+
+    return thumbnail
+
+async def Mdata01(download_directory):
+
+          width = 0
+          height = 0
+          duration = 0
+          metadata = extractMetadata(createParser(download_directory))
+          if metadata is not None:
+              if metadata.has("duration"):
+                  duration = metadata.get('duration').seconds
+              if metadata.has("width"):
+                  width = metadata.get("width")
+              if metadata.has("height"):
+                  height = metadata.get("height")
+
+          return width, height, duration
+
+async def Mdata02(download_directory):
+
+          width = 0
+          duration = 0
+          metadata = extractMetadata(createParser(download_directory))
+          if metadata is not None:
+              if metadata.has("duration"):
+                  duration = metadata.get('duration').seconds
+              if metadata.has("width"):
+                  width = metadata.get("width")
+
+          return width, duration
+
+async def Mdata03(download_directory):
+
+          duration = 0
+          metadata = extractMetadata(createParser(download_directory))
+          if metadata is not None:
+              if metadata.has("duration"):
+                  duration = metadata.get('duration').seconds
+
+          return duration

plugins/dl_button.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# (c) Shrimadhav U K | Modifieded By : @DC4_WARRIOR
+
+# the logging things
+import logging
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+import asyncio
+import aiohttp
+import json
+import math
+import os
+import shutil
+import time
+from datetime import datetime
+# the secret configuration specific things
+from config import Config
+# the Strings used for this "thing"
+from translation import Translation
+from plugins.custom_thumbnail import *
+logging.getLogger("pyrogram").setLevel(logging.WARNING)
+from helper_funcs.display_progress import progress_for_pyrogram, humanbytes, TimeFormatter
+from hachoir.metadata import extractMetadata
+from hachoir.parser import createParser
+# https://stackoverflow.com/a/37631799/4723940
+from PIL import Image
+
+
+async def ddl_call_back(bot, update):
+    logger.info(update)
+    cb_data = update.data
+    # youtube_dl extractors
+    tg_send_type, youtube_dl_format, youtube_dl_ext = cb_data.split("=")
+    thumb_image_path = Config.DOWNLOAD_LOCATION + \
+        "/" + str(update.from_user.id) + ".jpg"
+    youtube_dl_url = update.message.reply_to_message.text
+    custom_file_name = os.path.basename(youtube_dl_url)
+    if "|" in youtube_dl_url:
+        url_parts = youtube_dl_url.split("|")
+        if len(url_parts) == 2:
+            youtube_dl_url = url_parts[0]
+            custom_file_name = url_parts[1]
+        else:
+            for entity in update.message.reply_to_message.entities:
+                if entity.type == "text_link":
+                    youtube_dl_url = entity.url
+                elif entity.type == "url":
+                    o = entity.offset
+                    l = entity.length
+                    youtube_dl_url = youtube_dl_url[o:o + l]
+        if youtube_dl_url is not None:
+            youtube_dl_url = youtube_dl_url.strip()
+        if custom_file_name is not None:
+            custom_file_name = custom_file_name.strip()
+        # https://stackoverflow.com/a/761825/4723940
+        logger.info(youtube_dl_url)
+        logger.info(custom_file_name)
+    else:
+        for entity in update.message.reply_to_message.entities:
+            if entity.type == "text_link":
+                youtube_dl_url = entity.url
+            elif entity.type == "url":
+                o = entity.offset
+                l = entity.length
+                youtube_dl_url = youtube_dl_url[o:o + l]
+    user = await bot.get_me()
+    mention = user["mention"]
+    description = Translation.CUSTOM_CAPTION_UL_FILE.format(mention)
+    start = datetime.now()
+    await bot.edit_message_text(
+        text=Translation.DOWNLOAD_START,
+        chat_id=update.message.chat.id,
+        message_id=update.message.message_id
+    )
+    tmp_directory_for_each_user = Config.DOWNLOAD_LOCATION + "/" + str(update.from_user.id)
+    if not os.path.isdir(tmp_directory_for_each_user):
+        os.makedirs(tmp_directory_for_each_user)
+    download_directory = tmp_directory_for_each_user + "/" + custom_file_name
+    command_to_exec = []
+    async with aiohttp.ClientSession() as session:
+        c_time = time.time()
+        try:
+            await download_coroutine(
+                bot,
+                session,
+                youtube_dl_url,
+                download_directory,
+                update.message.chat.id,
+                update.message.message_id,
+                c_time
+            )
+        except asyncio.TimeoutError:
+            await bot.edit_message_text(
+                text=Translation.SLOW_URL_DECED,
+                chat_id=update.message.chat.id,
+                message_id=update.message.message_id
+            )
+            return False
+    if os.path.exists(download_directory):
+        end_one = datetime.now()
+        await bot.edit_message_text(
+            text=Translation.UPLOAD_START,
+            chat_id=update.message.chat.id,
+            message_id=update.message.message_id
+        )
+        file_size = Config.TG_MAX_FILE_SIZE + 1
+        try:
+            file_size = os.stat(download_directory).st_size
+        except FileNotFoundError as exc:
+            download_directory = os.path.splitext(download_directory)[0] + "." + "mkv"
+            # https://stackoverflow.com/a/678242/4723940
+            file_size = os.stat(download_directory).st_size
+        if file_size > Config.TG_MAX_FILE_SIZE:
+            await bot.edit_message_text(
+                chat_id=update.message.chat.id,
+                text=Translation.RCHD_TG_API_LIMIT,
+                message_id=update.message.message_id
+            )
+        else:
+            # ref: message from @SOURCES_CODES
+            start_time = time.time()
+            # try to upload file
+            if tg_send_type == "audio":
+                duration = await Mdata03(download_directory)
+                thumb_image_path = await Gthumb01(bot, update)
+                await bot.send_audio(
+                    chat_id=update.message.chat.id,
+                    audio=download_directory,
+                    caption=description,
+                    duration=duration,
+                    thumb=thumb_image_path,
+                    reply_to_message_id=update.message.reply_to_message.message_id,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Translation.UPLOAD_START,
+                        update.message,
+                        start_time
+                    )
+                )
+            elif tg_send_type == "file":
+                  thumb_image_path = await Gthumb01(bot, update)
+                  await bot.send_document(
+                    chat_id=update.message.chat.id,
+                    document=download_directory,
+                    thumb=thumb_image_path,
+                    caption=description,
+                    reply_to_message_id=update.message.reply_to_message.message_id,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Translation.UPLOAD_START,
+                        update.message,
+                        start_time
+                    )
+                )
+            elif tg_send_type == "vm":
+                 width, duration = await Mdata02(download_directory)
+                 thumb_image_path = await Gthumb02(bot, update, duration, download_directory)
+                 await bot.send_video_note(
+                    chat_id=update.message.chat.id,
+                    video_note=download_directory,
+                    duration=duration,
+                    length=width,
+                    thumb=thumb_image_path,
+                    reply_to_message_id=update.message.reply_to_message.message_id,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Translation.UPLOAD_START,
+                        update.message,
+                        start_time
+                    )
+                )
+            elif tg_send_type == "video":
+                 width, height, duration = await Mdata01(download_directory)
+                 thumb_image_path = await Gthumb02(bot, update, duration, download_directory)
+                 await bot.send_video(
+                    chat_id=update.message.chat.id,
+                    video=download_directory,
+                    caption=description,
+                    duration=duration,
+                    width=width,
+                    height=height,
+                    supports_streaming=True,
+                    thumb=thumb_image_path,
+                    reply_to_message_id=update.message.reply_to_message.message_id,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Translation.UPLOAD_START,
+                        update.message,
+                        start_time
+                    )
+                )
+            else:
+                logger.info("Did this happen? :\\")
+            end_two = datetime.now()
+            try:
+                os.remove(download_directory)
+                os.remove(thumb_image_path)
+            except:
+                pass
+            time_taken_for_download = (end_one - start).seconds
+            time_taken_for_upload = (end_two - end_one).seconds
+            await bot.edit_message_text(
+                text=Translation.AFTER_SUCCESSFUL_UPLOAD_MSG_WITH_TS.format(time_taken_for_download, time_taken_for_upload),
+                chat_id=update.message.chat.id,
+                message_id=update.message.message_id,
+                disable_web_page_preview=True
+            )
+    else:
+        await bot.edit_message_text(
+            text=Translation.NO_VOID_FORMAT_FOUND.format("Incorrect Link"),
+            chat_id=update.message.chat.id,
+            message_id=update.message.message_id,
+            disable_web_page_preview=True
+        )
+
+
+async def download_coroutine(bot, session, url, file_name, chat_id, message_id, start):
+    downloaded = 0
+    display_message = ""
+    async with session.get(url, timeout=Config.PROCESS_MAX_TIMEOUT) as response:
+        total_length = int(response.headers["Content-Length"])
+        content_type = response.headers["Content-Type"]
+        if "text" in content_type and total_length < 500:
+            return await response.release()
+        await bot.edit_message_text(
+            chat_id,
+            message_id,
+            text="""Initiating Download
+URL: {}
+File Size: {}""".format(url, humanbytes(total_length))
+        )
+        with open(file_name, "wb") as f_handle:
+            while True:
+                chunk = await response.content.read(Config.CHUNK_SIZE)
+                if not chunk:
+                    break
+                f_handle.write(chunk)
+                downloaded += Config.CHUNK_SIZE
+                now = time.time()
+                diff = now - start
+                if round(diff % 5.00) == 0 or downloaded == total_length:
+                    percentage = downloaded * 100 / total_length
+                    speed = downloaded / diff
+                    elapsed_time = round(diff) * 1000
+                    time_to_completion = round(
+                        (total_length - downloaded) / speed) * 1000
+                    estimated_total_time = elapsed_time + time_to_completion
+                    try:
+                        current_message = """**Download Status**
+URL: {}
+File Size: {}
+Downloaded: {}
+ETA: {}""".format(
+    url,
+    humanbytes(total_length),
+    humanbytes(downloaded),
+    TimeFormatter(estimated_total_time)
+)
+                        if current_message != display_message:
+                            await bot.edit_message_text(
+                                chat_id,
+                                message_id,
+                                text=current_message
+                            )
+                            display_message = current_message
+                    except Exception as e:
+                        logger.info(str(e))
+                        pass
+        return await response.release()

plugins/forcesub.py

@@ -0,0 +1,5 @@
+# soon...
+"""
+from config import Config
+from pyrogram.errors import UserNotParticipant
+"""

plugins/help_text.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# (c) Shrimadhav U K
+
+# the logging things
+import logging
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+import os
+
+from config import Config
+# the Strings used for this "thing"
+from translation import Translation
+
+from pyrogram import filters
+from database.adduser import AddUser
+from pyrogram import Client as Clinton
+logging.getLogger("pyrogram").setLevel(logging.WARNING)
+
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+
+
+@Clinton.on_message(filters.private & filters.command(["help"]))
+async def help_user(bot, update):
+    # logger.info(update)
+    await AddUser(bot, update)
+    await bot.send_message(
+        chat_id=update.chat.id,
+        text=Translation.HELP_USER,
+        parse_mode="html",
+        disable_web_page_preview=True,
+        reply_to_message_id=update.message_id
+    )
+
+
+@Clinton.on_message(filters.private & filters.command(["start"]))
+async def start(bot, update):
+    # logger.info(update)
+    await AddUser(bot, update)
+    await bot.send_message(
+        chat_id=update.chat.id,
+        text=Translation.START_TEXT.format(update.from_user.mention),
+        reply_markup=InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "Source code ⚡", url="https://github.com/imseldrith/UPLOADER-BOT"
+                    ),
+                    InlineKeyboardButton("Project Channel 👨🏻‍💻", url="https://t.me/url_upload_bots"),
+                ],
+                [InlineKeyboardButton("Developer 👨‍⚖️", url="https://t.me/imseldrith")],
+            ]
+        ),
+        reply_to_message_id=update.message_id
+    )

plugins/youtube_dl_button.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Modified By > @Clinton_Abraham
+
+import logging
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logging.getLogger("pyrogram").setLevel(logging.WARNING)
+logger = logging.getLogger(__name__)
+
+import os
+import json
+import math
+import time
+import shutil
+import asyncio
+from PIL import Image
+from config import Config
+from datetime import datetime
+from database.access import clinton
+from translation import Translation
+from plugins.custom_thumbnail import *
+from pyrogram.types import InputMediaPhoto
+from helper_funcs.display_progress import progress_for_pyrogram, humanbytes
+
+
+async def youtube_dl_call_back(bot, update):
+    cb_data = update.data
+    tg_send_type, youtube_dl_format, youtube_dl_ext = cb_data.split("|")
+    save_ytdl_json_path = Config.DOWNLOAD_LOCATION + "/" + str(update.from_user.id) + ".json"
+    try:
+        with open(save_ytdl_json_path, "r", encoding="utf8") as f:
+            response_json = json.load(f)
+    except (FileNotFoundError) as e:
+        await update.message.delete(True)
+        return False
+    youtube_dl_url = update.message.reply_to_message.text
+    custom_file_name = str(response_json.get("title"))[:50] + "_" + youtube_dl_format + "." + youtube_dl_ext
+    youtube_dl_username = None
+    youtube_dl_password = None
+    if "|" in youtube_dl_url:
+        url_parts = youtube_dl_url.split("|")
+        if len(url_parts) == 2:
+            youtube_dl_url = url_parts[0]
+            custom_file_name = url_parts[1]
+        elif len(url_parts) == 4:
+            youtube_dl_url = url_parts[0]
+            custom_file_name = url_parts[1]
+            youtube_dl_username = url_parts[2]
+            youtube_dl_password = url_parts[3]
+        else:
+            for entity in update.message.reply_to_message.entities:
+                if entity.type == "text_link":
+                    youtube_dl_url = entity.url
+                elif entity.type == "url":
+                    o = entity.offset
+                    l = entity.length
+                    youtube_dl_url = youtube_dl_url[o:o + l]
+        if youtube_dl_url is not None:
+            youtube_dl_url = youtube_dl_url.strip()
+        if custom_file_name is not None:
+            custom_file_name = custom_file_name.strip()
+        if youtube_dl_username is not None:
+            youtube_dl_username = youtube_dl_username.strip()
+        if youtube_dl_password is not None:
+            youtube_dl_password = youtube_dl_password.strip()
+    else:
+        for entity in update.message.reply_to_message.entities:
+            if entity.type == "text_link":
+                youtube_dl_url = entity.url
+            elif entity.type == "url":
+                o = entity.offset
+                l = entity.length
+                youtube_dl_url = youtube_dl_url[o:o + l]
+    await bot.edit_message_text(
+    text=Translation.DOWNLOAD_START,
+    chat_id=update.message.chat.id,
+    message_id=update.message.message_id)
+    description = Translation.CUSTOM_CAPTION_UL_FILE
+    if "fulltitle" in response_json:
+        description = response_json["fulltitle"][0:1021]
+        # escape Markdown and special characters
+    tmp_directory_for_each_user = Config.DOWNLOAD_LOCATION + "/" + str(update.from_user.id)
+    if not os.path.isdir(tmp_directory_for_each_user):
+        os.makedirs(tmp_directory_for_each_user)
+    if '/' in custom_file_name:
+        file_mimx = custom_file_name
+        file_maix = file_mimx.split('/')
+        file_name = ' '.join(file_maix)
+    else:
+        file_name = custom_file_name
+    download_directory = tmp_directory_for_each_user + "/" + str(file_name)
+    command_to_exec = []
+    if tg_send_type == "audio":
+        command_to_exec = ["yt-dlp", "-c",
+             "--max-filesize", str(Config.TG_MAX_FILE_SIZE),
+             "--prefer-ffmpeg", "--extract-audio",
+             "--audio-format", youtube_dl_ext,
+             "--audio-quality", youtube_dl_format,
+             youtube_dl_url, "-o", download_directory]
+    else:
+        minus_f_format = youtube_dl_format
+        if "youtu" in youtube_dl_url:
+            minus_f_format = youtube_dl_format + "+bestaudio"
+        command_to_exec = ["yt-dlp", "-c",
+            "--max-filesize", str(Config.TG_MAX_FILE_SIZE),
+            "--embed-subs", "-f", minus_f_format,
+            "--hls-prefer-ffmpeg", youtube_dl_url,
+            "-o", download_directory]
+
+    if Config.HTTP_PROXY != "":
+        command_to_exec.append("--proxy")
+        command_to_exec.append(Config.HTTP_PROXY)
+    if youtube_dl_username is not None:
+        command_to_exec.append("--username")
+        command_to_exec.append(youtube_dl_username)
+    if youtube_dl_password is not None:
+        command_to_exec.append("--password")
+        command_to_exec.append(youtube_dl_password)
+    command_to_exec.append("--no-warnings")
+    command_to_exec.append("--quiet")
+
+    start = datetime.now()
+    process = await asyncio.create_subprocess_exec(*command_to_exec,
+    stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,)
+
+    stdout, stderr = await process.communicate()
+    e_response = stderr.decode().strip()
+    t_response = stdout.decode().strip()
+
+    ad_string_to_replace = "please report this issue on https://yt-dl.org/bug . Make sure you are using the latest version; see  https://yt-dl.org/update  on how to update. Be sure to call youtube-dl with the --verbose flag and include its complete output."
+    if e_response and ad_string_to_replace in e_response:
+        error_message = e_response.replace(ad_string_to_replace, "")
+        await bot.edit_message_text(
+        chat_id=update.message.chat.id,
+        message_id=update.message.message_id,
+        text=error_message)
+        return False
+    if t_response:
+        asyncio.create_task(clendir(save_ytdl_json_path))
+        try:
+            file_size = os.stat(download_directory).st_size
+        except FileNotFoundError:
+            try:
+                download_directory = os.path.splitext(download_directory)[0] + "." + "mkv"
+                file_size = os.stat(download_directory).st_size
+            except Exception:
+                await update.message.edit(text="File Not found 🤒")
+                asyncio.create_task(clendir(tmp_directory_for_each_user))
+                return
+        if file_size > Config.TG_MAX_FILE_SIZE:
+            await bot.edit_message_text(
+            chat_id=update.message.chat.id,
+            text=Translation.RCHD_TG_API_LIMIT.format(time_taken_for_download, humanbytes(file_size)),
+            message_id=update.message.message_id)
+        else:
+            await bot.edit_message_text(
+            text=Translation.UPLOAD_START,
+            chat_id=update.message.chat.id,
+            message_id=update.message.message_id)
+            try:
+                start_time = time.time()
+                if tg_send_type == "audio":
+                    duration = await Mdata03(download_directory)
+                    thumbnail = await Gthumb01(bot, update)
+                    await bot.send_audio(
+                    chat_id=update.message.chat.id,
+                    audio=download_directory,
+                    caption=description,
+                    parse_mode="HTML",
+                    duration=duration,
+                    thumb=thumbnail,
+                    reply_to_message_id=update.message.reply_to_message.message_id,
+                    progress=progress_for_pyrogram,
+                    progress_args=(Translation.UPLOAD_START, update.message, start_time))
+                elif tg_send_type == "file":
+                    thumbnail = await Gthumb01(bot, update)
+                    await bot.send_document(chat_id=update.message.chat.id,
+                    document=download_directory,
+                    thumb=thumbnail,
+                    caption=description,
+                    parse_mode="HTML",
+                    reply_to_message_id=update.message.reply_to_message.message_id,
+                    progress=progress_for_pyrogram,
+                    progress_args=(Translation.UPLOAD_START, update.message, start_time))
+                elif tg_send_type == "vm":
+                    width, duration = await Mdata02(download_directory)
+                    thumbnail = await Gthumb02(bot, update, duration, download_directory)
+                    await bot.send_video_note(chat_id=update.message.chat.id,
+                    video_note=download_directory,
+                    duration=duration,
+                    length=width,
+                    thumb=thumb_image_path,
+                    reply_to_message_id=update.message.reply_to_message.message_id,
+                    progress=progress_for_pyrogram,
+                    progress_args=(Translation.UPLOAD_START, update.message, start_time))
+                elif tg_send_type == "video":
+                    width, height, duration = await Mdata01(download_directory)
+                    thumbnail = await Gthumb02(bot, update, duration, download_directory)
+                    await bot.send_video(chat_id=update.message.chat.id,
+                    video=download_directory,
+                    caption=description,
+                    parse_mode="HTML",
+                    duration=duration,
+                    width=width,
+                    height=height,
+                    thumb=thumbnail,
+                    supports_streaming=True,
+                    reply_to_message_id=update.message.reply_to_message.message_id,
+                    progress=progress_for_pyrogram,
+                    progress_args=(Translation.UPLOAD_START,
+                    update.message, start_time) )
+
+                asyncio.create_task(clendir(download_directory))
+                asyncio.create_task(clendir(thumbnail))
+                await bot.edit_message_text(
+                text="Uploaded sucessfully ✓\n\nJOIN : @url_upload_bots",
+                chat_id=update.message.chat.id,
+                message_id=update.message.message_id,
+                disable_web_page_preview=True)
+
+            except Exception as e:
+                asyncio.create_task(clendir(download_directory))
+                await bot.edit_message_text(text=Translation.ERROR.format(e),
+                chat_id=update.message.chat.id, message_id=update.message.message_id)
+
+#=================================
+
+async def clendir(directory):
+
+    try:
+        os.remove(directory)
+    except:
+        pass
+
+#=================================

plugins/youtube_dl_echo.py

@@ -0,0 +1,250 @@
+# @SPACE_X_BOTS | @Clinton_Abraham </> 
+
+import logging, requests, urllib.parse, os, time, shutil, asyncio, json, math
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logging.getLogger("pyrogram").setLevel(logging.WARNING)
+logger = logging.getLogger(__name__)
+
+from config import Config
+from pyrogram import filters
+from database.access import clinton
+from translation import Translation
+from database.adduser import AddUser
+from pyrogram import Client as Clinton
+from hachoir.parser import createParser
+from hachoir.metadata import extractMetadata
+from helper_funcs.display_progress import humanbytes
+from helper_funcs.help_uploadbot import DownLoadFile
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from helper_funcs.display_progress import progress_for_pyrogram, humanbytes, TimeFormatter
+
+@Clinton.on_message(filters.private & ~filters.via_bot & filters.regex(pattern=".*http.*"))
+async def echo(bot, update):
+    await AddUser(bot, update)
+    imog = await update.reply_text("Processing...⚡", reply_to_message_id=update.message_id)
+    youtube_dl_username = None
+    youtube_dl_password = None
+    file_name = None
+    url = update.text
+    if "|" in url:
+        url_parts = url.split("|")
+        if len(url_parts) == 2:
+            url = url_parts[0]
+            file_name = url_parts[1]
+        elif len(url_parts) == 4:
+            url = url_parts[0]
+            file_name = url_parts[1]
+            youtube_dl_username = url_parts[2]
+            youtube_dl_password = url_parts[3]
+        else:
+            for entity in update.entities:
+                if entity.type == "text_link":
+                    url = entity.url
+                elif entity.type == "url":
+                    o = entity.offset
+                    l = entity.length
+                    url = url[o:o + l]
+        if url is not None:
+            url = url.strip()
+        if file_name is not None:
+            file_name = file_name.strip()
+        # https://stackoverflow.com/a/761825/4723940
+        if youtube_dl_username is not None:
+            youtube_dl_username = youtube_dl_username.strip()
+        if youtube_dl_password is not None:
+            youtube_dl_password = youtube_dl_password.strip()
+        logger.info(url)
+        logger.info(file_name)
+    else:
+        for entity in update.entities:
+            if entity.type == "text_link":
+                url = entity.url
+            elif entity.type == "url":
+                o = entity.offset
+                l = entity.length
+                url = url[o:o + l]
+    if Config.HTTP_PROXY != "":
+        command_to_exec = [
+            "yt-dlp",
+            "--no-warnings",
+            "--youtube-skip-dash-manifest",
+            "-j",
+            url,
+            "--proxy", Config.HTTP_PROXY
+        ]
+    else:
+        command_to_exec = [
+            "yt-dlp",
+            "--no-warnings",
+            "--youtube-skip-dash-manifest",
+            "-j",
+            url
+        ]
+    if youtube_dl_username is not None:
+        command_to_exec.append("--username")
+        command_to_exec.append(youtube_dl_username)
+    if youtube_dl_password is not None:
+        command_to_exec.append("--password")
+        command_to_exec.append(youtube_dl_password)
+    process = await asyncio.create_subprocess_exec(*command_to_exec,
+    stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
+    stdout, stderr = await process.communicate()
+    e_response = stderr.decode().strip()
+    t_response = stdout.decode().strip()
+    if e_response and "nonnumeric port" not in e_response:
+        error_message = e_response.replace(Translation.ERROR_YTDLP, "")
+        if "This video is only available for registered users." in error_message:
+            error_message = Translation.SET_CUSTOM_USERNAME_PASSWORD
+        else:
+            error_message = "Invalid url 🚸</code>"
+        await bot.send_message(chat_id=update.chat.id,
+        text=Translation.NO_VOID_FORMAT_FOUND.format(str(error_message)),
+        disable_web_page_preview=True, parse_mode="html",
+        reply_to_message_id=update.message_id)
+        await imog.delete(True)
+        return False
+    if t_response:
+        # logger.info(t_response)
+        x_reponse = t_response
+        if "\n" in x_reponse:
+            x_reponse, _ = x_reponse.split("\n")
+        response_json = json.loads(x_reponse)
+        save_ytdl_json_path = Config.DOWNLOAD_LOCATION + \
+            "/" + str(update.from_user.id) + ".json"
+        with open(save_ytdl_json_path, "w", encoding="utf8") as outfile:
+            json.dump(response_json, outfile, ensure_ascii=False)
+        # logger.info(response_json)
+        inline_keyboard = []
+        duration = None
+        if "duration" in response_json:
+            duration = response_json["duration"]
+        if "formats" in response_json:
+            for formats in response_json["formats"]:
+                format_id = formats.get("format_id")
+                format_string = formats.get("format_note")
+                if format_string is None:
+                    format_string = formats.get("format")
+                format_ext = formats.get("ext")
+                approx_file_size = ""
+                if "filesize" in formats:
+                    approx_file_size = humanbytes(formats["filesize"])
+                cb_string_video = "{}|{}|{}".format(
+                    "video", format_id, format_ext)
+                cb_string_file = "{}|{}|{}".format(
+                    "file", format_id, format_ext)
+                if format_string is not None and not "audio only" in format_string:
+                    ikeyboard = [
+                        InlineKeyboardButton(
+                            "S " + format_string + " video " + approx_file_size + " ",
+                            callback_data=(cb_string_video).encode("UTF-8")
+                        ),
+                        InlineKeyboardButton(
+                            "D " + format_ext + " " + approx_file_size + " ",
+                            callback_data=(cb_string_file).encode("UTF-8")
+                        )
+                    ]
+                    """if duration is not None:
+                        cb_string_video_message = "{}|{}|{}".format(
+                            "vm", format_id, format_ext)
+                        ikeyboard.append(
+                            InlineKeyboardButton(
+                                "VM",
+                                callback_data=(
+                                    cb_string_video_message).encode("UTF-8")
+                            )
+                        )"""
+                else:
+                    # special weird case :\
+                    ikeyboard = [
+                        InlineKeyboardButton(
+                            "SVideo [" +
+                            "] ( " +
+                            approx_file_size + " )",
+                            callback_data=(cb_string_video).encode("UTF-8")
+                        ),
+                        InlineKeyboardButton(
+                            "DFile [" +
+                            "] ( " +
+                            approx_file_size + " )",
+                            callback_data=(cb_string_file).encode("UTF-8")
+                        )
+                    ]
+                inline_keyboard.append(ikeyboard)
+            if duration is not None:
+                cb_string_64 = "{}|{}|{}".format("audio", "64k", "mp3")
+                cb_string_128 = "{}|{}|{}".format("audio", "128k", "mp3")
+                cb_string = "{}|{}|{}".format("audio", "320k", "mp3")
+                inline_keyboard.append([
+                    InlineKeyboardButton(
+                        "MP3 " + "(" + "64 kbps" + ")", callback_data=cb_string_64.encode("UTF-8")),
+                    InlineKeyboardButton(
+                        "MP3 " + "(" + "128 kbps" + ")", callback_data=cb_string_128.encode("UTF-8"))
+                ])
+                inline_keyboard.append([
+                    InlineKeyboardButton(
+                        "MP3 " + "(" + "320 kbps" + ")", callback_data=cb_string.encode("UTF-8"))
+                ])
+        else:
+            format_id = response_json["format_id"]
+            format_ext = response_json["ext"]
+            cb_string_file = "{}|{}|{}".format(
+                "file", format_id, format_ext)
+            cb_string_video = "{}|{}|{}".format(
+                "video", format_id, format_ext)
+            inline_keyboard.append([
+                InlineKeyboardButton(
+                    "SVideo",
+                    callback_data=(cb_string_video).encode("UTF-8")
+                ),
+                InlineKeyboardButton(
+                    "DFile",
+                    callback_data=(cb_string_file).encode("UTF-8")
+                )
+            ])
+            cb_string_file = "{}={}={}".format(
+                "file", format_id, format_ext)
+            cb_string_video = "{}={}={}".format(
+                "video", format_id, format_ext)
+            inline_keyboard.append([
+                InlineKeyboardButton(
+                    "video",
+                    callback_data=(cb_string_video).encode("UTF-8")
+                ),
+                InlineKeyboardButton(
+                    "file",
+                    callback_data=(cb_string_file).encode("UTF-8")
+                )
+            ])
+        reply_markup = InlineKeyboardMarkup(inline_keyboard)
+        await imog.delete(True)
+        await bot.send_message(
+            chat_id=update.chat.id,
+            text=Translation.FORMAT_SELECTION + "\n" + Translation.SET_CUSTOM_USERNAME_PASSWORD,
+            reply_markup=reply_markup,
+            parse_mode="html",
+            reply_to_message_id=update.message_id
+        )
+    else:
+        inline_keyboard = []
+        cb_string_file = "{}={}={}".format(
+            "file", "LFO", "NONE")
+        cb_string_video = "{}={}={}".format(
+            "video", "OFL", "ENON")
+        inline_keyboard.append([
+            InlineKeyboardButton(
+                "SVideo",
+                callback_data=(cb_string_video).encode("UTF-8")
+            ),
+            InlineKeyboardButton(
+                "DFile",
+                callback_data=(cb_string_file).encode("UTF-8")
+            )
+        ])
+        reply_markup = InlineKeyboardMarkup(inline_keyboard)
+        await imog.delete(True)
+        await bot.send_message(
+        chat_id=update.chat.id,
+        text=Translation.FORMAT_SELECTION,
+        reply_markup=reply_markup,
+        parse_mode="html",
+        reply_to_message_id=update.message_id)