async def upload_to_tg(message: Message): """ upload to telegram """ path_ = message.filtered_input_str if not path_: await message.err("Input not foud!") return is_path_url = is_url(path_) del_path = False if is_path_url: del_path = True try: path_, _ = await url_download(message, path_) except ProcessCanceled: await message.canceled() return except Exception as e_e: # pylint: disable=broad-except await message.err(str(e_e)) return if "|" in path_: path_, file_name = path_.split("|") path_ = path_.strip() if os.path.isfile(path_): new_path = os.path.join(Config.DOWN_PATH, file_name.strip()) os.rename(path_, new_path) path_ = new_path try: string = Path(path_) except IndexError: await message.err("wrong syntax") else: await message.delete() with message.cancel_callback(): await upload_path(message, string, del_path)
async def tg_download(message: Message, to_download: Message, from_url: bool = False) -> Tuple[str, int]: """ download from tg file """ await message.edit("`Downloading From TG...`") start_t = datetime.now() custom_file_name = Config.DOWN_PATH if message.filtered_input_str and not from_url: custom_file_name = os.path.join(Config.DOWN_PATH, message.filtered_input_str.strip()) elif "|" in message.filtered_input_str: _, c_file_name = message.filtered_input_str.split("|", maxsplit=1) if c_file_name: custom_file_name = os.path.join(Config.DOWN_PATH, c_file_name.strip()) with message.cancel_callback(): dl_loc = await message.client.download_media( message=to_download, file_name=custom_file_name, progress=progress, progress_args=(message, "trying to download")) if message.process_is_canceled: raise ProcessCanceled if not isinstance(dl_loc, str): raise TypeError("File Corrupted!") dl_loc = os.path.relpath(dl_loc) return dl_loc, (datetime.now() - start_t).seconds
async def combine_(message: Message) -> None: """ combine split files """ file_path = message.input_str if not file_path: await message.err("missing file path!") return if not isfile(file_path): await message.err("file path not exists!") return _, ext = splitext(basename(file_path)) if not ext.lstrip('.').isdigit(): await message.err("unsupported file!") return await message.edit("`processing...`") start_t = datetime.now() c_obj = SCLib(file_path) c_obj.combine() tmp = \ "__Combining file path...__\n" + \ "```{}({}%)```\n" + \ "**File Path** : `{}`\n" + \ "**Dest** : `{}`\n" + \ "**Completed** : `{}`\n" + \ "**Total** : `{}`\n" + \ "**Speed** : `{}/s`\n" + \ "**ETA** : `{}`\n" + \ "**Completed Files** : `{}/{}`" async def _worker(): while not c_obj.finished: await message.edit( tmp.format(c_obj.progress, c_obj.percentage, file_path, c_obj.final_file_path, humanbytes(c_obj.completed), humanbytes(c_obj.total), humanbytes(c_obj.speed), c_obj.eta, c_obj.completed_files, c_obj.total_files)) await sleep(Config.EDIT_SLEEP_TIMEOUT) def _on_cancel(): c_obj.cancel() task.cancel() task = asyncio.create_task(_worker()) with message.cancel_callback(_on_cancel): try: await task except asyncio.CancelledError: await message.canceled() return if c_obj.output: await message.err(c_obj.output, show_help=False) else: end_t = datetime.now() m_s = (end_t - start_t).seconds await message.edit( f"**combined** `{file_path}` into `{c_obj.final_file_path}` " f"in `{m_s}` seconds.", log=__name__)
async def split_(message: Message) -> None: """ split files """ split_size = int(message.matches[0].group(1)) file_path = str(message.matches[0].group(2)) if not file_path: await message.err("missing file path!") return if not isfile(file_path): await message.err("file path not exists!") return await message.edit("`processing...`") start_t = datetime.now() s_obj = SCLib(file_path) s_obj.split(split_size) tmp = \ "__Splitting file path...__\n" + \ "```{}({}%)```\n" + \ "**File Path** : `{}`\n" + \ "**Dest** : `{}`\n" + \ "**Completed** : `{}`\n" + \ "**Total** : `{}`\n" + \ "**Speed** : `{}/s`\n" + \ "**ETA** : `{}`\n" + \ "**Completed Files** : `{}/{}`" async def _worker(): while not s_obj.finished: await message.edit(tmp.format(s_obj.progress, s_obj.percentage, file_path, s_obj.final_file_path, humanbytes(s_obj.completed), humanbytes(s_obj.total), humanbytes(s_obj.speed), s_obj.eta, s_obj.completed_files, s_obj.total_files)) await sleep(Config.EDIT_SLEEP_TIMEOUT) def _on_cancel(): s_obj.cancel() task.cancel() task = asyncio.create_task(_worker()) with message.cancel_callback(_on_cancel): try: await task except asyncio.CancelledError: await message.canceled() return if s_obj.output: await message.err(s_obj.output, show_help=False) else: end_t = datetime.now() m_s = (end_t - start_t).seconds await message.edit( f"**split** `{file_path}` into `{s_obj.final_file_path}` " f"in `{m_s}` seconds.", log=__name__)
async def term_(message: Message): """ run commands in shell (terminal with live update) """ cmd = await init_func(message) if cmd is None: return await message.edit("`Executing terminal ...`") try: parsed_cmd = parse_py_template(cmd, message) except Exception as e: # pylint: disable=broad-except await message.err(str(e)) await CHANNEL.log(f"**Exception**: {type(e).__name__}\n**Message**: " + str(e)) return try: t_obj = await Term.execute(parsed_cmd) # type: Term except Exception as t_e: # pylint: disable=broad-except await message.err(str(t_e)) return cur_user = getuser() try: uid = geteuid() except ImportError: uid = 1 prefix = f"<b>{cur_user}:~#</b>" if uid == 0 else f"<b>{cur_user}:~$</b>" output = f"{prefix} <pre>{cmd}</pre>\n" async def _worker(): await t_obj.wait() while not t_obj.finished: await message.edit(f"{output}<pre>{await t_obj.read_line()}</pre>", parse_mode='html') try: await asyncio.wait_for(t_obj.finish_listener, Config.EDIT_SLEEP_TIMEOUT) except asyncio.TimeoutError: pass def _on_cancel(): t_obj.cancel() task.cancel() task = asyncio.create_task(_worker()) with message.cancel_callback(_on_cancel): try: await task except asyncio.CancelledError: await message.canceled(reply=True) return out_data = f"{output}<pre>{await t_obj.get_output()}</pre>\n{prefix}" await message.edit_or_send_as_file(out_data, parse_mode='html', filename="term.txt", caption=cmd)
async def _handle_message(message: Message) -> None: try: dl_loc, _ = await tg_download(message, message.reply_to_message) except ProcessCanceled: await message.canceled() except Exception as e_e: # pylint: disable=broad-except await message.err(str(e_e)) else: await message.delete() with message.cancel_callback(): await upload(message, Path(dl_loc), True)
async def unpack_(message: Message) -> None: """ unpack packed file """ file_path = message.input_str if not file_path: await message.err("missing file path!") return if not exists(file_path): await message.err("file path not exists!") return if not PackLib.is_supported(file_path): await message.err("unsupported file type!") return await message.edit("`processing...`") start_t = datetime.now() p_obj = PackLib(file_path) p_obj.unpack_path() tmp = \ "__UnPacking file path...__\n" + \ "```{}({}%)```\n" + \ "**File Path** : `{}`\n" + \ "**Dest** : `{}`\n" + \ "**Completed** : `{}/{}`" async def _worker(): while not p_obj.finished: await message.edit(tmp.format(p_obj.progress, p_obj.percentage, file_path, p_obj.final_file_path, p_obj.completed_files, p_obj.total_files)) await sleep(Config.EDIT_SLEEP_TIMEOUT) def _on_cancel(): p_obj.cancel() task.cancel() task = asyncio.create_task(_worker()) with message.cancel_callback(_on_cancel): try: await task except asyncio.CancelledError: await message.canceled() return if p_obj.output: await message.err(p_obj.output, show_help=False) else: end_t = datetime.now() m_s = (end_t - start_t).seconds await message.edit( f"**unpacked** `{file_path}` into `{p_obj.final_file_path}` " f"in `{m_s}` seconds.", log=__name__)
async def url_download(message: Message, url: str) -> Tuple[str, int]: """ download from link """ await message.edit("`Downloading From URL...`") start_t = datetime.now() custom_file_name = unquote_plus(os.path.basename(url)) if "|" in url: url, c_file_name = url.split("|", maxsplit=1) url = url.strip() if c_file_name: custom_file_name = c_file_name.strip() dl_loc = os.path.join(Config.DOWN_PATH, custom_file_name) downloader = SmartDL(url, dl_loc, progress_bar=False) downloader.start(blocking=False) with message.cancel_callback(downloader.stop): while not downloader.isFinished(): total_length = downloader.filesize if downloader.filesize else 0 downloaded = downloader.get_dl_size() percentage = downloader.get_progress() * 100 speed = downloader.get_speed(human=True) estimated_total_time = downloader.get_eta(human=True) progress_str = \ "__{}__\n" + \ "```[{}{}]```\n" + \ "**Progress** : `{}%`\n" + \ "**URL** : `{}`\n" + \ "**FILENAME** : `{}`\n" + \ "**Completed** : `{}`\n" + \ "**Total** : `{}`\n" + \ "**Speed** : `{}`\n" + \ "**ETA** : `{}`" progress_str = progress_str.format( "trying to download", ''.join( (Config.FINISHED_PROGRESS_STR for _ in range(math.floor(percentage / 5)))), ''.join( (Config.UNFINISHED_PROGRESS_STR for _ in range(20 - math.floor(percentage / 5)))), round(percentage, 2), url, custom_file_name, humanbytes(downloaded), humanbytes(total_length), speed, estimated_total_time) await message.edit(progress_str, disable_web_page_preview=True) await asyncio.sleep(Config.EDIT_SLEEP_TIMEOUT) if message.process_is_canceled: raise ProcessCanceled return dl_loc, (datetime.now() - start_t).seconds
async def term_(message: Message): """ run commands in shell (terminal with live update) """ await message.edit("`Executing terminal ...`") cmd = message.filtered_input_str as_raw = '-r' in message.flags try: parsed_cmd = parse_py_template(cmd, message) except Exception as e: # pylint: disable=broad-except await message.err(str(e)) await CHANNEL.log(f"**Exception**: {type(e).__name__}\n**Message**: " + str(e)) return try: t_obj = await Term.execute(parsed_cmd) # type: Term except Exception as t_e: # pylint: disable=broad-except await message.err(str(t_e)) return cur_user = getuser() uid = geteuid() prefix = f"<b>{cur_user}:~#</b>" if uid == 0 else f"<b>{cur_user}:~$</b>" output = f"{prefix} <pre>{cmd}</pre>\n" with message.cancel_callback(t_obj.cancel): await t_obj.init() while not t_obj.finished: await message.edit(f"{output}<pre>{t_obj.line}</pre>", parse_mode='html') await t_obj.wait(config.Dynamic.EDIT_SLEEP_TIMEOUT) if t_obj.cancelled: await message.canceled(reply=True) return out_data = f"{output}<pre>{t_obj.output}</pre>\n{prefix}" await message.edit_or_send_as_file(out_data, as_raw=as_raw, parse_mode='html', filename="term.txt", caption=cmd)
async def tg_download(message: Message, to_download: Message, from_url: bool = False) -> Tuple[str, int]: """ download from tg file """ if not to_download.media: dl_loc, mite = [], 0 ets = extract_entities( to_download, [enums.MessageEntityType.URL, enums.MessageEntityType.TEXT_LINK]) if len(ets) == 0: raise Exception("nothing found to download") for uarl in ets: _dl_loc, b_ = await url_download(message, uarl) dl_loc.append(_dl_loc) mite += b_ return dumps(dl_loc), mite await message.edit("`Downloading From TG...`") start_t = datetime.now() custom_file_name = config.Dynamic.DOWN_PATH if message.filtered_input_str and not from_url: custom_file_name = os.path.join(config.Dynamic.DOWN_PATH, message.filtered_input_str.strip()) elif "|" in message.filtered_input_str: _, c_file_name = message.filtered_input_str.split("|", maxsplit=1) if c_file_name: custom_file_name = os.path.join(config.Dynamic.DOWN_PATH, c_file_name.strip()) with message.cancel_callback(): dl_loc = await message.client.download_media( message=to_download, file_name=custom_file_name, progress=progress, progress_args=(message, "trying to download")) if message.process_is_canceled: raise ProcessCanceled if not isinstance(dl_loc, str): raise TypeError("File Corrupted!") dl_loc = os.path.relpath(dl_loc) return dl_loc, (datetime.now() - start_t).seconds
async def url_download(message: Message, url: str) -> Tuple[str, int]: """ download from link """ pattern = r"^(?:(?:https|tg):\/\/)?(?:www\.)?(?:t\.me\/|openmessage\?)(?:(?:c\/(\d+))|(\w+)|(?:user_id\=(\d+)))(?:\/|&message_id\=)(\d+)(\?single)?$" # noqa # group 1: private supergroup id, group 2: chat username, # group 3: private group/chat id, group 4: message id # group 5: check for download single media from media group match = re.search(pattern, url.split('|', 1)[0].strip()) if match: chat_id = None msg_id = int(match.group(4)) if match.group(1): chat_id = int("-100" + match.group(1)) elif match.group(2): chat_id = match.group(2) elif match.group(3): chat_id = int(match.group(3)) if chat_id and msg_id: resource = await message.client.get_messages(chat_id, msg_id) if resource.media_group_id and not bool(match.group(5)): output = await handle_download(message, resource, True) elif resource.media: output = await tg_download(message, resource, True) else: raise Exception("given tg link doesn't have any media") return output raise Exception("invalid telegram message link!") await message.edit("`Downloading From URL...`") start_t = datetime.now() custom_file_name = unquote_plus(os.path.basename(url)) if "|" in url: url, c_file_name = url.split("|", maxsplit=1) url = url.strip() if c_file_name: custom_file_name = c_file_name.strip() dl_loc = os.path.join(config.Dynamic.DOWN_PATH, custom_file_name) downloader = SmartDL(url, dl_loc, progress_bar=False) downloader.start(blocking=False) with message.cancel_callback(downloader.stop): while not downloader.isFinished(): total_length = downloader.filesize if downloader.filesize else 0 downloaded = downloader.get_dl_size() percentage = downloader.get_progress() * 100 speed = downloader.get_speed(human=True) estimated_total_time = downloader.get_eta(human=True) progress_str = \ "__{}__\n" + \ "```[{}{}]```\n" + \ "**Progress** : `{}%`\n" + \ "**URL** : `{}`\n" + \ "**FILENAME** : `{}`\n" + \ "**Completed** : `{}`\n" + \ "**Total** : `{}`\n" + \ "**Speed** : `{}`\n" + \ "**ETA** : `{}`" progress_str = progress_str.format( "trying to download", ''.join( (config.FINISHED_PROGRESS_STR for _ in range(math.floor(percentage / 5)))), ''.join( (config.UNFINISHED_PROGRESS_STR for _ in range(20 - math.floor(percentage / 5)))), round(percentage, 2), url, custom_file_name, humanbytes(downloaded), humanbytes(total_length), speed, estimated_total_time) await message.edit(progress_str, disable_web_page_preview=True) await asyncio.sleep(config.Dynamic.EDIT_SLEEP_TIMEOUT) if message.process_is_canceled: raise ProcessCanceled return dl_loc, (datetime.now() - start_t).seconds