Upload 6 files

plugins/cb_buttons.py

@@ -0,0 +1,127 @@
+#!/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 json
+import math
+import os
+import shutil
+import subprocess
+import time
+
+# the secret configuration specific things
+if bool(os.environ.get("WEBHOOK", False)):
+    from sample_config import Config
+else:
+    from config import Config
+
+# the Strings used for this "thing"
+from translation import Translation
+
+import pyrogram
+logging.getLogger("pyrogram").setLevel(logging.WARNING)
+
+from helper_funcs.display_progress import progress_for_pyrogram, humanbytes
+from plugins.youtube_dl_button import youtube_dl_call_back
+from plugins.dl_button import ddl_call_back
+from hachoir.metadata import extractMetadata
+from hachoir.parser import createParser
+# https://stackoverflow.com/a/37631799/4723940
+from PIL import Image
+
+
+@pyrogram.Client.on_callback_query()
+async def button(bot, update):
+    if update.from_user.id in Config.AUTH_USERS:
+        # logger.info(update)
+        cb_data = update.data
+        if ":" in cb_data:
+            # unzip formats
+            extract_dir_path = Config.DOWNLOAD_LOCATION + \
+                "/" + str(update.from_user.id) + "zipped" + "/"
+            if not os.path.isdir(extract_dir_path):
+                await bot.delete_messages(
+                    chat_id=update.message.chat.id,
+                    message_ids=update.message.message_id,
+                    revoke=True
+                )
+                return False
+            zip_file_contents = os.listdir(extract_dir_path)
+            type_of_extract, index_extractor, undefined_tcartxe = cb_data.split(":")
+            if index_extractor == "NONE":
+                try:
+                    shutil.rmtree(extract_dir_path)
+                except:
+                    pass
+                await bot.edit_message_text(
+                    chat_id=update.message.chat.id,
+                    text=Translation.CANCEL_STR,
+                    message_id=update.message.message_id
+                )
+            elif index_extractor == "ALL":
+                i = 0
+                for file_content in zip_file_contents:
+                    current_file_name = os.path.join(extract_dir_path, file_content)
+                    start_time = time.time()
+                    await bot.send_document(
+                        chat_id=update.message.chat.id,
+                        document=current_file_name,
+                        # thumb=thumb_image_path,
+                        caption=file_content,
+                        # reply_markup=reply_markup,
+                        reply_to_message_id=update.message.message_id,
+                        progress=progress_for_pyrogram,
+                        progress_args=(
+                            Translation.UPLOAD_START,
+                            update.message,
+                            start_time
+                        )
+                    )
+                    i = i + 1
+                    os.remove(current_file_name)
+                try:
+                    shutil.rmtree(extract_dir_path)
+                except:
+                    pass
+                await bot.edit_message_text(
+                    chat_id=update.message.chat.id,
+                    text=Translation.ZIP_UPLOADED_STR.format(i, "0"),
+                    message_id=update.message.message_id
+                )
+            else:
+                file_content = zip_file_contents[int(index_extractor)]
+                current_file_name = os.path.join(extract_dir_path, file_content)
+                start_time = time.time()
+                await bot.send_document(
+                    chat_id=update.message.chat.id,
+                    document=current_file_name,
+                    # thumb=thumb_image_path,
+                    caption=file_content,
+                    # reply_markup=reply_markup,
+                    reply_to_message_id=update.message.message_id,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Translation.UPLOAD_START,
+                        update.message,
+                        start_time
+                    )
+                )
+                try:
+                    shutil.rmtree(extract_dir_path)
+                except:
+                    pass
+                await bot.edit_message_text(
+                    chat_id=update.message.chat.id,
+                    text=Translation.ZIP_UPLOADED_STR.format("1", "0"),
+                    message_id=update.message.message_id
+                )
+        elif "|" 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,120 @@
+#!/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 numpy
+import os
+from PIL import Image
+import time
+
+# the secret configuration specific things
+if bool(os.environ.get("WEBHOOK", False)):
+    from sample_config import Config
+else:
+    from config import Config
+
+# the Strings used for this "thing"
+from translation import Translation
+
+import pyrogram
+logging.getLogger("pyrogram").setLevel(logging.WARNING)
+
+
+@pyrogram.Client.on_message(pyrogram.filters.command(["genthumbnail"]))
+async def generate_custom_thumbnail(bot, update):
+    if update.from_user.id in Config.AUTH_USERS:
+        if update.reply_to_message is not None:
+            reply_message = update.reply_to_message
+            if reply_message.media_group_id is not None:
+                download_location = Config.DOWNLOAD_LOCATION + "/" + str(update.from_user.id) + "/" + str(reply_message.media_group_id) + "/"
+                save_final_image = download_location + str(round(time.time())) + ".jpg"
+                list_im = os.listdir(download_location)
+                if len(list_im) == 2:
+                    imgs = [ Image.open(download_location + i) for i in list_im ]
+                    inm_aesph = sorted([(numpy.sum(i.size), i.size) for i in imgs])
+                    min_shape = inm_aesph[1][1]
+                    imgs_comb = numpy.hstack(numpy.asarray(i.resize(min_shape)) for i in imgs)
+                    imgs_comb = Image.fromarray(imgs_comb)
+                    # combine: https://stackoverflow.com/a/30228789/4723940
+                    imgs_comb.save(save_final_image)
+                    # send
+                    user = await bot.get_me()
+                    mention = user["mention"]
+                    await bot.send_photo(
+                        chat_id=update.chat.id,
+                        photo=save_final_image,
+                        caption=Translation.CUSTOM_CAPTION_UL_FILE.format(mention),
+                        reply_to_message_id=update.message_id
+                    )
+                else:
+                    await bot.send_message(
+                        chat_id=update.chat.id,
+                        text=Translation.ERR_ONLY_TWO_MEDIA_IN_ALBUM,
+                        reply_to_message_id=update.message_id
+                    )
+                try:
+                    [os.remove(download_location + i) for i in list_im ]
+                    os.remove(download_location)
+                except:
+                    pass
+            else:
+                await bot.send_message(
+                    chat_id=update.chat.id,
+                    text=Translation.REPLY_TO_MEDIA_ALBUM_TO_GEN_THUMB,
+                    reply_to_message_id=update.message_id
+                )
+        else:
+            await bot.send_message(
+                chat_id=update.chat.id,
+                text=Translation.REPLY_TO_MEDIA_ALBUM_TO_GEN_THUMB,
+                reply_to_message_id=update.message_id
+            )
+
+
+@pyrogram.Client.on_message(pyrogram.filters.photo)
+async def save_photo(bot, update):
+    if update.from_user.id in Config.AUTH_USERS:
+        if update.media_group_id is not None:
+            # album is sent
+            download_location = Config.DOWNLOAD_LOCATION + "/" + str(update.from_user.id) + "/" + str(update.media_group_id) + "/"
+            # create download directory, if not exist
+            if not os.path.isdir(download_location):
+                os.makedirs(download_location)
+            await bot.download_media(
+                message=update,
+                file_name=download_location
+            )
+        else:
+            # received single photo
+            download_location = Config.DOWNLOAD_LOCATION + "/" + str(update.from_user.id) + ".jpg"
+            await bot.download_media(
+                message=update,
+                file_name=download_location
+            )
+            await bot.send_message(
+                chat_id=update.chat.id,
+                text=Translation.SAVED_CUSTOM_THUMB_NAIL,
+                reply_to_message_id=update.message_id
+            )
+
+
+@pyrogram.Client.on_message(pyrogram.filters.command(["delthumbnail"]))
+async def delthumbnail(bot, update):
+    if update.from_user.id in Config.AUTH_USERS:
+        download_location = Config.DOWNLOAD_LOCATION + "/" + str(update.from_user.id)
+        try:
+            os.remove(download_location + ".jpg")
+            # os.remove(download_location + ".json")
+        except:
+            pass
+        await bot.send_message(
+            chat_id=update.chat.id,
+            text=Translation.DEL_ETED_CUSTOM_THUMB_NAIL,
+            reply_to_message_id=update.message_id
+        )

