async def download(self) -> None: """ Download file/folder from GDrive """ await self._message.edit("`Loading GDrive Download...`") file_id, _ = self._get_file_id() pool.submit_thread(self._download, file_id) start_t = datetime.now() count = 0 while not self._is_finished: count += 1 if self._message.process_is_canceled: self._cancel() if self._progress is not None and count >= 5: count = 0 await self._message.try_to_edit(self._progress) await asyncio.sleep(1) end_t = datetime.now() m_s = (end_t - start_t).seconds if isinstance(self._output, HttpError): out = f"**ERROR** : `{self._output._get_reason()}`" # pylint: disable=protected-access elif self._output is not None and not self._is_canceled: out = f"**Downloaded Successfully** __in {m_s} seconds__\n\n`{self._output}`" elif self._output is not None and self._is_canceled: out = self._output else: out = "`failed to download.. check logs?`" await self._message.edit(out, disable_web_page_preview=True, log=__name__)
async def copy(self) -> None: """ Copy file/folder in GDrive """ if not self._parent_id: await self._message.edit("First set parent path by `.gset`", del_in=5) return await self._message.edit("`Loading GDrive Copy...`") file_id, _ = self._get_file_id() pool.submit_thread(self._copy, file_id) start_t = datetime.now() count = 0 while not self._is_finished: count += 1 if self._message.process_is_canceled: self._cancel() if self._progress is not None and count >= 5: count = 0 await self._message.try_to_edit(self._progress) await asyncio.sleep(1) end_t = datetime.now() m_s = (end_t - start_t).seconds if isinstance(self._output, HttpError): out = f"**ERROR** : `{self._output._get_reason()}`" # pylint: disable=protected-access elif self._output is not None and not self._is_canceled: out = f"**Copied Successfully** __in {m_s} seconds__\n\n{self._output}" elif self._output is not None and self._is_canceled: out = self._output else: out = "`failed to copy.. check logs?`" await self._message.edit(out, disable_web_page_preview=True, log=__name__)
def combine(self) -> None: """Combine Split files""" file_name, ext = splitext(basename(self._path)) self._final_file_path = join(dirname(self._path), file_name) file_list = sorted(glob(self._final_file_path + f".{'[0-9]' * len(ext.lstrip('.'))}")) self._total = len(file_list) self._file_size = sum((os.stat(f_).st_size for f_ in file_list)) pool.submit_thread(self._combine_worker, file_list)
async def upload(self) -> None: """ Upload from file/folder/link/tg file to GDrive """ replied = self._message.reply_to_message is_url = re.search(r"(?:https?|ftp)://[^|\s]+\.[^|\s]+", self._message.input_str) dl_loc = "" if replied and replied.media: try: dl_loc, _ = await tg_download(self._message, replied) except ProcessCanceled: await self._message.canceled() return except Exception as e_e: await self._message.err(str(e_e)) return elif is_url: try: dl_loc, _ = await url_download(self._message, self._message.input_str) except ProcessCanceled: await self._message.canceled() return except Exception as e_e: await self._message.err(str(e_e)) return file_path = dl_loc if dl_loc else self._message.input_str if not os.path.exists(file_path): await self._message.err("invalid file path provided?") return if "|" in file_path: file_path, file_name = file_path.split("|") new_path = os.path.join(os.path.dirname(file_path.strip()), file_name.strip()) os.rename(file_path.strip(), new_path) file_path = new_path await self._message.try_to_edit("`Loading GDrive Upload...`") pool.submit_thread(self._upload, file_path) start_t = datetime.now() with self._message.cancel_callback(self._cancel): while not self._is_finished: if self._progress is not None: await self._message.edit(self._progress) await asyncio.sleep(Config.EDIT_SLEEP_TIMEOUT) if dl_loc and os.path.exists(dl_loc): os.remove(dl_loc) end_t = datetime.now() m_s = (end_t - start_t).seconds if isinstance(self._output, HttpError): out = f"**ERROR** : `{self._output._get_reason()}`" # pylint: disable=protected-access elif self._output is not None and not self._is_canceled: out = f"**Uploaded Successfully** __in {m_s} seconds__\n\n{self._output}" elif self._output is not None and self._is_canceled: out = self._output else: out = "`failed to upload.. check logs?`" await self._message.edit(out, disable_web_page_preview=True, log=__name__)
def split(self, split_size: int) -> None: """Split files""" split_size = int(split_size) * 1024 * 1024 self._file_size = os.stat(self._path).st_size if self._chunk_size > split_size: self._chunk_size = split_size times = int(ceil(split_size / self._chunk_size)) self._total = int(ceil(self._file_size / split_size)) self._final_file_path = join( dirname(self._path), f"split_{basename(self._path).replace('.', '_')}") if not isdir(self._final_file_path): os.makedirs(self._final_file_path) pool.submit_thread(self._split_worker, times)
def pack_path(self, tar: bool) -> None: """PACK file path""" file_paths = [] def explorer(path: Path) -> None: if path.is_file(): self._total += 1 file_paths.append(str(path)) elif path.is_dir(): for i in path.iterdir(): explorer(i) explorer(Path(self._file_path)) file_name = basename(self._file_path) if tar: file_name += '.tar' p_type = tar_open else: file_name += '.zip' p_type = ZipFile self._final_file_path = join(Config.DOWN_PATH, file_name) pool.submit_thread(self._zip, p_type, file_paths, self._final_file_path)
def unpack_path(self) -> None: """ UNPACK file path """ chunked_file_names = [] temp_file_names = [] temp_size = 0 min_chunk_size = 1024 * 1024 * 10 for f_n, f_s in self.get_info(): self._total += 1 temp_size += f_s temp_file_names.append(f_n) if temp_size >= min_chunk_size: temp_size = 0 chunked_file_names.append(temp_file_names) temp_file_names = [] if temp_file_names: chunked_file_names.append(temp_file_names) dir_name = splitext(basename(self._file_path))[0] self._final_file_path = join( Config.DOWN_PATH, dir_name.replace('.tar', '').replace('.', '_')) for f_n_s in chunked_file_names: pool.submit_thread(self._unpack, f_n_s)
async def upload(self) -> None: """ Upload from file/folder/link/tg file to GDrive """ replied = self._message.reply_to_message is_url = re.search( r"(?:https?|ftp)://[^\|\s]+\.[^\|\s]+", self._message.input_str) dl_loc = None if replied and replied.media: await self._message.edit("`Downloading From TG...`") file_name = Config.DOWN_PATH if self._message.input_str: file_name = os.path.join(Config.DOWN_PATH, self._message.input_str) dl_loc = await self._message.client.download_media( message=replied, file_name=file_name, progress=progress, progress_args=(self._message, "trying to download") ) if self._message.process_is_canceled: await self._message.edit("`Process Canceled!`", del_in=5) return dl_loc = os.path.join(Config.DOWN_PATH, os.path.basename(dl_loc)) elif is_url: await self._message.edit("`Downloading From URL...`") url = is_url[0] file_name = unquote_plus(os.path.basename(url)) if "|" in self._message.input_str: file_name = self._message.input_str.split("|")[1].strip() dl_loc = os.path.join(Config.DOWN_PATH, file_name) try: downloader = SmartDL(url, dl_loc, progress_bar=False) downloader.start(blocking=False) count = 0 while not downloader.isFinished(): if self._message.process_is_canceled: downloader.stop() raise Exception('Process Canceled!') 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 i in range(math.floor(percentage / 5)))), ''.join((Config.UNFINISHED_PROGRESS_STR for i in range(20 - math.floor(percentage / 5)))), round(percentage, 2), url, file_name, humanbytes(downloaded), humanbytes(total_length), speed, estimated_total_time) count += 1 if count >= 5: count = 0 await self._message.try_to_edit( progress_str, disable_web_page_preview=True) await asyncio.sleep(1) except Exception as d_e: await self._message.err(d_e) return file_path = dl_loc if dl_loc else self._message.input_str if not os.path.exists(file_path): await self._message.err("invalid file path provided?") return if "|" in file_path: file_path, file_name = file_path.split("|") new_path = os.path.join(os.path.dirname(file_path.strip()), file_name.strip()) os.rename(file_path.strip(), new_path) file_path = new_path await self._message.edit("`Loading GDrive Upload...`") pool.submit_thread(self._upload, file_path) start_t = datetime.now() count = 0 while not self._is_finished: count += 1 if self._message.process_is_canceled: self._cancel() if self._progress is not None and count >= 5: count = 0 await self._message.try_to_edit(self._progress) await asyncio.sleep(1) if dl_loc and os.path.exists(dl_loc): os.remove(dl_loc) end_t = datetime.now() m_s = (end_t - start_t).seconds if isinstance(self._output, HttpError): out = f"**ERROR** : `{self._output._get_reason()}`" # pylint: disable=protected-access elif self._output is not None and not self._is_canceled: out = f"**Uploaded Successfully** __in {m_s} seconds__\n\n{self._output}" elif self._output is not None and self._is_canceled: out = self._output else: out = "`failed to upload.. check logs?`" await self._message.edit(out, disable_web_page_preview=True, log=__name__)
async def eval_(message: Message): """ run python code """ for t in tuple(_EVAL_TASKS): if t.done(): del _EVAL_TASKS[t] flags = message.flags size = len(_EVAL_TASKS) if '-l' in flags: if _EVAL_TASKS: out = "**Eval Tasks**\n\n" i = 0 for c in _EVAL_TASKS.values(): out += f"**{i}** - `{c}`\n" i += 1 out += f"\nuse `{Config.CMD_TRIGGER}eval -c[id]` to Cancel" await message.edit(out) else: await message.edit("No running eval tasks !", del_in=5) return if ('-c' in flags or '-ca' in flags) and size == 0: await message.edit("No running eval tasks !", del_in=5) return if '-ca' in flags: for t in _EVAL_TASKS: t.cancel() await message.edit(f"Canceled all running eval tasks [{size}] !", del_in=5) return if '-c' in flags: t_id = int(flags.get('-c', -1)) if t_id < 0 or t_id >= size: await message.edit(f"Invalid eval task id [{t_id}] !", del_in=5) return list(_EVAL_TASKS)[t_id].cancel() await message.edit(f"Canceled eval task [{t_id}] !", del_in=5) return cmd = await init_func(message) if cmd is None: return _flags = [] for _ in range(3): _found = False for f in ('-s', '-p', '-n'): if cmd.startswith(f): _found = True _flags.append(f) cmd = cmd[len(f):].strip() if not cmd: break if not _found or not cmd: break if not cmd: await message.err("Unable to Parse Input!") return silent_mode = '-s' in _flags if '-n' in _flags: context_type = _ContextType.NEW elif '-p' in _flags: context_type = _ContextType.PRIVATE else: context_type = _ContextType.GLOBAL async def _callback(output: Optional[str], errored: bool): final = "" if not silent_mode: final += f"**>** ```{cmd}```\n\n" if isinstance(output, str): output = output.strip() if output == '': output = None if output is not None: final += f"**>>** ```{output}```" if errored and message.chat.type in ("group", "supergroup", "channel"): msg_id = await CHANNEL.log(final) await msg.edit(f"**Logs**: {CHANNEL.get_link(msg_id)}") elif final: await msg.edit_or_send_as_file(text=final, parse_mode='md', filename="eval.txt", caption=cmd) else: await msg.delete() msg = message replied = message.reply_to_message if (replied and replied.from_user and replied.from_user.is_self and isinstance(replied.text, Str) and str(replied.text.html).startswith("<b>></b> <pre>")): msg = replied await msg.edit("`Executing eval ...`", parse_mode='md') _g, _l = _context(context_type, userge=userge, message=message, replied=message.reply_to_message) l_d = {} try: exec(_wrap_code(cmd, _l.keys()), _g, l_d) # nosec pylint: disable=W0122 except Exception: # pylint: disable=broad-except _g[_KEY] = _l await _callback(traceback.format_exc(), True) return future = asyncio.get_event_loop().create_future() pool.submit_thread(_run_coro, future, l_d['__aexec'](*_l.values()), _callback) hint = cmd.split('\n')[0] _EVAL_TASKS[future] = hint[:25] + "..." if len(hint) > 25 else hint with msg.cancel_callback(future.cancel): try: await future except asyncio.CancelledError: await asyncio.gather( msg.canceled(), CHANNEL.log(f"**EVAL Process Canceled!**\n\n```{cmd}```")) finally: _EVAL_TASKS.pop(future, None)