+
+
+## Getting GDTOT COOKIES
+- Watch This [Video](https://youtu.be/PjR6KpHJ23s)
+
+## Getting Google OAuth API credential file
+
+- Visit the [Google Cloud Console](https://console.developers.google.com/apis/credentials)
+- Go to the OAuth Consent tab, fill it, and save.
+- Go to the Credentials tab and click Create Credentials -> OAuth Client ID
+- Choose Desktop and Create.
+- Use the download button to download your credentials.
+- clone this repo https://github.com/tekeayush/Mirror-bot
+- Move that file to the root of mirrorbot, and rename it to credentials.json
+- install the requirements-cli.txt file by using
+
+``` pip3 install -r requirements-cli.txt ```
+
+- Visit [Google API page](https://console.developers.google.com/apis/library)
+- Search for Drive and enable it if it is disabled
+- Finally, run the script to generate **token.pickle** file for Google Drive:
+```
+python3 generate_drive_token.py
+```
+
+## Deploying on vps
+
+- Start docker daemon (skip if already running):
+```
+sudo dockerd
+```
+- Build Docker image:
+```
+sudo docker build . -t mirrorbot
+```
+- Run the image:
+```
+sudo docker run mirrorbot
+```
+
+
+## bot commands will be set automatically
+
+## some of the commands are changed because the group members use them without any reason
+
+## Using service accounts for uploading to avoid user rate limit
+For Service Account to work, you must set **USE_SERVICE_ACCOUNTS="True"** in config file or environment variables
+Many thanks to [AutoRClone](https://github.com/xyou365/AutoRclone) for the scripts
+**NOTE**: Using service accounts is only recommended while uploading to a team drive.
+
+## Generate service accounts. [What is service account](https://cloud.google.com/iam/docs/service-accounts)
+
+
+first enable IAM API from cloud console by Visiting [Google API page](https://console.developers.google.com/apis/library)
+
+Let us create only the service accounts that we need.
+**Warning**: abuse of this feature is not the aim of this project and we do **NOT** recommend that you make a lot of projects, just one project and 100 sa allow you plenty of use, its also possible that over abuse might get your projects banned by google.
+
+```
+Note: 1 service account can copy around 750gb a day, 1 project can make 100 service accounts so that's 75tb a day, for most users this should easily suffice.
+```
+
+`python3 gen_sa_accounts.py --quick-setup 1 --new-only`
+
+A folder named accounts will be created which will contain keys for the service accounts
+
+**NOTE**: If you have created SAs in past from this script, you can also just re download the keys by running:
+```
+python3 gen_sa_accounts.py --download-keys project_id
+```
+
+## Add all the service accounts to the Team Drive
+- Run:
+```
+python3 add_to_team_drive.py -d SharedTeamDriveSrcID
+```
+
+## Youtube-dl authentication using .netrc file
+For using your premium accounts in youtube-dl, edit the [.netrc] file according to following format:
+```
+machine host login username password my_youtube_password
+```
+where host is the name of extractor (eg. youtube, twitch). Multiple accounts of different hosts can be added each separated by a new line
+
+## Credits
+
+Thanks to:
+- [out386](https://github.com/out386) heavily inspired from telegram bot which is written in JS
+- [Izzy12](https://github.com/lzzy12/) for original repo
+- [Dank-del](https://github.com/Dank-del/) for base repo
+- [magneto261290](https://github.com/magneto261290/) for some features
+- [SVR666](https://github.com/SVR666/) for some fixes
+- [4amparaboy](https://github.com/4amparaboy/) for some help
+- [WinTenDev](https://github.com/WinTenDev/) for Uptobox support
+- [iamLiquidX](https://github.com/iamLiquidX/) for Speedtest module
+- [ydner](https://github.com/ydner/) for Usage module
+- [breakdowns](https://github.com/breakdowns) for main repo
+- [Jigarvarma2005](https://gitlab.com/Jigarvarma2005) For There GDTOT Code
+
diff --git a/add_to_team_drive.py b/add_to_team_drive.py
new file mode 100644
index 0000000..087c5a5
--- /dev/null
+++ b/add_to_team_drive.py
@@ -0,0 +1,77 @@
+from __future__ import print_function
+from google.oauth2.service_account import Credentials
+import googleapiclient.discovery, json, progress.bar, glob, sys, argparse, time
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+import os, pickle
+
+stt = time.time()
+
+parse = argparse.ArgumentParser(
+ description='A tool to add service accounts to a shared drive from a folder containing credential files.')
+parse.add_argument('--path', '-p', default='accounts',
+ help='Specify an alternative path to the service accounts folder.')
+parse.add_argument('--credentials', '-c', default='./credentials.json',
+ help='Specify the relative path for the credentials file.')
+parse.add_argument('--yes', '-y', default=False, action='store_true', help='Skips the sanity prompt.')
+parsereq = parse.add_argument_group('required arguments')
+parsereq.add_argument('--drive-id', '-d', help='The ID of the Shared Drive.', required=True)
+
+args = parse.parse_args()
+acc_dir = args.path
+did = args.drive_id
+credentials = glob.glob(args.credentials)
+
+try:
+ open(credentials[0], 'r')
+ print('>> Found credentials.')
+except IndexError:
+ print('>> No credentials found.')
+ sys.exit(0)
+
+if not args.yes:
+ # input('Make sure the following client id is added to the shared drive as Manager:\n' + json.loads((open(
+ # credentials[0],'r').read()))['installed']['client_id'])
+ input('>> Make sure the **Google account** that has generated credentials.json\n is added into your Team Drive '
+ '(shared drive) as Manager\n>> (Press any key to continue)')
+
+creds = None
+if os.path.exists('token_sa.pickle'):
+ with open('token_sa.pickle', 'rb') as token:
+ creds = pickle.load(token)
+# If there are no (valid) credentials available, let the user log in.
+if not creds or not creds.valid:
+ if creds and creds.expired and creds.refresh_token:
+ creds.refresh(Request())
+ else:
+ flow = InstalledAppFlow.from_client_secrets_file(credentials[0], scopes=[
+ 'https://www.googleapis.com/auth/admin.directory.group',
+ 'https://www.googleapis.com/auth/admin.directory.group.member'
+ ])
+ # creds = flow.run_local_server(port=0)
+ creds = flow.run_console()
+ # Save the credentials for the next run
+ with open('token_sa.pickle', 'wb') as token:
+ pickle.dump(creds, token)
+
+drive = googleapiclient.discovery.build("drive", "v3", credentials=creds)
+batch = drive.new_batch_http_request()
+
+aa = glob.glob('%s/*.json' % acc_dir)
+pbar = progress.bar.Bar("Readying accounts", max=len(aa))
+for i in aa:
+ ce = json.loads(open(i, 'r').read())['client_email']
+ batch.add(drive.permissions().create(fileId=did, supportsAllDrives=True, body={
+ "role": "organizer",
+ "type": "user",
+ "emailAddress": ce
+ }))
+ pbar.next()
+pbar.finish()
+print('Adding...')
+batch.execute()
+
+print('Complete.')
+hours, rem = divmod((time.time() - stt), 3600)
+minutes, sec = divmod(rem, 60)
+print("Elapsed Time:\n{:0>2}:{:0>2}:{:05.2f}".format(int(hours), int(minutes), sec))
diff --git a/alive.py b/alive.py
new file mode 100644
index 0000000..a939c19
--- /dev/null
+++ b/alive.py
@@ -0,0 +1,29 @@
+
+
+import time
+import requests
+import os
+from dotenv import load_dotenv
+
+load_dotenv('config.env')
+
+try:
+ BASE_URL = os.environ.get('BASE_URL_OF_BOT', None)
+ if len(BASE_URL) == 0:
+ BASE_URL = None
+except KeyError:
+ BASE_URL = None
+
+try:
+ IS_VPS = os.environ.get('IS_VPS', 'False')
+ if IS_VPS.lower() == 'true':
+ IS_VPS = True
+ else:
+ IS_VPS = False
+except KeyError:
+ IS_VPS = False
+
+if not IS_VPS and BASE_URL is not None:
+ while True:
+ time.sleep(1000)
+ status = requests.get(BASE_URL).status_code
diff --git a/aria.bat b/aria.bat
new file mode 100644
index 0000000..3880800
--- /dev/null
+++ b/aria.bat
@@ -0,0 +1 @@
+aria2c --enable-rpc --rpc-listen-all=false --rpc-listen-port 6800 --max-connection-per-server=10 --rpc-max-request-size=1024M --seed-time=0.01 --min-split-size=10M --follow-torrent=mem --split=10 --daemon=true --allow-overwrite=true
diff --git a/aria.sh b/aria.sh
new file mode 100644
index 0000000..aa12693
--- /dev/null
+++ b/aria.sh
@@ -0,0 +1,15 @@
+export MAX_DOWNLOAD_SPEED=0
+tracker_list=$(curl -Ns https://raw.githubusercontent.com/XIU2/TrackersListCollection/master/all.txt https://ngosang.github.io/trackerslist/trackers_all_http.txt https://raw.githubusercontent.com/DeSireFire/animeTrackerList/master/AT_all.txt https://raw.githubusercontent.com/hezhijie0327/Trackerslist/main/trackerslist_combine.txt | awk '$0' | tr '\n' ',')
+export MAX_CONCURRENT_DOWNLOADS=4
+
+aria2c --enable-rpc --rpc-listen-all=false --check-certificate=false \
+ --max-connection-per-server=10 --rpc-max-request-size=1024M \
+ --bt-tracker="[$tracker_list]" --bt-max-peers=0 --bt-tracker-connect-timeout=300 --bt-stop-timeout=1200 --min-split-size=10M \
+ --follow-torrent=mem --split=10 \
+ --daemon=true --allow-overwrite=true --max-overall-download-limit=$MAX_DOWNLOAD_SPEED \
+ --max-overall-upload-limit=1K --max-concurrent-downloads=$MAX_CONCURRENT_DOWNLOADS \
+ --peer-id-prefix=-qB4360- --user-agent=qBittorrent/4.3.6 --peer-agent=qBittorrent/4.3.6 \
+ --disk-cache=64M --file-allocation=prealloc --continue=true \
+ --max-file-not-found=0 --max-tries=20 --auto-file-renaming=true \
+ --bt-enable-lpd=true --seed-time=0.01 --seed-ratio=1.0 \
+ --content-disposition-default-utf8=true --http-accept-gzip=true --reuse-uri=true --netrc-path=/usr/src/app/.netrc
diff --git a/bot/__init__.py b/bot/__init__.py
new file mode 100644
index 0000000..bd0081a
--- /dev/null
+++ b/bot/__init__.py
@@ -0,0 +1,418 @@
+import logging
+import os
+import threading
+import time
+import random
+import string
+import subprocess
+import requests
+
+import aria2p
+import qbittorrentapi as qba
+import telegram.ext as tg
+from dotenv import load_dotenv
+from pyrogram import Client
+from telegraph import Telegraph
+
+import psycopg2
+from psycopg2 import Error
+
+import socket
+import faulthandler
+faulthandler.enable()
+
+socket.setdefaulttimeout(600)
+
+botStartTime = time.time()
+if os.path.exists('log.txt'):
+ with open('log.txt', 'r+') as f:
+ f.truncate(0)
+
+logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.FileHandler('log.txt'), logging.StreamHandler()],
+ level=logging.INFO)
+
+LOGGER = logging.getLogger(__name__)
+
+
+CONFIG_FILE_URL = os.environ.get('CONFIG_FILE_URL', None)
+if CONFIG_FILE_URL is not None:
+ res = requests.get(CONFIG_FILE_URL)
+ if res.status_code == 200:
+ with open('config.env', 'wb+') as f:
+ f.write(res.content)
+ f.close()
+ else:
+ logging.error(res.status_code)
+
+load_dotenv('config.env')
+
+
+SERVER_PORT = os.environ.get('SERVER_PORT', None)
+PORT = os.environ.get('PORT', SERVER_PORT)
+web = subprocess.Popen([f"gunicorn wserver:start_server --bind 0.0.0.0:{PORT} --worker-class aiohttp.GunicornWebWorker"], shell=True)
+time.sleep(1)
+alive = subprocess.Popen(["python3", "alive.py"])
+subprocess.run(["mkdir", "-p", "qBittorrent/config"])
+subprocess.run(["cp", "qBittorrent.conf", "qBittorrent/config/qBittorrent.conf"])
+subprocess.run(["qbittorrent-nox", "-d", "--profile=."])
+Interval = []
+DRIVES_NAMES = []
+DRIVES_IDS = []
+INDEX_URL = []
+
+
+def getConfig(name: str):
+ return os.environ[name]
+
+def mktable():
+ try:
+ conn = psycopg2.connect(DB_URI)
+ cur = conn.cursor()
+ sql = "CREATE TABLE users (uid bigint, sudo boolean DEFAULT FALSE);"
+ cur.execute(sql)
+ conn.commit()
+ LOGGER.info("Table Created!")
+ except Error as e:
+ LOGGER.error(e)
+ exit(1)
+
+try:
+ if bool(getConfig('_____REMOVE_THIS_LINE_____')):
+ logging.error('The README.md file there to be read! Exiting now!')
+ exit()
+except KeyError:
+ pass
+
+aria2 = aria2p.API(
+ aria2p.Client(
+ host="http://localhost",
+ port=6800,
+ secret="",
+ )
+)
+
+
+def get_client() -> qba.TorrentsAPIMixIn:
+ qb_client = qba.Client(host="localhost", port=8090, username="admin", password="adminadmin")
+ try:
+ qb_client.auth_log_in()
+ qb_client.application.set_preferences({"disk_cache":64, "incomplete_files_ext":True, "max_connec":3000, "max_connec_per_torrent":300, "async_io_threads":8, "preallocate_all":True, "upnp":True, "dl_limit":-1, "up_limit":-1, "dht":True, "pex":True, "lsd":True, "encryption":0, "queueing_enabled":True, "max_active_downloads":15, "max_active_torrents":50, "dont_count_slow_torrents":True, "bittorrent_protocol":0, "recheck_completed_torrents":True, "enable_multi_connections_from_same_ip":True, "slow_torrent_dl_rate_threshold":100,"slow_torrent_inactive_timer":600})
+ return qb_client
+ except qba.LoginFailed as e:
+ LOGGER.error(str(e))
+ return None
+
+
+DOWNLOAD_DIR = None
+BOT_TOKEN = None
+
+download_dict_lock = threading.Lock()
+status_reply_dict_lock = threading.Lock()
+# Key: update.effective_chat.id
+# Value: telegram.Message
+status_reply_dict = {}
+# Key: update.message.message_id
+# Value: An object of Status
+download_dict = {}
+# Stores list of users and chats the bot is authorized to use in
+AUTHORIZED_CHATS = set()
+SUDO_USERS = set()
+if os.path.exists('authorized_chats.txt'):
+ with open('authorized_chats.txt', 'r+') as f:
+ lines = f.readlines()
+ for line in lines:
+ AUTHORIZED_CHATS.add(int(line.split()[0]))
+if os.path.exists('sudo_users.txt'):
+ with open('sudo_users.txt', 'r+') as f:
+ lines = f.readlines()
+ for line in lines:
+ SUDO_USERS.add(int(line.split()[0]))
+try:
+ achats = getConfig('AUTHORIZED_CHATS')
+ achats = achats.split(" ")
+ for chats in achats:
+ AUTHORIZED_CHATS.add(int(chats))
+except:
+ pass
+try:
+ schats = getConfig('SUDO_USERS')
+ schats = schats.split(" ")
+ for chats in schats:
+ SUDO_USERS.add(int(chats))
+except:
+ pass
+try:
+ BOT_TOKEN = getConfig('BOT_TOKEN')
+ parent_id = getConfig('GDRIVE_FOLDER_ID')
+ DOWNLOAD_DIR = getConfig('DOWNLOAD_DIR')
+ if not DOWNLOAD_DIR.endswith("/"):
+ DOWNLOAD_DIR = DOWNLOAD_DIR + '/'
+ DOWNLOAD_STATUS_UPDATE_INTERVAL = int(getConfig('DOWNLOAD_STATUS_UPDATE_INTERVAL'))
+ OWNER_ID = int(getConfig('OWNER_ID'))
+ AUTO_DELETE_MESSAGE_DURATION = int(getConfig('AUTO_DELETE_MESSAGE_DURATION'))
+ TELEGRAM_API = getConfig('TELEGRAM_API')
+ TELEGRAM_HASH = getConfig('TELEGRAM_HASH')
+ UPSTREAM_REPO = getConfig('UPSTREAM_REPO')
+ UPSTREAM_BRANCH = getConfig('UPSTREAM_BRANCH')
+except KeyError as e:
+ LOGGER.error("One or more env variables missing! Exiting now")
+ exit(1)
+try:
+ DB_URI = getConfig('DATABASE_URL')
+ if len(DB_URI) == 0:
+ raise KeyError
+except KeyError:
+ logging.warning('Database not provided!')
+ DB_URI = None
+if DB_URI is not None:
+ try:
+ conn = psycopg2.connect(DB_URI)
+ cur = conn.cursor()
+ sql = "SELECT * from users;"
+ cur.execute(sql)
+ rows = cur.fetchall() #returns a list ==> (uid, sudo)
+ for row in rows:
+ AUTHORIZED_CHATS.add(row[0])
+ if row[1]:
+ SUDO_USERS.add(row[0])
+ except Error as e:
+ if 'relation "users" does not exist' in str(e):
+ mktable()
+ else:
+ LOGGER.error(e)
+ exit(1)
+ finally:
+ cur.close()
+ conn.close()
+
+LOGGER.info("Generating USER_SESSION_STRING")
+app = Client(':memory:', api_id=int(TELEGRAM_API), api_hash=TELEGRAM_HASH, bot_token=BOT_TOKEN)
+
+# Generate Telegraph Token
+sname = ''.join(random.SystemRandom().choices(string.ascii_letters, k=8))
+LOGGER.info("Generating TELEGRAPH_TOKEN using '" + sname + "' name")
+telegraph = Telegraph()
+telegraph.create_account(short_name=sname)
+telegraph_token = telegraph.get_access_token()
+
+try:
+ STATUS_LIMIT = getConfig('STATUS_LIMIT')
+ if len(STATUS_LIMIT) == 0:
+ raise KeyError
+ else:
+ STATUS_LIMIT = int(getConfig('STATUS_LIMIT'))
+except KeyError:
+ STATUS_LIMIT = None
+try:
+ MEGA_API_KEY = getConfig('MEGA_API_KEY')
+except KeyError:
+ logging.warning('MEGA API KEY not provided!')
+ MEGA_API_KEY = None
+try:
+ MEGA_EMAIL_ID = getConfig('MEGA_EMAIL_ID')
+ MEGA_PASSWORD = getConfig('MEGA_PASSWORD')
+ if len(MEGA_EMAIL_ID) == 0 or len(MEGA_PASSWORD) == 0:
+ raise KeyError
+except KeyError:
+ logging.warning('MEGA Credentials not provided!')
+ MEGA_EMAIL_ID = None
+ MEGA_PASSWORD = None
+try:
+ HEROKU_API_KEY = getConfig('HEROKU_API_KEY')
+except KeyError:
+ logging.warning('HEROKU API KEY not provided!')
+ HEROKU_API_KEY = None
+try:
+ HEROKU_APP_NAME = getConfig('HEROKU_APP_NAME')
+except KeyError:
+ logging.warning('HEROKU APP NAME not provided!')
+ HEROKU_APP_NAME = None
+try:
+ UPTOBOX_TOKEN = getConfig('UPTOBOX_TOKEN')
+except KeyError:
+ logging.warning('UPTOBOX_TOKEN not provided!')
+ UPTOBOX_TOKEN = None
+try:
+ INDEX_URL = getConfig('INDEX_URL')
+ if len(INDEX_URL) == 0:
+ INDEX_URL = None
+except KeyError:
+ INDEX_URL = None
+try:
+ TORRENT_DIRECT_LIMIT = getConfig('TORRENT_DIRECT_LIMIT')
+ if len(TORRENT_DIRECT_LIMIT) == 0:
+ TORRENT_DIRECT_LIMIT = None
+except KeyError:
+ TORRENT_DIRECT_LIMIT = None
+try:
+ CLONE_LIMIT = getConfig('CLONE_LIMIT')
+ if len(CLONE_LIMIT) == 0:
+ CLONE_LIMIT = None
+except KeyError:
+ CLONE_LIMIT = None
+try:
+ MEGA_LIMIT = getConfig('MEGA_LIMIT')
+ if len(MEGA_LIMIT) == 0:
+ MEGA_LIMIT = None
+except KeyError:
+ MEGA_LIMIT = None
+try:
+ TAR_UNZIP_LIMIT = getConfig('TAR_UNZIP_LIMIT')
+ if len(TAR_UNZIP_LIMIT) == 0:
+ TAR_UNZIP_LIMIT = None
+except KeyError:
+ TAR_UNZIP_LIMIT = None
+try:
+ BUTTON_FOUR_NAME = getConfig('BUTTON_FOUR_NAME')
+ BUTTON_FOUR_URL = getConfig('BUTTON_FOUR_URL')
+ if len(BUTTON_FOUR_NAME) == 0 or len(BUTTON_FOUR_URL) == 0:
+ raise KeyError
+except KeyError:
+ BUTTON_FOUR_NAME = None
+ BUTTON_FOUR_URL = None
+try:
+ BUTTON_FIVE_NAME = getConfig('BUTTON_FIVE_NAME')
+ BUTTON_FIVE_URL = getConfig('BUTTON_FIVE_URL')
+ if len(BUTTON_FIVE_NAME) == 0 or len(BUTTON_FIVE_URL) == 0:
+ raise KeyError
+except KeyError:
+ BUTTON_FIVE_NAME = None
+ BUTTON_FIVE_URL = None
+try:
+ BUTTON_SIX_NAME = getConfig('BUTTON_SIX_NAME')
+ BUTTON_SIX_URL = getConfig('BUTTON_SIX_URL')
+ if len(BUTTON_SIX_NAME) == 0 or len(BUTTON_SIX_URL) == 0:
+ raise KeyError
+except KeyError:
+ BUTTON_SIX_NAME = None
+ BUTTON_SIX_URL = None
+try:
+ IMAGE_URL = getConfig('IMAGE_URL')
+ if len(IMAGE_URL) == 0:
+ IMAGE_URL = 'https://telegra.ph/file/019996f816db9ed576cff.jpg'
+except KeyError:
+ IMAGE_URL = 'https://telegra.ph/file/019996f816db9ed576cff.jpg'
+try:
+ STOP_DUPLICATE = getConfig('STOP_DUPLICATE')
+ if STOP_DUPLICATE.lower() == 'true':
+ STOP_DUPLICATE = True
+ else:
+ STOP_DUPLICATE = False
+except KeyError:
+ STOP_DUPLICATE = False
+try:
+ VIEW_LINK = getConfig('VIEW_LINK')
+ if VIEW_LINK.lower() == 'true':
+ VIEW_LINK = True
+ else:
+ VIEW_LINK = False
+except KeyError:
+ VIEW_LINK = False
+try:
+ IS_TEAM_DRIVE = getConfig('IS_TEAM_DRIVE')
+ if IS_TEAM_DRIVE.lower() == 'true':
+ IS_TEAM_DRIVE = True
+ else:
+ IS_TEAM_DRIVE = False
+except KeyError:
+ IS_TEAM_DRIVE = False
+try:
+ USE_SERVICE_ACCOUNTS = getConfig('USE_SERVICE_ACCOUNTS')
+ if USE_SERVICE_ACCOUNTS.lower() == 'true':
+ USE_SERVICE_ACCOUNTS = True
+ else:
+ USE_SERVICE_ACCOUNTS = False
+except KeyError:
+ USE_SERVICE_ACCOUNTS = False
+try:
+ BLOCK_MEGA_FOLDER = getConfig('BLOCK_MEGA_FOLDER')
+ if BLOCK_MEGA_FOLDER.lower() == 'true':
+ BLOCK_MEGA_FOLDER = True
+ else:
+ BLOCK_MEGA_FOLDER = False
+except KeyError:
+ BLOCK_MEGA_FOLDER = False
+try:
+ BLOCK_MEGA_LINKS = getConfig('BLOCK_MEGA_LINKS')
+ if BLOCK_MEGA_LINKS.lower() == 'true':
+ BLOCK_MEGA_LINKS = True
+ else:
+ BLOCK_MEGA_LINKS = False
+except KeyError:
+ BLOCK_MEGA_LINKS = False
+try:
+ SHORTENER = getConfig('SHORTENER')
+ SHORTENER_API = getConfig('SHORTENER_API')
+ if len(SHORTENER) == 0 or len(SHORTENER_API) == 0:
+ raise KeyError
+except KeyError:
+ SHORTENER = None
+ SHORTENER_API = None
+
+IGNORE_PENDING_REQUESTS = False
+try:
+ if getConfig("IGNORE_PENDING_REQUESTS").lower() == "true":
+ IGNORE_PENDING_REQUESTS = True
+except KeyError:
+ pass
+
+try:
+ BASE_URL = getConfig('BASE_URL_OF_BOT')
+ if len(BASE_URL) == 0:
+ BASE_URL = None
+except KeyError:
+ logging.warning('BASE_URL_OF_BOT not provided! Bot will get down soon....')
+ BASE_URL = None
+
+try:
+ IS_VPS = getConfig('IS_VPS')
+ if IS_VPS.lower() == 'true':
+ IS_VPS = True
+ else:
+ IS_VPS = False
+except KeyError:
+ IS_VPS = False
+
+try:
+ SERVER_PORT = getConfig('SERVER_PORT')
+ if len(SERVER_PORT) == 0:
+ SERVER_PORT = None
+except KeyError:
+ logging.warning('SERVER_PORT not provided!')
+ SERVER_PORT = None
+
+try:
+ TOKEN_PICKLE_URL = getConfig('TOKEN_PICKLE_URL')
+ if len(TOKEN_PICKLE_URL) == 0:
+ TOKEN_PICKLE_URL = None
+ else:
+ out = subprocess.run(["wget", "-q", "-O", "token.pickle", TOKEN_PICKLE_URL])
+ if out.returncode != 0:
+ logging.error(out)
+except KeyError:
+ TOKEN_PICKLE_URL = None
+
+try:
+ GDTOT_COOKIES = getConfig('GDTOT_COOKIES')
+except KeyError:
+ logging.warning('GDTOT_COOKIES not provided!')
+ GDTOT_COOKIES = None
+
+try:
+ ACCOUNTS_ZIP_URL = getConfig('ACCOUNTS_ZIP_URL')
+ if len(ACCOUNTS_ZIP_URL) == 0:
+ ACCOUNTS_ZIP_URL = None
+ else:
+ out = subprocess.run(["wget", "-q", "-O", "accounts.zip", ACCOUNTS_ZIP_URL])
+ if out.returncode != 0:
+ logging.error(out)
+ raise KeyError
+ subprocess.run(["unzip", "-q", "-o", "accounts.zip"])
+ os.remove("accounts.zip")
+except KeyError:
+ ACCOUNTS_ZIP_URL = None
+
+updater = tg.Updater(token=BOT_TOKEN)
+bot = updater.bot
+dispatcher = updater.dispatcher
diff --git a/bot/__main__.py b/bot/__main__.py
new file mode 100644
index 0000000..fb53984
--- /dev/null
+++ b/bot/__main__.py
@@ -0,0 +1,215 @@
+import shutil, psutil
+import signal
+import os
+import asyncio
+
+from pyrogram import idle
+from bot import app
+from sys import executable
+
+from telegram import ParseMode
+from telegram.ext import CommandHandler
+from wserver import start_server_async
+from bot import bot, IMAGE_URL, dispatcher, updater, botStartTime, IGNORE_PENDING_REQUESTS, IS_VPS, SERVER_PORT, OWNER_ID, AUTHORIZED_CHATS
+from bot.helper.ext_utils import fs_utils
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot.helper.telegram_helper.message_utils import *
+from .helper.ext_utils.bot_utils import get_readable_file_size, get_readable_time
+from .helper.telegram_helper.filters import CustomFilters
+from bot.helper.telegram_helper import button_build
+from .modules import authorize, list, cancel_mirror, mirror_status, mirror, clone, watch, shell, eval, torrent_search, delete, speedtest, count, config, updates
+
+
+def stats(update, context):
+ currentTime = get_readable_time(time.time() - botStartTime)
+ total, used, free = shutil.disk_usage('.')
+ total = get_readable_file_size(total)
+ used = get_readable_file_size(used)
+ free = get_readable_file_size(free)
+ sent = get_readable_file_size(psutil.net_io_counters().bytes_sent)
+ recv = get_readable_file_size(psutil.net_io_counters().bytes_recv)
+ cpuUsage = psutil.cpu_percent(interval=0.5)
+ memory = psutil.virtual_memory().percent
+ disk = psutil.disk_usage('/').percent
+ stats = f'╭──「⭕️ BOT STATISTICS ⭕️」\n' \
+ f'│\n' \
+ f'├ ⏰ Bot Uptime : {currentTime}\n' \
+ f'├ 💾 Total Disk Space : {total}\n' \
+ f'├ 📀 Total Used Space : {used}\n' \
+ f'├ 💿 Total Free Space : {free}\n' \
+ f'├ 🔼 Total Upload : {sent}\n' \
+ f'├ 🔽 Total Download : {recv}\n' \
+ f'├ 🖥️ CPU : {cpuUsage}%\n' \
+ f'├ 🎮 RAM : {memory}%\n' \
+ f'├ 💽 DISK : {disk}%\n' \
+ f'│\n' \
+ f'╰──「 🚸 @AT_BOTs 🚸 」'
+ update.effective_message.reply_photo(IMAGE_URL, stats, parse_mode=ParseMode.HTML)
+
+
+def start(update, context):
+ start_string = f'''
+This bot can mirror all your links to Google Drive!
+Type /{BotCommands.HelpCommand} to get a list of available commands
+'''
+ buttons = button_build.ButtonMaker()
+ buttons.buildbutton("Repo", "https://github.com/ayushteke/slam_aria_mirror_bot")
+ buttons.buildbutton("Channel", "https://t.me/AT_BOTs")
+ reply_markup = InlineKeyboardMarkup(buttons.build_menu(2))
+ LOGGER.info('UID: {} - UN: {} - MSG: {}'.format(update.message.chat.id, update.message.chat.username, update.message.text))
+ uptime = get_readable_time((time.time() - botStartTime))
+ if CustomFilters.authorized_user(update) or CustomFilters.authorized_chat(update):
+ if update.message.chat.type == "private" :
+ sendMessage(f"Hey I'm Alive 🙂\nSince: Click here for more details
+ +``` +cp config_sample.env config.env +``` +- Remove the first line saying: +``` +_____REMOVE_THIS_LINE_____=True +``` +Fill up rest of the fields. Meaning of each fields are discussed below: +### Required Field +- **BOT_TOKEN**: The Telegram bot token that you get from [@BotFather](https://t.me/BotFather) +- **TELEGRAM_API**: This is to authenticate to your Telegram account for downloading Telegram files. You can get this from https://my.telegram.org DO NOT put this in quotes. +- **TELEGRAM_HASH**: This is to authenticate to your Telegram account for downloading Telegram files. You can get this from https://my.telegram.org +- **OWNER_ID**: The Telegram user ID (not username) of the Owner of the bot +- **DATABASE_URL**: Your Database URL. See [Generate Database](https://github.com/breakdowns/slam-mirrorbot/tree/master#generate-database) to generate database. (**NOTE**: If you deploying on Heroku using Heroku button, no need to generate database manually, because it will automatic generate database when first deploying) +- **GDRIVE_FOLDER_ID**: This is the folder ID of the Google Drive Folder to which you want to upload all the mirrors. +- **DOWNLOAD_DIR**: The path to the local folder where the downloads should be downloaded to +- **DOWNLOAD_STATUS_UPDATE_INTERVAL**: A short interval of time in seconds after which the Mirror progress message is updated. (I recommend to keep it `5` seconds at least) +- **AUTO_DELETE_MESSAGE_DURATION**: Interval of time (in seconds), after which the bot deletes it's message (and command message) which is expected to be viewed instantly. (**Note**: Set to `-1` to never automatically delete messages) +- **UPSTREAM_REPO**: Link for Bot Upstream Repo, if you want default update, fill . +- **UPSTREAM_BRANCH**: Branch name for Bot Upstream Repo (Recommended using master branch) +### Optional Field +- **GDTOT_COOKIES**: add your GDTOT cookies in form of "crypt=eXU2cDlzYWhzRk93eXV4cTQzMXFCeHE2UElEcUtJcEY1U0 ; PHPSESSID=0vt54of2tao357sltquke" +- **AUTHORIZED_CHATS**: Fill user_id and chat_id of you want to authorize. +- **IS_TEAM_DRIVE**: Set to `True` if `GDRIVE_FOLDER_ID` is from a Team Drive else `False` or Leave it empty. +- **USE_SERVICE_ACCOUNTS**: (Leave empty if unsure) Whether to use Service Accounts or not. For this to work see [Using service accounts](https://github.com/breakdowns/slam-mirrorbot#generate-service-accounts-what-is-service-account) section below. +- **INDEX_URL**: Refer to [Bhadoo Drive Index](https://bdi-generator.hashhackers.com/) The URL should not have any trailing '/' +- **MEGA_API_KEY**: Mega.nz api key to mirror mega.nz links. Get it from [Mega SDK Page](https://mega.nz/sdk) +- **MEGA_EMAIL_ID**: Your email id you used to sign up on mega.nz for using premium accounts (Leave th) +- **MEGA_PASSWORD**: Your password for your mega.nz account +- **BLOCK_MEGA_FOLDER**: If you want to remove mega.nz folder support, set it to `True`. +- **BLOCK_MEGA_LINKS**: If you want to remove mega.nz mirror support, set it to `True`. +- **STOP_DUPLICATE_MIRROR**: (Leave empty if unsure) if this field is set to `True`, bot will check file in Drive, if it is present in Drive, downloading will be stopped. (**Note**: File will be checked using filename, not using filehash, so this feature is not perfect yet) +- **STOP_DUPLICATE_MEGA**: (Leave empty if unsure) if this field is set to `True`, bot will check file in Drive, if it is present in Drive, downloading Mega will be stopped. +- **STOP_DUPLICATE_CLONE**: (Leave empty if unsure) if this field is set to `True`, bot will check file in Drive, if it is present in Drive, cloning will be stopped. +- **CLONE_LIMIT**: To limit cloning Google Drive (leave space between number and unit, Available units is (gb or GB, tb or TB). +- **MEGA_LIMIT**: To limit downloading Mega (leave space between number and unit, Available units is (gb or GB, tb or TB). +- **TORRENT_DIRECT_LIMIT**: To limit the Torrent/Direct mirror size, Leave space between number and unit. Available units is (gb or GB, tb or TB). +- **IMAGE_URL**: Show Image/Logo in /start message. Fill value of image your link image, use telegra.ph or any direct link image. +- **VIEW_LINK**: View Link button to open file Index Link in browser instead of direct download link, you can figure out if it's compatible with your Index code or not, open any video from you Index and check if the END of link from browser link bar is `?a=view`, if yes make it `True` it will work (Compatible with [Bhadoo Index](https://github.com/ParveenBhadooOfficial/Google-Drive-Index) Code) +- **UPTOBOX_TOKEN**: Uptobox token to mirror uptobox links. Get it from [Uptobox Premium Account](https://uptobox.com/my_account). +- **HEROKU_API_KEY**: (Only if you deploying on Heroku) Your Heroku API key, get it from https://dashboard.heroku.com/account. +- **HEROKU_APP_NAME**: (Only if you deploying on Heroku) Your Heroku app name. +- **IGNORE_PENDING_REQUESTS**: (Optional field) If you want the bot to ignore pending requests after it restarts, set this to `True`. +- **SHORTENER_API**: Fill your Shortener api key if you are using Shortener. +- **SHORTENER**: if you want to use Shortener in Gdrive and index link, fill Shortener url here. Examples: +``` +exe.io, gplinks.in, shrinkme.io, urlshortx.com, shortzon.com +``` + +Above are the supported url Shorteners. Except these only some url Shorteners are supported. + +**Note**: You can limit maximum concurrent downloads by changing the value of **MAX_CONCURRENT_DOWNLOADS** in aria.sh. By default, it's set to `4`. +### Add more buttons (Optional Field) +Three buttons are already added of Drive Link, Index Link, and View Link, you can add extra buttons, these are optional, if you don't know what are below entries, simply leave them, don't fill anything in them. +- **BUTTON_FOUR_NAME**: +- **BUTTON_FOUR_URL**: +- **BUTTON_FIVE_NAME**: +- **BUTTON_FIVE_URL**: +- **BUTTON_SIX_NAME**: +- **BUTTON_SIX_URL**: + +{uptime}", context.bot, update)
+ else :
+ sendMarkup(IMAGE_URL, start_string, context.bot, update, reply_markup)
+ else :
+ sendMarkup(f"Oops! You are not allowed to use me..", context.bot, update, reply_markup)
+
+
+def restart(update, context):
+ restart_message = sendMessage("Restarting, Please wait!", context.bot, update)
+ # Save restart message object in order to reply to it after restarting
+ with open(".restartmsg", "w") as f:
+ f.truncate(0)
+ f.write(f"{restart_message.chat.id}\n{restart_message.message_id}\n")
+ fs_utils.clean_all()
+ os.execl(executable, executable, "-m", "bot")
+
+
+def ping(update, context):
+ start_time = int(round(time.time() * 1000))
+ reply = sendMessage("Starting Ping", context.bot, update)
+ end_time = int(round(time.time() * 1000))
+ editMessage(f'{end_time - start_time} ms', reply)
+
+
+def log(update, context):
+ sendLogFile(context.bot, update)
+
+
+def bot_help(update, context):
+ help_string_adm = f'''
+/{BotCommands.HelpCommand}: To get this message
+/{BotCommands.MirrorCommand} [download_url][magnet_link]: Start mirroring the link to Google Drive. Use /{BotCommands.MirrorCommand} qb to mirror with qBittorrent, and use /{BotCommands.MirrorCommand} qbs to select files before downloading
+/{BotCommands.TarMirrorCommand} [download_url][magnet_link]: Start mirroring and upload the archived (.tar) version of the download
+/{BotCommands.ZipMirrorCommand} [download_url][magnet_link]: Start mirroring and upload the archived (.zip) version of the download
+/{BotCommands.UnzipMirrorCommand} [download_url][magnet_link]: Starts mirroring and if downloaded file is any archive, extracts it to Google Drive
+/{BotCommands.CloneCommand} [drive_url]: Copy file/folder to Google Drive
+/{BotCommands.CountCommand} [drive_url]: Count file/folder of Google Drive Links
+/{BotCommands.DeleteCommand} [drive_url]: Delete file from Google Drive (Only Owner & Sudo)
+/{BotCommands.WatchCommand} [youtube-dl supported link]: Mirror through youtube-dl. Click /{BotCommands.WatchCommand} for more help
+/{BotCommands.TarWatchCommand} [youtube-dl supported link]: Mirror through youtube-dl and tar before uploading
+/{BotCommands.CancelMirror}: Reply to the message by which the download was initiated and that download will be cancelled
+/{BotCommands.CancelAllCommand}: Cancel all running tasks
+/{BotCommands.ListCommand} [search term]: Searches the search term in the Google Drive, If found replies with the link
+/{BotCommands.StatusCommand}: Shows a status of all the downloads
+/{BotCommands.StatsCommand}: Show Stats of the machine the bot is hosted on
+/{BotCommands.PingCommand}: Check how long it takes to Ping the Bot
+/{BotCommands.AuthorizeCommand}: Authorize a chat or a user to use the bot (Can only be invoked by Owner & Sudo of the bot)
+/{BotCommands.UnAuthorizeCommand}: Unauthorize a chat or a user to use the bot (Can only be invoked by Owner & Sudo of the bot)
+/{BotCommands.AuthorizedUsersCommand}: Show authorized users (Only Owner & Sudo)
+/{BotCommands.AddSudoCommand}: Add sudo user (Only Owner)
+/{BotCommands.RmSudoCommand}: Remove sudo users (Only Owner)
+/{BotCommands.RestartCommand}: Restart the bot
+/{BotCommands.LogCommand}: Get a log file of the bot. Handy for getting crash reports
+/{BotCommands.ConfigMenuCommand}: Get Info Menu about bot config (Owner Only)
+/{BotCommands.UpdateCommand}: Update Bot from Upstream Repo (Owner Only)
+/{BotCommands.SpeedCommand}: Check Internet Speed of the Host
+/{BotCommands.ShellCommand}: Run commands in Shell (Terminal)
+/{BotCommands.ExecHelpCommand}: Get help for Executor module (Only Owner)
+/{BotCommands.TsHelpCommand}: Get help for Torrent search module
+'''
+
+ help_string = f'''
+/{BotCommands.HelpCommand}: To get this message
+/{BotCommands.MirrorCommand} [download_url][magnet_link]: Start mirroring the link to Google Drive. Use /{BotCommands.MirrorCommand} qb to mirror with qBittorrent, and use /{BotCommands.MirrorCommand} qbs to select files before downloading
+/{BotCommands.TarMirrorCommand} [download_url][magnet_link]: Start mirroring and upload the archived (.tar) version of the download
+/{BotCommands.ZipMirrorCommand} [download_url][magnet_link]: Start mirroring and upload the archived (.zip) version of the download
+/{BotCommands.UnzipMirrorCommand} [download_url][magnet_link]: Starts mirroring and if downloaded file is any archive, extracts it to Google Drive
+/{BotCommands.CloneCommand} [drive_url]: Copy file/folder to Google Drive
+/{BotCommands.CountCommand} [drive_url]: Count file/folder of Google Drive Links
+/{BotCommands.WatchCommand} [youtube-dl supported link]: Mirror through youtube-dl. Click /{BotCommands.WatchCommand} for more help
+/{BotCommands.TarWatchCommand} [youtube-dl supported link]: Mirror through youtube-dl and tar before uploading
+/{BotCommands.CancelMirror}: Reply to the message by which the download was initiated and that download will be cancelled
+/{BotCommands.ListCommand} [search term]: Searches the search term in the Google Drive, If found replies with the link
+/{BotCommands.StatusCommand}: Shows a status of all the downloads
+/{BotCommands.StatsCommand}: Show Stats of the machine the bot is hosted on
+/{BotCommands.PingCommand}: Check how long it takes to Ping the Bot
+/{BotCommands.TsHelpCommand}: Get help for Torrent search module
+'''
+
+ if CustomFilters.sudo_user(update) or CustomFilters.owner_filter(update):
+ sendMessage(help_string_adm, context.bot, update)
+ else:
+ sendMessage(help_string, context.bot, update)
+
+
+botcmds = [
+ (f'{BotCommands.HelpCommand}','Get Detailed Help'),
+ (f'{BotCommands.MirrorCommand}', 'Start Mirroring'),
+ (f'{BotCommands.TarMirrorCommand}','Start mirroring and upload as .tar'),
+ (f'{BotCommands.UnzipMirrorCommand}','Extract files'),
+ (f'{BotCommands.ZipMirrorCommand}','Start mirroring and upload as .zip'),
+ (f'{BotCommands.CloneCommand}','Copy file/folder to Drive'),
+ (f'{BotCommands.CountCommand}','Count file/folder of Drive link'),
+ (f'{BotCommands.DeleteCommand}','Delete file from Drive'),
+ (f'{BotCommands.WatchCommand}','Mirror Youtube-dl support link'),
+ (f'{BotCommands.TarWatchCommand}','Mirror Youtube playlist link as .tar'),
+ (f'{BotCommands.CancelMirror}','Cancel a task'),
+ (f'{BotCommands.CancelAllCommand}','Cancel all tasks'),
+ (f'{BotCommands.ListCommand}','Searches files in Drive'),
+ (f'{BotCommands.StatusCommand}','Get Mirror Status message'),
+ (f'{BotCommands.StatsCommand}','Bot Usage Stats'),
+ (f'{BotCommands.PingCommand}','Ping the Bot'),
+ (f'{BotCommands.RestartCommand}','Restart the bot [owner/sudo only]'),
+ (f'{BotCommands.LogCommand}','Get the Bot Log [owner/sudo only]'),
+ (f'{BotCommands.TsHelpCommand}','Get help for Torrent search module')
+ ]
+
+
+def main():
+ fs_utils.start_cleanup()
+ if IS_VPS:
+ asyncio.get_event_loop().run_until_complete(start_server_async(PORT))
+ # Check if the bot is restarting
+ if os.path.isfile(".restartmsg"):
+ with open(".restartmsg") as f:
+ chat_id, msg_id = map(int, f)
+ bot.edit_message_text("Restarted successfully!", chat_id, msg_id)
+ os.remove(".restartmsg")
+ elif OWNER_ID:
+ try:
+ text = "Bot Restarted!"
+ bot.sendMessage(chat_id=OWNER_ID, text=text, parse_mode=ParseMode.HTML)
+ if AUTHORIZED_CHATS:
+ for i in AUTHORIZED_CHATS:
+ bot.sendMessage(chat_id=i, text=text, parse_mode=ParseMode.HTML)
+ except Exception as e:
+ LOGGER.warning(e)
+
+ bot.set_my_commands(botcmds)
+
+ start_handler = CommandHandler(BotCommands.StartCommand, start, run_async=True)
+ ping_handler = CommandHandler(BotCommands.PingCommand, ping,
+ filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+ restart_handler = CommandHandler(BotCommands.RestartCommand, restart,
+ filters=CustomFilters.owner_filter | CustomFilters.sudo_user, run_async=True)
+ help_handler = CommandHandler(BotCommands.HelpCommand,
+ bot_help, filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+ stats_handler = CommandHandler(BotCommands.StatsCommand,
+ stats, filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+ log_handler = CommandHandler(BotCommands.LogCommand, log, filters=CustomFilters.owner_filter | CustomFilters.sudo_user, run_async=True)
+ dispatcher.add_handler(start_handler)
+ dispatcher.add_handler(ping_handler)
+ dispatcher.add_handler(restart_handler)
+ dispatcher.add_handler(help_handler)
+ dispatcher.add_handler(stats_handler)
+ dispatcher.add_handler(log_handler)
+ updater.start_polling(drop_pending_updates=IGNORE_PENDING_REQUESTS)
+ LOGGER.info("Bot Started!")
+ signal.signal(signal.SIGINT, fs_utils.exit_clean_up)
+
+app.start()
+main()
+idle()
diff --git a/bot/helper/__init__.py b/bot/helper/__init__.py
new file mode 100644
index 0000000..4d60510
--- /dev/null
+++ b/bot/helper/__init__.py
@@ -0,0 +1,70 @@
+import heroku3
+
+from functools import wraps
+from pyrogram.types import Message
+from bot import HEROKU_API_KEY, HEROKU_APP_NAME
+
+# Implement by https://github.com/jusidama18
+# Setting Message
+
+def get_text(message: Message) -> [None, str]:
+ """Extract Text From Commands"""
+ text_to_return = message.text
+ if message.text is None:
+ return None
+ if " " in text_to_return:
+ try:
+ return message.text.split(None, 1)[1]
+ except IndexError:
+ return None
+ else:
+ return None
+
+# Preparing For Setting Config
+# Implement by https://github.com/jusidama18 and Based on this https://github.com/DevsExpo/FridayUserbot/blob/master/plugins/heroku_helpers.py
+
+heroku_client = None
+if HEROKU_API_KEY:
+ heroku_client = heroku3.from_key(HEROKU_API_KEY)
+
+def check_heroku(func):
+ @wraps(func)
+ async def heroku_cli(client, message):
+ heroku_app = None
+ if not heroku_client:
+ await message.reply_text("`Please Add HEROKU_API_KEY Key For This To Function To Work!`", parse_mode="markdown")
+ elif not HEROKU_APP_NAME:
+ await message.reply_text("`Please Add HEROKU_APP_NAME For This To Function To Work!`", parse_mode="markdown")
+ if HEROKU_APP_NAME and heroku_client:
+ try:
+ heroku_app = heroku_client.app(HEROKU_APP_NAME)
+ except:
+ await message.reply_text(message, "`Heroku Api Key And App Name Doesn't Match!`", parse_mode="markdown")
+ if heroku_app:
+ await func(client, message, heroku_app)
+
+ return heroku_cli
+
+# Preparing For Update Bot
+# Implement by https://github.com/jusidama18 and Based on this https://github.com/DevsExpo/FridayUserbot/blob/master/plugins/updater.py
+
+def fetch_heroku_git_url(api_key, app_name):
+ if not api_key:
+ return None
+ if not app_name:
+ return None
+ heroku = heroku3.from_key(api_key)
+ try:
+ heroku_applications = heroku.apps()
+ except:
+ return None
+ heroku_app = None
+ for app in heroku_applications:
+ if app.name == app_name:
+ heroku_app = app
+ break
+ if not heroku_app:
+ return None
+ return heroku_app.git_url.replace("https://", "https://api:" + api_key + "@")
+
+HEROKU_URL = fetch_heroku_git_url(HEROKU_API_KEY, HEROKU_APP_NAME)
diff --git a/bot/helper/custom_filters.py b/bot/helper/custom_filters.py
new file mode 100644
index 0000000..0b17f44
--- /dev/null
+++ b/bot/helper/custom_filters.py
@@ -0,0 +1,23 @@
+from pyrogram import filters
+
+def callback_data(data):
+ def func(flt, client, callback_query):
+ return callback_query.data in flt.data
+
+ data = data if isinstance(data, list) else [data]
+ return filters.create(
+ func,
+ 'CustomCallbackDataFilter',
+ data=data
+ )
+
+def callback_chat(chats):
+ def func(flt, client, callback_query):
+ return callback_query.message.chat.id in flt.chats
+
+ chats = chats if isinstance(chats, list) else [chats]
+ return filters.create(
+ func,
+ 'CustomCallbackChatsFilter',
+ chats=chats
+ )
diff --git a/bot/helper/ext_utils/__init__.py b/bot/helper/ext_utils/__init__.py
new file mode 100644
index 0000000..bba8f51
--- /dev/null
+++ b/bot/helper/ext_utils/__init__.py
@@ -0,0 +1 @@
+#TEKEAYUSH
\ No newline at end of file
diff --git a/bot/helper/ext_utils/bot_utils.py b/bot/helper/ext_utils/bot_utils.py
new file mode 100644
index 0000000..b4ad005
--- /dev/null
+++ b/bot/helper/ext_utils/bot_utils.py
@@ -0,0 +1,265 @@
+import logging
+import re
+import threading
+import time
+import math
+
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot import dispatcher, download_dict, download_dict_lock, STATUS_LIMIT
+from telegram import InlineKeyboardMarkup
+from telegram.ext import CallbackQueryHandler
+from bot.helper.telegram_helper import button_build, message_utils
+
+LOGGER = logging.getLogger(__name__)
+
+MAGNET_REGEX = r"magnet:\?xt=urn:btih:[a-zA-Z0-9]*"
+
+URL_REGEX = r"(?:(?:https?|ftp):\/\/)?[\w/\-?=%.]+\.[\w/\-?=%.]+"
+
+COUNT = 0
+PAGE_NO = 1
+
+
+class MirrorStatus:
+ STATUS_UPLOADING = "Uploading...📤"
+ STATUS_DOWNLOADING = "Downloading...📥"
+ STATUS_CLONING = "Cloning...♻️"
+ STATUS_WAITING = "Queued...📝"
+ STATUS_FAILED = "Failed 🚫. Cleaning Download..."
+ STATUS_PAUSE = "Paused...⭕️"
+ STATUS_ARCHIVING = "Archiving...🔐"
+ STATUS_EXTRACTING = "Extracting...📂"
+
+
+PROGRESS_MAX_SIZE = 100 // 8
+PROGRESS_INCOMPLETE = ['☆', '☆', '☆', '☆', '☆', '☆', '☆']
+
+SIZE_UNITS = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
+
+
+class setInterval:
+ def __init__(self, interval, action):
+ self.interval = interval
+ self.action = action
+ self.stopEvent = threading.Event()
+ thread = threading.Thread(target=self.__setInterval)
+ thread.start()
+
+ def __setInterval(self):
+ nextTime = time.time() + self.interval
+ while not self.stopEvent.wait(nextTime - time.time()):
+ nextTime += self.interval
+ self.action()
+
+ def cancel(self):
+ self.stopEvent.set()
+
+
+def get_readable_file_size(size_in_bytes) -> str:
+ if size_in_bytes is None:
+ return '0B'
+ index = 0
+ while size_in_bytes >= 1024:
+ size_in_bytes /= 1024
+ index += 1
+ try:
+ return f'{round(size_in_bytes, 2)}{SIZE_UNITS[index]}'
+ except IndexError:
+ return 'File too large'
+
+
+def getDownloadByGid(gid):
+ with download_dict_lock:
+ for dl in download_dict.values():
+ status = dl.status()
+ if status != MirrorStatus.STATUS_ARCHIVING and status != MirrorStatus.STATUS_EXTRACTING:
+ if dl.gid() == gid:
+ return dl
+ return None
+
+
+def getAllDownload():
+ with download_dict_lock:
+ for dlDetails in download_dict.values():
+ if dlDetails.status() == MirrorStatus.STATUS_DOWNLOADING or dlDetails.status() == MirrorStatus.STATUS_WAITING:
+ if dlDetails:
+ return dlDetails
+ return None
+
+
+def get_progress_bar_string(status):
+ completed = status.processed_bytes() / 8
+ total = status.size_raw() / 8
+ if total == 0:
+ p = 0
+ else:
+ p = round(completed * 100 / total)
+ p = min(max(p, 0), 100)
+ cFull = p // 8
+ cPart = p % 8 - 1
+ p_str = '★' * cFull
+ if cPart >= 0:
+ p_str += PROGRESS_INCOMPLETE[cPart]
+ p_str += ' ' * (PROGRESS_MAX_SIZE - cFull)
+ p_str = f"[{p_str}]"
+ return p_str
+
+
+def get_readable_message():
+ with download_dict_lock:
+ msg = ""
+ INDEX = 0
+ if STATUS_LIMIT is not None:
+ dick_no = len(download_dict)
+ global pages
+ pages = math.ceil(dick_no/STATUS_LIMIT)
+ if PAGE_NO > pages and pages != 0:
+ globals()['COUNT'] -= STATUS_LIMIT
+ globals()['PAGE_NO'] -= 1
+ for download in list(download_dict.values()):
+ INDEX += 1
+ if INDEX > COUNT:
+ msg += f"☞ 🗃️Filename : {download.name()}"
+ msg += f"\n☞ 🚦Status : {download.status()}"
+ if download.status() != MirrorStatus.STATUS_ARCHIVING and download.status() != MirrorStatus.STATUS_EXTRACTING:
+ msg += f"\n{get_progress_bar_string(download)} {download.progress()}"
+ if download.status() == MirrorStatus.STATUS_CLONING:
+ msg += f"\n☞ 🚦Cloned: {get_readable_file_size(download.processed_bytes())} of {download.size()}"
+ elif download.status() == MirrorStatus.STATUS_UPLOADING:
+ msg += f"\n☞ 📤Uploaded : {get_readable_file_size(download.processed_bytes())} of {download.size()}"
+ else:
+ msg += f"\n☞ 📥Downloaded : {get_readable_file_size(download.processed_bytes())} of {download.size()}"
+ msg += f"\n☞ ⚡️Speed : {download.speed()}" \
+ f"\n☞ ⏰ETA : {download.eta()} "
+ # if hasattr(download, 'is_torrent'):
+ try:
+ msg += f"\n☞ Seeders : {download.aria_download().num_seeders}" \
+ f" | ☞ Peers : {download.aria_download().connections}"
+ except:
+ pass
+ try:
+ msg += f"\n☞ Seeders : {download.torrent_info().num_seeds}" \
+ f" | ☞ Leechers : {download.torrent_info().num_leechs}"
+ except:
+ pass
+ msg += f"\n☞ To cancel ❌ : /{BotCommands.CancelMirror} {download.gid()}"
+ msg += "\n\n"
+ if STATUS_LIMIT is not None:
+ if INDEX >= COUNT + STATUS_LIMIT:
+ break
+ if STATUS_LIMIT is not None:
+ if INDEX > COUNT + STATUS_LIMIT:
+ return None, None
+ if dick_no > STATUS_LIMIT:
+ msg += f"Page: {PAGE_NO}/{pages} | Tasks: {dick_no}\n"
+ buttons = button_build.ButtonMaker()
+ buttons.sbutton("Previous", "pre")
+ buttons.sbutton("Next", "nex")
+ button = InlineKeyboardMarkup(buttons.build_menu(2))
+ return msg, button
+ return msg, ""
+
+
+def flip(update, context):
+ query = update.callback_query
+ query.answer()
+ global COUNT, PAGE_NO
+ if query.data == "nex":
+ if PAGE_NO == pages:
+ COUNT = 0
+ PAGE_NO = 1
+ else:
+ COUNT += STATUS_LIMIT
+ PAGE_NO += 1
+ elif query.data == "pre":
+ if PAGE_NO == 1:
+ COUNT = STATUS_LIMIT * (pages - 1)
+ PAGE_NO = pages
+ else:
+ COUNT -= STATUS_LIMIT
+ PAGE_NO -= 1
+ message_utils.update_all_messages()
+
+
+def check_limit(size, limit, tar_unzip_limit=None, is_tar_ext=False):
+ LOGGER.info(f"Checking File/Folder Size...")
+ if is_tar_ext and tar_unzip_limit is not None:
+ limit = tar_unzip_limit
+ if limit is not None:
+ limit = limit.split(' ', maxsplit=1)
+ limitint = int(limit[0])
+ if 'G' in limit[1] or 'g' in limit[1]:
+ if size > limitint * 1024**3:
+ return True
+ elif 'T' in limit[1] or 't' in limit[1]:
+ if size > limitint * 1024**4:
+ return True
+
+def get_readable_time(seconds: int) -> str:
+ result = ''
+ (days, remainder) = divmod(seconds, 86400)
+ days = int(days)
+ if days != 0:
+ result += f'{days}d'
+ (hours, remainder) = divmod(remainder, 3600)
+ hours = int(hours)
+ if hours != 0:
+ result += f'{hours}h'
+ (minutes, seconds) = divmod(remainder, 60)
+ minutes = int(minutes)
+ if minutes != 0:
+ result += f'{minutes}m'
+ seconds = int(seconds)
+ result += f'{seconds}s'
+ return result
+
+
+def is_url(url: str):
+ url = re.findall(URL_REGEX, url)
+ if url:
+ return True
+ return False
+
+
+def is_gdrive_link(url: str):
+ return "drive.google.com" in url
+
+
+def is_mega_link(url: str):
+ return "mega.nz" in url or "mega.co.nz" in url
+
+
+def get_mega_link_type(url: str):
+ if "folder" in url:
+ return "folder"
+ elif "file" in url:
+ return "file"
+ elif "/#F!" in url:
+ return "folder"
+ return "file"
+
+
+def is_magnet(url: str):
+ magnet = re.findall(MAGNET_REGEX, url)
+ if magnet:
+ return True
+ return False
+
+
+def new_thread(fn):
+ """To use as decorator to make a function call threaded.
+ Needs import
+ from threading import Thread"""
+
+ def wrapper(*args, **kwargs):
+ thread = threading.Thread(target=fn, args=args, kwargs=kwargs)
+ thread.start()
+ return thread
+
+ return wrapper
+
+
+next_handler = CallbackQueryHandler(flip, pattern="nex", run_async=True)
+previous_handler = CallbackQueryHandler(flip, pattern="pre", run_async=True)
+dispatcher.add_handler(next_handler)
+dispatcher.add_handler(previous_handler)
diff --git a/bot/helper/ext_utils/db_handler.py b/bot/helper/ext_utils/db_handler.py
new file mode 100644
index 0000000..2273942
--- /dev/null
+++ b/bot/helper/ext_utils/db_handler.py
@@ -0,0 +1,75 @@
+import psycopg2
+from psycopg2 import Error
+from bot import AUTHORIZED_CHATS, SUDO_USERS, DB_URI, LOGGER
+
+class DbManger:
+ def __init__(self):
+ self.err = False
+
+ def connect(self):
+ try:
+ self.conn = psycopg2.connect(DB_URI)
+ self.cur = self.conn.cursor()
+ except psycopg2.DatabaseError as error :
+ LOGGER.error("Error in dbMang : ", error)
+ self.err = True
+
+ def disconnect(self):
+ self.cur.close()
+ self.conn.close()
+
+ def db_auth(self,chat_id: int):
+ self.connect()
+ if self.err :
+ return "There's some error check log for details"
+ else:
+ sql = 'INSERT INTO users VALUES ({});'.format(chat_id)
+ self.cur.execute(sql)
+ self.conn.commit()
+ self.disconnect()
+ AUTHORIZED_CHATS.add(chat_id)
+ return 'Authorized successfully'
+
+ def db_unauth(self,chat_id: int):
+ self.connect()
+ if self.err :
+ return "There's some error check log for details"
+ else:
+ sql = 'DELETE from users where uid = {};'.format(chat_id)
+ self.cur.execute(sql)
+ self.conn.commit()
+ self.disconnect()
+ AUTHORIZED_CHATS.remove(chat_id)
+ return 'Unauthorized successfully'
+
+ def db_addsudo(self,chat_id: int):
+ self.connect()
+ if self.err :
+ return "There's some error check log for details"
+ else:
+ if chat_id in AUTHORIZED_CHATS:
+ sql = 'UPDATE users SET sudo = TRUE where uid = {};'.format(chat_id)
+ self.cur.execute(sql)
+ self.conn.commit()
+ self.disconnect()
+ SUDO_USERS.add(chat_id)
+ return 'Successfully promoted as Sudo'
+ else:
+ sql = 'INSERT INTO users VALUES ({},TRUE);'.format(chat_id)
+ self.cur.execute(sql)
+ self.conn.commit()
+ self.disconnect()
+ SUDO_USERS.add(chat_id)
+ return 'Successfully Authorized and promoted as Sudo'
+
+ def db_rmsudo(self,chat_id: int):
+ self.connect()
+ if self.err :
+ return "There's some error check log for details"
+ else:
+ sql = 'UPDATE users SET sudo = FALSE where uid = {};'.format(chat_id)
+ self.cur.execute(sql)
+ self.conn.commit()
+ self.disconnect()
+ SUDO_USERS.remove(chat_id)
+ return 'Successfully removed from Sudo'
diff --git a/bot/helper/ext_utils/exceptions.py b/bot/helper/ext_utils/exceptions.py
new file mode 100644
index 0000000..a2f600c
--- /dev/null
+++ b/bot/helper/ext_utils/exceptions.py
@@ -0,0 +1,8 @@
+class DirectDownloadLinkException(Exception):
+ """Not method found for extracting direct download link from the http link"""
+ pass
+
+
+class NotSupportedExtractionArchive(Exception):
+ """The archive format use is trying to extract is not supported"""
+ pass
diff --git a/bot/helper/ext_utils/fs_utils.py b/bot/helper/ext_utils/fs_utils.py
new file mode 100644
index 0000000..a7e1a4b
--- /dev/null
+++ b/bot/helper/ext_utils/fs_utils.py
@@ -0,0 +1,156 @@
+import sys
+from bot import aria2, LOGGER, DOWNLOAD_DIR, get_client
+import shutil
+import os
+import pathlib
+import magic
+import tarfile
+from .exceptions import NotSupportedExtractionArchive
+
+
+def clean_download(path: str):
+ if os.path.exists(path):
+ LOGGER.info(f"Cleaning download: {path}")
+ shutil.rmtree(path)
+
+
+def start_cleanup():
+ try:
+ shutil.rmtree(DOWNLOAD_DIR)
+ except FileNotFoundError:
+ pass
+
+
+def clean_all():
+ aria2.remove_all(True)
+ get_client().torrents_delete(torrent_hashes="all", delete_files=True)
+ try:
+ shutil.rmtree(DOWNLOAD_DIR)
+ except FileNotFoundError:
+ pass
+
+
+def exit_clean_up(signal, frame):
+ try:
+ LOGGER.info("Please wait, while we clean up the downloads and stop running downloads")
+ clean_all()
+ sys.exit(0)
+ except KeyboardInterrupt:
+ LOGGER.warning("Force Exiting before the cleanup finishes!")
+ sys.exit(1)
+
+
+def get_path_size(path):
+ if os.path.isfile(path):
+ return os.path.getsize(path)
+ total_size = 0
+ for root, dirs, files in os.walk(path):
+ for f in files:
+ abs_path = os.path.join(root, f)
+ total_size += os.path.getsize(abs_path)
+ return total_size
+
+
+def tar(org_path):
+ tar_path = org_path + ".tar"
+ #path = pathlib.PurePath(org_path)
+ LOGGER.info(f'Tar: orig_path: {org_path}, tar_path: {tar_path}')
+ tar = tarfile.open(tar_path, "w")
+ tar.add(org_path, arcname=os.path.basename(org_path))
+ tar.close()
+ return tar_path
+
+
+def zip(name, path):
+ root_dir = os.path.dirname(path)
+ base_dir = os.path.basename(path.strip(os.sep))
+ zip_file = shutil.make_archive(name, "zip", root_dir, base_dir)
+ zip_path = shutil.move(zip_file, root_dir)
+ LOGGER.info(f"Zip: {zip_path}")
+ return zip_path
+
+
+def get_base_name(orig_path: str):
+ if orig_path.endswith(".tar.bz2"):
+ return orig_path.replace(".tar.bz2", "")
+ elif orig_path.endswith(".tar.gz"):
+ return orig_path.replace(".tar.gz", "")
+ elif orig_path.endswith(".bz2"):
+ return orig_path.replace(".bz2", "")
+ elif orig_path.endswith(".gz"):
+ return orig_path.replace(".gz", "")
+ elif orig_path.endswith(".tar.xz"):
+ return orig_path.replace(".tar.xz", "")
+ elif orig_path.endswith(".tar"):
+ return orig_path.replace(".tar", "")
+ elif orig_path.endswith(".tbz2"):
+ return orig_path.replace("tbz2", "")
+ elif orig_path.endswith(".tgz"):
+ return orig_path.replace(".tgz", "")
+ elif orig_path.endswith(".zip"):
+ return orig_path.replace(".zip", "")
+ elif orig_path.endswith(".7z"):
+ return orig_path.replace(".7z", "")
+ elif orig_path.endswith(".Z"):
+ return orig_path.replace(".Z", "")
+ elif orig_path.endswith(".rar"):
+ return orig_path.replace(".rar", "")
+ elif orig_path.endswith(".iso"):
+ return orig_path.replace(".iso", "")
+ elif orig_path.endswith(".wim"):
+ return orig_path.replace(".wim", "")
+ elif orig_path.endswith(".cab"):
+ return orig_path.replace(".cab", "")
+ elif orig_path.endswith(".apm"):
+ return orig_path.replace(".apm", "")
+ elif orig_path.endswith(".arj"):
+ return orig_path.replace(".arj", "")
+ elif orig_path.endswith(".chm"):
+ return orig_path.replace(".chm", "")
+ elif orig_path.endswith(".cpio"):
+ return orig_path.replace(".cpio", "")
+ elif orig_path.endswith(".cramfs"):
+ return orig_path.replace(".cramfs", "")
+ elif orig_path.endswith(".deb"):
+ return orig_path.replace(".deb", "")
+ elif orig_path.endswith(".dmg"):
+ return orig_path.replace(".dmg", "")
+ elif orig_path.endswith(".fat"):
+ return orig_path.replace(".fat", "")
+ elif orig_path.endswith(".hfs"):
+ return orig_path.replace(".hfs", "")
+ elif orig_path.endswith(".lzh"):
+ return orig_path.replace(".lzh", "")
+ elif orig_path.endswith(".lzma"):
+ return orig_path.replace(".lzma", "")
+ elif orig_path.endswith(".lzma2"):
+ return orig_path.replace(".lzma2", "")
+ elif orig_path.endswith(".mbr"):
+ return orig_path.replace(".mbr", "")
+ elif orig_path.endswith(".msi"):
+ return orig_path.replace(".msi", "")
+ elif orig_path.endswith(".mslz"):
+ return orig_path.replace(".mslz", "")
+ elif orig_path.endswith(".nsis"):
+ return orig_path.replace(".nsis", "")
+ elif orig_path.endswith(".ntfs"):
+ return orig_path.replace(".ntfs", "")
+ elif orig_path.endswith(".rpm"):
+ return orig_path.replace(".rpm", "")
+ elif orig_path.endswith(".squashfs"):
+ return orig_path.replace(".squashfs", "")
+ elif orig_path.endswith(".udf"):
+ return orig_path.replace(".udf", "")
+ elif orig_path.endswith(".vhd"):
+ return orig_path.replace(".vhd", "")
+ elif orig_path.endswith(".xar"):
+ return orig_path.replace(".xar", "")
+ else:
+ raise NotSupportedExtractionArchive('File format not supported for extraction')
+
+
+def get_mime_type(file_path):
+ mime = magic.Magic(mime=True)
+ mime_type = mime.from_file(file_path)
+ mime_type = mime_type if mime_type else "text/plain"
+ return mime_type
diff --git a/bot/helper/mirror_utils/__init__.py b/bot/helper/mirror_utils/__init__.py
new file mode 100644
index 0000000..bba8f51
--- /dev/null
+++ b/bot/helper/mirror_utils/__init__.py
@@ -0,0 +1 @@
+#TEKEAYUSH
\ No newline at end of file
diff --git a/bot/helper/mirror_utils/download_utils/__init__.py b/bot/helper/mirror_utils/download_utils/__init__.py
new file mode 100644
index 0000000..bba8f51
--- /dev/null
+++ b/bot/helper/mirror_utils/download_utils/__init__.py
@@ -0,0 +1 @@
+#TEKEAYUSH
\ No newline at end of file
diff --git a/bot/helper/mirror_utils/download_utils/aria2_download.py b/bot/helper/mirror_utils/download_utils/aria2_download.py
new file mode 100644
index 0000000..a66a0f6
--- /dev/null
+++ b/bot/helper/mirror_utils/download_utils/aria2_download.py
@@ -0,0 +1,106 @@
+from bot import aria2, download_dict_lock, STOP_DUPLICATE, TORRENT_DIRECT_LIMIT, TAR_UNZIP_LIMIT
+from bot.helper.mirror_utils.upload_utils.gdriveTools import GoogleDriveHelper
+from bot.helper.ext_utils.bot_utils import *
+from .download_helper import DownloadHelper
+from bot.helper.mirror_utils.status_utils.aria_download_status import AriaDownloadStatus
+from bot.helper.telegram_helper.message_utils import *
+import threading
+from aria2p import API
+from time import sleep
+
+
+class AriaDownloadHelper(DownloadHelper):
+
+ def __init__(self):
+ super().__init__()
+
+ @new_thread
+ def __onDownloadStarted(self, api, gid):
+ if STOP_DUPLICATE or TORRENT_DIRECT_LIMIT is not None or TAR_UNZIP_LIMIT is not None:
+ sleep(2)
+ dl = getDownloadByGid(gid)
+ download = aria2.get_download(gid)
+ if STOP_DUPLICATE and dl is not None:
+ LOGGER.info(f"Checking File/Folder if already in Drive...")
+ sname = aria2.get_download(gid).name
+ if dl.getListener().isTar:
+ sname = sname + ".tar"
+ if dl.getListener().extract:
+ smsg = None
+ else:
+ gdrive = GoogleDriveHelper(None)
+ smsg, button = gdrive.drive_list(sname)
+ if smsg:
+ dl.getListener().onDownloadError(f'File/Folder already available in Drive.\n\n')
+ aria2.remove([download], force=True)
+ sendMarkup("Here are the search results:", dl.getListener().bot, dl.getListener().update, button)
+ return
+ if (TORRENT_DIRECT_LIMIT is not None or TAR_UNZIP_LIMIT is not None) and dl is not None:
+ size = aria2.get_download(gid).total_length
+ if dl.getListener().isTar or dl.getListener().extract:
+ is_tar_ext = True
+ mssg = f'Tar/Unzip limit is {TAR_UNZIP_LIMIT}'
+ else:
+ is_tar_ext = False
+ mssg = f'Torrent/Direct limit is {TORRENT_DIRECT_LIMIT}'
+ result = check_limit(size, TORRENT_DIRECT_LIMIT, TAR_UNZIP_LIMIT, is_tar_ext)
+ if result:
+ dl.getListener().onDownloadError(f'{mssg}.\nYour File/Folder size is {get_readable_file_size(size)}')
+ aria2.remove([download], force=True)
+ return
+ update_all_messages()
+
+ def __onDownloadComplete(self, api: API, gid):
+ dl = getDownloadByGid(gid)
+ download = aria2.get_download(gid)
+ if download.followed_by_ids:
+ new_gid = download.followed_by_ids[0]
+ new_download = aria2.get_download(new_gid)
+ if dl is None:
+ dl = getDownloadByGid(new_gid)
+ with download_dict_lock:
+ download_dict[dl.uid()] = AriaDownloadStatus(new_gid, dl.getListener())
+ if new_download.is_torrent:
+ download_dict[dl.uid()].is_torrent = True
+ update_all_messages()
+ LOGGER.info(f'Changed gid from {gid} to {new_gid}')
+ else:
+ if dl:
+ threading.Thread(target=dl.getListener().onDownloadComplete).start()
+
+ @new_thread
+ def __onDownloadStopped(self, api, gid):
+ sleep(4)
+ dl = getDownloadByGid(gid)
+ if dl:
+ dl.getListener().onDownloadError('★ 𝗠𝗔𝗚𝗡𝗘𝗧/𝗧𝗢𝗥𝗥𝗘𝗡𝗧 𝗟𝗜𝗡𝗞 𝗜𝗦 𝗗𝗘𝗔𝗗 ❌ ★')
+
+ @new_thread
+ def __onDownloadError(self, api, gid):
+ LOGGER.info(f"onDownloadError: {gid}")
+ sleep(0.5) # sleep for split second to ensure proper dl gid update from onDownloadComplete
+ dl = getDownloadByGid(gid)
+ download = aria2.get_download(gid)
+ error = download.error_message
+ LOGGER.info(f"Download Error: {error}")
+ if dl:
+ dl.getListener().onDownloadError(error)
+
+ def start_listener(self):
+ aria2.listen_to_notifications(threaded=True, on_download_start=self.__onDownloadStarted,
+ on_download_error=self.__onDownloadError,
+ on_download_stop=self.__onDownloadStopped,
+ on_download_complete=self.__onDownloadComplete,
+ timeout=1)
+
+ def add_download(self, link: str, path, listener, filename):
+ if is_magnet(link):
+ download = aria2.add_magnet(link, {'dir': path, 'out': filename})
+ else:
+ download = aria2.add_uris([link], {'dir': path, 'out': filename})
+ if download.error_message: # no need to proceed further at this point
+ listener.onDownloadError(download.error_message)
+ return
+ with download_dict_lock:
+ download_dict[listener.uid] = AriaDownloadStatus(download.gid, listener)
+ LOGGER.info(f"Started: {download.gid} DIR:{download.dir} ")
diff --git a/bot/helper/mirror_utils/download_utils/direct_link_generator.py b/bot/helper/mirror_utils/download_utils/direct_link_generator.py
new file mode 100644
index 0000000..04a1f89
--- /dev/null
+++ b/bot/helper/mirror_utils/download_utils/direct_link_generator.py
@@ -0,0 +1,416 @@
+# Copyright (C) 2019 The Raphielscape Company LLC.
+#
+# Licensed under the Raphielscape Public License, Version 1.c (the "License");
+# you may not use this file except in compliance with the License.
+#
+""" Helper Module containing various sites direct links generators. This module is copied and modified as per need
+from https://github.com/AvinashReddy3108/PaperplaneExtended . I hereby take no credit of the following code other
+than the modifications. See https://github.com/AvinashReddy3108/PaperplaneExtended/commits/master/userbot/modules/direct_links.py
+for original authorship. """
+
+from bot import LOGGER, UPTOBOX_TOKEN
+import json
+import math
+import re
+import urllib.parse
+from os import popen
+from random import choice
+from urllib.parse import urlparse
+
+import lk21
+import requests, cfscrape
+from bs4 import BeautifulSoup
+from js2py import EvalJs
+from lk21.extractors.bypasser import Bypass
+from base64 import standard_b64encode
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot.helper.ext_utils.exceptions import DirectDownloadLinkException
+
+
+def direct_link_generator(link: str):
+ """ direct links generator """
+ if not link:
+ raise DirectDownloadLinkException("No links found!")
+ elif 'youtube.com' in link or 'youtu.be' in link:
+ raise DirectDownloadLinkException(f"Use /{BotCommands.WatchCommand} to mirror Youtube link\nUse /{BotCommands.TarWatchCommand} to make tar of Youtube playlist")
+ elif 'zippyshare.com' in link:
+ return zippy_share(link)
+ elif 'yadi.sk' in link:
+ return yandex_disk(link)
+ elif 'mediafire.com' in link:
+ return mediafire(link)
+ elif 'uptobox.com' in link:
+ return uptobox(link)
+ elif 'osdn.net' in link:
+ return osdn(link)
+ elif 'github.com' in link:
+ return github(link)
+ elif 'hxfile.co' in link:
+ return hxfile(link)
+ elif 'anonfiles.com' in link:
+ return anonfiles(link)
+ elif 'letsupload.io' in link:
+ return letsupload(link)
+ elif 'fembed.net' in link:
+ return fembed(link)
+ elif 'fembed.com' in link:
+ return fembed(link)
+ elif 'femax20.com' in link:
+ return fembed(link)
+ elif 'fcdn.stream' in link:
+ return fembed(link)
+ elif 'feurl.com' in link:
+ return fembed(link)
+ elif 'naniplay.nanime.in' in link:
+ return fembed(link)
+ elif 'naniplay.nanime.biz' in link:
+ return fembed(link)
+ elif 'naniplay.com' in link:
+ return fembed(link)
+ elif 'layarkacaxxi.icu' in link:
+ return fembed(link)
+ elif 'sbembed.com' in link:
+ return sbembed(link)
+ elif 'streamsb.net' in link:
+ return sbembed(link)
+ elif 'sbplay.org' in link:
+ return sbembed(link)
+ elif '1drv.ms' in link:
+ return onedrive(link)
+ elif 'pixeldrain.com' in link:
+ return pixeldrain(link)
+ elif 'antfiles.com' in link:
+ return antfiles(link)
+ elif 'streamtape.com' in link:
+ return streamtape(link)
+ elif 'bayfiles.com' in link:
+ return anonfiles(link)
+ elif 'racaty.net' in link:
+ return racaty(link)
+ elif '1fichier.com' in link:
+ return fichier(link)
+ elif 'solidfiles.com' in link:
+ return solidfiles(link)
+ else:
+ raise DirectDownloadLinkException(f'No Direct link function found for {link}')
+
+
+def zippy_share(url: str) -> str:
+ """ ZippyShare direct links generator
+ Based on https://github.com/KenHV/Mirror-Bot
+ https://github.com/jovanzers/WinTenCermin """
+ try:
+ link = re.findall(r'\bhttps?://.*zippyshare\.com\S+', url)[0]
+ except IndexError:
+ raise DirectDownloadLinkException("No Zippyshare links found")
+ try:
+ base_url = re.search('http.+.zippyshare.com', link).group()
+ response = requests.get(link).content
+ pages = BeautifulSoup(response, "lxml")
+ try:
+ js_script = pages.find("div", {"class": "center"}).find_all("script")[1]
+ except IndexError:
+ js_script = pages.find("div", {"class": "right"}).find_all("script")[0]
+ js_content = re.findall(r'\.href.=."/(.*?)";', str(js_script))
+ js_content = 'var x = "/' + js_content[0] + '"'
+ evaljs = EvalJs()
+ setattr(evaljs, "x", None)
+ evaljs.execute(js_content)
+ js_content = getattr(evaljs, "x")
+ return base_url + js_content
+ except IndexError:
+ raise DirectDownloadLinkException("ERROR: Can't find download button")
+
+
+def yandex_disk(url: str) -> str:
+ """ Yandex.Disk direct links generator
+ Based on https://github.com/wldhx/yadisk-direct """
+ try:
+ link = re.findall(r'\bhttps?://.*yadi\.sk\S+', url)[0]
+ except IndexError:
+ reply = "No Yandex.Disk links found\n"
+ return reply
+ api = 'https://cloud-api.yandex.net/v1/disk/public/resources/download?public_key={}'
+ try:
+ dl_url = requests.get(api.format(link)).json()['href']
+ return dl_url
+ except KeyError:
+ raise DirectDownloadLinkException("ERROR: File not found/Download limit reached\n")
+
+
+def uptobox(url: str) -> str:
+ """ Uptobox direct links generator
+ based on https://github.com/jovanzers/WinTenCermin """
+ try:
+ link = re.findall(r'\bhttps?://.*uptobox\.com\S+', url)[0]
+ except IndexError:
+ raise DirectDownloadLinkException("No Uptobox links found\n")
+ if UPTOBOX_TOKEN is None:
+ LOGGER.error('UPTOBOX_TOKEN not provided!')
+ dl_url = link
+ else:
+ try:
+ link = re.findall(r'\bhttp?://.*uptobox\.com/dl\S+', url)[0]
+ dl_url = link
+ except:
+ file_id = re.findall(r'\bhttps?://.*uptobox\.com/(\w+)', url)[0]
+ file_link = 'https://uptobox.com/api/link?token=%s&file_code=%s' % (UPTOBOX_TOKEN, file_id)
+ req = requests.get(file_link)
+ result = req.json()
+ dl_url = result['data']['dlLink']
+ return dl_url
+
+
+def mediafire(url: str) -> str:
+ """ MediaFire direct links generator """
+ try:
+ link = re.findall(r'\bhttps?://.*mediafire\.com\S+', url)[0]
+ except IndexError:
+ raise DirectDownloadLinkException("No MediaFire links found\n")
+ page = BeautifulSoup(requests.get(link).content, 'lxml')
+ info = page.find('a', {'aria-label': 'Download file'})
+ dl_url = info.get('href')
+ return dl_url
+
+
+def osdn(url: str) -> str:
+ """ OSDN direct links generator """
+ osdn_link = 'https://osdn.net'
+ try:
+ link = re.findall(r'\bhttps?://.*osdn\.net\S+', url)[0]
+ except IndexError:
+ raise DirectDownloadLinkException("No OSDN links found\n")
+ page = BeautifulSoup(
+ requests.get(link, allow_redirects=True).content, 'lxml')
+ info = page.find('a', {'class': 'mirror_link'})
+ link = urllib.parse.unquote(osdn_link + info['href'])
+ mirrors = page.find('form', {'id': 'mirror-select-form'}).findAll('tr')
+ urls = []
+ for data in mirrors[1:]:
+ mirror = data.find('input')['value']
+ urls.append(re.sub(r'm=(.*)&f', f'm={mirror}&f', link))
+ return urls[0]
+
+
+def github(url: str) -> str:
+ """ GitHub direct links generator """
+ try:
+ re.findall(r'\bhttps?://.*github\.com.*releases\S+', url)[0]
+ except IndexError:
+ raise DirectDownloadLinkException("No GitHub Releases links found\n")
+ download = requests.get(url, stream=True, allow_redirects=False)
+ try:
+ dl_url = download.headers["location"]
+ return dl_url
+ except KeyError:
+ raise DirectDownloadLinkException("ERROR: Can't extract the link\n")
+
+
+def hxfile(url: str) -> str:
+ """ Hxfile direct link generator
+ Based on https://github.com/zevtyardt/lk21
+ https://github.com/breakdowns/slam-mirrorbot """
+ bypasser = lk21.Bypass()
+ dl_url=bypasser.bypass_filesIm(url)
+ return dl_url
+
+
+def anonfiles(url: str) -> str:
+ """ Anonfiles direct link generator
+ Based on https://github.com/zevtyardt/lk21
+ https://github.com/breakdowns/slam-mirrorbot """
+ bypasser = lk21.Bypass()
+ dl_url=bypasser.bypass_anonfiles(url)
+ return dl_url
+
+
+def letsupload(url: str) -> str:
+ """ Letsupload direct link generator
+ Based on https://github.com/zevtyardt/lk21
+ https://github.com/breakdowns/slam-mirrorbot """
+ dl_url = ''
+ try:
+ link = re.findall(r'\bhttps?://.*letsupload\.io\S+', url)[0]
+ except IndexError:
+ raise DirectDownloadLinkException("No Letsupload links found\n")
+ bypasser = lk21.Bypass()
+ dl_url=bypasser.bypass_url(link)
+ return dl_url
+
+
+def fembed(link: str) -> str:
+ """ Fembed direct link generator
+ Based on https://github.com/zevtyardt/lk21
+ https://github.com/breakdowns/slam-mirrorbot """
+ bypasser = lk21.Bypass()
+ dl_url=bypasser.bypass_fembed(link)
+ lst_link = []
+ count = len(dl_url)
+ for i in dl_url:
+ lst_link.append(dl_url[i])
+ return lst_link[count-1]
+
+
+def sbembed(link: str) -> str:
+ """ Sbembed direct link generator
+ Based on https://github.com/zevtyardt/lk21
+ https://github.com/breakdowns/slam-mirrorbot """
+ bypasser = lk21.Bypass()
+ dl_url=bypasser.bypass_sbembed(link)
+ lst_link = []
+ count = len(dl_url)
+ for i in dl_url:
+ lst_link.append(dl_url[i])
+ return lst_link[count-1]
+
+
+def onedrive(link: str) -> str:
+ """ Onedrive direct link generator
+ Based on https://github.com/UsergeTeam/Userge """
+ link_without_query = urlparse(link)._replace(query=None).geturl()
+ direct_link_encoded = str(standard_b64encode(bytes(link_without_query, "utf-8")), "utf-8")
+ direct_link1 = f"https://api.onedrive.com/v1.0/shares/u!{direct_link_encoded}/root/content"
+ resp = requests.head(direct_link1)
+ if resp.status_code != 302:
+ return "ERROR: Unauthorized link, the link may be private"
+ dl_link = resp.next.url
+ file_name = dl_link.rsplit("/", 1)[1]
+ resp2 = requests.head(dl_link)
+ return dl_link
+
+
+def pixeldrain(url: str) -> str:
+ """ Based on https://github.com/yash-dk/TorToolkit-Telegram """
+ url = url.strip("/ ")
+ file_id = url.split("/")[-1]
+ info_link = f"https://pixeldrain.com/api/file/{file_id}/info"
+ dl_link = f"https://pixeldrain.com/api/file/{file_id}"
+ resp = requests.get(info_link).json()
+ if resp["success"]:
+ return dl_link
+ else:
+ raise DirectDownloadLinkException("ERROR: Cant't download due {}.".format(resp.text["value"]))
+
+
+def antfiles(url: str) -> str:
+ """ Antfiles direct link generator
+ Based on https://github.com/zevtyardt/lk21
+ https://github.com/breakdowns/slam-mirrorbot """
+ bypasser = lk21.Bypass()
+ dl_url=bypasser.bypass_antfiles(url)
+ return dl_url
+
+
+def streamtape(url: str) -> str:
+ """ Streamtape direct link generator
+ Based on https://github.com/zevtyardt/lk21
+ https://github.com/breakdowns/slam-mirrorbot """
+ bypasser = lk21.Bypass()
+ dl_url=bypasser.bypass_streamtape(url)
+ return dl_url
+
+
+def racaty(url: str) -> str:
+ """ Racaty direct links generator
+ based on https://github.com/breakdowns/slam-mirrorbot """
+ dl_url = ''
+ try:
+ link = re.findall(r'\bhttps?://.*racaty\.net\S+', url)[0]
+ except IndexError:
+ raise DirectDownloadLinkException("No Racaty links found\n")
+ scraper = cfscrape.create_scraper()
+ r = scraper.get(url)
+ soup = BeautifulSoup(r.text, "lxml")
+ op = soup.find("input", {"name": "op"})["value"]
+ ids = soup.find("input", {"name": "id"})["value"]
+ rpost = scraper.post(url, data = {"op": op, "id": ids})
+ rsoup = BeautifulSoup(rpost.text, "lxml")
+ dl_url = rsoup.find("a", {"id": "uniqueExpirylink"})["href"].replace(" ", "%20")
+ return dl_url
+
+
+def fichier(link: str) -> str:
+ """ 1Fichier direct links generator
+ Based on https://github.com/Maujar
+ https://github.com/breakdowns/slam-mirrorbot """
+ regex = r"^([http:\/\/|https:\/\/]+)?.*1fichier\.com\/\?.+"
+ gan = re.match(regex, link)
+ if not gan:
+ raise DirectDownloadLinkException("ERROR: The link you entered is wrong!")
+ if "::" in link:
+ pswd = link.split("::")[-1]
+ url = link.split("::")[-2]
+ else:
+ pswd = None
+ url = link
+ try:
+ if pswd is None:
+ req = requests.post(url)
+ else:
+ pw = {"pass": pswd}
+ req = requests.post(url, data=pe)
+ except:
+ raise DirectDownloadLinkException("ERROR: Unable to reach 1fichier server!")
+ if req.status_code == 404:
+ raise DirectDownloadLinkException("ERROR: File not found/The link you entered is wrong!")
+ soup = BeautifulSoup(req.content, 'lxml')
+ if soup.find("a", {"class": "ok btn-general btn-orange"}) is not None:
+ dl_url = soup.find("a", {"class": "ok btn-general btn-orange"})["href"]
+ if dl_url is None:
+ raise DirectDownloadLinkException("ERROR: Unable to generate Direct Link 1fichier!")
+ else:
+ return dl_url
+ else:
+ if len(soup.find_all("div", {"class": "ct_warn"})) == 2:
+ str_2 = soup.find_all("div", {"class": "ct_warn"})[-1]
+ if "you must wait" in str(str_2).lower():
+ numbers = [int(word) for word in str(str_2).split() if word.isdigit()]
+ if len(numbers) == 0:
+ raise DirectDownloadLinkException("ERROR: 1fichier is on a limit. Please wait a few minutes/hour.")
+ else:
+ raise DirectDownloadLinkException(f"ERROR: 1fichier is on a limit. Please wait {numbers[0]} minute.")
+ elif "protect access" in str(str_2).lower():
+ raise DirectDownloadLinkException("ERROR: This link requires a password!\n\nThis link requires a password!\n- Insert sign :: after the link and write the password after the sign.\n\nExample:\n/mirror https://1fichier.com/?smmtd8twfpm66awbqz04::love you\n\n* No spaces between the signs ::\n* For the password, you can use a space!")
+ else:
+ raise DirectDownloadLinkException("ERROR: Error trying to generate Direct Link from 1fichier!")
+ elif len(soup.find_all("div", {"class": "ct_warn"})) == 3:
+ str_1 = soup.find_all("div", {"class": "ct_warn"})[-2]
+ str_3 = soup.find_all("div", {"class": "ct_warn"})[-1]
+ if "you must wait" in str(str_1).lower():
+ numbers = [int(word) for word in str(str_1).split() if word.isdigit()]
+ if len(numbers) == 0:
+ raise DirectDownloadLinkException("ERROR: 1fichier is on a limit. Please wait a few minutes/hour.")
+ else:
+ raise DirectDownloadLinkException(f"ERROR: 1fichier is on a limit. Please wait {numbers[0]} minute.")
+ elif "bad password" in str(str_3).lower():
+ raise DirectDownloadLinkException("ERROR: The password you entered is wrong!")
+ else:
+ raise DirectDownloadLinkException("ERROR: Error trying to generate Direct Link from 1fichier!")
+ else:
+ raise DirectDownloadLinkException("ERROR: Error trying to generate Direct Link from 1fichier!")
+
+
+def solidfiles(url: str) -> str:
+ """ Solidfiles direct links generator
+ Based on https://github.com/Xonshiz/SolidFiles-Downloader
+ By https://github.com/Jusidama18 """
+ headers = {
+ 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/36.0.1985.125 Safari/537.36'
+ }
+ pageSource = requests.get(url, headers = headers).text
+ mainOptions = str(re.search(r'viewerOptions\'\,\ (.*?)\)\;', pageSource).group(1))
+ dl_url = json.loads(mainOptions)["downloadUrl"]
+ return dl_url
+
+
+def useragent():
+ """
+ useragent random setter
+ """
+ useragents = BeautifulSoup(
+ requests.get(
+ 'https://developers.whatismybrowser.com/'
+ 'useragents/explore/operating_system_name/android/').content,
+ 'lxml').findAll('td', {'class': 'useragent'})
+ user_agent = choice(useragents)
+ return user_agent.text
diff --git a/bot/helper/mirror_utils/download_utils/direct_link_generator_license.md b/bot/helper/mirror_utils/download_utils/direct_link_generator_license.md
new file mode 100644
index 0000000..c37c0d9
--- /dev/null
+++ b/bot/helper/mirror_utils/download_utils/direct_link_generator_license.md
@@ -0,0 +1,82 @@
+ RAPHIELSCAPE PUBLIC LICENSE
+ Version 1.c, June 2019
+
+ Copyright (C) 2019 Raphielscape LLC.
+ Copyright (C) 2019 Devscapes Open Source Holding GmbH.
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+ RAPHIELSCAPE PUBLIC LICENSE
+ A-1. DEFINITIONS
+
+0. “This License” refers to version 1.c of the Raphielscape Public License.
+
+1. “Copyright” also means copyright-like laws that apply to other kinds of works.
+
+2. “The Work" refers to any copyrightable work licensed under this License. Each licensee is addressed as “you”.
+ “Licensees” and “recipients” may be individuals or organizations.
+
+3. To “modify” a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission,
+ other than the making of an exact copy. The resulting work is called a “modified version” of the earlier work
+ or a work “based on” the earlier work.
+
+4. Source Form. The “source form” for a work means the preferred form of the work for making modifications to it.
+ “Object code” means any non-source form of a work.
+
+ The “Corresponding Source” for a work in object code form means all the source code needed to generate, install, and
+ (for an executable work) run the object code and to modify the work, including scripts to control those activities.
+
+ The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.
+ The Corresponding Source for a work in source code form is that same work.
+
+5. "The author" refers to "author" of the code, which is the one that made the particular code which exists inside of
+ the Corresponding Source.
+
+6. "Owner" refers to any parties which is made the early form of the Corresponding Source.
+
+ A-2. TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+1. You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+2. You must retain, in the Source form of any Derivative Works that You distribute,
+ this license, all copyright, patent, trademark, authorships and attribution notices
+ from the Source form of the Work; and
+
+3. Respecting the author and owner of works that are distributed in any way.
+
+ You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction,
+or distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+ B. DISCLAIMER OF WARRANTY
+
+ THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+ C. REVISED VERSION OF THIS LICENSE
+
+ The Devscapes Open Source Holding GmbH. may publish revised and/or new versions of the
+Raphielscape Public License from time to time. Such new versions will be similar in spirit
+to the present version, but may differ in detail to address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the Program specifies that a
+certain numbered version of the Raphielscape Public License "or any later version" applies to it,
+you have the option of following the terms and conditions either of that numbered version or of
+any later version published by the Devscapes Open Source Holding GmbH. If the Program does not specify a
+version number of the Raphielscape Public License, you may choose any version ever published
+by the Devscapes Open Source Holding GmbH.
+
+ END OF LICENSE
\ No newline at end of file
diff --git a/bot/helper/mirror_utils/download_utils/download_helper.py b/bot/helper/mirror_utils/download_utils/download_helper.py
new file mode 100644
index 0000000..ebcca14
--- /dev/null
+++ b/bot/helper/mirror_utils/download_utils/download_helper.py
@@ -0,0 +1,27 @@
+# An abstract class which will be inherited by the tool specific classes like aria2_helper or mega_download_helper
+import threading
+
+
+class MethodNotImplementedError(NotImplementedError):
+ def __init__(self):
+ super(self, 'Not implemented method')
+
+
+class DownloadHelper:
+ def __init__(self):
+ self.name = '' # Name of the download; empty string if no download has been started
+ self.size = 0.0 # Size of the download
+ self.downloaded_bytes = 0.0 # Bytes downloaded
+ self.speed = 0.0 # Download speed in bytes per second
+ self.progress = 0.0
+ self.progress_string = '0.00%'
+ self.eta = 0 # Estimated time of download complete
+ self.eta_string = '0s' # A listener class which have event callbacks
+ self._resource_lock = threading.Lock()
+
+ def add_download(self, link: str, path):
+ raise MethodNotImplementedError
+
+ def cancel_download(self):
+ # Returns None if successfully cancelled, else error string
+ raise MethodNotImplementedError
diff --git a/bot/helper/mirror_utils/download_utils/mega_downloader.py b/bot/helper/mirror_utils/download_utils/mega_downloader.py
new file mode 100644
index 0000000..0d0b474
--- /dev/null
+++ b/bot/helper/mirror_utils/download_utils/mega_downloader.py
@@ -0,0 +1,201 @@
+from bot import LOGGER, MEGA_API_KEY, download_dict_lock, download_dict, MEGA_EMAIL_ID, MEGA_PASSWORD
+import threading
+from mega import (MegaApi, MegaListener, MegaRequest, MegaTransfer, MegaError)
+from bot.helper.telegram_helper.message_utils import *
+import os
+from bot.helper.ext_utils.bot_utils import new_thread, get_mega_link_type, get_readable_file_size, check_limit
+from bot.helper.mirror_utils.status_utils.mega_download_status import MegaDownloadStatus
+from bot.helper.mirror_utils.upload_utils.gdriveTools import GoogleDriveHelper
+from bot import MEGA_LIMIT, STOP_DUPLICATE, TAR_UNZIP_LIMIT
+import random
+import string
+
+class MegaDownloaderException(Exception):
+ pass
+
+
+class MegaAppListener(MegaListener):
+ _NO_EVENT_ON = (MegaRequest.TYPE_LOGIN,MegaRequest.TYPE_FETCH_NODES)
+ NO_ERROR = "no error"
+
+ def __init__(self, continue_event: threading.Event, listener):
+ self.continue_event = continue_event
+ self.node = None
+ self.public_node = None
+ self.listener = listener
+ self.uid = listener.uid
+ self.__bytes_transferred = 0
+ self.is_cancelled = False
+ self.__speed = 0
+ self.__name = ''
+ self.__size = 0
+ self.error = None
+ self.gid = ""
+ super(MegaAppListener, self).__init__()
+
+ @property
+ def speed(self):
+ """Returns speed of the download in bytes/second"""
+ return self.__speed
+
+ @property
+ def name(self):
+ """Returns name of the download"""
+ return self.__name
+
+ def setValues(self, name, size, gid):
+ self.__name = name
+ self.__size = size
+ self.gid = gid
+
+ @property
+ def size(self):
+ """Size of download in bytes"""
+ return self.__size
+
+ @property
+ def downloaded_bytes(self):
+ return self.__bytes_transferred
+
+ def onRequestStart(self, api, request):
+ pass
+
+ def onRequestFinish(self, api, request, error):
+ if str(error).lower() != "no error":
+ self.error = error.copy()
+ return
+ request_type = request.getType()
+ if request_type == MegaRequest.TYPE_LOGIN:
+ api.fetchNodes()
+ elif request_type == MegaRequest.TYPE_GET_PUBLIC_NODE:
+ self.public_node = request.getPublicMegaNode()
+ elif request_type == MegaRequest.TYPE_FETCH_NODES:
+ LOGGER.info("Fetching Root Node.")
+ self.node = api.getRootNode()
+ LOGGER.info(f"Node Name: {self.node.getName()}")
+ if request_type not in self._NO_EVENT_ON or self.node and "cloud drive" not in self.node.getName().lower():
+ self.continue_event.set()
+
+ def onRequestTemporaryError(self, api, request, error: MegaError):
+ LOGGER.info(f'Mega Request error in {error}')
+ if not self.is_cancelled:
+ self.listener.onDownloadError("RequestTempError: " + error.toString())
+ self.is_cancelled = True
+ self.error = error.toString()
+ self.continue_event.set()
+
+ def onTransferStart(self, api: MegaApi, transfer: MegaTransfer):
+ pass
+
+ def onTransferUpdate(self, api: MegaApi, transfer: MegaTransfer):
+ if self.is_cancelled:
+ api.cancelTransfer(transfer, None)
+ self.__speed = transfer.getSpeed()
+ self.__bytes_transferred = transfer.getTransferredBytes()
+
+ def onTransferFinish(self, api: MegaApi, transfer: MegaTransfer, error):
+ try:
+ if transfer.isFolderTransfer() and transfer.isFinished() or transfer.getFileName() == self.name and not self.is_cancelled:
+ self.listener.onDownloadComplete()
+ self.continue_event.set()
+ except Exception as e:
+ LOGGER.error(e)
+
+ def onTransferTemporaryError(self, api, transfer, error):
+ filen = transfer.getFileName()
+ state = transfer.getState()
+ errStr = error.toString()
+ LOGGER.info(f'Mega download error in file {transfer} {filen}: {error}')
+
+ if state == 1 or state == 4:
+ # Sometimes MEGA (offical client) can't stream a node either and raises a temp failed error.
+ # Don't break the transfer queue if transfer's in queued (1) or retrying (4) state [causes seg fault]
+ return
+
+ self.error = errStr
+ if not self.is_cancelled:
+ self.is_cancelled = True
+ self.listener.onDownloadError(f"TransferTempError: {errStr} ({filen})")
+
+ def cancel_download(self):
+ self.is_cancelled = True
+ self.listener.onDownloadError("Download Canceled by user")
+
+
+class AsyncExecutor:
+
+ def __init__(self):
+ self.continue_event = threading.Event()
+
+ def do(self, function, args):
+ self.continue_event.clear()
+ function(*args)
+ self.continue_event.wait()
+
+listeners = []
+
+class MegaDownloadHelper:
+ def __init__(self):
+ pass
+
+ @staticmethod
+ @new_thread
+ def add_download(mega_link: str, path: str, listener):
+ if MEGA_API_KEY is None:
+ raise MegaDownloaderException('Mega API KEY not provided! Cannot mirror Mega links')
+ executor = AsyncExecutor()
+ api = MegaApi(MEGA_API_KEY, None, None, 'telegram-mirror-bot')
+ global listeners
+ mega_listener = MegaAppListener(executor.continue_event, listener)
+ listeners.append(mega_listener)
+ api.addListener(mega_listener)
+ if MEGA_EMAIL_ID is not None and MEGA_PASSWORD is not None:
+ executor.do(api.login, (MEGA_EMAIL_ID, MEGA_PASSWORD))
+ link_type = get_mega_link_type(mega_link)
+ if link_type == "file":
+ LOGGER.info("File. If your download didn't start, then check your link if it's available to download")
+ executor.do(api.getPublicNode, (mega_link,))
+ node = mega_listener.public_node
+ else:
+ LOGGER.info("Folder. If your download didn't start, then check your link if it's available to download")
+ folder_api = MegaApi(MEGA_API_KEY,None,None,'TgBot')
+ folder_api.addListener(mega_listener)
+ executor.do(folder_api.loginToFolder, (mega_link,))
+ node = folder_api.authorizeNode(mega_listener.node)
+ if mega_listener.error is not None:
+ return listener.onDownloadError(str(mega_listener.error))
+ if STOP_DUPLICATE:
+ LOGGER.info(f'Checking File/Folder if already in Drive')
+ mname = node.getName()
+ if listener.isTar:
+ mname = mname + ".tar"
+ if listener.extract:
+ smsg = None
+ else:
+ gd = GoogleDriveHelper()
+ smsg, button = gd.drive_list(mname)
+ if smsg:
+ msg1 = "File/Folder is already available in Drive.\nHere are the search results:"
+ sendMarkup(msg1, listener.bot, listener.update, button)
+ executor.continue_event.set()
+ return
+ if MEGA_LIMIT is not None or TAR_UNZIP_LIMIT is not None:
+ size = api.getSize(node)
+ if listener.isTar or listener.extract:
+ is_tar_ext = True
+ msg3 = f'Failed, Tar/Unzip limit is {TAR_UNZIP_LIMIT}.\nYour File/Folder size is {get_readable_file_size(api.getSize(node))}.'
+ else:
+ is_tar_ext = False
+ msg3 = f'Failed, Mega limit is {MEGA_LIMIT}.\nYour File/Folder size is {get_readable_file_size(api.getSize(node))}.'
+ result = check_limit(size, MEGA_LIMIT, TAR_UNZIP_LIMIT, is_tar_ext)
+ if result:
+ sendMessage(msg3, listener.bot, listener.update)
+ executor.continue_event.set()
+ return
+ with download_dict_lock:
+ download_dict[listener.uid] = MegaDownloadStatus(mega_listener, listener)
+ os.makedirs(path)
+ gid = ''.join(random.SystemRandom().choices(string.ascii_letters + string.digits, k=8))
+ mega_listener.setValues(node.getName(), api.getSize(node), gid)
+ sendStatusMessage(listener.update, listener.bot)
+ executor.do(api.startDownload,(node,path))
diff --git a/bot/helper/mirror_utils/download_utils/qbit_downloader.py b/bot/helper/mirror_utils/download_utils/qbit_downloader.py
new file mode 100644
index 0000000..5d66ede
--- /dev/null
+++ b/bot/helper/mirror_utils/download_utils/qbit_downloader.py
@@ -0,0 +1,240 @@
+# Implement By - @anasty17 (https://github.com/breakdowns/slam-mirrorbot/commit/0bfba523f095ab1dccad431d72561e0e002e7a59)
+# (c) https://github.com/breakdowns/slam-mirrorbot
+# All rights reserved
+
+import os
+import random
+import string
+import time
+import logging
+import shutil
+
+import qbittorrentapi as qba
+from fnmatch import fnmatch
+from urllib.parse import urlparse, parse_qs
+from torrentool.api import Torrent
+from telegram import InlineKeyboardMarkup
+from telegram.ext import CallbackQueryHandler
+
+from bot import download_dict, download_dict_lock, BASE_URL, dispatcher, get_client, TORRENT_DIRECT_LIMIT, TAR_UNZIP_LIMIT
+from bot.helper.mirror_utils.status_utils.qbit_download_status import QbDownloadStatus
+from bot.helper.telegram_helper.message_utils import *
+from bot.helper.ext_utils.bot_utils import setInterval, new_thread, MirrorStatus, getDownloadByGid, get_readable_file_size, check_limit
+from bot.helper.telegram_helper import button_build
+
+LOGGER = logging.getLogger(__name__)
+
+
+class qbittorrent:
+
+
+ def __init__(self):
+ self.update_interval = 2
+ self.meta_time = time.time()
+ self.stalled_time = time.time()
+ self.checked = False
+
+ @new_thread
+ def add_torrent(self, link, dire, listener, qbitsel):
+ self.client = get_client()
+ self.listener = listener
+ self.dire = dire
+ self.qbitsel = qbitsel
+ is_file = False
+ count = 0
+ pincode = ""
+ try:
+ if os.path.exists(link):
+ is_file = True
+ self.ext_hash = get_hash_file(link)
+ else:
+ self.ext_hash = get_hash_magnet(link)
+ tor_info = self.client.torrents_info(torrent_hashes=self.ext_hash)
+ if len(tor_info) > 0:
+ sendMessage("This torrent is already in list.", listener.bot, listener.update)
+ return
+ if is_file:
+ op = self.client.torrents_add(torrent_files=[link], save_path=dire)
+ os.remove(link)
+ else:
+ op = self.client.torrents_add(link, save_path=dire)
+ if op.lower() == "ok.":
+ tor_info = self.client.torrents_info(torrent_hashes=self.ext_hash)
+ if len(tor_info) == 0:
+ while True:
+ if time.time() - self.meta_time >= 300:
+ sendMessage("The torrent was not added. report when u see this error", listener.bot, listener.update)
+ return False
+ tor_info = self.client.torrents_info(torrent_hashes=self.ext_hash)
+ if len(tor_info) > 0:
+ break
+ else:
+ sendMessage("This is an unsupported/invalid link.", listener.bot, listener.update)
+ return
+ gid = ''.join(random.SystemRandom().choices(string.ascii_letters + string.digits, k=14))
+ with download_dict_lock:
+ download_dict[listener.uid] = QbDownloadStatus(gid, listener, self.ext_hash, self.client)
+ tor_info = tor_info[0]
+ LOGGER.info(f"QbitDownload started: {tor_info.name}")
+ self.updater = setInterval(self.update_interval, self.update)
+ if BASE_URL is not None and qbitsel:
+ if is_file:
+ self.client.torrents_pause(torrent_hashes=self.ext_hash)
+ else:
+ meta = sendMessage("Downloading Metadata...Please wait then you can select files or mirror torrent file if it have low seeders", listener.bot, listener.update)
+ while True:
+ tor_info = self.client.torrents_info(torrent_hashes=self.ext_hash)
+ if len(tor_info) == 0:
+ deleteMessage(listener.bot, meta)
+ return False
+ try:
+ tor_info = tor_info[0]
+ if tor_info.state == "metaDL" or tor_info.state == "checkingResumeData":
+ time.sleep(0.5)
+ else:
+ self.client.torrents_pause(torrent_hashes=self.ext_hash)
+ deleteMessage(listener.bot, meta)
+ break
+ except:
+ deleteMessage(listener.bot, meta)
+ return False
+ for n in str(self.ext_hash):
+ if n.isdigit():
+ pincode += str(n)
+ count += 1
+ if count == 4:
+ break
+ URL = f"{BASE_URL}/slam/files/{self.ext_hash}"
+ pindata = f"pin {gid} {pincode}"
+ donedata = f"done {gid} {self.ext_hash}"
+ buttons = button_build.ButtonMaker()
+ buttons.buildbutton("Select Files", URL)
+ buttons.sbutton("Pincode", pindata)
+ buttons.sbutton("Done Selecting", donedata)
+ QBBUTTONS = InlineKeyboardMarkup(buttons.build_menu(2))
+ msg = "Your download paused. Choose files then press Done Selecting button to start downloading."
+ sendMarkup(msg, listener.bot, listener.update, QBBUTTONS)
+ else:
+ sendStatusMessage(listener.update, listener.bot)
+ except qba.UnsupportedMediaType415Error as e:
+ LOGGER.error(str(e))
+ sendMessage("This is an unsupported/invalid link. {str(e)}", listener.bot, listener.update)
+ except Exception as e:
+ LOGGER.error(str(e))
+ sendMessage(str(e), listener.bot, listener.update)
+ self.client.torrents_delete(torrent_hashes=self.ext_hash, delete_files=True)
+
+
+ def update(self):
+ tor_info = self.client.torrents_info(torrent_hashes=self.ext_hash)
+ if len(tor_info) == 0:
+ self.updater.cancel()
+ return
+ try:
+ tor_info = tor_info[0]
+ if tor_info.state == "metaDL":
+ self.stalled_time = time.time()
+ if time.time() - self.meta_time >= 600:
+ self.listener.onDownloadError("Dead Torrent!")
+ self.client.torrents_delete(torrent_hashes=self.ext_hash, delete_files=True)
+ self.updater.cancel()
+ return
+ elif tor_info.state == "downloading":
+ self.stalled_time = time.time()
+ if (TORRENT_DIRECT_LIMIT is not None or TAR_UNZIP_LIMIT is not None) and not self.checked:
+ if self.listener.isTar or self.listener.extract:
+ is_tar_ext = True
+ mssg = f'Tar/Unzip limit is {TAR_UNZIP_LIMIT}'
+ else:
+ is_tar_ext = False
+ mssg = f'Torrent/Direct limit is {TORRENT_DIRECT_LIMIT}'
+ size = tor_info.size
+ result = check_limit(size, TORRENT_DIRECT_LIMIT, TAR_UNZIP_LIMIT, is_tar_ext)
+ self.checked = True
+ if result:
+ self.listener.onDownloadError(f"{mssg}.\nYour File/Folder size is {get_readable_file_size(size)}")
+ self.client.torrents_delete(torrent_hashes=self.ext_hash, delete_files=True)
+ self.updater.cancel()
+ return
+ elif tor_info.state == "stalledDL":
+ if time.time() - self.stalled_time >= 900:
+ self.listener.onDownloadError("Dead Torrent!")
+ self.client.torrents_delete(torrent_hashes=self.ext_hash, delete_files=True)
+ self.updater.cancel()
+ return
+ elif tor_info.state == "error":
+ self.listener.onDownloadError("Error. IDK why, report in support group")
+ self.client.torrents_delete(torrent_hashes=self.ext_hash, delete_files=True)
+ self.updater.cancel()
+ return
+ elif tor_info.state == "uploading" or tor_info.state.lower().endswith("up"):
+ self.client.torrents_pause(torrent_hashes=self.ext_hash)
+ if self.qbitsel:
+ for dirpath, subdir, files in os.walk(f"{self.dire}", topdown=False):
+ for file in files:
+ if fnmatch(file, "*.!qB"):
+ os.remove(os.path.join(dirpath, file))
+ for folder in subdir:
+ if fnmatch(folder, ".unwanted"):
+ shutil.rmtree(os.path.join(dirpath, folder))
+ if not os.listdir(dirpath):
+ os.rmdir(dirpath)
+ self.listener.onDownloadComplete()
+ self.client.torrents_delete(torrent_hashes=self.ext_hash, delete_files=True)
+ self.updater.cancel()
+ except:
+ self.updater.cancel()
+
+
+def get_confirm(update, context):
+ query = update.callback_query
+ user_id = query.from_user.id
+ data = query.data
+ data = data.split(" ")
+ qdl = getDownloadByGid(data[1])
+ if qdl is not None:
+ if user_id != qdl.listener.message.from_user.id:
+ query.answer(text="Don't waste your time!", show_alert=True)
+ return
+ if data[0] == "pin":
+ query.answer(text=data[2], show_alert=True)
+ elif data[0] == "done":
+ query.answer()
+ qdl.client.torrents_resume(torrent_hashes=data[2])
+ sendStatusMessage(qdl.listener.update, qdl.listener.bot)
+ query.message.delete()
+ else:
+ query.answer(text="This task has been cancelled!", show_alert=True)
+ query.message.delete()
+
+
+def get_hash_magnet(mgt):
+ if mgt.startswith('magnet:'):
+ _, _, _, _, query, _ = urlparse(mgt)
+
+ qs = parse_qs(query)
+ v = qs.get('xt', None)
+
+ if v == None or v == []:
+ LOGGER.error('Invalid magnet URI: no "xt" query parameter.')
+ return False
+
+ v = v[0]
+ if not v.startswith('urn:btih:'):
+ LOGGER.error('Invalid magnet URI: "xt" value not valid for BitTorrent.')
+ return False
+
+ mgt = v[len('urn:btih:'):]
+ return mgt.lower()
+
+
+def get_hash_file(path):
+ tr = Torrent.from_file(path)
+ mgt = tr.magnet_link
+ return get_hash_magnet(mgt)
+
+
+pin_handler = CallbackQueryHandler(get_confirm, pattern="pin", run_async=True)
+done_handler = CallbackQueryHandler(get_confirm, pattern="done", run_async=True)
+dispatcher.add_handler(pin_handler)
+dispatcher.add_handler(done_handler)
diff --git a/bot/helper/mirror_utils/download_utils/telegram_downloader.py b/bot/helper/mirror_utils/download_utils/telegram_downloader.py
new file mode 100644
index 0000000..5721d00
--- /dev/null
+++ b/bot/helper/mirror_utils/download_utils/telegram_downloader.py
@@ -0,0 +1,126 @@
+import logging
+import threading
+import time
+from bot import LOGGER, download_dict, download_dict_lock, app, STOP_DUPLICATE
+from .download_helper import DownloadHelper
+from ..status_utils.telegram_download_status import TelegramDownloadStatus
+from bot.helper.telegram_helper.message_utils import sendMarkup, sendStatusMessage
+from bot.helper.mirror_utils.upload_utils.gdriveTools import GoogleDriveHelper
+
+global_lock = threading.Lock()
+GLOBAL_GID = set()
+logging.getLogger("pyrogram").setLevel(logging.WARNING)
+
+
+class TelegramDownloadHelper(DownloadHelper):
+ def __init__(self, listener):
+ super().__init__()
+ self.__listener = listener
+ self.__resource_lock = threading.RLock()
+ self.__name = ""
+ self.__start_time = time.time()
+ self.__gid = ""
+ self._bot = app
+ self.__is_cancelled = False
+
+ @property
+ def gid(self):
+ with self.__resource_lock:
+ return self.__gid
+
+ @property
+ def download_speed(self):
+ with self.__resource_lock:
+ return self.downloaded_bytes / (time.time() - self.__start_time)
+
+ def __onDownloadStart(self, name, size, file_id):
+ with download_dict_lock:
+ download_dict[self.__listener.uid] = TelegramDownloadStatus(self, self.__listener)
+ with global_lock:
+ GLOBAL_GID.add(file_id)
+ with self.__resource_lock:
+ self.name = name
+ self.size = size
+ self.__gid = file_id
+ self.__listener.onDownloadStarted()
+
+ def __onDownloadProgress(self, current, total):
+ if self.__is_cancelled:
+ self.__onDownloadError('Cancelled by user!')
+ self._bot.stop_transmission()
+ return
+ with self.__resource_lock:
+ self.downloaded_bytes = current
+ try:
+ self.progress = current / self.size * 100
+ except ZeroDivisionError:
+ self.progress = 0
+
+ def __onDownloadError(self, error):
+ with global_lock:
+ try:
+ GLOBAL_GID.remove(self.gid)
+ except KeyError:
+ pass
+ self.__listener.onDownloadError(error)
+
+ def __onDownloadComplete(self):
+ with global_lock:
+ GLOBAL_GID.remove(self.gid)
+ self.__listener.onDownloadComplete()
+
+ def __download(self, message, path):
+ download = self._bot.download_media(
+ message,
+ progress = self.__onDownloadProgress,
+ file_name = path
+ )
+ if download is not None:
+ self.__onDownloadComplete()
+ else:
+ if not self.__is_cancelled:
+ self.__onDownloadError('Internal error occurred')
+
+ def add_download(self, message, path, filename):
+ _message = self._bot.get_messages(message.chat.id, reply_to_message_ids=message.message_id)
+ media = None
+ media_array = [_message.document, _message.video, _message.audio]
+ for i in media_array:
+ if i is not None:
+ media = i
+ break
+ if media is not None:
+ with global_lock:
+ # For avoiding locking the thread lock for long time unnecessarily
+ download = media.file_id not in GLOBAL_GID
+ if filename == "":
+ name = media.file_name
+ else:
+ name = filename
+ path = path + name
+
+ if download:
+ if STOP_DUPLICATE:
+ LOGGER.info(f"Checking File/Folder if already in Drive...")
+ if self.__listener.isTar:
+ name = name + ".tar"
+ if self.__listener.extract:
+ smsg = None
+ else:
+ gd = GoogleDriveHelper()
+ smsg, button = gd.drive_list(name)
+ if smsg:
+ sendMarkup("File/Folder is already available in Drive.\nHere are the search results:", self.__listener.bot, self.__listener.update, button)
+ return
+ sendStatusMessage(self.__listener.update, self.__listener.bot)
+ self.__onDownloadStart(name, media.file_size, media.file_id)
+ LOGGER.info(f'Downloading Telegram file with id: {media.file_id}')
+ threading.Thread(target=self.__download, args=(_message, path)).start()
+ else:
+ self.__onDownloadError('File already being downloaded!')
+ else:
+ self.__onDownloadError('No document in the replied message')
+
+ def cancel_download(self):
+ LOGGER.info(f'Cancelling download on user request: {self.gid}')
+ self.__is_cancelled = True
diff --git a/bot/helper/mirror_utils/download_utils/youtube_dl_download_helper.py b/bot/helper/mirror_utils/download_utils/youtube_dl_download_helper.py
new file mode 100644
index 0000000..6997ce0
--- /dev/null
+++ b/bot/helper/mirror_utils/download_utils/youtube_dl_download_helper.py
@@ -0,0 +1,167 @@
+from .download_helper import DownloadHelper
+import time
+from yt_dlp import YoutubeDL, DownloadError
+from bot import download_dict_lock, download_dict
+from ..status_utils.youtube_dl_download_status import YoutubeDLDownloadStatus
+import logging
+import re
+import threading
+
+LOGGER = logging.getLogger(__name__)
+
+
+class MyLogger:
+ def __init__(self, obj):
+ self.obj = obj
+
+ def debug(self, msg):
+ LOGGER.debug(msg)
+ match = re.search(r'.ffmpeg..Merging formats into..(.*?).$', msg)
+ if match and not self.obj.is_playlist:
+ newname = match.group(1)
+ newname = newname.split("/")
+ newname = newname[-1]
+ self.obj.name = newname
+
+ @staticmethod
+ def warning(msg):
+ LOGGER.warning(msg)
+
+ @staticmethod
+ def error(msg):
+ LOGGER.error(msg)
+
+
+class YoutubeDLHelper(DownloadHelper):
+ def __init__(self, listener):
+ super().__init__()
+ self.name = ""
+ self.__start_time = time.time()
+ self.__listener = listener
+ self.__gid = ""
+ self.opts = {
+ 'progress_hooks': [self.__onDownloadProgress],
+ 'logger': MyLogger(self),
+ 'usenetrc': True
+ }
+ self.__download_speed = 0
+ self.downloaded_bytes = 0
+ self.size = 0
+ self.is_playlist = False
+ self.last_downloaded = 0
+ self.is_cancelled = False
+ self.vid_id = ''
+ self.__resource_lock = threading.RLock()
+
+ @property
+ def download_speed(self):
+ with self.__resource_lock:
+ return self.__download_speed
+
+ @property
+ def gid(self):
+ with self.__resource_lock:
+ return self.__gid
+
+ def __onDownloadProgress(self, d):
+ if self.is_cancelled:
+ raise ValueError("Cancelling Download..")
+ if d['status'] == "finished":
+ if self.is_playlist:
+ self.last_downloaded = 0
+ elif d['status'] == "downloading":
+ with self.__resource_lock:
+ self.__download_speed = d['speed']
+ try:
+ tbyte = d['total_bytes']
+ except KeyError:
+ tbyte = d['total_bytes_estimate']
+ if self.is_playlist:
+ progress = d['downloaded_bytes'] / tbyte
+ chunk_size = d['downloaded_bytes'] - self.last_downloaded
+ self.last_downloaded = tbyte * progress
+ self.downloaded_bytes += chunk_size
+ else:
+ self.size = tbyte
+ self.downloaded_bytes = d['downloaded_bytes']
+ try:
+ self.progress = (self.downloaded_bytes / self.size) * 100
+ except ZeroDivisionError:
+ pass
+
+ def __onDownloadStart(self):
+ with download_dict_lock:
+ download_dict[self.__listener.uid] = YoutubeDLDownloadStatus(self, self.__listener)
+
+ def __onDownloadComplete(self):
+ self.__listener.onDownloadComplete()
+
+ def onDownloadError(self, error):
+ self.__listener.onDownloadError(error)
+
+ def extractMetaData(self, link, qual, name):
+ if "hotstar" in link or "sonyliv" in link:
+ self.opts['geo_bypass_country'] = 'IN'
+
+ with YoutubeDL(self.opts) as ydl:
+ try:
+ result = ydl.extract_info(link, download=False)
+ name = ydl.prepare_filename(result) if name == "" else name
+ if qual == "audio":
+ name = name.replace(".mp4", ".mp3").replace(".webm", ".mp3")
+ except DownloadError as e:
+ self.onDownloadError(str(e))
+ return
+ if result.get('direct'):
+ return None
+ if 'entries' in result:
+ video = result['entries'][0]
+ for v in result['entries']:
+ if v and v.get('filesize'):
+ self.size += float(v['filesize'])
+ # For playlists, ydl.prepare-filename returns the following format: {meta.get("name")}\nSize: {get_readable_file_size(self.transferred_size)}'
+ msg += f'\n☞ 🌀Type : Folder'
+ msg += f'\n☞ Powerd by : @AT_BOTs'
+ buttons = button_build.ButtonMaker()
+ if SHORTENER is not None and SHORTENER_API is not None:
+ surl = requests.get(f'https://{SHORTENER}/api?api={SHORTENER_API}&url={durl}&format=text').text
+ buttons.buildbutton("🌠 Drive Link 🌠", surl)
+ else:
+ buttons.buildbutton("🌠 Drive Link 🌠", durl)
+ if INDEX_URL is not None:
+ url_path = requests.utils.quote(f'{meta.get("name")}')
+ url = f'{INDEX_URL}/{url_path}/'
+ if SHORTENER is not None and SHORTENER_API is not None:
+ siurl = requests.get(f'https://{SHORTENER}/api?api={SHORTENER_API}&url={url}&format=text').text
+ buttons.buildbutton("☄️ Index Link ☄️", siurl)
+ else:
+ buttons.buildbutton("☄️ Index Link ☄️", url)
+ if BUTTON_FOUR_NAME is not None and BUTTON_FOUR_URL is not None:
+ buttons.buildbutton(f"{BUTTON_FOUR_NAME}", f"{BUTTON_FOUR_URL}")
+ if BUTTON_FIVE_NAME is not None and BUTTON_FIVE_URL is not None:
+ buttons.buildbutton(f"{BUTTON_FIVE_NAME}", f"{BUTTON_FIVE_URL}")
+ if BUTTON_SIX_NAME is not None and BUTTON_SIX_URL is not None:
+ buttons.buildbutton(f"{BUTTON_SIX_NAME}", f"{BUTTON_SIX_URL}")
+ else:
+ file = self.copyFile(meta.get('id'), parent_id)
+ msg += f'☞ 📂Filename : {file.get("name")}'
+ durl = self.__G_DRIVE_BASE_DOWNLOAD_URL.format(file.get("id"))
+ buttons = button_build.ButtonMaker()
+ if SHORTENER is not None and SHORTENER_API is not None:
+ surl = requests.get(f'https://{SHORTENER}/api?api={SHORTENER_API}&url={durl}&format=text').text
+ buttons.buildbutton("🌠 Drive Link 🌠", surl)
+ else:
+ buttons.buildbutton("🌠 Drive Link 🌠", durl)
+ try:
+ typeee = file.get('mimeType')
+ except:
+ typeee = 'File'
+ try:
+ msg += f'\n☞ 📦Size : {get_readable_file_size(int(meta.get("size")))}'
+ msg += f'\n☞ 🗳Powerd by : @AT_BOTS '
+ except TypeError:
+ pass
+ if INDEX_URL is not None:
+ url_path = requests.utils.quote(f'{file.get("name")}')
+ url = f'{INDEX_URL}/{url_path}'
+ urls = f'{INDEX_URL}/{url_path}?a=view'
+ if SHORTENER is not None and SHORTENER_API is not None:
+ siurl = requests.get(f'https://{SHORTENER}/api?api={SHORTENER_API}&url={url}&format=text').text
+ siurls = requests.get(f'https://{SHORTENER}/api?api={SHORTENER_API}&url={urls}&format=text').text
+ buttons.buildbutton("☄️ Index Link ☄️", siurl)
+ if VIEW_LINK:
+ buttons.buildbutton(" View Link", siurls)
+ else:
+ buttons.buildbutton("☄️ Index Link ☄️", url)
+ if VIEW_LINK:
+ buttons.buildbutton(" View Link", urls)
+ if BUTTON_FOUR_NAME is not None and BUTTON_FOUR_URL is not None:
+ buttons.buildbutton(f"{BUTTON_FOUR_NAME}", f"{BUTTON_FOUR_URL}")
+ if BUTTON_FIVE_NAME is not None and BUTTON_FIVE_URL is not None:
+ buttons.buildbutton(f"{BUTTON_FIVE_NAME}", f"{BUTTON_FIVE_URL}")
+ if BUTTON_SIX_NAME is not None and BUTTON_SIX_URL is not None:
+ buttons.buildbutton(f"{BUTTON_SIX_NAME}", f"{BUTTON_SIX_URL}")
+ except Exception as err:
+ if isinstance(err, RetryError):
+ LOGGER.info(f"Total Attempts: {err.last_attempt.attempt_number}")
+ err = err.last_attempt.exception()
+ err = str(err).replace('>', '').replace('<', '')
+ LOGGER.error(err)
+ if "User rate limit exceeded" in str(err):
+ msg = "User rate limit exceeded."
+ elif "File not found" in str(err):
+ msg = "File not found."
+ else:
+ msg = f"Error.\n{err}"
+ return msg, ""
+ return msg, InlineKeyboardMarkup(buttons.build_menu(2))
+
+ def cloneFolder(self, name, local_path, folder_id, parent_id):
+ LOGGER.info(f"Syncing: {local_path}")
+ files = self.getFilesByFolderId(folder_id)
+ new_id = None
+ if len(files) == 0:
+ return parent_id
+ for file in files:
+ if file.get('mimeType') == self.__G_DRIVE_DIR_MIME_TYPE:
+ self.total_folders += 1
+ file_path = os.path.join(local_path, file.get('name'))
+ current_dir_id = self.create_directory(file.get('name'), parent_id)
+ new_id = self.cloneFolder(file.get('name'), file_path, file.get('id'), current_dir_id)
+ else:
+ try:
+ self.total_files += 1
+ self.transferred_size += int(file.get('size'))
+ except TypeError:
+ pass
+ self.copyFile(file.get('id'), parent_id)
+ new_id = parent_id
+ if self.is_cancelled:
+ break
+
+ @retry(wait=wait_exponential(multiplier=2, min=3, max=6), stop=stop_after_attempt(5),
+ retry=retry_if_exception_type(HttpError), before=before_log(LOGGER, logging.DEBUG))
+ def create_directory(self, directory_name, parent_id):
+ file_metadata = {
+ "name": directory_name,
+ "mimeType": self.__G_DRIVE_DIR_MIME_TYPE
+ }
+ if parent_id is not None:
+ file_metadata["parents"] = [parent_id]
+ file = self.__service.files().create(supportsTeamDrives=True, body=file_metadata).execute()
+ file_id = file.get("id")
+ if not IS_TEAM_DRIVE:
+ self.__set_permission(file_id)
+ LOGGER.info("Created G-Drive Folder:\nName: {}\nID: {} ".format(file.get("name"), file_id))
+ return file_id
+
+ def upload_dir(self, input_directory, parent_id):
+ list_dirs = os.listdir(input_directory)
+ if len(list_dirs) == 0:
+ return parent_id
+ new_id = None
+ for item in list_dirs:
+ current_file_name = os.path.join(input_directory, item)
+ if os.path.isdir(current_file_name):
+ current_dir_id = self.create_directory(item, parent_id)
+ new_id = self.upload_dir(current_file_name, current_dir_id)
+ self.total_folders += 1
+ else:
+ mime_type = get_mime_type(current_file_name)
+ file_name = current_file_name.split("/")[-1]
+ # current_file_name will have the full path
+ self.upload_file(current_file_name, file_name, mime_type, parent_id)
+ self.total_files += 1
+ new_id = parent_id
+ if self.is_cancelled:
+ break
+ return new_id
+
+ def authorize(self):
+ # Get credentials
+ credentials = None
+ if not USE_SERVICE_ACCOUNTS:
+ if os.path.exists(self.__G_DRIVE_TOKEN_FILE):
+ with open(self.__G_DRIVE_TOKEN_FILE, 'rb') as f:
+ credentials = pickle.load(f)
+ if credentials is None or not credentials.valid:
+ if credentials and credentials.expired and credentials.refresh_token:
+ credentials.refresh(Request())
+ else:
+ flow = InstalledAppFlow.from_client_secrets_file(
+ 'credentials.json', self.__OAUTH_SCOPE)
+ LOGGER.info(flow)
+ credentials = flow.run_console(port=0)
+
+ # Save the credentials for the next run
+ with open(self.__G_DRIVE_TOKEN_FILE, 'wb') as token:
+ pickle.dump(credentials, token)
+ else:
+ LOGGER.info(f"Authorizing with {SERVICE_ACCOUNT_INDEX}.json service account")
+ credentials = service_account.Credentials.from_service_account_file(
+ f'accounts/{SERVICE_ACCOUNT_INDEX}.json',
+ scopes=self.__OAUTH_SCOPE)
+ return build('drive', 'v3', credentials=credentials, cache_discovery=False)
+ def edit_telegraph(self):
+ nxt_page = 1
+ prev_page = 0
+ for content in self.telegraph_content :
+ if nxt_page == 1 :
+ content += f'Next'
+ nxt_page += 1
+ else :
+ if prev_page <= self.num_of_path:
+ content += f'Prev'
+ prev_page += 1
+ if nxt_page < self.num_of_path:
+ content += f' | Next'
+ nxt_page += 1
+ Telegraph(access_token=telegraph_token).edit_page(path = self.path[prev_page],
+ title = 'AT_BOTs Mirror bot search',
+ author_name='AT_BOTs',
+ author_url='https://t.me/AT_BOTs',
+ html_content=content)
+ return
+
+ def escapes(self, str):
+ chars = ['\\', "'", '"', r'\a', r'\b', r'\f', r'\n', r'\r', r'\t']
+ for char in chars:
+ str = str.replace(char, '\\'+char)
+ return str
+
+ def drive_list(self, fileName):
+ msg = ""
+ fileName = self.escapes(str(fileName))
+ # Create Search Query for API request.
+ query = f"'{parent_id}' in parents and (name contains '{fileName}')"
+ response = self.__service.files().list(supportsTeamDrives=True,
+ includeTeamDriveItems=True,
+ q=query,
+ spaces='drive',
+ pageSize=200,
+ fields='files(id, name, mimeType, size)',
+ orderBy='name asc').execute()
+ content_count = 0
+ if response["files"]:
+ msg += f'{len(response["files"])} Results: {fileName}
' + for file in response.get('files', []): + if file.get('mimeType') == "application/vnd.google-apps.folder": # Detect Whether Current Entity is a Folder or File. + furl = f"https://drive.google.com/drive/folders/{file.get('id')}" + msg += f"📁
{file.get('name')}
(folder)" + if SHORTENER is not None and SHORTENER_API is not None: + sfurl = requests.get(f'https://{SHORTENER}/api?api={SHORTENER_API}&url={furl}&format=text').text + msg += f"Drive Link" + else: + msg += f"Drive Link" + if INDEX_URL is not None: + url_path = requests.utils.quote(f'{file.get("name")}') + url = f'{INDEX_URL}/{url_path}/' + if SHORTENER is not None and SHORTENER_API is not None: + siurl = requests.get(f'https://{SHORTENER}/api?api={SHORTENER_API}&url={url}&format=text').text + msg += f' | Index Link' + else: + msg += f' | Index Link' + elif file.get('mimeType') == 'application/vnd.google-apps.shortcut': + msg += f"⁍{file.get('name')}" \ + f" (shortcut)" + # Excluded index link as indexes cant download or open these shortcuts + else: + furl = f"https://drive.google.com/uc?id={file.get('id')}&export=download" + msg += f"📄
{file.get('name')}
({get_readable_file_size(int(file.get('size')))})" + if SHORTENER is not None and SHORTENER_API is not None: + sfurl = requests.get(f'https://{SHORTENER}/api?api={SHORTENER_API}&url={furl}&format=text').text + msg += f"Drive Link" + else: + msg += f"Drive Link" + if INDEX_URL is not None: + url_path = requests.utils.quote(f'{file.get("name")}') + url = f'{INDEX_URL}/{url_path}' + urls = f'{INDEX_URL}/{url_path}?a=view' + if SHORTENER is not None and SHORTENER_API is not None: + siurl = requests.get(f'https://{SHORTENER}/api?api={SHORTENER_API}&url={url}&format=text').text + siurls = requests.get(f'https://{SHORTENER}/api?api={SHORTENER_API}&url={urls}&format=text').text + msg += f' | Index Link' + if VIEW_LINK: + msg += f' | View Link' + else: + msg += f' | Index Link' + if VIEW_LINK: + msg += f' | View Link' + msg += '
' + content_count += 1 + if content_count == TELEGRAPHLIMIT : + self.telegraph_content.append(msg) + msg = "" + content_count = 0 + + if msg != '': + self.telegraph_content.append(msg) + + if len(self.telegraph_content) == 0: + return "No Result Found ❌", None + + for content in self.telegraph_content : + self.path.append(Telegraph(access_token=telegraph_token).create_page( + title = 'AT_BOTs Mirror bot search', + author_name='AT_BOTs Mirrorbot', + author_url='https://t.me/AT_BOTs', + html_content=content + )['path']) + + self.num_of_path = len(self.path) + if self.num_of_path > 1: + self.edit_telegraph() + + msg = f"Found
{len(response['files'])} results for {fileName}"
+ buttons = button_build.ButtonMaker()
+ buttons.buildbutton("🔎 VIEW", f"https://telegra.ph/{self.path[0]}")
+
+ return msg, InlineKeyboardMarkup(buttons.build_menu(1))
+
+ else :
+ return '', ''
+
+ def count(self, link):
+ try:
+ file_id = self.getIdFromUrl(link)
+ except (KeyError,IndexError):
+ msg = "Google Drive ID could not be found in the provided link"
+ return msg
+ msg = ""
+ LOGGER.info(f"File ID: {file_id}")
+ try:
+ drive_file = self.__service.files().get(fileId=file_id, fields="id, name, mimeType, size",
+ supportsTeamDrives=True).execute()
+ name = drive_file['name']
+ LOGGER.info(f"Counting: {name}")
+ if drive_file['mimeType'] == self.__G_DRIVE_DIR_MIME_TYPE:
+ self.gDrive_directory(**drive_file)
+ msg += f'☞ 📂Filename : {name}'
+ msg += f'\n☞ 📦Size : {get_readable_file_size(self.total_bytes)}'
+ msg += f'\n☞ 🌀Type : Folder'
+ msg += f'\n☞ 🗳Powered by : @AT_BOTs'
+ else:
+ msg += f'☞ 📂Filename : {name}'
+ try:
+ typee = drive_file['mimeType']
+ except:
+ typee = 'File'
+ try:
+ self.total_files += 1
+ self.gDrive_file(**drive_file)
+ msg += f'\n☞ 📦Size : {get_readable_file_size(self.total_bytes)}'
+ msg += f'\n☞ 🌀Type : {typee}'
+ msg += f'\n☞ 🗳Powered by : @AT_BOTs'
+ except TypeError:
+ pass
+ except Exception as err:
+ err = str(err).replace('>', '').replace('<', '')
+ LOGGER.error(err)
+ if "File not found" in str(err):
+ msg = "File not found."
+ else:
+ msg = f"Error.\n{err}"
+ return msg
+ return msg
+
+ def gDrive_file(self, **kwargs):
+ try:
+ size = int(kwargs['size'])
+ except:
+ size = 0
+ self.total_bytes += size
+
+ def gDrive_directory(self, **kwargs) -> None:
+ files = self.getFilesByFolderId(kwargs['id'])
+ if len(files) == 0:
+ return
+ for file_ in files:
+ if file_['mimeType'] == self.__G_DRIVE_DIR_MIME_TYPE:
+ self.total_folders += 1
+ self.gDrive_directory(**file_)
+ else:
+ self.total_files += 1
+ self.gDrive_file(**file_)
+
+ def clonehelper(self, link):
+ try:
+ file_id = self.getIdFromUrl(link)
+ except (KeyError,IndexError):
+ msg = "Google Drive ID could not be found in the provided link"
+ return msg, "", "", ""
+ LOGGER.info(f"File ID: {file_id}")
+ try:
+ drive_file = self.__service.files().get(fileId=file_id, fields="id, name, mimeType, size",
+ supportsTeamDrives=True).execute()
+ name = drive_file['name']
+ LOGGER.info(f"Checking: {name}")
+ if drive_file['mimeType'] == self.__G_DRIVE_DIR_MIME_TYPE:
+ self.gDrive_directory(**drive_file)
+ else:
+ try:
+ self.total_files += 1
+ self.gDrive_file(**drive_file)
+ except TypeError:
+ pass
+ clonesize = self.total_bytes
+ files = self.total_files
+ except Exception as err:
+ err = str(err).replace('>', '').replace('<', '')
+ LOGGER.error(err)
+ if "File not found" in str(err):
+ msg = "File not found."
+ else:
+ msg = f"Error.\n{err}"
+ return msg, "", "", ""
+ return "", clonesize, name, files
+
+ def download(self, link):
+ self.is_downloading = True
+ file_id = self.getIdFromUrl(link)
+ if USE_SERVICE_ACCOUNTS:
+ self.service_account_count = len(os.listdir("accounts"))
+ self.updater = setInterval(self.update_interval, self._on_download_progress)
+ try:
+ meta = self.getFileMetadata(file_id)
+ path = f"{DOWNLOAD_DIR}{self.__listener.uid}/"
+ if meta.get("mimeType") == self.__G_DRIVE_DIR_MIME_TYPE:
+ self.download_folder(file_id, path, meta.get('name'))
+ else:
+ os.makedirs(path)
+ self.download_file(file_id, path, meta.get('name'), meta.get('mimeType'))
+ except Exception as err:
+ err = str(err).replace('>', '').replace('<', '')
+ LOGGER.error(err)
+ if "downloadQuotaExceeded" in str(err):
+ err = "Download Quota Exceeded."
+ self.__listener.onDownloadError(err)
+ return
+ finally:
+ self.updater.cancel()
+ if self.is_cancelled:
+ return
+ self.__listener.onDownloadComplete()
+
+ def download_folder(self, folder_id, path, folder_name):
+ if not os.path.exists(path + folder_name):
+ os.makedirs(path + folder_name)
+ path += folder_name + '/'
+ result = []
+ page_token = None
+ while True:
+ files = self.__service.files().list(
+ supportsTeamDrives=True,
+ includeTeamDriveItems=True,
+ q=f"'{folder_id}' in parents",
+ fields='nextPageToken, files(id, name, mimeType, size, shortcutDetails)',
+ pageToken=page_token,
+ pageSize=1000).execute()
+ result.extend(files['files'])
+ page_token = files.get("nextPageToken")
+ if not page_token:
+ break
+
+ result = sorted(result, key=lambda k: k['name'])
+ for item in result:
+ file_id = item['id']
+ filename = item['name']
+ mime_type = item['mimeType']
+ shortcut_details = item.get('shortcutDetails', None)
+ if shortcut_details != None:
+ file_id = shortcut_details['targetId']
+ mime_type = shortcut_details['targetMimeType']
+ if mime_type == 'application/vnd.google-apps.folder':
+ self.download_folder(file_id, path, filename)
+ elif not os.path.isfile(path + filename):
+ self.download_file(file_id, path, filename, mime_type)
+ if self.is_cancelled:
+ break
+
+ def download_file(self, file_id, path, filename, mime_type):
+ request = self.__service.files().get_media(fileId=file_id)
+ filename = filename.replace('/', '')
+ fh = io.FileIO('{}{}'.format(path, filename), 'wb')
+ downloader = MediaIoBaseDownload(fh, request, chunksize = 65 * 1024 * 1024)
+ done = False
+ while not done:
+ if self.is_cancelled:
+ fh.close()
+ break
+ try:
+ self.dstatus, done = downloader.next_chunk()
+ except HttpError as err:
+ if err.resp.get('content-type', '').startswith('application/json'):
+ reason = json.loads(err.content).get('error').get('errors')[0].get('reason')
+ if reason == 'downloadQuotaExceeded' or reason == 'dailyLimitExceeded':
+ if USE_SERVICE_ACCOUNTS:
+ if self.sa_count == self.service_account_count:
+ self.is_cancelled = True
+ raise err
+ else:
+ self.switchServiceAccount()
+ LOGGER.info(f"Got: {reason}, Trying Again...")
+ return self.download_file(file_id, path, filename, mime_type)
+ else:
+ self.is_cancelled = True
+ LOGGER.info(f"Got: {reason}")
+ raise err
+ else:
+ raise err
+ self._file_downloaded_bytes = 0
+
+ def _on_download_progress(self):
+ if self.dstatus is not None:
+ chunk_size = self.dstatus.total_size * self.dstatus.progress() - self._file_downloaded_bytes
+ self._file_downloaded_bytes = self.dstatus.total_size * self.dstatus.progress()
+ self.downloaded_bytes += chunk_size
+ self.dtotal_time += self.update_interval
+
+ def cancel_download(self):
+ self.is_cancelled = True
+ if self.is_downloading:
+ LOGGER.info(f"Cancelling Download: {self.name}")
+ self.__listener.onDownloadError('Download stopped by user!')
+ elif self.is_cloning:
+ LOGGER.info(f"Cancelling Clone: {self.name}")
+ elif self.is_uploading:
+ LOGGER.info(f"Cancelling upload: {self.name}")
+ self.__listener.onUploadError('your upload has been stopped and uploaded data has been deleted!')
diff --git a/bot/helper/mirror_utils/upload_utils/gdtot_helper.py b/bot/helper/mirror_utils/upload_utils/gdtot_helper.py
new file mode 100644
index 0000000..57f8df0
--- /dev/null
+++ b/bot/helper/mirror_utils/upload_utils/gdtot_helper.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+# (C) Jigarvarma2005 (Jigar varma)
+# coded by noob
+import sys
+import os
+import requests as rq
+import re
+import json as js
+from bs4 import BeautifulSoup as bt
+import random
+from bot import GDTOT_COOKIES
+
+
+def cookie_checker():
+ """added support to use many GDtot cookies to Bypass limit"""
+ GDTOT_COOKIES_SET = set()
+ try:
+ a_gdtot_cookies = GDTOT_COOKIES.split("||")
+ for cookie in a_gdtot_cookies:
+ GDTOT_COOKIES_SET.add(str(cookie))
+ GDTOT_COOKIES_LIST = list(GDTOT_COOKIES_SET)
+ return {"cookie": random.choice(GDTOT_COOKIES_LIST)}
+ except:
+ return ""
+
+class GDTOT:
+ def __init__(self):
+ self.r = 'https://new.gdtot.top/'
+ self.COOKIES = cookie_checker()
+ self.c = GDTOT.check(self)
+ self.h = {
+ 'upgrade-insecure-requests': '1',
+ 'save-data': 'on',
+ 'user-agent': 'Mozilla/5.0 (Linux; Android 10; Redmi 8A Dual) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.101 Mobile Safari/537.36',
+ 'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9',
+ 'sec-fetch-site': 'same-origin',
+ 'sec-fetch-mode': 'navigate',
+ 'sec-fetch-dest': 'document',
+ 'referer': self.r,
+ 'prefetchAd_3621940': 'true',
+ 'accept-language': 'en-IN,en-GB;q=0.9,en-US;q=0.8,en;q=0.7'
+ }
+
+ def check(self):
+ """Check cookies and Ready it for work"""
+ try:
+ j = js.loads(js.dumps(self.COOKIES))['cookie'].replace('=',': ').replace(';',',')
+ f = re.sub(r'([a-zA-Z_0-9.%]+)', r'"\1"', "{%s}" %j)
+ c = js.loads(f)
+ return c
+ except Exception as e:
+ print(e)
+ return ""
+
+ def parse(self, url):
+ """Main function to get the URL"""
+ if url == "":
+ return
+ if self.c == "":
+ print("Please provide cookies")
+ return
+ else:
+ try:
+ r1 = rq.get(url, headers=self.h, cookies=self.c).content
+ p = bt(r1, 'html.parser').find('button', id="down").get('onclick').split("'")[1]
+ self.r = url
+ r2 = bt(rq.get(p, headers=self.h, cookies=self.c).content, 'html.parser').find('meta').get('content').split('=',1)[1]
+ self.r = p
+ r3 = bt(rq.get(r2, headers=self.h, cookies=self.c).content, 'html.parser').find('div', align="center")
+ if r3 == None:
+ r3 = bt(rq.get(r2, headers=self.h, cookies=self.c).content, 'html.parser')
+ f = r3.find('h4').text
+ return 404, f
+ else:
+ s = r3.find('h6').text
+ i = r3.find('a', class_="btn btn-outline-light btn-user font-weight-bold").get('href')
+ return s,i
+ except Exception as e:
+ print(e)
+ return 404, 404
diff --git a/bot/helper/telegram_helper/__init__.py b/bot/helper/telegram_helper/__init__.py
new file mode 100644
index 0000000..bba8f51
--- /dev/null
+++ b/bot/helper/telegram_helper/__init__.py
@@ -0,0 +1 @@
+#TEKEAYUSH
\ No newline at end of file
diff --git a/bot/helper/telegram_helper/bot_commands.py b/bot/helper/telegram_helper/bot_commands.py
new file mode 100644
index 0000000..2ab9ae2
--- /dev/null
+++ b/bot/helper/telegram_helper/bot_commands.py
@@ -0,0 +1,35 @@
+class _BotCommands:
+ def __init__(self):
+ self.StartCommand = 'start'
+ self.MirrorCommand = 'mirror'
+ self.UnzipMirrorCommand = 'unzip'
+ self.TarMirrorCommand = 'tar'
+ self.ZipMirrorCommand = 'zip'
+ self.CancelMirror = 'cancel'
+ self.CancelAllCommand = 'cnlall'
+ self.ListCommand = 'list'
+ self.StatusCommand = 'status'
+ self.AuthorizedUsersCommand = 'users'
+ self.AuthorizeCommand = 'auth'
+ self.UnAuthorizeCommand = 'unauth'
+ self.AddSudoCommand = 'addsudo'
+ self.RmSudoCommand = 'rmsudo'
+ self.PingCommand = 'ping'
+ self.RestartCommand = 'restart'
+ self.StatsCommand = 'stat'
+ self.HelpCommand = 'hlp'
+ self.LogCommand = 'log'
+ self.SpeedCommand = 'speedtest'
+ self.CloneCommand = 'clone'
+ self.CountCommand = 'count'
+ self.WatchCommand = 'watch'
+ self.TarWatchCommand = 'tarwatch'
+ self.DeleteCommand = 'del'
+ self.ConfigMenuCommand = 'config'
+ self.ShellCommand = 'shell'
+ self.UpdateCommand = 'update'
+ self.ExecHelpCommand = 'exechelp'
+ self.TsHelpCommand = 'tshelp'
+ self.GDTOTCommand = 'gdtot'
+
+BotCommands = _BotCommands()
diff --git a/bot/helper/telegram_helper/button_build.py b/bot/helper/telegram_helper/button_build.py
new file mode 100644
index 0000000..f0605a2
--- /dev/null
+++ b/bot/helper/telegram_helper/button_build.py
@@ -0,0 +1,20 @@
+from telegram import InlineKeyboardButton
+
+
+class ButtonMaker:
+ def __init__(self):
+ self.button = []
+
+ def buildbutton(self, key, link):
+ self.button.append(InlineKeyboardButton(text = key, url = link))
+
+ def sbutton(self, key, data):
+ self.button.append(InlineKeyboardButton(text = key, callback_data = data))
+
+ def build_menu(self, n_cols, footer_buttons=None, header_buttons=None):
+ menu = [self.button[i:i + n_cols] for i in range(0, len(self.button), n_cols)]
+ if header_buttons:
+ menu.insert(0, header_buttons)
+ if footer_buttons:
+ menu.append(footer_buttons)
+ return menu
diff --git a/bot/helper/telegram_helper/filters.py b/bot/helper/telegram_helper/filters.py
new file mode 100644
index 0000000..2be1fa5
--- /dev/null
+++ b/bot/helper/telegram_helper/filters.py
@@ -0,0 +1,51 @@
+from telegram.ext import MessageFilter
+from telegram import Message
+from bot import AUTHORIZED_CHATS, SUDO_USERS, OWNER_ID, download_dict, download_dict_lock
+
+
+class CustomFilters:
+ class _OwnerFilter(MessageFilter):
+ def filter(self, message):
+ return bool(message.from_user.id == OWNER_ID)
+
+ owner_filter = _OwnerFilter()
+
+ class _AuthorizedUserFilter(MessageFilter):
+ def filter(self, message):
+ id = message.from_user.id
+ return bool(id in AUTHORIZED_CHATS or id in SUDO_USERS or id == OWNER_ID)
+
+ authorized_user = _AuthorizedUserFilter()
+
+ class _AuthorizedChat(MessageFilter):
+ def filter(self, message):
+ return bool(message.chat.id in AUTHORIZED_CHATS)
+
+ authorized_chat = _AuthorizedChat()
+
+ class _SudoUser(MessageFilter):
+ def filter(self,message):
+ return bool(message.from_user.id in SUDO_USERS)
+
+ sudo_user = _SudoUser()
+
+ class _MirrorOwner(MessageFilter):
+ def filter(self, message: Message):
+ user_id = message.from_user.id
+ if user_id == OWNER_ID:
+ return True
+ args = str(message.text).split(' ')
+ if len(args) > 1:
+ # Cancelling by gid
+ with download_dict_lock:
+ for message_id, status in download_dict.items():
+ if status.gid() == args[1] and status.message.from_user.id == user_id:
+ return True
+ else:
+ return False
+ if not message.reply_to_message and len(args) == 1:
+ return True
+ # Cancelling by replying to original mirror message
+ reply_user = message.reply_to_message.from_user.id
+ return bool(reply_user == user_id)
+ mirror_owner_filter = _MirrorOwner()
diff --git a/bot/helper/telegram_helper/message_utils.py b/bot/helper/telegram_helper/message_utils.py
new file mode 100644
index 0000000..6ad748d
--- /dev/null
+++ b/bot/helper/telegram_helper/message_utils.py
@@ -0,0 +1,154 @@
+from telegram import InlineKeyboardMarkup
+from telegram.message import Message
+from telegram.update import Update
+import psutil, shutil
+import time
+from bot import AUTO_DELETE_MESSAGE_DURATION, LOGGER, bot, \
+ status_reply_dict, status_reply_dict_lock, download_dict, download_dict_lock, botStartTime, Interval, DOWNLOAD_STATUS_UPDATE_INTERVAL
+from bot.helper.ext_utils.bot_utils import get_readable_message, get_readable_file_size, get_readable_time, MirrorStatus, setInterval
+from telegram.error import TimedOut, BadRequest
+
+
+def sendMessage(text: str, bot, update: Update):
+ try:
+ return bot.send_message(update.message.chat_id,
+ reply_to_message_id=update.message.message_id,
+ text=text, allow_sending_without_reply=True, parse_mode='HTMl')
+ except Exception as e:
+ LOGGER.error(str(e))
+def sendMarkup(text: str, bot, update: Update, reply_markup: InlineKeyboardMarkup):
+ return bot.send_message(update.message.chat_id,
+ reply_to_message_id=update.message.message_id,
+ text=text, reply_markup=reply_markup, allow_sending_without_reply=True, parse_mode='HTMl')
+
+def editMessage(text: str, message: Message, reply_markup=None):
+ try:
+ bot.edit_message_text(text=text, message_id=message.message_id,
+ chat_id=message.chat.id,reply_markup=reply_markup,
+ parse_mode='HTMl')
+ except Exception as e:
+ LOGGER.error(str(e))
+
+
+def deleteMessage(bot, message: Message):
+ try:
+ bot.delete_message(chat_id=message.chat.id,
+ message_id=message.message_id)
+ except Exception as e:
+ LOGGER.error(str(e))
+
+
+def sendLogFile(bot, update: Update):
+ with open('log.txt', 'rb') as f:
+ bot.send_document(document=f, filename=f.name,
+ reply_to_message_id=update.message.message_id,
+ chat_id=update.message.chat_id)
+
+
+def auto_delete_message(bot, cmd_message: Message, bot_message: Message):
+ if AUTO_DELETE_MESSAGE_DURATION != -1:
+ time.sleep(AUTO_DELETE_MESSAGE_DURATION)
+ try:
+ # Skip if None is passed meaning we don't want to delete bot xor cmd message
+ deleteMessage(bot, cmd_message)
+ deleteMessage(bot, bot_message)
+ except AttributeError:
+ pass
+
+
+def delete_all_messages():
+ with status_reply_dict_lock:
+ for message in list(status_reply_dict.values()):
+ try:
+ deleteMessage(bot, message)
+ del status_reply_dict[message.chat.id]
+ except Exception as e:
+ LOGGER.error(str(e))
+
+
+def update_all_messages():
+ total, used, free = shutil.disk_usage('.')
+ free = get_readable_file_size(free)
+ currentTime = get_readable_time(time.time() - botStartTime)
+ msg, buttons = get_readable_message()
+ if msg is None:
+ return
+ msg += f"CPU: {psutil.cpu_percent()}%" \
+ f" RAM: {psutil.virtual_memory().percent}%" \
+ f" DISK: {psutil.disk_usage('/').percent}%"
+ with download_dict_lock:
+ dlspeed_bytes = 0
+ uldl_bytes = 0
+ for download in list(download_dict.values()):
+ speedy = download.speed()
+ if download.status() == MirrorStatus.STATUS_DOWNLOADING:
+ if 'K' in speedy:
+ dlspeed_bytes += float(speedy.split('K')[0]) * 1024
+ elif 'M' in speedy:
+ dlspeed_bytes += float(speedy.split('M')[0]) * 1048576
+ if download.status() == MirrorStatus.STATUS_UPLOADING:
+ if 'KB/s' in speedy:
+ uldl_bytes += float(speedy.split('K')[0]) * 1024
+ elif 'MB/s' in speedy:
+ uldl_bytes += float(speedy.split('M')[0]) * 1048576
+ dlspeed = get_readable_file_size(dlspeed_bytes)
+ ulspeed = get_readable_file_size(uldl_bytes)
+ msg += f"\nFREESPACE: {free} | BOTUPTIME: {currentTime}\nDL: {dlspeed}/s 🔻 | UL: {ulspeed}/s 🔺\n"
+ with status_reply_dict_lock:
+ for chat_id in list(status_reply_dict.keys()):
+ if status_reply_dict[chat_id] and msg != status_reply_dict[chat_id].text:
+ try:
+ if buttons == "":
+ editMessage(msg, status_reply_dict[chat_id])
+ else:
+ editMessage(msg, status_reply_dict[chat_id], buttons)
+ except Exception as e:
+ LOGGER.error(str(e))
+ status_reply_dict[chat_id].text = msg
+
+
+def sendStatusMessage(msg, bot):
+ if len(Interval) == 0:
+ Interval.append(setInterval(DOWNLOAD_STATUS_UPDATE_INTERVAL, update_all_messages))
+ total, used, free = shutil.disk_usage('.')
+ free = get_readable_file_size(free)
+ currentTime = get_readable_time(time.time() - botStartTime)
+ progress, buttons = get_readable_message()
+ if progress is None:
+ progress, buttons = get_readable_message()
+ progress += f"CPU: {psutil.cpu_percent()}%" \
+ f" RAM: {psutil.virtual_memory().percent}%" \
+ f" DISK: {psutil.disk_usage('/').percent}%"
+ with download_dict_lock:
+ dlspeed_bytes = 0
+ uldl_bytes = 0
+ for download in list(download_dict.values()):
+ speedy = download.speed()
+ if download.status() == MirrorStatus.STATUS_DOWNLOADING:
+ if 'K' in speedy:
+ dlspeed_bytes += float(speedy.split('K')[0]) * 1024
+ elif 'M' in speedy:
+ dlspeed_bytes += float(speedy.split('M')[0]) * 1048576
+ if download.status() == MirrorStatus.STATUS_UPLOADING:
+ if 'KB/s' in speedy:
+ uldl_bytes += float(speedy.split('K')[0]) * 1024
+ elif 'MB/s' in speedy:
+ uldl_bytes += float(speedy.split('M')[0]) * 1048576
+ dlspeed = get_readable_file_size(dlspeed_bytes)
+ ulspeed = get_readable_file_size(uldl_bytes)
+ progress += f"\nFREESPACE: {free} | BOTUPTIME: {currentTime}\nDL: {dlspeed}/s 🔻 | UL: {ulspeed}/s 🔺\n"
+ with status_reply_dict_lock:
+ if msg.message.chat.id in list(status_reply_dict.keys()):
+ try:
+ message = status_reply_dict[msg.message.chat.id]
+ deleteMessage(bot, message)
+ del status_reply_dict[msg.message.chat.id]
+ except Exception as e:
+ LOGGER.error(str(e))
+ del status_reply_dict[msg.message.chat.id]
+ pass
+ if buttons == "":
+ message = sendMessage(progress, bot, msg)
+ else:
+ message = sendMarkup(progress, bot, msg, buttons)
+ status_reply_dict[msg.message.chat.id] = message
diff --git a/bot/modules/__init__.py b/bot/modules/__init__.py
new file mode 100644
index 0000000..bba8f51
--- /dev/null
+++ b/bot/modules/__init__.py
@@ -0,0 +1 @@
+#TEKEAYUSH
\ No newline at end of file
diff --git a/bot/modules/authorize.py b/bot/modules/authorize.py
new file mode 100644
index 0000000..b7a8415
--- /dev/null
+++ b/bot/modules/authorize.py
@@ -0,0 +1,198 @@
+from bot.helper.telegram_helper.message_utils import sendMessage
+from bot import AUTHORIZED_CHATS, SUDO_USERS, dispatcher, DB_URI
+from telegram.ext import CommandHandler
+from bot.helper.telegram_helper.filters import CustomFilters
+from telegram.ext import Filters
+from telegram import Update
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot.helper.ext_utils.db_handler import DbManger
+
+
+def authorize(update, context):
+ reply_message = None
+ message_ = None
+ reply_message = update.message.reply_to_message
+ message_ = update.message.text.split(' ')
+ if len(message_) == 2:
+ user_id = int(message_[1])
+ if user_id not in AUTHORIZED_CHATS:
+ if DB_URI is not None:
+ msg = DbManger().db_auth(user_id)
+ else:
+ with open('authorized_chats.txt', 'a') as file:
+ file.write(f'{user_id}\n')
+ AUTHORIZED_CHATS.add(user_id)
+ msg = 'User Authorized'
+ else:
+ msg = 'User Already Authorized'
+ else:
+ if reply_message is None:
+ # Trying to authorize a chat
+ chat_id = update.effective_chat.id
+ if chat_id not in AUTHORIZED_CHATS:
+ if DB_URI is not None:
+ msg = DbManger().db_auth(chat_id)
+ else:
+ with open('authorized_chats.txt', 'a') as file:
+ file.write(f'{chat_id}\n')
+ AUTHORIZED_CHATS.add(chat_id)
+ msg = 'Chat Authorized'
+ else:
+ msg = 'Chat Already Authorized'
+
+ else:
+ # Trying to authorize someone by replying
+ user_id = reply_message.from_user.id
+ if user_id not in AUTHORIZED_CHATS:
+ if DB_URI is not None:
+ msg = DbManger().db_auth(user_id)
+ else:
+ with open('authorized_chats.txt', 'a') as file:
+ file.write(f'{user_id}\n')
+ AUTHORIZED_CHATS.add(user_id)
+ msg = 'User Authorized'
+ else:
+ msg = 'User Already Authorized'
+ sendMessage(msg, context.bot, update)
+
+
+def unauthorize(update, context):
+ reply_message = None
+ message_ = None
+ reply_message = update.message.reply_to_message
+ message_ = update.message.text.split(' ')
+ if len(message_) == 2:
+ user_id = int(message_[1])
+ if user_id in AUTHORIZED_CHATS:
+ if DB_URI is not None:
+ msg = DbManger().db_unauth(user_id)
+ else:
+ AUTHORIZED_CHATS.remove(user_id)
+ msg = 'User Unauthorized'
+ else:
+ msg = 'User Already Unauthorized'
+ else:
+ if reply_message is None:
+ # Trying to unauthorize a chat
+ chat_id = update.effective_chat.id
+ if chat_id in AUTHORIZED_CHATS:
+ if DB_URI is not None:
+ msg = DbManger().db_unauth(chat_id)
+ else:
+ AUTHORIZED_CHATS.remove(chat_id)
+ msg = 'Chat Unauthorized'
+ else:
+ msg = 'Chat Already Unauthorized'
+ else:
+ # Trying to authorize someone by replying
+ user_id = reply_message.from_user.id
+ if user_id in AUTHORIZED_CHATS:
+ if DB_URI is not None:
+ msg = DbManger().db_unauth(user_id)
+ else:
+ AUTHORIZED_CHATS.remove(user_id)
+ msg = 'User Unauthorized'
+ else:
+ msg = 'User Already Unauthorized'
+ with open('authorized_chats.txt', 'a') as file:
+ file.truncate(0)
+ for i in AUTHORIZED_CHATS:
+ file.write(f'{i}\n')
+ sendMessage(msg, context.bot, update)
+
+
+def addSudo(update, context):
+ reply_message = None
+ message_ = None
+ reply_message = update.message.reply_to_message
+ message_ = update.message.text.split(' ')
+ if len(message_) == 2:
+ user_id = int(message_[1])
+ if user_id not in SUDO_USERS:
+ if DB_URI is not None:
+ msg = DbManger().db_addsudo(user_id)
+ else:
+ with open('sudo_users.txt', 'a') as file:
+ file.write(f'{user_id}\n')
+ SUDO_USERS.add(user_id)
+ msg = 'Promoted as Sudo'
+ else:
+ msg = 'Already Sudo'
+ else:
+ if reply_message is None:
+ msg = "Give ID or Reply To message of whom you want to Promote"
+ else:
+ # Trying to authorize someone by replying
+ user_id = reply_message.from_user.id
+ if user_id not in SUDO_USERS:
+ if DB_URI is not None:
+ msg = DbManger().db_addsudo(user_id)
+ else:
+ with open('sudo_users.txt', 'a') as file:
+ file.write(f'{user_id}\n')
+ SUDO_USERS.add(user_id)
+ msg = 'Promoted as Sudo'
+ else:
+ msg = 'Already Sudo'
+ sendMessage(msg, context.bot, update)
+
+
+def removeSudo(update, context):
+ reply_message = None
+ message_ = None
+ reply_message = update.message.reply_to_message
+ message_ = update.message.text.split(' ')
+ if len(message_) == 2:
+ user_id = int(message_[1])
+ if user_id in SUDO_USERS:
+ if DB_URI is not None:
+ msg = DbManger().db_rmsudo(user_id)
+ else:
+ SUDO_USERS.remove(user_id)
+ msg = 'Demoted'
+ else:
+ msg = 'Not a Sudo'
+ else:
+ if reply_message is None:
+ msg = "Give ID or Reply To message of whom you want to remove from Sudo"
+ else:
+ user_id = reply_message.from_user.id
+ if user_id in SUDO_USERS:
+ if DB_URI is not None:
+ msg = DbManger().db_rmsudo(user_id)
+ else:
+ SUDO_USERS.remove(user_id)
+ msg = 'Demoted'
+ else:
+ msg = 'Not a Sudo'
+ if DB_URI is None:
+ with open('sudo_users.txt', 'a') as file:
+ file.truncate(0)
+ for i in SUDO_USERS:
+ file.write(f'{i}\n')
+ sendMessage(msg, context.bot, update)
+
+
+def sendAuthChats(update, context):
+ user = sudo = ''
+ user += '\n'.join(str(id) for id in AUTHORIZED_CHATS)
+ sudo += '\n'.join(str(id) for id in SUDO_USERS)
+ sendMessage(f'Authorized Chats\n{user}\nSudo Users\n{sudo}', context.bot, update)
+
+
+send_auth_handler = CommandHandler(command=BotCommands.AuthorizedUsersCommand, callback=sendAuthChats,
+ filters=CustomFilters.owner_filter | CustomFilters.sudo_user, run_async=True)
+authorize_handler = CommandHandler(command=BotCommands.AuthorizeCommand, callback=authorize,
+ filters=CustomFilters.owner_filter | CustomFilters.sudo_user, run_async=True)
+unauthorize_handler = CommandHandler(command=BotCommands.UnAuthorizeCommand, callback=unauthorize,
+ filters=CustomFilters.owner_filter | CustomFilters.sudo_user, run_async=True)
+addsudo_handler = CommandHandler(command=BotCommands.AddSudoCommand, callback=addSudo,
+ filters=CustomFilters.owner_filter, run_async=True)
+removesudo_handler = CommandHandler(command=BotCommands.RmSudoCommand, callback=removeSudo,
+ filters=CustomFilters.owner_filter, run_async=True)
+
+dispatcher.add_handler(send_auth_handler)
+dispatcher.add_handler(authorize_handler)
+dispatcher.add_handler(unauthorize_handler)
+dispatcher.add_handler(addsudo_handler)
+dispatcher.add_handler(removesudo_handler)
diff --git a/bot/modules/cancel_mirror.py b/bot/modules/cancel_mirror.py
new file mode 100644
index 0000000..369877f
--- /dev/null
+++ b/bot/modules/cancel_mirror.py
@@ -0,0 +1,77 @@
+from telegram.ext import CommandHandler
+from bot import download_dict, dispatcher, download_dict_lock, DOWNLOAD_DIR
+from bot.helper.ext_utils.fs_utils import clean_download
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot.helper.telegram_helper.filters import CustomFilters
+from bot.helper.telegram_helper.message_utils import *
+
+from time import sleep
+from bot.helper.ext_utils.bot_utils import getDownloadByGid, MirrorStatus, getAllDownload
+
+
+def cancel_mirror(update, context):
+ args = update.message.text.split(" ", maxsplit=1)
+ mirror_message = None
+ if len(args) > 1:
+ gid = args[1]
+ dl = getDownloadByGid(gid)
+ if not dl:
+ sendMessage(f"GID: {gid} Not Found.", context.bot, update)
+ return
+ mirror_message = dl.message
+ elif update.message.reply_to_message:
+ mirror_message = update.message.reply_to_message
+ with download_dict_lock:
+ keys = list(download_dict.keys())
+ try:
+ dl = download_dict[mirror_message.message_id]
+ except:
+ pass
+ if len(args) == 1:
+ msg = f"Please reply to the /{BotCommands.MirrorCommand} message which was used to start the download or send /{BotCommands.CancelMirror} GID to cancel it!"
+ if mirror_message and mirror_message.message_id not in keys:
+ if BotCommands.MirrorCommand in mirror_message.text or \
+ BotCommands.TarMirrorCommand in mirror_message.text or \
+ BotCommands.UnzipMirrorCommand in mirror_message.text:
+ msg1 = "Mirror Already Have Been Cancelled"
+ sendMessage(msg1, context.bot, update)
+ return
+ else:
+ sendMessage(msg, context.bot, update)
+ return
+ elif not mirror_message:
+ sendMessage(msg, context.bot, update)
+ return
+ if dl.status() == MirrorStatus.STATUS_ARCHIVING:
+ sendMessage("Archival in Progress, You Can't Cancel It.", context.bot, update)
+ elif dl.status() == MirrorStatus.STATUS_EXTRACTING:
+ sendMessage("Extract in Progress, You Can't Cancel It.", context.bot, update)
+ else:
+ dl.download().cancel_download()
+ sleep(3) # incase of any error with ondownloaderror listener
+ clean_download(f'{DOWNLOAD_DIR}{mirror_message.message_id}/')
+
+
+def cancel_all(update, context):
+ count = 0
+ gid = 0
+ while True:
+ dl = getAllDownload()
+ if dl:
+ if dl.gid() != gid:
+ gid = dl.gid()
+ dl.download().cancel_download()
+ count += 1
+ sleep(0.3)
+ else:
+ break
+ sendMessage(f'{count} Download(s) has been Cancelled!', context.bot, update)
+
+
+
+cancel_mirror_handler = CommandHandler(BotCommands.CancelMirror, cancel_mirror,
+ filters=(CustomFilters.authorized_chat | CustomFilters.authorized_user) & CustomFilters.mirror_owner_filter | CustomFilters.sudo_user, run_async=True)
+cancel_all_handler = CommandHandler(BotCommands.CancelAllCommand, cancel_all,
+ filters=CustomFilters.owner_filter | CustomFilters.sudo_user, run_async=True)
+dispatcher.add_handler(cancel_all_handler)
+dispatcher.add_handler(cancel_mirror_handler)
diff --git a/bot/modules/clone.py b/bot/modules/clone.py
new file mode 100644
index 0000000..0d79918
--- /dev/null
+++ b/bot/modules/clone.py
@@ -0,0 +1,74 @@
+from telegram.ext import CommandHandler
+from bot.helper.mirror_utils.upload_utils import gdriveTools
+from bot.helper.telegram_helper.message_utils import *
+from bot.helper.telegram_helper.filters import CustomFilters
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot.helper.mirror_utils.status_utils.clone_status import CloneStatus
+from bot import dispatcher, LOGGER, CLONE_LIMIT, STOP_DUPLICATE, download_dict, download_dict_lock, Interval
+from bot.helper.ext_utils.bot_utils import get_readable_file_size, check_limit
+import random
+import string
+
+
+def cloneNode(update, context):
+ args = update.message.text.split(" ", maxsplit=1)
+ if len(args) > 1:
+ link = args[1]
+ gd = gdriveTools.GoogleDriveHelper()
+ res, size, name, files = gd.clonehelper(link)
+ if res != "":
+ sendMessage(res, context.bot, update)
+ return
+ if STOP_DUPLICATE:
+ LOGGER.info(f"Checking File/Folder if already in Drive...")
+ smsg, button = gd.drive_list(name)
+ if smsg:
+ msg3 = "File/Folder is already available in Drive.\nHere are the search results:"
+ sendMarkup(msg3, context.bot, update, button)
+ return
+ if CLONE_LIMIT is not None:
+ result = check_limit(size, CLONE_LIMIT)
+ if result:
+ msg2 = f'Failed, Clone limit is {CLONE_LIMIT}.\nYour File/Folder size is {get_readable_file_size(clonesize)}.'
+ sendMessage(msg2, context.bot, update)
+ return
+ if files < 15:
+ msg = sendMessage(f"Cloning: {link}", context.bot, update)
+ result, button = gd.clone(link)
+ deleteMessage(context.bot, msg)
+ else:
+ drive = gdriveTools.GoogleDriveHelper(name)
+ gid = ''.join(random.SystemRandom().choices(string.ascii_letters + string.digits, k=12))
+ clone_status = CloneStatus(drive, size, update, gid)
+ with download_dict_lock:
+ download_dict[update.message.message_id] = clone_status
+ sendStatusMessage(update, context.bot)
+ result, button = drive.clone(link)
+ with download_dict_lock:
+ del download_dict[update.message.message_id]
+ count = len(download_dict)
+ try:
+ if count == 0:
+ Interval[0].cancel()
+ del Interval[0]
+ delete_all_messages()
+ else:
+ update_all_messages()
+ except IndexError:
+ pass
+ if update.message.from_user.username:
+ uname = f'@{update.message.from_user.username}'
+ else:
+ uname = f'{update.message.from_user.first_name}'
+ if uname is not None:
+ cc = f'\n\ncc: {uname}'
+ men = f'{uname} '
+ if button == "cancelled" or button == "":
+ sendMessage(men + result, context.bot, update)
+ else:
+ sendMarkup(result + cc, context.bot, update, button)
+ else:
+ sendMessage('Provide G-Drive Shareable Link to Clone.', context.bot, update)
+
+clone_handler = CommandHandler(BotCommands.CloneCommand, cloneNode, filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+dispatcher.add_handler(clone_handler)
diff --git a/bot/modules/config.py b/bot/modules/config.py
new file mode 100644
index 0000000..c84d981
--- /dev/null
+++ b/bot/modules/config.py
@@ -0,0 +1,221 @@
+# Implement By https://github.com/jusidama18
+# Based on this https://github.com/DevsExpo/FridayUserbot/blob/master/plugins/heroku_helpers.py
+
+from pyrogram import filters, types, emoji
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot import app, OWNER_ID, bot
+from bot.helper import get_text, check_heroku
+from bot import *
+
+# Add Variable
+
+@app.on_message(filters.command(['setvar', f'setvar@{bot.username}']) & filters.user(OWNER_ID))
+@check_heroku
+async def set_varr(client, message, app_):
+ msg_ = await message.reply_text("`Please Wait!`")
+ heroku_var = app_.config()
+ _var = get_text(message)
+ if not _var:
+ await msg_.edit("`Here is Usage Syntax: /setvar KEY VALUE`", parse_mode="markdown")
+ return
+ if not " " in _var:
+ await msg_.edit("`Variable VALUE needed !`", parse_mode="markdown")
+ return
+ var_ = _var.split(" ", 1)
+ if len(var_) > 2:
+ await msg_.edit("`Here is Usage Syntax: /setvar KEY VALUE`", parse_mode="markdown")
+ return
+ _varname, _varvalue = var_
+ await msg_.edit(
+ f"`Variable {_varname} Added With Value {_varvalue}!`" \
+ f"\nYour Heroku app will restart. Be patient."
+ )
+ heroku_var[_varname] = _varvalue
+
+# Delete Variable
+
+@app.on_message(filters.command(['delvar', f'delvar@{bot.username}']) & filters.user(OWNER_ID))
+@check_heroku
+async def del_varr(client, message, app_):
+ msg_ = await message.reply_text("`Please Wait!`", parse_mode="markdown")
+ heroku_var = app_.config()
+ _var = get_text(message)
+ if not _var:
+ await msg_.edit("`Give Var Name As Input!`", parse_mode="markdown")
+ return
+ if not _var in heroku_var:
+ await msg_.edit("`This Var Doesn't Exists!`", parse_mode="markdown")
+ return
+ await msg_.edit(
+ f"`Sucessfully Deleted {_var} Var!`" \
+ f"\nYour Heroku app will restart. Be patient.",
+ parse_mode="markdown")
+ del heroku_var[_var]
+
+@app.on_message(filters.command(['reboot', f'reboot@{bot.username}']) & filters.user(OWNER_ID))
+@check_heroku
+async def gib_restart(client, message, hap):
+ msg_ = await message.reply_text("[HEROKU] - Restarting")
+ hap.restart()
+
+# CONFIG LIST #
+
+__header__='📕 **Page** **{}**\n\n'
+
+@app.on_message(filters.command([BotCommands.ConfigMenuCommand, f'{BotCommands.ConfigMenuCommand}@{bot.username}']) & filters.user(OWNER_ID))
+async def config_menu(_, message):
+ await message.reply(
+ f"**Hello {message.from_user.mention}**,\n\n**If you want to add or set Variable in Heroku use** `/setvar`\n\n**If you want to delete Variable in Heroku use `/delvar`**\n\n**WARNING! Very Recommended to do this command in private since it's contain Bot info.**\n\n**Here's This is Slam-MirrorBot Current Configs**",
+ reply_markup=types.InlineKeyboardMarkup(
+ [[types.InlineKeyboardButton(f"{emoji.CROSS_MARK}", callback_data='docs_end'), types.InlineKeyboardButton(f"BOT CONFIG", callback_data='docs_1')]]
+ )
+ )
+
+@app.on_callback_query(filters.regex('^docs_') & filters.user(OWNER_ID))
+async def config_button(_, query):
+ data = query.data.split('_')[1]
+ if data == '1':
+ return await query.message.edit(
+ __header__.format(data)
+ + f"**[ Telegram Config ]**\n\n**BOT_TOKEN:** `{BOT_TOKEN}`\n\n**TELEGRAM_API:** `{TELEGRAM_API}`\n\n**TELEGRAM_HASH:** `{TELEGRAM_HASH}`\n\n**TELEGRAPH_TOKEN:** `{telegraph_token}`",
+ reply_markup=types.InlineKeyboardMarkup(
+ [
+ [
+ types.InlineKeyboardButton(f"{emoji.LEFT_ARROW}", callback_data='docs_10'),
+ types.InlineKeyboardButton(f"{emoji.CROSS_MARK}", callback_data='docs_end'),
+ types.InlineKeyboardButton(f"{emoji.RIGHT_ARROW}", callback_data='docs_2')
+ ]
+ ]
+ )
+ )
+ elif data == '2':
+ return await query.message.edit(
+ __header__.format(data)
+ + f"**[ Drive and Index Config ]**\n\n**GDRIVE_FOLDER_ID:** `{parent_id}`\n\n**IS_TEAM_DRIVE:** `{IS_TEAM_DRIVE}`\n\n**USE_SERVICE_ACCOUNTS:** `{USE_SERVICE_ACCOUNTS}`\n\n**INDEX_URL:** `{INDEX_URL}`",
+ reply_markup=types.InlineKeyboardMarkup(
+ [
+ [
+ types.InlineKeyboardButton(f"{emoji.LEFT_ARROW}", callback_data='docs_1'),
+ types.InlineKeyboardButton(f"{emoji.CROSS_MARK}", callback_data='docs_end'),
+ types.InlineKeyboardButton(f"{emoji.RIGHT_ARROW}", callback_data='docs_3')
+ ]
+ ]
+ )
+ )
+ elif data == '3':
+ return await query.message.edit(
+ __header__.format(data)
+ + f"**[ Mega and Uptobox Config ]**\n\n**MEGA_API_KEY:** `{MEGA_API_KEY}`\n\n**MEGA_EMAIL_ID:** `{MEGA_EMAIL_ID}`\n\n**MEGA_PASSWORD:** `{MEGA_PASSWORD}`\n\n**UPTOBOX_TOKEN:** `{UPTOBOX_TOKEN}`",
+ reply_markup=types.InlineKeyboardMarkup(
+ [
+ [
+ types.InlineKeyboardButton(f"{emoji.LEFT_ARROW}", callback_data='docs_2'),
+ types.InlineKeyboardButton(f"{emoji.CROSS_MARK}", callback_data='docs_end'),
+ types.InlineKeyboardButton(f"{emoji.RIGHT_ARROW}", callback_data='docs_4')
+ ]
+ ]
+ )
+ )
+ elif data == '4':
+ return await query.message.edit(
+ __header__.format(data)
+ + f"**[ Stop and Block Config ]**\n\n**STOP_DUPLICATE:** `{STOP_DUPLICATE}`\n\n**BLOCK_MEGA_FOLDER:** `{BLOCK_MEGA_FOLDER}`\n\n**BLOCK_MEGA_LINKS:** `{BLOCK_MEGA_LINKS}`",
+ reply_markup=types.InlineKeyboardMarkup(
+ [
+ [
+ types.InlineKeyboardButton(f"{emoji.LEFT_ARROW}", callback_data='docs_3'),
+ types.InlineKeyboardButton(f"{emoji.CROSS_MARK}", callback_data='docs_end'),
+ types.InlineKeyboardButton(f"{emoji.RIGHT_ARROW}", callback_data='docs_5')
+ ]
+ ]
+ )
+ )
+ elif data == '5':
+ return await query.message.edit(
+ __header__.format(data)
+ + f"**[ Limit Size Config ]**\n\n**TORRENT_DIRECT_LIMIT:** `{TORRENT_DIRECT_LIMIT}`\n\n**TAR_UNZIP_LIMIT:** `{TAR_UNZIP_LIMIT}`\n\n**CLONE_LIMIT:** `{CLONE_LIMIT}`\n\n**MEGA_LIMIT:** `{MEGA_LIMIT}`",
+ reply_markup=types.InlineKeyboardMarkup(
+ [
+ [
+ types.InlineKeyboardButton(f"{emoji.LEFT_ARROW}", callback_data='docs_4'),
+ types.InlineKeyboardButton(f"{emoji.CROSS_MARK}", callback_data='docs_end'),
+ types.InlineKeyboardButton(f"{emoji.RIGHT_ARROW}", callback_data='docs_6')
+ ]
+ ]
+ )
+ )
+ elif data == '6':
+ user = sudo = ''
+ user += '\n'.join(str(id) for id in AUTHORIZED_CHATS)
+ sudo += '\n'.join(str(id) for id in SUDO_USERS)
+ return await query.message.edit(
+ __header__.format(data)
+ + f"**[ User ID Config ]**\n\n**OWNER_ID:** `{OWNER_ID}`\n\n**AUTHORIZED_CHATS:**\n`{user}`\n\n**SUDO_USERS:**\n`{sudo}`",
+ reply_markup=types.InlineKeyboardMarkup(
+ [
+ [
+ types.InlineKeyboardButton(f"{emoji.LEFT_ARROW}", callback_data='docs_5'),
+ types.InlineKeyboardButton(f"{emoji.CROSS_MARK}", callback_data='docs_end'),
+ types.InlineKeyboardButton(f"{emoji.RIGHT_ARROW}", callback_data='docs_7')
+ ]
+ ]
+ )
+ )
+ elif data == '7':
+ return await query.message.edit(
+ __header__.format(data)
+ + f"**[ Button Config ]**\n\n**BUTTON_FOUR_NAME:** `{BUTTON_FOUR_NAME}`\n\n**BUTTON_FOUR_URL:** `{BUTTON_FOUR_URL}`\n\n**BUTTON_FIVE_NAME:** `{BUTTON_FIVE_NAME}`\n\n**BUTTON_FIVE_URL:** `{BUTTON_FIVE_URL}`\n\n**BUTTON_SIX_NAME:** `{BUTTON_SIX_NAME}`\n\n**BUTTON_SIX_URL:** `{BUTTON_SIX_URL}`",
+ reply_markup=types.InlineKeyboardMarkup(
+ [
+ [
+ types.InlineKeyboardButton(f"{emoji.LEFT_ARROW}", callback_data='docs_6'),
+ types.InlineKeyboardButton(f"{emoji.CROSS_MARK}", callback_data='docs_end'),
+ types.InlineKeyboardButton(f"{emoji.RIGHT_ARROW}", callback_data='docs_8')
+ ]
+ ]
+ )
+ )
+ elif data == '8':
+ return await query.message.edit(
+ __header__.format(data)
+ + f"**[ Heroku Config ]**\n\n**HEROKU_API_KEY:** `{HEROKU_API_KEY}`\n\n**HEROKU_APP_NAME:** `{HEROKU_APP_NAME}`\n\n**[ Shortener Config ]**\n\n**SHORTENER:** `{SHORTENER}`\n\n**SHORTENER_API:** `{SHORTENER_API}`",
+ reply_markup=types.InlineKeyboardMarkup(
+ [
+ [
+ types.InlineKeyboardButton(f"{emoji.LEFT_ARROW}", callback_data='docs_7'),
+ types.InlineKeyboardButton(f"{emoji.CROSS_MARK}", callback_data='docs_end'),
+ types.InlineKeyboardButton(f"{emoji.RIGHT_ARROW}", callback_data='docs_9')
+ ]
+ ]
+ )
+ )
+ elif data == '9':
+ return await query.message.edit(
+ __header__.format(data)
+ + f"**[ Others Config ]**\n\n**VIEW_LINK:** `{VIEW_LINK}`\n\n**STATUS_LIMIT:** `{STATUS_LIMIT}`\n\n**DOWNLOAD_STATUS_UPDATE_INTERVAL:** `{DOWNLOAD_STATUS_UPDATE_INTERVAL}`\n\n**IGNORE_PENDING_REQUESTS:** `{IGNORE_PENDING_REQUESTS}`\n\n**AUTO_DELETE_MESSAGE_DURATION:** `{AUTO_DELETE_MESSAGE_DURATION}`\n\n**DOWNLOAD_DIR:** `{DOWNLOAD_DIR}`\n\n**DATABASE_URL:** `{DB_URI}`",
+ reply_markup=types.InlineKeyboardMarkup(
+ [
+ [
+ types.InlineKeyboardButton(f"{emoji.LEFT_ARROW}", callback_data='docs_8'),
+ types.InlineKeyboardButton(f"{emoji.CROSS_MARK}", callback_data='docs_end'),
+ types.InlineKeyboardButton(f"{emoji.RIGHT_ARROW}", callback_data='docs_10')
+ ]
+ ]
+ )
+ )
+ elif data == '10':
+ return await query.message.edit(
+ __header__.format(data)
+ + f"**[ qBittorrent Config ]**\n\n**IS_VPS:** `{IS_VPS}`\n\n**SERVER_PORT:** `{SERVER_PORT}`\n\n**BASE_URL_OF_BOT:** `{BASE_URL}`\n\n**[ Updater Config ]**\n\n**UPSTREAM_REPO:** `{UPSTREAM_REPO}`\n\n**UPSTREAM_BRANCH:** `{UPSTREAM_BRANCH}`\n\n**ACCOUNTS_ZIP_URL:** `{ACCOUNTS_ZIP_URL}`\n\n**TOKEN_PICKLE_URL:** `{TOKEN_PICKLE_URL}`",
+ reply_markup=types.InlineKeyboardMarkup(
+ [
+ [
+ types.InlineKeyboardButton(f"{emoji.LEFT_ARROW}", callback_data='docs_9'),
+ types.InlineKeyboardButton(f"{emoji.CROSS_MARK}", callback_data='docs_end'),
+ types.InlineKeyboardButton(f"{emoji.RIGHT_ARROW}", callback_data='docs_1')
+ ]
+ ]
+ )
+ )
+ elif data == 'end':
+ return await query.message.delete()
diff --git a/bot/modules/count.py b/bot/modules/count.py
new file mode 100644
index 0000000..fd845a6
--- /dev/null
+++ b/bot/modules/count.py
@@ -0,0 +1,31 @@
+# Implement By https://github.com/anasty17
+# © https://github.com/breakdowns/slam-mirrorbot
+
+from telegram.ext import CommandHandler
+from bot.helper.mirror_utils.upload_utils.gdriveTools import GoogleDriveHelper
+from bot.helper.telegram_helper.message_utils import deleteMessage, sendMessage
+from bot.helper.telegram_helper.filters import CustomFilters
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot import dispatcher
+
+
+def countNode(update, context):
+ args = update.message.text.split(" ", maxsplit=1)
+ if len(args) > 1:
+ link = args[1]
+ msg = sendMessage(f"Counting: {link}", context.bot, update)
+ gd = GoogleDriveHelper()
+ result = gd.count(link)
+ deleteMessage(context.bot, msg)
+ if update.message.from_user.username:
+ uname = f'@{update.message.from_user.username}'
+ else:
+ uname = f'{update.message.from_user.first_name}'
+ if uname is not None:
+ cc = f'\n\ncc: {uname}'
+ sendMessage(result + cc, context.bot, update)
+ else:
+ sendMessage("Provide G-Drive Shareable Link to Count.", context.bot, update)
+
+count_handler = CommandHandler(BotCommands.CountCommand, countNode, filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+dispatcher.add_handler(count_handler)
diff --git a/bot/modules/delete.py b/bot/modules/delete.py
new file mode 100644
index 0000000..32ebdd8
--- /dev/null
+++ b/bot/modules/delete.py
@@ -0,0 +1,29 @@
+from telegram.ext import CommandHandler
+import threading
+from telegram import Update
+from bot import dispatcher, LOGGER
+from bot.helper.telegram_helper.message_utils import auto_delete_message, sendMessage
+from bot.helper.telegram_helper.filters import CustomFilters
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot.helper.mirror_utils.upload_utils import gdriveTools
+
+
+def deletefile(update, context):
+ msg_args = update.message.text.split(None, 1)
+ msg = ''
+ try:
+ link = msg_args[1]
+ LOGGER.info(msg_args[1])
+ except IndexError:
+ msg = 'Send a link along with command'
+
+ if msg == '' :
+ drive = gdriveTools.GoogleDriveHelper()
+ msg = drive.deletefile(link)
+ LOGGER.info(f"DeleteFileCmd : {msg}")
+ reply_message = sendMessage(msg, context.bot, update)
+
+ threading.Thread(target=auto_delete_message, args=(context.bot, update.message, reply_message)).start()
+
+delete_handler = CommandHandler(command=BotCommands.DeleteCommand, callback=deletefile, filters=CustomFilters.owner_filter | CustomFilters.sudo_user, run_async=True)
+dispatcher.add_handler(delete_handler)
diff --git a/bot/modules/eval.py b/bot/modules/eval.py
new file mode 100644
index 0000000..12541bb
--- /dev/null
+++ b/bot/modules/eval.py
@@ -0,0 +1,142 @@
+import io
+import os
+# Common imports for eval
+import textwrap
+import traceback
+from contextlib import redirect_stdout
+from bot.helper.telegram_helper.filters import CustomFilters
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot.helper.telegram_helper.message_utils import sendMessage
+from bot import LOGGER, dispatcher
+from telegram import ParseMode
+from telegram.ext import CommandHandler
+
+namespaces = {}
+
+
+def namespace_of(chat, update, bot):
+ if chat not in namespaces:
+ namespaces[chat] = {
+ '__builtins__': globals()['__builtins__'],
+ 'bot': bot,
+ 'effective_message': update.effective_message,
+ 'effective_user': update.effective_user,
+ 'effective_chat': update.effective_chat,
+ 'update': update
+ }
+
+ return namespaces[chat]
+
+
+def log_input(update):
+ user = update.effective_user.id
+ chat = update.effective_chat.id
+ LOGGER.info(
+ f"IN: {update.effective_message.text} (user={user}, chat={chat})")
+
+
+def send(msg, bot, update):
+ if len(str(msg)) > 2000:
+ with io.BytesIO(str.encode(msg)) as out_file:
+ out_file.name = "output.txt"
+ bot.send_document(
+ chat_id=update.effective_chat.id, document=out_file)
+ else:
+ LOGGER.info(f"OUT: '{msg}'")
+ bot.send_message(
+ chat_id=update.effective_chat.id,
+ text=f"`{msg}`",
+ parse_mode=ParseMode.MARKDOWN)
+
+
+def evaluate(update, context):
+ bot = context.bot
+ send(do(eval, bot, update), bot, update)
+
+
+def execute(update, context):
+ bot = context.bot
+ send(do(exec, bot, update), bot, update)
+
+
+def cleanup_code(code):
+ if code.startswith('```') and code.endswith('```'):
+ return '\n'.join(code.split('\n')[1:-1])
+ return code.strip('` \n')
+
+
+def do(func, bot, update):
+ log_input(update)
+ content = update.message.text.split(' ', 1)[-1]
+ body = cleanup_code(content)
+ env = namespace_of(update.message.chat_id, update, bot)
+
+ os.chdir(os.getcwd())
+ with open(
+ os.path.join(os.getcwd(),
+ 'bot/modules/temp.txt'),
+ 'w') as temp:
+ temp.write(body)
+
+ stdout = io.StringIO()
+
+ to_compile = f'def func():\n{textwrap.indent(body, " ")}'
+
+ try:
+ exec(to_compile, env)
+ except Exception as e:
+ return f'{e.__class__.__name__}: {e}'
+
+ func = env['func']
+
+ try:
+ with redirect_stdout(stdout):
+ func_return = func()
+ except Exception as e:
+ value = stdout.getvalue()
+ return f'{value}{traceback.format_exc()}'
+ else:
+ value = stdout.getvalue()
+ result = None
+ if func_return is None:
+ if value:
+ result = f'{value}'
+ else:
+ try:
+ result = f'{repr(eval(body, env))}'
+ except:
+ pass
+ else:
+ result = f'{value}{func_return}'
+ if result:
+ return result
+
+
+def clear(update, context):
+ bot = context.bot
+ log_input(update)
+ global namespaces
+ if update.message.chat_id in namespaces:
+ del namespaces[update.message.chat_id]
+ send("Cleared locals.", bot, update)
+
+
+def exechelp(update, context):
+ help_string = '''
+Executor
+• /eval Run Python Code Line | Lines
+• /exec Run Commands In Exec
+• /clearlocals Cleared locals
+'''
+ sendMessage(help_string, context.bot, update)
+
+
+EVAL_HANDLER = CommandHandler(('eval'), evaluate, filters=CustomFilters.owner_filter, run_async=True)
+EXEC_HANDLER = CommandHandler(('exec'), execute, filters=CustomFilters.owner_filter, run_async=True)
+CLEAR_HANDLER = CommandHandler('clearlocals', clear, filters=CustomFilters.owner_filter, run_async=True)
+EXECHELP_HANDLER = CommandHandler(BotCommands.ExecHelpCommand, exechelp, filters=CustomFilters.owner_filter, run_async=True)
+
+dispatcher.add_handler(EVAL_HANDLER)
+dispatcher.add_handler(EXEC_HANDLER)
+dispatcher.add_handler(CLEAR_HANDLER)
+dispatcher.add_handler(EXECHELP_HANDLER)
diff --git a/bot/modules/list.py b/bot/modules/list.py
new file mode 100644
index 0000000..a4b1e4b
--- /dev/null
+++ b/bot/modules/list.py
@@ -0,0 +1,57 @@
+from telegram.ext import CommandHandler
+from bot.helper.mirror_utils.upload_utils.gdriveTools import GoogleDriveHelper
+from bot import LOGGER, dispatcher
+from bot.helper.telegram_helper.message_utils import sendMessage, sendMarkup, editMessage
+from bot.helper.telegram_helper.filters import CustomFilters
+import threading
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot.helper.mirror_utils.upload_utils.gdtot_helper import GDTOT
+
+def list_drive(update, context):
+ try:
+ search = update.message.text.split(' ',maxsplit=1)[1]
+ LOGGER.info(f"Searching: {search}")
+ reply = sendMessage('Searching..... Please wait!', context.bot, update)
+ gdrive = GoogleDriveHelper(None)
+ msg, button = gdrive.drive_list(search)
+
+ if button:
+ editMessage(msg, reply, button)
+ else:
+ editMessage(f'No result found for {search}', reply, button)
+
+ except IndexError:
+ sendMessage('Send a search key along with command', context.bot, update)
+
+
+def gdtot(update, context):
+ try:
+ search = update.message.text.split(' ', 1)[1]
+ search_list = search.split(' ')
+ for glink in search_list:
+ LOGGER.info(f"Extracting gdtot link: {glink}")
+ button = None
+ reply = sendMessage('Getting Your GDTOT File Wait....', context.bot, update)
+ file_name, file_url = GDTOT().parse(url=glink)
+ if file_name == 404:
+ sendMessage(file_url, context.bot, update)
+ return
+ if file_url != 404:
+ gdrive = GoogleDriveHelper(None)
+ msg, button = gdrive.clone(file_url)
+ if button:
+ editMessage(msg, reply, button)
+ else:
+ editMessage(file_name, reply, button)
+ except IndexError:
+ sendMessage('Send cmd along with url', context.bot, update)
+ except Exception as e:
+ LOGGER.info(e)
+
+list_handler = CommandHandler(BotCommands.ListCommand, list_drive, filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+gdtot_handler = CommandHandler(BotCommands.GDTOTCommand, gdtot, filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+
+
+
+dispatcher.add_handler(list_handler)
+dispatcher.add_handler(gdtot_handler)
diff --git a/bot/modules/mirror.py b/bot/modules/mirror.py
new file mode 100644
index 0000000..83484f4
--- /dev/null
+++ b/bot/modules/mirror.py
@@ -0,0 +1,425 @@
+import requests
+from telegram.ext import CommandHandler
+from telegram import InlineKeyboardMarkup
+
+from bot import Interval, INDEX_URL, BUTTON_FOUR_NAME, BUTTON_FOUR_URL, BUTTON_FIVE_NAME, BUTTON_FIVE_URL, BUTTON_SIX_NAME, BUTTON_SIX_URL, BLOCK_MEGA_FOLDER, BLOCK_MEGA_LINKS, VIEW_LINK, aria2, get_client
+from bot import dispatcher, DOWNLOAD_DIR, download_dict, download_dict_lock, SHORTENER, SHORTENER_API, TAR_UNZIP_LIMIT
+from bot.helper.ext_utils import fs_utils, bot_utils
+from bot.helper.ext_utils.bot_utils import get_mega_link_type, check_limit
+from bot.helper.ext_utils.exceptions import DirectDownloadLinkException, NotSupportedExtractionArchive
+from bot.helper.mirror_utils.download_utils.aria2_download import AriaDownloadHelper
+from bot.helper.mirror_utils.download_utils.mega_downloader import MegaDownloadHelper
+from bot.helper.mirror_utils.download_utils.qbit_downloader import qbittorrent
+from bot.helper.mirror_utils.download_utils.direct_link_generator import direct_link_generator
+from bot.helper.mirror_utils.download_utils.telegram_downloader import TelegramDownloadHelper
+from bot.helper.mirror_utils.status_utils import listeners
+from bot.helper.mirror_utils.status_utils.extract_status import ExtractStatus
+from bot.helper.mirror_utils.status_utils.tar_status import TarStatus
+from bot.helper.mirror_utils.status_utils.upload_status import UploadStatus
+from bot.helper.mirror_utils.status_utils.gdownload_status import DownloadStatus
+from bot.helper.mirror_utils.upload_utils import gdriveTools
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot.helper.telegram_helper.filters import CustomFilters
+from bot.helper.telegram_helper.message_utils import *
+from bot.helper.telegram_helper import button_build
+import urllib
+import pathlib
+import os
+import subprocess
+import threading
+import re
+import random
+import string
+import time
+import shutil
+
+ariaDlManager = AriaDownloadHelper()
+ariaDlManager.start_listener()
+
+class MirrorListener(listeners.MirrorListeners):
+ def __init__(self, bot, update, pswd, isTar=False, extract=False, isZip=False, isQbit=False):
+ super().__init__(bot, update)
+ self.isTar = isTar
+ self.extract = extract
+ self.isZip = isZip
+ self.isQbit = isQbit
+ self.pswd = pswd
+
+ def onDownloadStarted(self):
+ pass
+
+ def onDownloadProgress(self):
+ # We are handling this on our own!
+ pass
+
+ def clean(self):
+ try:
+ aria2.purge()
+ get_client().torrents_delete(torrent_hashes="all", delete_files=True)
+ Interval[0].cancel()
+ del Interval[0]
+ delete_all_messages()
+ except IndexError:
+ pass
+ def onDownloadComplete(self):
+ with download_dict_lock:
+ LOGGER.info(f"Download completed: {download_dict[self.uid].name()}")
+ download = download_dict[self.uid]
+ name = f"{download.name()}".replace('/', '')
+ gid = download.gid()
+ size = download.size_raw()
+ if name == "None" or self.isQbit: # when pyrogram's media.file_name is of NoneType
+ name = os.listdir(f'{DOWNLOAD_DIR}{self.uid}')[0]
+ m_path = f'{DOWNLOAD_DIR}{self.uid}/{name}'
+ if self.isTar:
+ try:
+ with download_dict_lock:
+ download_dict[self.uid] = TarStatus(name, m_path, size)
+ if self.isZip:
+ path = fs_utils.zip(name, m_path)
+ else:
+ path = fs_utils.tar(m_path)
+ except FileNotFoundError:
+ LOGGER.info('File to archive not found!')
+ self.onUploadError('Internal error occurred!!')
+ return
+ try:
+ shutil.rmtree(m_path)
+ except:
+ os.remove(m_path)
+ elif self.extract:
+ try:
+ path = fs_utils.get_base_name(m_path)
+ LOGGER.info(f"Extracting: {name}")
+ with download_dict_lock:
+ download_dict[self.uid] = ExtractStatus(name, m_path, size)
+ pswd = self.pswd
+ if pswd is not None:
+ archive_result = subprocess.run(["pextract", m_path, pswd])
+ else:
+ archive_result = subprocess.run(["extract", m_path])
+ if archive_result.returncode == 0:
+ threading.Thread(target=os.remove, args=(m_path)).start()
+ LOGGER.info(f"Deleting archive: {m_path}")
+ else:
+ LOGGER.warning('Unable to extract archive! Uploading anyway')
+ path = f'{DOWNLOAD_DIR}{self.uid}/{name}'
+ LOGGER.info(f'got path: {path}')
+
+ except NotSupportedExtractionArchive:
+ LOGGER.info("Not any valid archive, uploading file as it is.")
+ path = f'{DOWNLOAD_DIR}{self.uid}/{name}'
+ else:
+ path = f'{DOWNLOAD_DIR}{self.uid}/{name}'
+ up_name = pathlib.PurePath(path).name
+ up_path = f'{DOWNLOAD_DIR}{self.uid}/{up_name}'
+ LOGGER.info(f"Upload Name: {up_name}")
+ drive = gdriveTools.GoogleDriveHelper(up_name, self)
+ size = fs_utils.get_path_size(up_path)
+ upload_status = UploadStatus(drive, size, gid, self)
+ with download_dict_lock:
+ download_dict[self.uid] = upload_status
+ update_all_messages()
+ drive.upload(up_name)
+
+ def onDownloadError(self, error):
+ error = error.replace('<', ' ')
+ error = error.replace('>', ' ')
+ with download_dict_lock:
+ try:
+ download = download_dict[self.uid]
+ del download_dict[self.uid]
+ fs_utils.clean_download(download.path())
+ except Exception as e:
+ LOGGER.error(str(e))
+ pass
+ count = len(download_dict)
+ if self.message.from_user.username:
+ uname = f"@{self.message.from_user.username}"
+ else:
+ uname = f'{self.message.from_user.first_name}'
+ msg = f"{uname} your download has been stopped due to: {error}"
+ sendMessage(msg, self.bot, self.update)
+ if count == 0:
+ self.clean()
+ else:
+ update_all_messages()
+
+ def onUploadStarted(self):
+ pass
+
+ def onUploadProgress(self):
+ pass
+
+ def onUploadComplete(self, link: str, size, files, folders, typ):
+ with download_dict_lock:
+ msg = f'☞ 📂Filename : {download_dict[self.uid].name()}\n☞ 📦Size : {size}'
+ if os.path.isdir(f'{DOWNLOAD_DIR}/{self.uid}/{download_dict[self.uid].name()}'):
+ msg += '\n☞ 🌀Type : Folder'
+ msg += f'\n☞ 🗳Powerd by : @AT_BOTs'
+ else:
+ msg += f'\n☞ 🗳Powerd by : @AT_BOTs'
+ buttons = button_build.ButtonMaker()
+ if SHORTENER is not None and SHORTENER_API is not None:
+ surl = requests.get(f'https://{SHORTENER}/api?api={SHORTENER_API}&url={link}&format=text').text
+ buttons.buildbutton("🌠 Drive Link 🌠", surl)
+ else:
+ buttons.buildbutton("🌠 Drive Link 🌠", link)
+ LOGGER.info(f'Done Uploading {download_dict[self.uid].name()}')
+ if INDEX_URL is not None:
+ url_path = requests.utils.quote(f'{download_dict[self.uid].name()}')
+ share_url = f'{INDEX_URL}/{url_path}'
+ if os.path.isdir(f'{DOWNLOAD_DIR}/{self.uid}/{download_dict[self.uid].name()}'):
+ share_url += '/'
+ if SHORTENER is not None and SHORTENER_API is not None:
+ siurl = requests.get(f'https://{SHORTENER}/api?api={SHORTENER_API}&url={share_url}&format=text').text
+ buttons.buildbutton("☄️ Index Link ☄️", siurl)
+ else:
+ buttons.buildbutton("☄️ Index Link ☄️", share_url)
+ else:
+ share_urls = f'{INDEX_URL}/{url_path}?a=view'
+ if SHORTENER is not None and SHORTENER_API is not None:
+ siurl = requests.get(f'https://{SHORTENER}/api?api={SHORTENER_API}&url={share_url}&format=text').text
+ siurls = requests.get(f'https://{SHORTENER}/api?api={SHORTENER_API}&url={share_urls}&format=text').text
+ buttons.buildbutton("☄️ Index Link ☄️", siurl)
+ if VIEW_LINK:
+ buttons.buildbutton(" View Link", siurls)
+ else:
+ buttons.buildbutton("☄️ Index Link ☄️", share_url)
+ if VIEW_LINK:
+ buttons.buildbutton(" View Link", share_urls)
+ if BUTTON_FOUR_NAME is not None and BUTTON_FOUR_URL is not None:
+ buttons.buildbutton(f"{BUTTON_FOUR_NAME}", f"{BUTTON_FOUR_URL}")
+ if BUTTON_FIVE_NAME is not None and BUTTON_FIVE_URL is not None:
+ buttons.buildbutton(f"{BUTTON_FIVE_NAME}", f"{BUTTON_FIVE_URL}")
+ if BUTTON_SIX_NAME is not None and BUTTON_SIX_URL is not None:
+ buttons.buildbutton(f"{BUTTON_SIX_NAME}", f"{BUTTON_SIX_URL}")
+ if self.message.from_user.username:
+ uname = f"@{self.message.from_user.username}"
+ else:
+ uname = f'{self.message.from_user.first_name}'
+ if uname is not None:
+ msg += f'\n\ncc: {uname}'
+ try:
+ fs_utils.clean_download(download_dict[self.uid].path())
+ except FileNotFoundError:
+ pass
+ del download_dict[self.uid]
+ count = len(download_dict)
+ sendMarkup(msg, self.bot, self.update, InlineKeyboardMarkup(buttons.build_menu(2)))
+ if count == 0:
+ self.clean()
+ else:
+ update_all_messages()
+
+ def onUploadError(self, error):
+ e_str = error.replace('<', '').replace('>', '')
+ with download_dict_lock:
+ try:
+ fs_utils.clean_download(download_dict[self.uid].path())
+ except FileNotFoundError:
+ pass
+ del download_dict[self.message.message_id]
+ count = len(download_dict)
+ if self.message.from_user.username:
+ uname = f"@{self.message.from_user.username}"
+ else:
+ uname = f'{self.message.from_user.first_name}'
+ if uname is not None:
+ men = f'{uname} '
+ sendMessage(men + e_str, self.bot, self.update)
+ if count == 0:
+ self.clean()
+ else:
+ update_all_messages()
+
+def _mirror(bot, update, isTar=False, extract=False, isZip=False, isQbit=False):
+ mesg = update.message.text.split('\n')
+ message_args = mesg[0].split(' ')
+ name_args = mesg[0].split('|')
+ qbitsel = False
+ try:
+ link = message_args[1]
+ if link == "qb" or link == "qbs":
+ isQbit = True
+ if link == "qbs":
+ qbitsel = True
+ link = message_args[2]
+ elif (
+ not bot_utils.is_url(link)
+ and not bot_utils.is_magnet(link)
+ or len(link) == 0
+ ) and file is None:
+ reply_text = reply_to.text
+ reply_text = re.split('\n ', reply_text)[0]
+ if bot_utils.is_url(reply_text) or bot_utils.is_magnet(reply_text):
+ link = reply_text
+
+ elif bot_utils.is_url(link) and not bot_utils.is_magnet(link) and not os.path.exists(link) and isQbit:
+ resp = requests.get(link)
+ if resp.status_code == 200:
+ file_name = str(time.time()).replace(".", "") + ".torrent"
+ open(file_name, "wb").write(resp.content)
+ link = f"{file_name}"
+ else:
+ sendMessage("ERROR: link got HTTP response:" + resp.status_code, bot, update)
+ return
+ if link.startswith("|") or link.startswith("pswd: "):
+ link = ''
+ except IndexError:
+ link = ''
+ try:
+ name = name_args[1]
+ name = name.strip()
+ if name.startswith("pswd: "):
+ name = ''
+ except IndexError:
+ name = ''
+ try:
+ ussr = urllib.parse.quote(mesg[1], safe='')
+ pssw = urllib.parse.quote(mesg[2], safe='')
+ except:
+ ussr = ''
+ pssw = ''
+ if ussr != '' and pssw != '':
+ link = link.split("://", maxsplit=1)
+ link = f'{link[0]}://{ussr}:{pssw}@{link[1]}'
+ pswd = re.search('(?<=pswd: )(.*)', update.message.text)
+ if pswd is not None:
+ pswd = pswd.groups()
+ pswd = " ".join(pswd)
+ if link != '':
+ LOGGER.info(link)
+ link = link.strip()
+ reply_to = update.message.reply_to_message
+ if reply_to is not None:
+ file = None
+ media_array = [reply_to.document, reply_to.video, reply_to.audio]
+ for i in media_array:
+ if i is not None:
+ file = i
+ break
+
+ if (
+ not bot_utils.is_url(link)
+ and not bot_utils.is_magnet(link)
+ or len(link) == 0
+ ):
+ if file is None:
+ reply_text = reply_to.text
+ reply_text = re.split('\n ', reply_text)[0]
+ if bot_utils.is_url(reply_text) or bot_utils.is_magnet(reply_text):
+ link = reply_text
+
+ if not bot_utils.is_url(link) and not bot_utils.is_magnet(link) or len(link) == 0:
+ if file is not None:
+ if file.mime_type != "application/x-bittorrent":
+ listener = MirrorListener(bot, update, pswd, isTar, extract, isZip)
+ tg_downloader = TelegramDownloadHelper(listener)
+ ms = update.message
+ tg_downloader.add_download(ms, f'{DOWNLOAD_DIR}{listener.uid}/', name)
+ return
+ else:
+ if isQbit:
+ file.get_file().download(custom_path=f"/usr/src/app/{file.file_name}")
+ link = f"/usr/src/app/{file.file_name}"
+ else:
+ link = file.get_file().file_path
+
+ if bot_utils.is_url(link) and not bot_utils.is_magnet(link) and not os.path.exists(link) and isQbit:
+ resp = requests.get(link)
+ if resp.status_code == 200:
+ file_name = str(time.time()).replace(".", "") + ".torrent"
+ open(file_name, "wb").write(resp.content)
+ link = f"{file_name}"
+ else:
+ sendMessage("ERROR: link got HTTP response:" + resp.status_code, bot, update)
+ return
+
+
+
+ elif not bot_utils.is_url(link) and not bot_utils.is_magnet(link):
+ sendMessage('No download source provided', bot, update)
+ return
+ elif not os.path.exists(link) and not bot_utils.is_mega_link(link) and not bot_utils.is_gdrive_link(link) and not bot_utils.is_magnet(link):
+ try:
+ link = direct_link_generator(link)
+ except DirectDownloadLinkException as e:
+ LOGGER.info(e)
+ if "ERROR:" in str(e):
+ sendMessage(f"{e}", bot, update)
+ return
+ if "Youtube" in str(e):
+ sendMessage(f"{e}", bot, update)
+ return
+
+ listener = MirrorListener(bot, update, pswd, isTar, extract, isZip, isQbit)
+
+ if bot_utils.is_gdrive_link(link):
+ if not isTar and not extract:
+ sendMessage(f"Use /{BotCommands.CloneCommand} to clone Google Drive file/folder\nUse /{BotCommands.TarMirrorCommand} to make tar of Google Drive folder\nUse /{BotCommands.UnzipMirrorCommand} to extracts archive Google Drive file", bot, update)
+ return
+ res, size, name, files = gdriveTools.GoogleDriveHelper().clonehelper(link)
+ if res != "":
+ sendMessage(res, bot, update)
+ return
+ if TAR_UNZIP_LIMIT is not None:
+ result = check_limit(size, TAR_UNZIP_LIMIT)
+ if result:
+ msg = f'Failed, Tar/Unzip limit is {TAR_UNZIP_LIMIT}.\nYour File/Folder size is {get_readable_file_size(size)}.'
+ sendMessage(msg, listener.bot, listener.update)
+ return
+ LOGGER.info(f"Download Name : {name}")
+ drive = gdriveTools.GoogleDriveHelper(name, listener)
+ gid = ''.join(random.SystemRandom().choices(string.ascii_letters + string.digits, k=12))
+ download_status = DownloadStatus(drive, size, listener, gid)
+ with download_dict_lock:
+ download_dict[listener.uid] = download_status
+ sendStatusMessage(update, bot)
+ drive.download(link)
+
+ elif bot_utils.is_mega_link(link):
+ link_type = get_mega_link_type(link)
+ if link_type == "folder" and BLOCK_MEGA_FOLDER:
+ sendMessage("Mega folder are blocked!", bot, update)
+ elif BLOCK_MEGA_LINKS:
+ sendMessage("Mega links are blocked!", bot, update)
+ else:
+ mega_dl = MegaDownloadHelper()
+ mega_dl.add_download(link, f'{DOWNLOAD_DIR}{listener.uid}/', listener)
+
+ elif isQbit and (bot_utils.is_magnet(link) or os.path.exists(link)):
+ qbit = qbittorrent()
+ qbit.add_torrent(link, f'{DOWNLOAD_DIR}{listener.uid}/', listener, qbitsel)
+
+ else:
+ ariaDlManager.add_download(link, f'{DOWNLOAD_DIR}{listener.uid}/', listener, name)
+ sendStatusMessage(update, bot)
+
+
+def mirror(update, context):
+ _mirror(context.bot, update)
+
+
+def tar_mirror(update, context):
+ _mirror(context.bot, update, True)
+
+
+def unzip_mirror(update, context):
+ _mirror(context.bot, update, extract=True)
+
+def zip_mirror(update, context):
+ _mirror(context.bot, update, True, isZip=True)
+
+mirror_handler = CommandHandler(BotCommands.MirrorCommand, mirror,
+ filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+tar_mirror_handler = CommandHandler(BotCommands.TarMirrorCommand, tar_mirror,
+ filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+unzip_mirror_handler = CommandHandler(BotCommands.UnzipMirrorCommand, unzip_mirror,
+ filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+zip_mirror_handler = CommandHandler(BotCommands.ZipMirrorCommand, zip_mirror,
+ filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+dispatcher.add_handler(mirror_handler)
+dispatcher.add_handler(tar_mirror_handler)
+dispatcher.add_handler(unzip_mirror_handler)
+dispatcher.add_handler(zip_mirror_handler)
diff --git a/bot/modules/mirror_status.py b/bot/modules/mirror_status.py
new file mode 100644
index 0000000..ee5aa97
--- /dev/null
+++ b/bot/modules/mirror_status.py
@@ -0,0 +1,28 @@
+from telegram.ext import CommandHandler
+from bot import dispatcher, status_reply_dict, status_reply_dict_lock, download_dict, download_dict_lock
+from bot.helper.telegram_helper.message_utils import *
+from telegram.error import BadRequest
+from bot.helper.telegram_helper.filters import CustomFilters
+from bot.helper.telegram_helper.bot_commands import BotCommands
+import threading
+
+
+def mirror_status(update, context):
+ with download_dict_lock:
+ if len(download_dict) == 0:
+ message = "No active downloads"
+ reply_message = sendMessage(message, context.bot, update)
+ threading.Thread(target=auto_delete_message, args=(bot, update.message, reply_message)).start()
+ return
+ index = update.effective_chat.id
+ with status_reply_dict_lock:
+ if index in status_reply_dict.keys():
+ deleteMessage(bot, status_reply_dict[index])
+ del status_reply_dict[index]
+ sendStatusMessage(update, context.bot)
+ deleteMessage(context.bot, update.message)
+
+
+mirror_status_handler = CommandHandler(BotCommands.StatusCommand, mirror_status,
+ filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+dispatcher.add_handler(mirror_status_handler)
diff --git a/bot/modules/shell.py b/bot/modules/shell.py
new file mode 100644
index 0000000..38364b3
--- /dev/null
+++ b/bot/modules/shell.py
@@ -0,0 +1,43 @@
+import subprocess
+from bot import LOGGER, dispatcher
+from telegram import ParseMode
+from telegram.ext import CommandHandler
+from bot.helper.telegram_helper.filters import CustomFilters
+from bot.helper.telegram_helper.bot_commands import BotCommands
+
+
+def shell(update, context):
+ message = update.effective_message
+ cmd = message.text.split(' ', 1)
+ if len(cmd) == 1:
+ message.reply_text('No command to execute was given.')
+ return
+ cmd = cmd[1]
+ process = subprocess.Popen(
+ cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
+ stdout, stderr = process.communicate()
+ reply = ''
+ stderr = stderr.decode()
+ stdout = stdout.decode()
+ if stdout:
+ reply += f"*Stdout*\n`{stdout}`\n"
+ LOGGER.info(f"Shell - {cmd} - {stdout}")
+ if stderr:
+ reply += f"*Stderr*\n`{stderr}`\n"
+ LOGGER.error(f"Shell - {cmd} - {stderr}")
+ if len(reply) > 3000:
+ with open('shell_output.txt', 'w') as file:
+ file.write(reply)
+ with open('shell_output.txt', 'rb') as doc:
+ context.bot.send_document(
+ document=doc,
+ filename=doc.name,
+ reply_to_message_id=message.message_id,
+ chat_id=message.chat_id)
+ else:
+ message.reply_text(reply, parse_mode=ParseMode.MARKDOWN)
+
+
+SHELL_HANDLER = CommandHandler(BotCommands.ShellCommand, shell,
+ filters=CustomFilters.owner_filter, run_async=True)
+dispatcher.add_handler(SHELL_HANDLER)
diff --git a/bot/modules/speedtest.py b/bot/modules/speedtest.py
new file mode 100644
index 0000000..4df260a
--- /dev/null
+++ b/bot/modules/speedtest.py
@@ -0,0 +1,46 @@
+from speedtest import Speedtest
+from bot.helper.telegram_helper.filters import CustomFilters
+from bot import dispatcher
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot.helper.telegram_helper.message_utils import sendMessage, editMessage
+from telegram.ext import CommandHandler
+
+
+def speedtest(update, context):
+ speed = sendMessage("Running Speed Test . . . ", context.bot, update)
+ test = Speedtest()
+ test.get_best_server()
+ test.download()
+ test.upload()
+ test.results.share()
+ result = test.results.dict()
+ string_speed = f'''
+Server
+Name: {result['server']['name']}
+Country: {result['server']['country']}, {result['server']['cc']}
+Sponsor: {result['server']['sponsor']}
+ISP: {result['client']['isp']}
+SpeedTest Results
+Upload: {speed_convert(result['upload'] / 8)}
+Download: {speed_convert(result['download'] / 8)}
+Ping: {result['ping']} ms
+ISP Rating: {result['client']['isprating']}
+'''
+ editMessage(string_speed, speed)
+
+
+def speed_convert(size):
+ """Hi human, you can't read bytes?"""
+ power = 2 ** 10
+ zero = 0
+ units = {0: "", 1: "Kb/s", 2: "MB/s", 3: "Gb/s", 4: "Tb/s"}
+ while size > power:
+ size /= power
+ zero += 1
+ return f"{round(size, 2)} {units[zero]}"
+
+
+SPEED_HANDLER = CommandHandler(BotCommands.SpeedCommand, speedtest,
+ filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+
+dispatcher.add_handler(SPEED_HANDLER)
diff --git a/bot/modules/torrent_search.py b/bot/modules/torrent_search.py
new file mode 100644
index 0000000..048f93c
--- /dev/null
+++ b/bot/modules/torrent_search.py
@@ -0,0 +1,339 @@
+import os
+import time
+import html
+import asyncio
+import aiohttp
+import json
+import feedparser
+import requests
+import itertools
+
+from telegram.ext import CommandHandler
+from telegram import ParseMode
+
+from urllib.parse import quote as urlencode, urlsplit
+
+from pyrogram import Client, filters, emoji
+from pyrogram.parser import html as pyrogram_html
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from pyrogram.handlers import MessageHandler, CallbackQueryHandler
+
+from bot import app, dispatcher, bot
+from bot.helper import custom_filters
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot.helper.telegram_helper.filters import CustomFilters
+from bot.helper.telegram_helper.message_utils import sendMessage
+
+search_lock = asyncio.Lock()
+search_info = {False: dict(), True: dict()}
+
+async def return_search(query, page=1, sukebei=False):
+ page -= 1
+ query = query.lower().strip()
+ used_search_info = search_info[sukebei]
+ async with search_lock:
+ results, get_time = used_search_info.get(query, (None, 0))
+ if (time.time() - get_time) > 3600:
+ results = []
+ async with aiohttp.ClientSession() as session:
+ async with session.get(f'https://{"sukebei." if sukebei else ""}nyaa.si/?page=rss&q={urlencode(query)}') as resp:
+ d = feedparser.parse(await resp.text())
+ text = ''
+ a = 0
+ parser = pyrogram_html.HTML(None)
+ for i in sorted(d['entries'], key=lambda i: int(i['nyaa_seeders']), reverse=True):
+ if i['nyaa_size'].startswith('0'):
+ continue
+ if not int(i['nyaa_seeders']):
+ break
+ link = i['link']
+ splitted = urlsplit(link)
+ if splitted.scheme == 'magnet' and splitted.query:
+ link = f'{link}'
+ newtext = f'''{a + 1}. {html.escape(i["title"])}
+Link: {link}
+Size: {i["nyaa_size"]}
+Seeders: {i["nyaa_seeders"]}
+Leechers: {i["nyaa_leechers"]}
+Category: {i["nyaa_category"]}\n\n'''
+ futtext = text + newtext
+ if (a and not a % 10) or len((await parser.parse(futtext))['message']) > 4096:
+ results.append(text)
+ futtext = newtext
+ text = futtext
+ a += 1
+ results.append(text)
+ ttl = time.time()
+ used_search_info[query] = results, ttl
+ try:
+ return results[page], len(results), ttl
+ except IndexError:
+ return '', len(results), ttl
+
+message_info = dict()
+ignore = set()
+
+@app.on_message(filters.command(['nyaasi', f'nyaasi@{bot.username}']))
+async def nyaa_search(client, message):
+ text = message.text.split(' ')
+ text.pop(0)
+ query = ' '.join(text)
+ await init_search(client, message, query, False)
+
+@app.on_message(filters.command(['sukebei', f'sukebei@{bot.username}']))
+async def nyaa_search_sukebei(client, message):
+ text = message.text.split(' ')
+ text.pop(0)
+ query = ' '.join(text)
+ await init_search(client, message, query, True)
+
+async def init_search(client, message, query, sukebei):
+ result, pages, ttl = await return_search(query, sukebei=sukebei)
+ if not result:
+ await message.reply_text('No results found')
+ else:
+ buttons = [InlineKeyboardButton(f'1/{pages}', 'nyaa_nop'), InlineKeyboardButton(f'Next', 'nyaa_next')]
+ if pages == 1:
+ buttons.pop()
+ reply = await message.reply_text(result, reply_markup=InlineKeyboardMarkup([
+ buttons
+ ]))
+ message_info[(reply.chat.id, reply.message_id)] = message.from_user.id, ttl, query, 1, pages, sukebei
+
+@app.on_callback_query(custom_filters.callback_data('nyaa_nop'))
+async def nyaa_nop(client, callback_query):
+ await callback_query.answer(cache_time=3600)
+
+callback_lock = asyncio.Lock()
+@app.on_callback_query(custom_filters.callback_data(['nyaa_back', 'nyaa_next']))
+async def nyaa_callback(client, callback_query):
+ message = callback_query.message
+ message_identifier = (message.chat.id, message.message_id)
+ data = callback_query.data
+ async with callback_lock:
+ if message_identifier in ignore:
+ await callback_query.answer()
+ return
+ user_id, ttl, query, current_page, pages, sukebei = message_info.get(message_identifier, (None, 0, None, 0, 0, None))
+ og_current_page = current_page
+ if data == 'nyaa_back':
+ current_page -= 1
+ elif data == 'nyaa_next':
+ current_page += 1
+ if current_page < 1:
+ current_page = 1
+ elif current_page > pages:
+ current_page = pages
+ ttl_ended = (time.time() - ttl) > 3600
+ if ttl_ended:
+ text = getattr(message.text, 'html', 'Search expired')
+ else:
+ if callback_query.from_user.id != user_id:
+ await callback_query.answer('...no', cache_time=3600)
+ return
+ text, pages, ttl = await return_search(query, current_page, sukebei)
+ buttons = [InlineKeyboardButton(f'Prev', 'nyaa_back'), InlineKeyboardButton(f'{current_page}/{pages}', 'nyaa_nop'), InlineKeyboardButton(f'Next', 'nyaa_next')]
+ if ttl_ended:
+ buttons = [InlineKeyboardButton('Search Expired', 'nyaa_nop')]
+ else:
+ if current_page == 1:
+ buttons.pop(0)
+ if current_page == pages:
+ buttons.pop()
+ if ttl_ended or current_page != og_current_page:
+ await callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup([
+ buttons
+ ]))
+ message_info[message_identifier] = user_id, ttl, query, current_page, pages, sukebei
+ if ttl_ended:
+ ignore.add(message_identifier)
+ await callback_query.answer()
+
+# Using upstream API based on: https://github.com/Ryuk-me/Torrents-Api
+# Implemented by https://github.com/jusidama18
+
+class TorrentSearch:
+ index = 0
+ query = None
+ message = None
+ response = None
+ response_range = None
+
+ RESULT_LIMIT = 4
+ RESULT_STR = None
+
+ def __init__(self, command: str, source: str, result_str: str):
+ self.command = command
+ self.source = source.rstrip('/')
+ self.RESULT_STR = result_str
+
+ app.add_handler(MessageHandler(self.find, filters.command([command, f'{self.command}@{bot.username}'])))
+ app.add_handler(CallbackQueryHandler(self.previous, filters.regex(f"{self.command}_previous")))
+ app.add_handler(CallbackQueryHandler(self.delete, filters.regex(f"{self.command}_delete")))
+ app.add_handler(CallbackQueryHandler(self.next, filters.regex(f"{self.command}_next")))
+
+ @staticmethod
+ def format_magnet(string: str):
+ if not string:
+ return ""
+ return string.split('&tr', 1)[0]
+
+ def get_formatted_string(self, values):
+ string = self.RESULT_STR.format(**values)
+ extra = ""
+ if "Files" in values:
+ tmp_str = "➲[{Quality} - {Type} ({Size})]({Torrent}): `{magnet}`"
+ extra += "\n".join(
+ tmp_str.format(**f, magnet=self.format_magnet(f['Magnet']))
+ for f in values['Files']
+ )
+ else:
+ magnet = values.get('magnet', values.get('Magnet')) # Avoid updating source dict
+ if magnet:
+ extra += f"➲Magnet: `{self.format_magnet(magnet)}`"
+ if (extra):
+ string += "\n" + extra
+ return string
+
+ async def update_message(self):
+ prevBtn = InlineKeyboardButton(f"Prev", callback_data=f"{self.command}_previous")
+ delBtn = InlineKeyboardButton(f"{emoji.CROSS_MARK}", callback_data=f"{self.command}_delete")
+ nextBtn = InlineKeyboardButton(f"Next", callback_data=f"{self.command}_next")
+
+ inline = []
+ if (self.index != 0):
+ inline.append(prevBtn)
+ inline.append(delBtn)
+ if (self.index != len(self.response_range) - 1):
+ inline.append(nextBtn)
+
+ res_lim = min(self.RESULT_LIMIT, len(self.response) - self.RESULT_LIMIT*self.index)
+ result = f"**Page - {self.index+1}**\n\n"
+ result += "\n\n=======================\n\n".join(
+ self.get_formatted_string(self.response[self.response_range[self.index]+i])
+ for i in range(res_lim)
+ )
+
+ await self.message.edit(
+ result,
+ reply_markup=InlineKeyboardMarkup([inline]),
+ parse_mode="markdown",
+ )
+
+ async def find(self, client, message):
+ if len(message.command) < 2:
+ await message.reply_text(f"Usage: /{self.command} query")
+ return
+
+ query = urlencode(message.text.split(None, 1)[1])
+ self.message = await message.reply_text("Searching")
+ try:
+ async with aiohttp.ClientSession() as session:
+ async with session.get(f"{self.source}/{query}") as resp:
+ if (resp.status != 200):
+ raise Exception('unsuccessful request')
+ result = await resp.json()
+ if (result and isinstance(result[0], list)):
+ result = list(itertools.chain(*result))
+ self.response = result
+ self.response_range = range(0, len(self.response), self.RESULT_LIMIT)
+ except:
+ await self.message.edit("No Results Found.")
+ return
+ await self.update_message()
+
+ async def delete(self, client, message):
+ index = 0
+ query = None
+ message = None
+ response = None
+ response_range = None
+ await self.message.delete()
+
+ async def previous(self, client, message):
+ self.index -= 1
+ await self.update_message()
+
+ async def next(self, client, message):
+ self.index += 1
+ await self.update_message()
+
+RESULT_STR_1337 = (
+ "➲Name: `{Name}`\n"
+ "➲Size: {Size}\n"
+ "➲Seeders: {Seeders} || ➲Leechers: {Leechers}"
+)
+RESULT_STR_PIRATEBAY = (
+ "➲Name: `{Name}`\n"
+ "➲Size: {Size}\n"
+ "➲Seeders: {Seeders} || ➲Leechers: {Leechers}"
+)
+RESULT_STR_TGX = (
+ "➲Name: `{Name}`\n"
+ "➲Size: {Size}\n"
+ "➲Seeders: {Seeders} || ➲Leechers: {Leechers}"
+)
+RESULT_STR_YTS = (
+ "➲Name: `{Name}`\n"
+ "➲Released on: {ReleasedDate}\n"
+ "➲Genre: {Genre}\n"
+ "➲Rating: {Rating}\n"
+ "➲Likes: {Likes}\n"
+ "➲Duration: {Runtime}\n"
+ "➲Language: {Language}"
+)
+RESULT_STR_EZTV = (
+ "➲Name: `{Name}`\n"
+ "➲Size: {Size}\n"
+ "➲Seeders: {Seeders}"
+)
+RESULT_STR_TORLOCK = (
+ "➲Name: `{Name}`\n"
+ "➲Size: {Size}\n"
+ "➲Seeders: {Seeders} || ➲Leechers: {Leechers}"
+)
+RESULT_STR_RARBG = (
+ "➲Name: `{Name}`\n"
+ "➲Size: {Size}\n"
+ "➲Seeders: {Seeders} || ➲Leechers: {Leechers}"
+)
+RESULT_STR_ALL = (
+ "➲Name: `{Name}`\n"
+ "➲Size: {Size}\n"
+ "➲Seeders: {Seeders} || ➲Leechers: {Leechers}"
+)
+
+torrents_dict = {
+ '1337x': {'source': "https://torrenter-api.herokuapp.com/api/1337x/", 'result_str': RESULT_STR_1337},
+ 'piratebay': {'source': "https://torrenter-api.herokuapp.com/api/piratebay/", 'result_str': RESULT_STR_PIRATEBAY},
+ 'tgx': {'source': "https://torrenter-api.herokuapp.com/api/tgx/", 'result_str': RESULT_STR_TGX},
+ 'yts': {'source': "https://torrenter-api.herokuapp.com/api/yts/", 'result_str': RESULT_STR_YTS},
+ 'eztv': {'source': "https://torrenter-api.herokuapp.com/api/eztv/", 'result_str': RESULT_STR_EZTV},
+ 'torlock': {'source': "https://torrenter-api.herokuapp.com/api/torlock/", 'result_str': RESULT_STR_TORLOCK},
+ 'rarbg': {'source': "https://torrenter-api.herokuapp.com/api/rarbg/", 'result_str': RESULT_STR_RARBG},
+ 'ts': {'source': "https://torrenter-api.herokuapp.com/api/all/", 'result_str': RESULT_STR_ALL}
+}
+
+torrent_handlers = []
+for command, value in torrents_dict.items():
+ torrent_handlers.append(TorrentSearch(command, value['source'], value['result_str']))
+
+def searchhelp(update, context):
+ help_string = '''
+Torrent Search
+• /nyaasi [search query]
+• /sukebei [search query]
+• /1337x [search query]
+• /piratebay [search query]
+• /tgx [search query]
+• /yts [search query]
+• /eztv [search query]
+• /torlock [search query]
+• /rarbg [search query]
+• /ts [search query]
+'''
+ sendMessage(help_string, context.bot, update)
+
+
+SEARCHHELP_HANDLER = CommandHandler(BotCommands.TsHelpCommand, searchhelp, filters=(CustomFilters.authorized_chat | CustomFilters.authorized_user) & CustomFilters.mirror_owner_filter, run_async=True)
+dispatcher.add_handler(SEARCHHELP_HANDLER)
diff --git a/bot/modules/updates.py b/bot/modules/updates.py
new file mode 100644
index 0000000..79f67ad
--- /dev/null
+++ b/bot/modules/updates.py
@@ -0,0 +1,83 @@
+# Implement By https://github.com/jusidama18
+# Based on this https://github.com/DevsExpo/FridayUserbot/blob/master/plugins/updater.py
+
+import sys
+import subprocess
+import heroku3
+
+from datetime import datetime
+from os import environ, execle, path, remove
+
+from git import Repo
+from git.exc import GitCommandError, InvalidGitRepositoryError, NoSuchPathError
+
+from pyrogram import filters
+
+from bot import app, OWNER_ID, UPSTREAM_REPO, UPSTREAM_BRANCH, bot
+from bot.helper import get_text, HEROKU_URL
+from bot.helper.telegram_helper.bot_commands import BotCommands
+
+REPO_ = UPSTREAM_REPO
+BRANCH_ = UPSTREAM_BRANCH
+
+
+# Update Command
+
+@app.on_message(filters.command([BotCommands.UpdateCommand, f'{BotCommands.UpdateCommand}@{bot.username}']) & filters.user(OWNER_ID))
+async def update_it(client, message):
+ msg_ = await message.reply_text("`Updating Please Wait!`")
+ try:
+ repo = Repo()
+ except GitCommandError:
+ return await msg_.edit(
+ "**Invalid Git Command. Please Report This Bug To [Support Group](https://t.me/SlamMirrorSupport)**"
+ )
+ except InvalidGitRepositoryError:
+ repo = Repo.init()
+ if "upstream" in repo.remotes:
+ origin = repo.remote("upstream")
+ else:
+ origin = repo.create_remote("upstream", REPO_)
+ origin.fetch()
+ repo.create_head(UPSTREAM_BRANCH, origin.refs.master)
+ repo.heads.master.set_tracking_branch(origin.refs.master)
+ repo.heads.master.checkout(True)
+ if repo.active_branch.name != UPSTREAM_BRANCH:
+ return await msg_.edit(
+ f"`Seems Like You Are Using Custom Branch - {repo.active_branch.name}! Please Switch To {UPSTREAM_BRANCH} To Make This Updater Function!`"
+ )
+ try:
+ repo.create_remote("upstream", REPO_)
+ except BaseException:
+ pass
+ ups_rem = repo.remote("upstream")
+ ups_rem.fetch(UPSTREAM_BRANCH)
+ if not HEROKU_URL:
+ try:
+ ups_rem.pull(UPSTREAM_BRANCH)
+ except GitCommandError:
+ repo.git.reset("--hard", "FETCH_HEAD")
+ subprocess.run(["pip3", "install", "--no-cache-dir", "-r", "requirements.txt"])
+ await msg_.edit("`Updated Sucessfully! Give Me Some Time To Restart!`")
+ with open("./aria.sh", 'rb') as file:
+ script = file.read()
+ subprocess.call("./aria.sh", shell=True)
+ args = [sys.executable, "-m", "bot"]
+ execle(sys.executable, *args, environ)
+ exit()
+ return
+ else:
+ await msg_.edit("`Heroku Detected! Pushing, Please wait!`")
+ ups_rem.fetch(UPSTREAM_BRANCH)
+ repo.git.reset("--hard", "FETCH_HEAD")
+ if "heroku" in repo.remotes:
+ remote = repo.remote("heroku")
+ remote.set_url(HEROKU_URL)
+ else:
+ remote = repo.create_remote("heroku", HEROKU_URL)
+ try:
+ remote.push(refspec="HEAD:refs/heads/master", force=True)
+ except BaseException as error:
+ await msg_.edit(f"**Updater Error** \nTraceBack : `{error}`")
+ return repo.__del__()
+ await msg_.edit(f"`Updated Sucessfully! \n\nCheck your config with` `/{BotCommands.ConfigMenuCommand}`")
diff --git a/bot/modules/watch.py b/bot/modules/watch.py
new file mode 100644
index 0000000..f9967f5
--- /dev/null
+++ b/bot/modules/watch.py
@@ -0,0 +1,68 @@
+from telegram.ext import CommandHandler
+from telegram import Bot, Update
+from bot import DOWNLOAD_DIR, dispatcher, LOGGER
+from bot.helper.telegram_helper.message_utils import sendMessage, sendStatusMessage
+from .mirror import MirrorListener
+from bot.helper.mirror_utils.download_utils.youtube_dl_download_helper import YoutubeDLHelper
+from bot.helper.telegram_helper.bot_commands import BotCommands
+from bot.helper.telegram_helper.filters import CustomFilters
+import threading
+
+
+def _watch(bot: Bot, update, isTar=False):
+ mssg = update.message.text
+ message_args = mssg.split(' ')
+ name_args = mssg.split('|')
+
+ try:
+ link = message_args[1]
+ except IndexError:
+ msg = f"/{BotCommands.WatchCommand} [youtube-dl supported link] [quality] |[CustomName] to mirror with youtube-dl.\n\n"
+ msg += "Note: Quality and custom name are optional\n\nExample of quality: audio, 144, 240, 360, 480, 720, 1080, 2160."
+ msg += "\n\nIf you want to use custom filename, enter it after |"
+ msg += f"\n\nExample:\n/{BotCommands.WatchCommand} https://youtu.be/Pk_TthHfLeE 720 |Slam\n\n"
+ msg += "This file will be downloaded in 720p quality and it's name will be Slam"
+ sendMessage(msg, bot, update)
+ return
+
+ try:
+ if "|" in mssg:
+ mssg = mssg.split("|")
+ qual = mssg[0].split(" ")[2]
+ if qual == "":
+ raise IndexError
+ else:
+ qual = message_args[2]
+ if qual != "audio":
+ qual = f'bestvideo[height<={qual}]+bestaudio/best[height<={qual}]'
+ except IndexError:
+ qual = "bestvideo+bestaudio/best"
+
+ try:
+ name = name_args[1]
+ except IndexError:
+ name = ""
+
+ pswd = ""
+ listener = MirrorListener(bot, update, pswd, isTar)
+ ydl = YoutubeDLHelper(listener)
+ threading.Thread(target=ydl.add_download,args=(link, f'{DOWNLOAD_DIR}{listener.uid}', qual, name)).start()
+ sendStatusMessage(update, bot)
+
+
+def watchTar(update, context):
+ _watch(context.bot, update, True)
+
+
+def watch(update, context):
+ _watch(context.bot, update)
+
+
+mirror_handler = CommandHandler(BotCommands.WatchCommand, watch,
+ filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+tar_mirror_handler = CommandHandler(BotCommands.TarWatchCommand, watchTar,
+ filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True)
+
+
+dispatcher.add_handler(mirror_handler)
+dispatcher.add_handler(tar_mirror_handler)
diff --git a/captain-definition b/captain-definition
new file mode 100644
index 0000000..0e14f82
--- /dev/null
+++ b/captain-definition
@@ -0,0 +1,4 @@
+{
+ "schemaVersion": 2,
+ "dockerfilePath": "./Dockerfile"
+}
diff --git a/config_sample.env b/config_sample.env
new file mode 100644
index 0000000..9c34e54
--- /dev/null
+++ b/config_sample.env
@@ -0,0 +1,61 @@
+# Remove this line before deploying
+_____REMOVE_THIS_LINE_____=True
+
+# REQUIRED CONFIG
+BOT_TOKEN = ""
+GDRIVE_FOLDER_ID = ""
+OWNER_ID =
+DOWNLOAD_DIR = "/usr/src/app/downloads"
+DOWNLOAD_STATUS_UPDATE_INTERVAL = 5
+AUTO_DELETE_MESSAGE_DURATION = 20
+IS_TEAM_DRIVE = ""
+TELEGRAM_API =
+TELEGRAM_HASH = ""
+UPSTREAM_REPO = "https://github.com/tekeayush/Mirror-bot"
+UPSTREAM_BRANCH = "master"
+# OPTIONAL CONFIG
+DATABASE_URL = ""
+AUTHORIZED_CHATS = "" # Split by space
+SUDO_USERS = "" # Split by space
+IGNORE_PENDING_REQUESTS = ""
+USE_SERVICE_ACCOUNTS = ""
+INDEX_URL = ""
+STATUS_LIMIT = "" # Recommend limit status to 4 tasks max
+UPTOBOX_TOKEN = ""
+MEGA_API_KEY = ""
+MEGA_EMAIL_ID = ""
+MEGA_PASSWORD = ""
+BLOCK_MEGA_FOLDER = ""
+BLOCK_MEGA_LINKS = ""
+STOP_DUPLICATE = ""
+SHORTENER = ""
+SHORTENER_API = ""
+# GDTOT ( provide gdtot cookies if you want to use GDTOT function )
+GDTOT_COOKIES = "crypt= ; PHPSESSID= "
+# qBittorrent
+IS_VPS = ""
+SERVER_PORT = "80" # Only for VPS
+BASE_URL_OF_BOT = "" # Required for Heroku
+# If you want to use Credentials externally from Index Links, fill these vars with the direct links
+# These are optional, if you don't know, simply leave them, don't fill anything in them.
+ACCOUNTS_ZIP_URL = ""
+TOKEN_PICKLE_URL = ""
+# To use limit leave space between number and unit. Available units is (gb or GB, tb or TB)
+TORRENT_DIRECT_LIMIT = ""
+TAR_UNZIP_LIMIT = ""
+CLONE_LIMIT = ""
+MEGA_LIMIT = ""
+# Fill only if you deploying with heroku-cli and Goorm IDE
+HEROKU_API_KEY = ""
+HEROKU_APP_NAME = ""
+# View Link button to open file Index Link in browser instead of direct download link
+# You can figure out if it's compatible with your Index code or not, open any video from you Index and check if the END of link from browser link bar is ?a=view, if yes make it "True" it will work (Compatible with Bhadoo Index Code)
+VIEW_LINK = "False"
+# Add more buttons (Three buttons are already added of Drive Link, Index Link, and View Link, you can add extra buttons too, these are optional)
+# If you don't know what are below entries, simply leave them, Don't fill anything in them.
+BUTTON_FOUR_NAME = ""
+BUTTON_FOUR_URL = ""
+BUTTON_FIVE_NAME = ""
+BUTTON_FIVE_URL = ""
+BUTTON_SIX_NAME = ""
+BUTTON_SIX_URL = ""
diff --git "a/d\303\251but.sh" "b/d\303\251but.sh"
new file mode 100644
index 0000000..27862b3
--- /dev/null
+++ "b/d\303\251but.sh"
@@ -0,0 +1,11 @@
+if [[ -n $TOKEN_PICKLE_URL ]]; then
+ wget -q $TOKEN_PICKLE_URL -O /usr/src/app/token.pickle
+fi
+
+if [[ -n $ACCOUNTS_ZIP_URL ]]; then
+ wget -q $ACCOUNTS_ZIP_URL -O /usr/src/app/accounts.zip
+ unzip accounts.zip -d /usr/src/app/accounts
+ rm accounts.zip
+fi
+
+gunicorn wserver:start_server --bind 0.0.0.0:$PORT --worker-class aiohttp.GunicornWebWorker & qbittorrent-nox -d --webui-port=8090 & python3 alive.py & ./aria.sh; python3 -m bot
diff --git a/extract b/extract
new file mode 100644
index 0000000..7500a40
--- /dev/null
+++ b/extract
@@ -0,0 +1,199 @@
+#!/bin/bash
+
+if [ $# -lt 1 ]; then
+ echo "Usage: $(basename $0) FILES"
+ exit 1
+fi
+
+extract() {
+ arg="$1"
+ cd "$(dirname "$arg")" || exit
+ case "$arg" in
+ *.tar.bz2)
+ tar xjf "$arg" --one-top-level
+ local code=$?
+ ;;
+ *.tar.gz)
+ tar xzf "$arg" --one-top-level
+ local code=$?
+ ;;
+ *.bz2)
+ bunzip2 "$arg"
+ local code=$?
+ ;;
+ *.gz)
+ gunzip "$arg"
+ local code=$?
+ ;;
+ *.tar)
+ tar xf "$arg" --one-top-level
+ local code=$?
+ ;;
+ *.tbz2)
+ (tar xjf "$arg" --one-top-level)
+ local code=$?
+ ;;
+ *.tgz)
+ tar xzf "$arg" --one-top-level
+ local code=$?
+ ;;
+ *.tar.xz)
+ a_dir=$(expr "$arg" : '\(.*\).tar.xz')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.zip)
+ a_dir=$(expr "$arg" : '\(.*\).zip')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.7z)
+ a_dir=$(expr "$arg" : '\(.*\).7z')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.Z)
+ uncompress "$arg"
+ local code=$?
+ ;;
+ *.rar)
+ a_dir=$(expr "$arg" : '\(.*\).rar')
+ mkdir "$a_dir"
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.iso)
+ a_dir=$(expr "$arg" : '\(.*\).iso')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.wim)
+ a_dir=$(expr "$arg" : '\(.*\).wim')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.cab)
+ a_dir=$(expr "$arg" : '\(.*\).cab')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.apm)
+ a_dir=$(expr "$arg" : '\(.*\).apm')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.arj)
+ a_dir=$(expr "$arg" : '\(.*\).arj')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.chm)
+ a_dir=$(expr "$arg" : '\(.*\).chm')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.cpio)
+ a_dir=$(expr "$arg" : '\(.*\).cpio')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.cramfs)
+ a_dir=$(expr "$arg" : '\(.*\).cramfs')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.deb)
+ a_dir=$(expr "$arg" : '\(.*\).deb')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.dmg)
+ a_dir=$(expr "$arg" : '\(.*\).dmg')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.fat)
+ a_dir=$(expr "$arg" : '\(.*\).fat')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.hfs)
+ a_dir=$(expr "$arg" : '\(.*\).hfs')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.lzh)
+ a_dir=$(expr "$arg" : '\(.*\).lzh')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.lzma)
+ a_dir=$(expr "$arg" : '\(.*\).lzma')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.lzma2)
+ a_dir=$(expr "$arg" : '\(.*\).lzma2')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.mbr)
+ a_dir=$(expr "$arg" : '\(.*\).mbr')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.msi)
+ a_dir=$(expr "$arg" : '\(.*\).msi')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.mslz)
+ a_dir=$(expr "$arg" : '\(.*\).mslz')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.nsis)
+ a_dir=$(expr "$arg" : '\(.*\).nsis')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.ntfs)
+ a_dir=$(expr "$arg" : '\(.*\).ntfs')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.rpm)
+ a_dir=$(expr "$arg" : '\(.*\).rpm')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.squashfs)
+ a_dir=$(expr "$arg" : '\(.*\).squashfs')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.udf)
+ a_dir=$(expr "$arg" : '\(.*\).udf')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.vhd)
+ a_dir=$(expr "$arg" : '\(.*\).vhd')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *.xar)
+ a_dir=$(expr "$arg" : '\(.*\).xar')
+ 7z x "$arg" -o"$a_dir"
+ local code=$?
+ ;;
+ *)
+ echo "'$arg' cannot be extracted via extract()" 1>&2
+ exit 1
+ ;;
+ esac
+ cd - || exit $?
+ exit $code
+}
+
+extract "$1"
diff --git a/gen_sa_accounts.py b/gen_sa_accounts.py
new file mode 100644
index 0000000..ff6f144
--- /dev/null
+++ b/gen_sa_accounts.py
@@ -0,0 +1,365 @@
+import errno
+import os
+import pickle
+import sys
+from argparse import ArgumentParser
+from base64 import b64decode
+from glob import glob
+from json import loads
+from random import choice
+from time import sleep
+
+from google.auth.transport.requests import Request
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+
+SCOPES = ['https://www.googleapis.com/auth/drive', 'https://www.googleapis.com/auth/cloud-platform',
+ 'https://www.googleapis.com/auth/iam']
+project_create_ops = []
+current_key_dump = []
+sleep_time = 30
+
+
+# Create count SAs in project
+def _create_accounts(service, project, count):
+ batch = service.new_batch_http_request(callback=_def_batch_resp)
+ for i in range(count):
+ aid = _generate_id('mfc-')
+ batch.add(service.projects().serviceAccounts().create(name='projects/' + project, body={'accountId': aid,
+ 'serviceAccount': {
+ 'displayName': aid}}))
+ batch.execute()
+
+
+# Create accounts needed to fill project
+def _create_remaining_accounts(iam, project):
+ print('Creating accounts in %s' % project)
+ sa_count = len(_list_sas(iam, project))
+ while sa_count != 100:
+ _create_accounts(iam, project, 100 - sa_count)
+ sa_count = len(_list_sas(iam, project))
+
+
+# Generate a random id
+def _generate_id(prefix='saf-'):
+ chars = '-abcdefghijklmnopqrstuvwxyz1234567890'
+ return prefix + ''.join(choice(chars) for _ in range(25)) + choice(chars[1:])
+
+
+# List projects using service
+def _get_projects(service):
+ return [i['projectId'] for i in service.projects().list().execute()['projects']]
+
+
+# Default batch callback handler
+def _def_batch_resp(id, resp, exception):
+ if exception is not None:
+ if str(exception).startswith('- "
+ for i in par.children:
+ if i.is_folder:
+ msg[0] += "
- " + if i.name != ".unwanted": + msg[0] += f" " + create_list(i,msg) + msg[0] += " " + msg[1] += 1 + else: + msg[0] += "
- " + if i.priority == 0: + msg[0] += f" " + msg[0] += f"" + + else: + msg[0] += f" " + msg[0] += f"" + + + msg[0] += " " + + if par.name != ".unwanted": + msg[0] += "
+