def sendStatusMessage(msg, bot): progress = get_readable_message() progress += f"<b>CPU:</b> {psutil.cpu_percent()}%" \ f" <b>DISK:</b> {psutil.disk_usage('/').percent}%" \ f" <b>RAM:</b> {psutil.virtual_memory().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 'KiB/s' in speedy: dlspeed_bytes += float(speedy.split('K')[0]) * 1024 elif 'MiB/s' 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"\n<b>DL:</b>{dlspeed}ps 🔻| <b>UL:</b>{ulspeed}ps 🔺\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 len(progress) == 0: progress = "Starting DL" message = sendMessage(progress, bot, msg) status_reply_dict[msg.message.chat.id] = message
def update_all_messages(): msg = get_readable_message() 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"<b>DL:</b> {dlspeed}ps 🔻 | <b>UL:</b> {ulspeed}ps 🔺" 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: if len(msg) == 0: msg = "Starting DL" try: keyboard = [[ InlineKeyboardButton("♻️ Stats", callback_data="stats_") ]] editMessage(msg, status_reply_dict[chat_id], reply_markup=InlineKeyboardMarkup(keyboard)) except Exception as e: LOGGER.error(str(e)) status_reply_dict[chat_id].text = msg
def update_all_messages(): total, used, free = shutil.disk_usage('.') used = get_readable_file_size(used) free = get_readable_file_size(free) msg = get_readable_message() msg += f"<b>📟𝙲𝙿𝚄:</b> {psutil.cpu_percent()}%" \ f" <b>💾𝚁𝙰𝙼:</b> {psutil.virtual_memory().percent}%" \ f" <b>💿𝙳𝙸𝚂𝙺:</b> {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 'KiB/s' in speedy: dlspeed_bytes += float(speedy.split('K')[0]) * 1024 elif 'MiB/s' 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"\n<b>📮𝚄𝚂𝙴𝙳8:</b> {used} | <b>🏮𝙵𝚁𝙴𝙴:</b> {free}\n<b>𝗗𝗢𝗪𝗡:</b> {dlspeed}ps 🔻 | <b>𝗨𝗣:</b> {ulspeed}ps 🔺\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: if len(msg) == 0: msg = "Starting DL" try: editMessage(msg, status_reply_dict[chat_id]) except Exception as e: LOGGER.error(str(e)) status_reply_dict[chat_id].text = msg
def onDownloadError(self, error): error = error.replace('<', ' ') error = error.replace('>', ' ') LOGGER.info(self.update.effective_chat.id) with download_dict_lock: try: download = download_dict[self.uid] del download_dict[self.uid] LOGGER.info(f"Deleting folder: {download.path()}") fs_utils.clean_download(download.path()) LOGGER.info(str(download_dict)) except Exception as e: LOGGER.error(str(e)) count = len(download_dict) if self.message.from_user.username: uname = f"@{self.message.from_user.username}" else: uname = f'<a href="tg://user?id={self.message.from_user.id}">{self.message.from_user.first_name}</a>' 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 shellExecute(bot: Bot, update: Update): cmd = update.message.text.split(' ',maxsplit=1) if len(cmd) == 1: sendMessage("No command provided!", bot, update) return LOGGER.info(cmd) output = shell(cmd[1]) if output[1].decode(): LOGGER.error(f"Shell: {output[1].decode()}") if len(output[0].decode()) > 4000: with open("shell.txt",'w') as f: f.write(f"Output\n-----------\n{output[0].decode()}\n") if output[1]: f.write(f"STDError\n-----------\n{output[1].decode()}\n") with open("shell.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) else: if output[1].decode(): sendMessage(f"<code>{output[1].decode()}</code>", bot, update) return else: sendMessage(f"<code>{output[0].decode()}</code>", bot, update)
def update_all_messages(): msg = get_readable_message() msg += f"<b>📊 Performance Meter 📊</b>\n\n" \ f"<b>🖥️ CPU : {psutil.cpu_percent()}%</b>\n" \ f"<b>🗃️ DISK : {psutil.disk_usage('/').percent}%</b>\n" \ f"<b>⚙️ RAM : {psutil.virtual_memory().percent}%</b>" 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 'KiB/s' in speedy: dlspeed_bytes += float(speedy.split('K')[0]) * 1024 elif 'MiB/s' 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"<b>\n\n⚡️ Speed Meter ⚡️</b>\n" \ f"<b>D : {dlspeed}/s 🔻 </b> | <b>U : {ulspeed}/s 🔺</b>" 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: if len(msg) == 0: msg = "Starting DL" try: editMessage(msg, status_reply_dict[chat_id]) except Exception as e: LOGGER.error(str(e)) status_reply_dict[chat_id].text = msg
def shellExecute(bot: Bot, update: Update): cmd = update.message.text.split(' ',maxsplit=1) if len(cmd) == 1: sendMessage("Heç bir əmr verilməyib!", bot, update) return LOGGER.info(cmd) output = shell(cmd[1]) if output[1].decode(): LOGGER.error(f"Qabıq: {output[1].decode()}") if len(output[0].decode()) > 4000: with open("qabıq.txt",'w') as f: f.write(f"Çıxış\n-----------\n{output[0].decode()}\n") if output[1]: f.write(f"STDXəta\n-----------\n{output[1].decode()}\n") with open("qabıq.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) else: if output[1].decode(): sendMessage(f"<code>{output[1].decode()}</code>", bot, update) return else: sendMessage(f"<code>{output[0].decode()}</code>", bot, update)
def update_all_messages(): total, used, free = shutil.disk_usage('.') free = get_readable_file_size(free) currentTime = get_readable_time(time.time() - botStartTime) msg = get_readable_message() msg += f"<b>CPU:</b> {psutil.cpu_percent()}%" \ f" <b>RAM:</b> {psutil.virtual_memory().percent}%" \ f" <b>DISK:</b> {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"\n<b>FREE:</b> {free} | <b>UPTIME:</b> {currentTime}\n<b>DL:</b> {dlspeed}ps 🔻 | <b>UL:</b> {ulspeed}ps 🔺\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: if len(msg) == 0: msg = "Starting DL" try: editMessage(msg, status_reply_dict[chat_id]) except Exception as e: LOGGER.error(str(e)) status_reply_dict[chat_id].text = msg
def onDownloadComplete(self): with download_dict_lock: LOGGER.info(f"Download completed: {download_dict[self.uid].name()}") download = download_dict[self.uid] name = str(download.name()).replace('/', '') gid = download.gid() size = download.size_raw() if name == "None" or self.isQbit: name = listdir(f'{DOWNLOAD_DIR}{self.uid}')[-1] m_path = f'{DOWNLOAD_DIR}{self.uid}/{name}' if self.isZip: try: with download_dict_lock: download_dict[self.uid] = ZipStatus(name, m_path, size) pswd = self.pswd path = m_path + ".zip" LOGGER.info(f'Zip: orig_path: {m_path}, zip_path: {path}') if pswd is not None: if self.isLeech and int(size) > TG_SPLIT_SIZE: path = m_path + ".zip" srun(["7z", f"-v{TG_SPLIT_SIZE}b", "a", "-mx=0", f"-p{pswd}", path, m_path]) else: srun(["7z", "a", "-mx=0", f"-p{pswd}", path, m_path]) elif self.isLeech and int(size) > TG_SPLIT_SIZE: path = m_path + ".zip" srun(["7z", f"-v{TG_SPLIT_SIZE}b", "a", "-mx=0", path, m_path]) else: srun(["7z", "a", "-mx=0", path, m_path]) except FileNotFoundError: LOGGER.info('File to archive not found!') self.onUploadError('Internal error occurred!!') return try: rmtree(m_path) except: osremove(m_path) elif self.extract: try: if ospath.isfile(m_path): path = 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 ospath.isdir(m_path): for dirpath, subdir, files in walk(m_path, topdown=False): for file_ in files: if search(r'\.part0*1.rar$', file_) or search(r'\.7z.0*1$', file_) \ or (file_.endswith(".rar") and not search(r'\.part\d+.rar$', file_)) \ or file_.endswith(".zip") or search(r'\.zip.0*1$', file_): m_path = ospath.join(dirpath, file_) if pswd is not None: result = srun(["7z", "x", f"-p{pswd}", m_path, f"-o{dirpath}", "-aot"]) else: result = srun(["7z", "x", m_path, f"-o{dirpath}", "-aot"]) if result.returncode != 0: LOGGER.error('Unable to extract archive!') for file_ in files: if file_.endswith(".rar") or search(r'\.r\d+$', file_) \ or search(r'\.7z.\d+$', file_) or search(r'\.z\d+$', file_) \ or search(r'\.zip.\d+$', file_) or file_.endswith(".zip"): del_path = ospath.join(dirpath, file_) osremove(del_path) path = f'{DOWNLOAD_DIR}{self.uid}/{name}' else: if pswd is not None: result = srun(["bash", "pextract", m_path, pswd]) else: result = srun(["bash", "extract", m_path]) if result.returncode == 0: LOGGER.info(f"Extract Path: {path}") osremove(m_path) LOGGER.info(f"Deleting archive: {m_path}") else: LOGGER.error('Unable to extract archive! Uploading anyway') path = f'{DOWNLOAD_DIR}{self.uid}/{name}' 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 = PurePath(path).name up_path = f'{DOWNLOAD_DIR}{self.uid}/{up_name}' size = get_path_size(f'{DOWNLOAD_DIR}{self.uid}') if self.isLeech and not self.isZip: checked = False for dirpath, subdir, files in walk(f'{DOWNLOAD_DIR}{self.uid}', topdown=False): for file_ in files: f_path = ospath.join(dirpath, file_) f_size = ospath.getsize(f_path) if int(f_size) > TG_SPLIT_SIZE: if not checked: checked = True with download_dict_lock: download_dict[self.uid] = SplitStatus(up_name, up_path, size) LOGGER.info(f"Splitting: {up_name}") fssplit(f_path, f_size, file_, dirpath, TG_SPLIT_SIZE) osremove(f_path) if self.isLeech: LOGGER.info(f"Leech Name: {up_name}") tg = TgUploader(up_name, self) tg_upload_status = TgUploadStatus(tg, size, gid, self) with download_dict_lock: download_dict[self.uid] = tg_upload_status update_all_messages() tg.upload() else: LOGGER.info(f"Upload Name: {up_name}") drive = GoogleDriveHelper(up_name, self) 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 _mirror(bot, update, isZip=False, extract=False, isQbit=False, isLeech=False, pswd=None): mesg = update.message.text.split('\n') message_args = mesg[0].split(' ', maxsplit=1) name_args = mesg[0].split('|', maxsplit=1) qbitsel = False try: link = message_args[1] if link.startswith("s ") or link == "s": qbitsel = True message_args = mesg[0].split(' ', maxsplit=2) link = message_args[2].strip() if link.startswith("|") or link.startswith("pswd: "): link = '' except IndexError: link = '' try: name = name_args[1] name = name.split(' pswd: ')[0] name = name.strip() except IndexError: name = '' link = resplit(r"pswd:| \|", link)[0] link = link.strip() pswdMsg = mesg[0].split(' pswd: ') if len(pswdMsg) > 1: pswd = pswdMsg[1] if update.message.from_user.username: tag = f"@{update.message.from_user.username}" else: tag = update.message.from_user.mention_html(update.message.from_user.first_name) 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 is_url(link) and not is_magnet(link) or len(link) == 0 ): if not reply_to.from_user.is_bot: if reply_to.from_user.username: tag = f"@{reply_to.from_user.username}" else: tag = reply_to.from_user.mention_html(reply_to.from_user.first_name) if file is None: reply_text = reply_to.text if is_url(reply_text) or is_magnet(reply_text): link = reply_text.strip() elif isQbit: file_name = str(time()).replace(".", "") + ".torrent" link = file.get_file().download(custom_path=file_name) elif file.mime_type != "application/x-bittorrent": listener = MirrorListener(bot, update, isZip, extract, isQbit, isLeech, pswd, tag) tg_downloader = TelegramDownloadHelper(listener) ms = update.message tg_downloader.add_download(ms, f'{DOWNLOAD_DIR}{listener.uid}/', name) return else: link = file.get_file().file_path if len(mesg) > 1: try: ussr = quote(mesg[1], safe='') pssw = quote(mesg[2], safe='') link = link.split("://", maxsplit=1) link = f'{link[0]}://{ussr}:{pssw}@{link[1]}' except IndexError: pass if not is_url(link) and not is_magnet(link) and not ospath.exists(link): help_msg = "<b>Send link along with command line:</b>" help_msg += "\n<code>/command</code> {link} |newname pswd: mypassword [𝚣𝚒𝚙/𝚞𝚗𝚣𝚒𝚙]" help_msg += "\n\n<b>By replying to link or file:</b>" help_msg += "\n<code>/command</code> |newname pswd: mypassword [𝚣𝚒𝚙/𝚞𝚗𝚣𝚒𝚙]" help_msg += "\n\n<b>Direct link authorization:</b>" help_msg += "\n<code>/command</code> {link} |newname pswd: mypassword\nusername\npassword" help_msg += "\n\n<b>Qbittorrent selection:</b>" help_msg += "\n<code>/qbcommand</code> <b>s</b> {link} or by replying to {file}" return sendMessage(help_msg, bot, update) LOGGER.info(link) gdtot_link = is_gdtot_link(link) if not is_mega_link(link) and not isQbit and not is_magnet(link) \ and not ospath.exists(link) and not is_gdrive_link(link) and not link.endswith('.torrent'): content_type = get_content_type(link) if content_type is None or match(r'text/html|text/plain', content_type): try: link = direct_link_generator(link) LOGGER.info(f"Generated link: {link}") except DirectDownloadLinkException as e: LOGGER.info(str(e)) if str(e).startswith('ERROR:'): return sendMessage(str(e), bot, update) elif isQbit and not is_magnet(link) and not ospath.exists(link): content_type = get_content_type(link) if content_type is None or link.endswith('.torrent') \ or match(r'application/x-bittorrent|application/octet-stream', content_type): try: resp = requests.get(link, timeout=10) if resp.status_code == 200: file_name = str(time()).replace(".", "") + ".torrent" open(file_name, "wb").write(resp.content) link = f"{file_name}" else: return sendMessage(f"ERROR: link got HTTP response: {resp.status_code}", bot, update) except Exception as e: LOGGER.error(str(e)) error = str(e).replace('<', ' ').replace('>', ' ') return sendMessage(error, bot, update) else: msg = "Qb commands for torrents only. if you are trying to dowload torrent then report." return sendMessage(msg, bot, update) listener = MirrorListener(bot, update, isZip, extract, isQbit, isLeech, pswd, tag) if is_gdrive_link(link): if not isZip and not extract and not isLeech: gmsg = f"Use /{BotCommands.CloneCommand} to clone Google Drive file/folder\n\n" gmsg += f"Use /{BotCommands.ZipMirrorCommand} to make zip of Google Drive folder\n\n" gmsg += f"Use /{BotCommands.UnzipMirrorCommand} to extracts Google Drive archive file" return sendMessage(gmsg, bot, update) Thread(target=add_gd_download, args=(link, listener, gdtot_link)).start() elif is_mega_link(link): if BLOCK_MEGA_LINKS: sendMessage("Mega links are blocked!", bot, update) return link_type = get_mega_link_type(link) if link_type == "folder" and BLOCK_MEGA_FOLDER: sendMessage("Mega folder are blocked!", bot, update) else: Thread(target=add_mega_download, args=(link, f'{DOWNLOAD_DIR}{listener.uid}/', listener)).start() elif isQbit and (is_magnet(link) or ospath.exists(link)): Thread(target=add_qb_torrent, args=(link, f'{DOWNLOAD_DIR}{listener.uid}/', listener, qbitsel)).start() else: Thread(target=add_aria2c_download, args=(link, f'{DOWNLOAD_DIR}{listener.uid}/', listener, name)).start()
def clone(self, link, status): self.transferred_size = 0 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: meta = self.__service.files().get( supportsAllDrives=True, fileId=file_id, fields="name,id,mimeType,size").execute() except Exception as e: return f"{str(e).replace('>', '').replace('<', '')}" if meta.get("mimeType") == self.__G_DRIVE_DIR_MIME_TYPE: dir_id = self.check_folder_exists(meta.get('name'), GDRIVE_FOLDER_ID) if not dir_id: dir_id = self.create_directory(meta.get('name'), GDRIVE_FOLDER_ID) try: result = self.cloneFolder(meta.get('name'), meta.get('name'), meta.get('id'), dir_id, status) except Exception as e: if isinstance(e, RetryError): LOGGER.info( f"Total Attempts: {e.last_attempt.attempt_number}") err = e.last_attempt.exception() else: err = str(e).replace('>', '').replace('<', '') LOGGER.error(err) return err status.set_status(True) msg += f'<a href="{self.__G_DRIVE_DIR_BASE_DOWNLOAD_URL.format(dir_id)}">{meta.get("name")}</a>' \ f' ({get_readable_file_size(self.transferred_size)})' if INDEX_URL: url = requests.utils.requote_uri( f'{INDEX_URL}/{meta.get("name")}/') msg += f' | <a href="{url}"> Index URL</a>' else: try: file = self.check_file_exists(meta.get('id'), GDRIVE_FOLDER_ID) if file: status.checkFileExist(True) if not file: status.checkFileExist(False) file = self.copyFile(meta.get('id'), GDRIVE_FOLDER_ID, status) except Exception as e: if isinstance(e, RetryError): LOGGER.info( f"Total Attempts: {e.last_attempt.attempt_number}") err = e.last_attempt.exception() else: err = str(e).replace('>', '').replace('<', '') LOGGER.error(err) return err msg += f'<a href="{self.__G_DRIVE_BASE_DOWNLOAD_URL.format(file.get("id"))}">{file.get("name")}</a>' try: msg += f' ({get_readable_file_size(int(meta.get("size")))}) ' if INDEX_URL is not None: url = requests.utils.requote_uri( f'{INDEX_URL}/{file.get("name")}') msg += f' | <a href="{url}"> Index URL</a>' except TypeError: pass return msg
def deleteMessage(message: Message): try: message.delete() except Exception as e: LOGGER.error(str(e))
def cloneFolder(self, name, local_path, folder_id, parent_id, status, ignoreList=[]): page_token = None q = f"'{folder_id}' in parents" files = [] LOGGER.info(f"Syncing: {local_path}") new_id = None while True: response = self.__service.files().list( supportsTeamDrives=True, includeTeamDriveItems=True, q=q, spaces='drive', fields='nextPageToken, files(id, name, mimeType,size)', pageToken=page_token).execute() for file in response.get('files', []): files.append(file) page_token = response.get('nextPageToken', None) if page_token is None: break if len(files) == 0: return parent_id for file in files: if file.get('mimeType') == self.__G_DRIVE_DIR_MIME_TYPE: file_path = os.path.join(local_path, file.get('name')) current_dir_id = self.check_folder_exists( file.get('name'), parent_id) if not current_dir_id: current_dir_id = self.create_directory( file.get('name'), parent_id) if not str(file.get('id')) in ignoreList: new_id = self.cloneFolder(file.get('name'), file_path, file.get('id'), current_dir_id, status, ignoreList) else: LOGGER.info("Ignoring FolderID from clone: " + str(file.get('id'))) else: try: if not self.check_file_exists(file.get('name'), parent_id): status.checkFileExist(False) self.transferred_size += int(file.get('size')) status.add_size(int(file.get('size'))) status.set_name(file.get('name')) else: status.checkFileExist(True) except TypeError: pass try: if not self.check_file_exists(file.get('name'), parent_id): self.copyFile(file.get('id'), parent_id, status) status.checkFileExist(False) else: status.checkFileExist(True) new_id = parent_id except Exception as e: if isinstance(e, RetryError): LOGGER.info( f"Total Attempts: {e.last_attempt.attempt_number}") err = e.last_attempt.exception() else: err = e LOGGER.error(err) return new_id
def _qb_listener(listener, client, ext_hash, select, path): stalled_time = time() uploaded = False sizeChecked = False dupChecked = False rechecked = False while True: sleep(4) try: tor_info = client.torrents_info(torrent_hashes=ext_hash) if len(tor_info) == 0: with download_dict_lock: if listener.uid not in list(download_dict.keys()): client.auth_log_out() break continue tor_info = tor_info[0] if tor_info.state == "metaDL": stalled_time = time() if QB_TIMEOUT is not None and time( ) - tor_info.added_on >= QB_TIMEOUT: #timeout while downloading metadata _onDownloadError("Dead Torrent!", client, ext_hash, listener) break elif tor_info.state == "downloading": stalled_time = time() if STOP_DUPLICATE and not dupChecked and ospath.isdir( f'{path}') and not listener.isLeech: LOGGER.info('Checking File/Folder if already in Drive') qbname = str(listdir(f'{path}')[-1]) if qbname.endswith('.!qB'): qbname = ospath.splitext(qbname)[0] if listener.isZip: qbname = qbname + ".zip" elif listener.extract: try: qbname = get_base_name(qbname) except: qbname = None if qbname is not None: qbmsg, button = GoogleDriveHelper().drive_list( qbname, True) if qbmsg: msg = "File/Folder is already available in Drive." _onDownloadError(msg, client, ext_hash, listener) sendMarkup("Here are the search results:", listener.bot, listener.update, button) break dupChecked = True if not sizeChecked: sleep(1) size = tor_info.size arch = any([listener.isZip, listener.extract]) if STORAGE_THRESHOLD is not None: acpt = check_storage_threshold(size, arch) if not acpt: msg = f'You must leave {STORAGE_THRESHOLD}GB free storage.' msg += f'\nYour File/Folder size is {get_readable_file_size(size)}' _onDownloadError(msg, client, ext_hash, listener) break limit = None if ZIP_UNZIP_LIMIT is not None and arch: mssg = f'Zip/Unzip limit is {ZIP_UNZIP_LIMIT}GB' limit = ZIP_UNZIP_LIMIT elif TORRENT_DIRECT_LIMIT is not None: mssg = f'Torrent limit is {TORRENT_DIRECT_LIMIT}GB' limit = TORRENT_DIRECT_LIMIT if limit is not None: LOGGER.info('Checking File/Folder Size...') if size > limit * 1024**3: fmsg = f"{mssg}.\nYour File/Folder size is {get_readable_file_size(size)}" _onDownloadError(fmsg, client, ext_hash, listener) break sizeChecked = True elif tor_info.state == "stalledDL": if not rechecked and 0.99989999999999999 < tor_info.progress < 1: msg = f"Force recheck - Name: {tor_info.name} Hash: " msg += f"{ext_hash} Downloaded Bytes: {tor_info.downloaded} " msg += f"Size: {tor_info.size} Total Size: {tor_info.total_size}" LOGGER.info(msg) client.torrents_recheck(torrent_hashes=ext_hash) rechecked = True elif QB_TIMEOUT is not None and time( ) - stalled_time >= QB_TIMEOUT: # timeout after downloading metadata _onDownloadError("Dead Torrent!", client, ext_hash, listener) break elif tor_info.state == "missingFiles": client.torrents_recheck(torrent_hashes=ext_hash) elif tor_info.state == "error": _onDownloadError("No enough space for this torrent on device", client, ext_hash, listener) break elif (tor_info.state.lower().endswith("up") or tor_info.state == "uploading") and not uploaded: LOGGER.info(f"onQbDownloadComplete: {ext_hash}") uploaded = True if not QB_SEED: client.torrents_pause(torrent_hashes=ext_hash) if select: clean_unwanted(path) listener.onDownloadComplete() if QB_SEED and not listener.isLeech and not listener.extract: with download_dict_lock: if listener.uid not in list(download_dict.keys()): client.torrents_delete(torrent_hashes=ext_hash, delete_files=True) client.auth_log_out() break download_dict[listener.uid] = QbDownloadStatus( listener, client, ext_hash, select) update_all_messages() LOGGER.info(f"Seeding started: {tor_info.name}") else: client.torrents_delete(torrent_hashes=ext_hash, delete_files=True) client.auth_log_out() break elif tor_info.state == 'pausedUP' and QB_SEED: listener.onUploadError( f"Seeding stopped with Ratio: {round(tor_info.ratio, 3)} and Time: {get_readable_time(tor_info.seeding_time)}" ) client.torrents_delete(torrent_hashes=ext_hash, delete_files=True) client.auth_log_out() update_all_messages() break except Exception as e: LOGGER.error(str(e))
def clone(self, link, status, ignoreList=[]): self.transferred_size = 0 try: file_id = self.getIdFromUrl(link) except (KeyError, IndexError): msg = "No se pudo encontrar el ID de la unidad de Google en el enlace proporcionado" return msg msg = "" LOGGER.info(f"File ID: {file_id}") try: meta = self.__service.files().get( supportsAllDrives=True, fileId=file_id, fields="name,id,mimeType,size").execute() dest_meta = self.__service.files().get( supportsAllDrives=True, fileId=self.gparentid, fields="name,id,size").execute() status.SetMainFolder( meta.get('name'), self.__G_DRIVE_DIR_BASE_DOWNLOAD_URL.format(meta.get('id'))) status.SetDestinationFolder( dest_meta.get('name'), self.__G_DRIVE_DIR_BASE_DOWNLOAD_URL.format( dest_meta.get('id'))) except Exception as e: return f"{str(e).replace('>', '').replace('<', '')}" if meta.get("mimeType") == self.__G_DRIVE_DIR_MIME_TYPE: dir_id = self.check_folder_exists(meta.get('name'), self.gparentid) if not dir_id: dir_id = self.create_directory(meta.get('name'), self.gparentid) try: self.cloneFolder(meta.get('name'), meta.get('name'), meta.get('id'), dir_id, status, ignoreList) except Exception as e: if isinstance(e, RetryError): LOGGER.info( f"Total Attempts: {e.last_attempt.attempt_number}") err = e.last_attempt.exception() else: err = str(e).replace('>', '').replace('<', '') LOGGER.error(err) return err status.set_status(True) msg += f'<a href="{self.__G_DRIVE_DIR_BASE_DOWNLOAD_URL.format(dir_id)}">{meta.get("name")}</a>' \ f' ({get_readable_file_size(self.transferred_size)})' if INDEX_URL: url = requests.utils.requote_uri( f'{INDEX_URL}/{meta.get("name")}/') msg += f' | <a href="{url}"> URL de índice</a>' else: try: file = self.check_file_exists(meta.get('id'), self.gparentid) if file: status.checkFileExist(True) if not file: status.checkFileExist(False) file = self.copyFile(meta.get('id'), self.gparentid, status) except Exception as e: if isinstance(e, RetryError): LOGGER.info( f"Intentos totales: {e.last_attempt.attempt_number}") err = e.last_attempt.exception() else: err = str(e).replace('>', '').replace('<', '') LOGGER.error(err) return err msg += f'<a href="{self.__G_DRIVE_BASE_DOWNLOAD_URL.format(file.get("id"))}">{file.get("name")}</a>' try: msg += f' ({get_readable_file_size(int(meta.get("size")))}) ' if INDEX_URL is not None: url = requests.utils.requote_uri( f'{INDEX_URL}/{file.get("name")}') msg += f' | <a href="{url}"> Index URL</a>' except TypeError: pass return msg
def rss_sub(update, context): try: args = update.message.text.split(" ", 3) title = str(args[1]) feed_link = str(args[2]) f_lists = [] try: filters = str(args[3]).lower() if filters.startswith('f: '): filters = filters.split('f: ', 1)[1] filters_list = filters.split('|') for x in filters_list: y = x.split(' or ') f_lists.append(y) else: filters = None except: filters = None exists = rss_dict.get(title) if exists is not None: LOGGER.error( "This title already subscribed! Choose another title!") return sendMessage( "This title already subscribed! Choose another title!", context.bot, update) try: rss_d = feedparse(feed_link) sub_msg = "<b>Subscribed!</b>" sub_msg += f"\n\n<b>Title: </b><code>{title}</code>\n<b>Feed Url: </b>{feed_link}" sub_msg += f"\n\n<b>latest record for </b>{rss_d.feed.title}:" sub_msg += f"\n\n<b>Name: </b><code>{rss_d.entries[0]['title']}</code>" try: link = rss_d.entries[0]['links'][1]['href'] except IndexError: link = rss_d.entries[0]['link'] sub_msg += f"\n\n<b>Link: </b><code>{link}</code>" sub_msg += f"\n\n<b>Filters: </b><code>{filters}</code>" last_link = str(rss_d.entries[0]['link']) last_title = str(rss_d.entries[0]['title']) DbManger().rss_add(title, feed_link, last_link, last_title, filters) with rss_dict_lock: if len(rss_dict) == 0: rss_job.enabled = True rss_dict[title] = [feed_link, last_link, last_title, f_lists] sendMessage(sub_msg, context.bot, update) LOGGER.info(f"Rss Feed Added: {title} - {feed_link} - {filters}") except (IndexError, AttributeError) as e: LOGGER.error(str(e)) msg = "The link doesn't seem to be a RSS feed or it's region-blocked!" sendMessage(msg, context.bot, update) except Exception as e: LOGGER.error(str(e)) sendMessage(str(e), context.bot, update) except IndexError: msg = f"Use this format to add feed url:\n/{BotCommands.RssSubCommand} Title https://www.rss-url.com" msg += " f: 1080 or 720 or 144p|mkv or mp4|hevc (optional)\n\nThis filter will parse links that it's titles" msg += " contains `(1080 or 720 or 144p) and (mkv or mp4) and hevc` words. You can add whatever you want.\n\n" msg += "Another example: f: 1080 or 720p|.web. or .webrip.|hvec or x264 .. This will parse titles that contains" msg += " ( 1080 or 720p) and (.web. or .webrip.) and (hvec or x264). I have added space before and after 1080" msg += " to avoid wrong matching. If this `10805695` number in title it will match 1080 if added 1080 without" msg += " spaces after it." msg += "\n\nFilters Notes:\n\n1. | means and.\n\n2. Add `or` between similar keys, you can add it" msg += " between qualities or between extensions, so don't add filter like this f: 1080|mp4 or 720|web" msg += " because this will parse 1080 and (mp4 or 720) and web ... not (1080 and mp4) or (720 and web)." msg += "\n\n3. You can add `or` and `|` as much as you want." msg += "\n\n4. Take look on title if it has static special character after or before the qualities or extensions" msg += " or whatever and use them in filter to avoid wrong match" sendMessage(msg, context.bot, update)
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 editMessage(text: str, message: Message): try: message.edit_text(text) except Exception as e: LOGGER.error(str(e))