plugins/dl_button.py

@@ -0,0 +1,326 @@
+#!/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 asyncio
+import aiohttp
+import json
+import math
+import os
+import shutil
+import time
+from datetime import datetime
+
+# the secret configuration specific things
+if bool(os.environ.get("WEBHOOK", False)):
+    from sample_config import Config
+else:
+    from config import Config
+
+# the Strings used for this "thing"
+from translation import Translation
+
+import pyrogram
+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:
+            # get the correct width, height, and duration for videos greater than 10MB
+            # ref: message from @BotSupport
+            width = 0
+            height = 0
+            duration = 0
+            if tg_send_type != "file":
+                metadata = extractMetadata(createParser(download_directory))
+                if metadata is not None:
+                    if metadata.has("duration"):
+                        duration = metadata.get('duration').seconds
+            # get the correct width, height, and duration for videos greater than 10MB
+            if os.path.exists(thumb_image_path):
+                width = 0
+                height = 0
+                metadata = extractMetadata(createParser(thumb_image_path))
+                if metadata.has("width"):
+                    width = metadata.get("width")
+                if metadata.has("height"):
+                    height = metadata.get("height")
+                if tg_send_type == "vm":
+                    height = width
+                # resize image
+                # ref: https://t.me/PyrogramChat/44663
+                # https://stackoverflow.com/a/21669827/4723940
+                Image.open(thumb_image_path).convert(
+                    "RGB").save(thumb_image_path)
+                img = Image.open(thumb_image_path)
+                # https://stackoverflow.com/a/37631799/4723940
+                # img.thumbnail((90, 90))
+                if tg_send_type == "file":
+                    img.resize((320, height))
+                else:
+                    img.resize((90, height))
+                img.save(thumb_image_path, "JPEG")
+                # https://pillow.readthedocs.io/en/3.1.x/reference/Image.html#create-thumbnails
+            else:
+                thumb_image_path = None
+            start_time = time.time()
+            # try to upload file
+            if tg_send_type == "audio":
+                user = await bot.get_me()
+                mention = user["mention"]
+                audio = await bot.send_audio(
+                    chat_id=update.message.chat.id,
+                    audio=download_directory,
+                    caption=description + f"\n\nSubmitted by {update.from_user.mention}\nUploaded by {mention}",
+                    duration=duration,
+                    # performer=response_json["uploader"],
+                    # title=response_json["title"],
+                    # reply_markup=reply_markup,
+                    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
+                    )
+                )
+                await audio.forward(Config.LOG_CHANNEL)
+            elif tg_send_type == "file":
+                user = await bot.get_me()
+                mention = user["mention"]
+                document = await bot.send_document(
+                    chat_id=update.message.chat.id,
+                    document=download_directory,
+                    thumb=thumb_image_path,
+                    caption=description + f"\n\nSubmitted by {update.from_user.mention}\nUploaded by {mention}",
+                    # reply_markup=reply_markup,
+                    reply_to_message_id=update.message.reply_to_message.message_id,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Translation.UPLOAD_START,
+                        update.message,
+                        start_time
+                    )
+                )
+                await document.forward(Config.LOG_CHANNEL)
+            elif tg_send_type == "vm":
+                user = await bot.get_me()
+                mention = user["mention"]
+                video_note = 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
+                    )
+                )
+                vm = await video_note.forward(Config.LOG_CHANNEL)
+                await vm.reply_text(f"Submitted by {update.from_user.mention}\nUploaded by {mention}")
+            elif tg_send_type == "video":
+                user = await bot.get_me()
+                mention = user["mention"]
+                video = await bot.send_video(
+                    chat_id=update.message.chat.id,
+                    video=download_directory,
+                    caption=description + f"\n\nSubmitted by {update.from_user.mention}\nUploaded by {mention}",
+                    duration=duration,
+                    width=width,
+                    height=height,
+                    supports_streaming=True,
+                    # reply_markup=reply_markup,
+                    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
+                    )
+                )
+                await video.forward(Config.LOG_CHANNEL)
+            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/help_text.py

@@ -0,0 +1,61 @@
+#!/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
+import sqlite3
+
+# the secret configuration specific things
+if bool(os.environ.get("WEBHOOK", False)):
+    from sample_config import Config
+else:
+    from config import Config
+
+# the Strings used for this "thing"
+from translation import Translation
+
+import pyrogram
+logging.getLogger("pyrogram").setLevel(logging.WARNING)
+
+from pyrogram.types.bots_and_keyboards import InlineKeyboardButton, InlineKeyboardMarkup
+
+
+@pyrogram.Client.on_message(pyrogram.filters.command(["help"]))
+async def help_user(bot, update):
+    if update.from_user.id in Config.AUTH_USERS:
+        # logger.info(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
+        )
+
+
+@pyrogram.Client.on_message(pyrogram.filters.command(["start"]))
+async def start(bot, update):
+    if update.from_user.id in Config.AUTH_USERS:
+        # logger.info(update)
+        await bot.send_message(
+            chat_id=update.chat.id,
+            text=Translation.START_TEXT.format(update.from_user.first_name),
+            reply_markup=InlineKeyboardMarkup(
+                [
+                    [
+                        InlineKeyboardButton(
+                            "Source", url="https://github.com/X-Gorn/X-URL-Uploader"
+                        ),
+                        InlineKeyboardButton("Project Channel", url="https://t.me/xTeamBots"),
+                    ],
+                    [InlineKeyboardButton("Author", url="https://t.me/xgorn")],
+                ]
+            ),
+            reply_to_message_id=update.message_id
+        )

plugins/youtube_dl_button.py

@@ -0,0 +1,365 @@
+#!/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 asyncio
+import json
+import math
+import os
+import shutil
+import time
+from datetime import datetime
+
+# the secret configuration specific things
+if bool(os.environ.get("WEBHOOK", False)):
+    from sample_config import Config
+else:
+    from config import Config
+
+# the Strings used for this "thing"
+from translation import Translation
+
+import pyrogram
+logging.getLogger("pyrogram").setLevel(logging.WARNING)
+
+from pyrogram.types import InputMediaPhoto
+from helper_funcs.display_progress import progress_for_pyrogram, humanbytes
+from hachoir.metadata import extractMetadata
+from hachoir.parser import createParser
+# https://stackoverflow.com/a/37631799/4723940
+from PIL import Image
+from helper_funcs.help_Nekmo_ffmpeg import generate_screen_shots
+
+
+async def youtube_dl_call_back(bot, 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"
+    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 bot.delete_messages(
+            chat_id=update.message.chat.id,
+            message_ids=update.message.message_id,
+            revoke=True
+        )
+        return False
+    youtube_dl_url = update.message.reply_to_message.text
+    custom_file_name = str(response_json.get("title")) + \
+        "_" + 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()
+        # 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(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]
+    await bot.edit_message_text(
+        text=Translation.DOWNLOAD_START,
+        chat_id=update.message.chat.id,
+        message_id=update.message.message_id
+    )
+    user = await bot.get_me()
+    mention = user["mention"]
+    description = Translation.CUSTOM_CAPTION_UL_FILE.format(mention)
+    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)
+    download_directory = tmp_directory_for_each_user + "/" + custom_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:
+        # command_to_exec = ["youtube-dl", "-f", youtube_dl_format, "--hls-prefer-ffmpeg", "--recode-video", "mp4", "-k", youtube_dl_url, "-o", download_directory]
+        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")
+    logger.info(command_to_exec)
+    start = datetime.now()
+    process = await asyncio.create_subprocess_exec(
+        *command_to_exec,
+        # stdout must a pipe to be accessible as process.stdout
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    # Wait for the subprocess to finish
+    stdout, stderr = await process.communicate()
+    e_response = stderr.decode().strip()
+    t_response = stdout.decode().strip()
+    logger.info(e_response)
+    logger.info(t_response)
+    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:
+        # logger.info(t_response)
+        os.remove(save_ytdl_json_path)
+        end_one = datetime.now()
+        time_taken_for_download = (end_one -start).seconds
+        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.format(time_taken_for_download, humanbytes(file_size)),
+                message_id=update.message.message_id
+            )
+        else:
+            is_w_f = False
+            images = await generate_screen_shots(
+                download_directory,
+                tmp_directory_for_each_user,
+                is_w_f,
+                Config.DEF_WATER_MARK_FILE,
+                300,
+                9
+            )
+            logger.info(images)
+            await bot.edit_message_text(
+                text=Translation.UPLOAD_START,
+                chat_id=update.message.chat.id,
+                message_id=update.message.message_id
+            )
+            # get the correct width, height, and duration for videos greater than 10MB
+            # ref: message from @BotSupport
+            width = 0
+            height = 0
+            duration = 0
+            if tg_send_type != "file":
+                metadata = extractMetadata(createParser(download_directory))
+                if metadata is not None:
+                    if metadata.has("duration"):
+                        duration = metadata.get('duration').seconds
+            # get the correct width, height, and duration for videos greater than 10MB
+            if os.path.exists(thumb_image_path):
+                width = 0
+                height = 0
+                metadata = extractMetadata(createParser(thumb_image_path))
+                if metadata.has("width"):
+                    width = metadata.get("width")
+                if metadata.has("height"):
+                    height = metadata.get("height")
+                if tg_send_type == "vm":
+                    height = width
+                # resize image
+                # ref: https://t.me/PyrogramChat/44663
+                # https://stackoverflow.com/a/21669827/4723940
+                Image.open(thumb_image_path).convert(
+                    "RGB").save(thumb_image_path)
+                img = Image.open(thumb_image_path)
+                # https://stackoverflow.com/a/37631799/4723940
+                # img.thumbnail((90, 90))
+                if tg_send_type == "file":
+                    img.resize((320, height))
+                else:
+                    img.resize((90, height))
+                img.save(thumb_image_path, "JPEG")
+                # https://pillow.readthedocs.io/en/3.1.x/reference/Image.html#create-thumbnails
+                
+            else:
+                thumb_image_path = None
+            start_time = time.time()
+            # try to upload file
+            if tg_send_type == "audio":
+                await bot.send_audio(
+                    chat_id=update.message.chat.id,
+                    audio=download_directory,
+                    caption=description,
+                    parse_mode="HTML",
+                    duration=duration,
+                    # performer=response_json["uploader"],
+                    # title=response_json["title"],
+                    # reply_markup=reply_markup,
+                    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":
+                await bot.send_document(
+                    chat_id=update.message.chat.id,
+                    document=download_directory,
+                    thumb=thumb_image_path,
+                    caption=description,
+                    parse_mode="HTML",
+                    # reply_markup=reply_markup,
+                    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":
+                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":
+                await bot.send_video(
+                    chat_id=update.message.chat.id,
+                    video=download_directory,
+                    caption=description,
+                    parse_mode="HTML",
+                    duration=duration,
+                    width=width,
+                    height=height,
+                    supports_streaming=True,
+                    # reply_markup=reply_markup,
+                    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()
+            time_taken_for_upload = (end_two - end_one).seconds
+            #
+            media_album_p = []
+            if images is not None:
+                i = 0
+                caption = "© @xTeamBots"
+                if is_w_f:
+                    caption = "@xurluploaderbot"
+                for image in images:
+                    if os.path.exists(str(image)):
+                        if i == 0:
+                            media_album_p.append(
+                                InputMediaPhoto(
+                                    media=image,
+                                    caption=caption,
+                                    parse_mode="html"
+                                )
+                            )
+                        else:
+                            media_album_p.append(
+                                InputMediaPhoto(
+                                    media=image
+                                )
+                            )
+                        i = i + 1
+            await bot.send_media_group(
+                chat_id=update.message.chat.id,
+                disable_notification=True,
+                reply_to_message_id=update.message.message_id,
+                media=media_album_p
+            )
+            #
+            try:
+                shutil.rmtree(tmp_directory_for_each_user)
+                os.remove(thumb_image_path)
+            except:
+                pass
+            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
+            )

plugins/youtube_dl_echo.py

@@ -0,0 +1,376 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# (c) Shrimadhav U K | X-Noid
+
+# the logging things
+import logging
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+import lk21, urllib.parse, filetype, shutil, time, tldextract, asyncio, json, math, os, requests
+from PIL import Image
+# the secret configuration specific things
+if bool(os.environ.get("WEBHOOK", False)):
+    from sample_config import Config
+else:
+    from config import Config
+
+# the Strings used for this "thing"
+from translation import Translation
+
+import pyrogram
+logging.getLogger("pyrogram").setLevel(logging.WARNING)
+from helper_funcs.display_progress import humanbytes
+from helper_funcs.help_uploadbot import DownLoadFile
+from helper_funcs.display_progress import progress_for_pyrogram
+from hachoir.metadata import extractMetadata
+from hachoir.parser import createParser
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from pyrogram.errors import UserNotParticipant
+
+
+@pyrogram.Client.on_message(pyrogram.filters.regex(pattern=".*http.*"))
+async def echo(bot, update):
+    if update.from_user.id in Config.AUTH_USERS:
+        logger.info(update.from_user)
+        url = update.text
+        youtube_dl_username = None
+        youtube_dl_password = None
+        file_name = None
+        folder = f'./lk21/{update.from_user.id}/'
+        bypass = ['zippyshare', 'hxfile', 'mediafire', 'anonfiles', 'antfiles']
+        ext = tldextract.extract(url)
+        if ext.domain in bypass:
+            pablo = await update.reply_text('LK21 link detected')
+            time.sleep(2.5)
+            if os.path.isdir(folder):
+                await update.reply_text("Don't spam, wait till your previous task done.")
+                await pablo.delete()
+                return
+            os.makedirs(folder)
+            await pablo.edit_text('Downloading...')
+            bypasser = lk21.Bypass()
+            xurl = bypasser.bypass_url(url)
+            if ' | ' in url:
+                url_parts = url.split(' | ')
+                url = url_parts[0]
+                file_name = url_parts[1]
+            else:
+                if xurl.find('/'):
+                    urlname = xurl.rsplit('/', 1)[1]
+                file_name = urllib.parse.unquote(urlname)
+                if '+' in file_name:
+                    file_name = file_name.replace('+', ' ')
+            dldir = f'{folder}{file_name}'
+            r = requests.get(xurl, allow_redirects=True)
+            open(dldir, 'wb').write(r.content)
+            try:
+                file = filetype.guess(dldir)
+                xfiletype = file.mime
+            except AttributeError:
+                xfiletype = file_name
+            if xfiletype in ['video/mp4', 'video/x-matroska', 'video/webm', 'audio/mpeg']:
+                metadata = extractMetadata(createParser(dldir))
+                if metadata is not None:
+                    if metadata.has("duration"):
+                        duration = metadata.get('duration').seconds
+            await pablo.edit_text('Uploading...')
+            start_time = time.time()
+            if xfiletype in ['video/mp4', 'video/x-matroska', 'video/webm']:
+                await bot.send_video(
+                    chat_id=update.chat.id,
+                    video=dldir,
+                    caption=file_name,
+                    duration=duration,
+                    reply_to_message_id=update.message_id,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Translation.UPLOAD_START,
+                        pablo,
+                        start_time
+                    )
+                )
+            elif xfiletype == 'audio/mpeg':
+                await bot.send_audio(
+                    chat_id=update.chat.id,
+                    audio=dldir,
+                    caption=file_name,
+                    duration=duration,
+                    reply_to_message_id=update.message_id,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Translation.UPLOAD_START,
+                        pablo,
+                        start_time
+                    )
+                )
+            else:
+                await bot.send_document(
+                    chat_id=update.chat.id,
+                    document=dldir,
+                    caption=file_name,
+                    reply_to_message_id=update.message_id,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Translation.UPLOAD_START,
+                        pablo,
+                        start_time
+                    )
+                )
+            await pablo.delete()
+            shutil.rmtree(folder)
+            return
+        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)
+        # logger.info(command_to_exec)
+        process = await asyncio.create_subprocess_exec(
+            *command_to_exec,
+            # stdout must a pipe to be accessible as process.stdout
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        # Wait for the subprocess to finish
+        stdout, stderr = await process.communicate()
+        e_response = stderr.decode().strip()
+        # logger.info(e_response)
+        t_response = stdout.decode().strip()
+        # logger.info(t_response)
+        # https://github.com/rg3/youtube-dl/issues/2630#issuecomment-38635239
+        if e_response and "nonnumeric port" not in e_response:
+            # logger.warn("Status : FAIL", exc.returncode, exc.output)
+            error_message = e_response.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 "This video is only available for registered users." in error_message:
+                error_message += Translation.SET_CUSTOM_USERNAME_PASSWORD
+            await bot.send_message(
+                chat_id=update.chat.id,
+                text=Translation.NO_VOID_FORMAT_FOUND.format(str(error_message)),
+                reply_to_message_id=update.message_id,
+                parse_mode="html",
+                disable_web_page_preview=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)
+            # logger.info(reply_markup)
+            thumbnail = Config.DEF_THUMB_NAIL_VID_S
+            thumbnail_image = Config.DEF_THUMB_NAIL_VID_S
+            if "thumbnail" in response_json:
+                if response_json["thumbnail"] is not None:
+                    thumbnail = response_json["thumbnail"]
+                    thumbnail_image = response_json["thumbnail"]
+            thumb_image_path = DownLoadFile(
+                thumbnail_image,
+                Config.DOWNLOAD_LOCATION + "/" +
+                str(update.from_user.id) + ".webp",
+                Config.CHUNK_SIZE,
+                None,  # bot,
+                Translation.DOWNLOAD_START,
+                update.message_id,
+                update.chat.id
+            )
+            if os.path.exists(thumb_image_path):
+                im = Image.open(thumb_image_path).convert("RGB")
+                im.save(thumb_image_path.replace(".webp", ".jpg"), "jpeg")
+            else:
+                thumb_image_path = None
+            await bot.send_message(
+                chat_id=update.chat.id,
+                text=Translation.FORMAT_SELECTION.format(thumbnail) + "\n" + Translation.SET_CUSTOM_USERNAME_PASSWORD,
+                reply_markup=reply_markup,
+                parse_mode="html",
+                reply_to_message_id=update.message_id
+            )
+        else:
+            # fallback for nonnumeric port a.k.a seedbox.io
+            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 bot.send_message(
+                chat_id=update.chat.id,
+                text=Translation.FORMAT_SELECTION.format(""),
+                reply_markup=reply_markup,
+                parse_mode="html",
+                reply_to_message_id=update.message_id
+            )