def test_download(self): obj = SmartDL(self.default_7za920_mirrors, dest=self.dl_dir, progress_bar=False) obj.start() data = obj.get_data(binary=True, bytes=2) self.assertEqual(data, 'PK')
def largeNzedbPre(): if os.path.isfile('predb_dump-062714.csv.gz'): fileExists = True else: try: url = "https://www.dropbox.com/s/btr42dtzzyu3hh3/predb_dump-062714.csv.gz?dl=1" dest = "." print("pre-import: File predb_dump-062714.csv not found, attempt to download - may take a while, its 300mb") obj = SmartDL(url, dest) obj.start() fileExists = True except: print("pre-import: Error downloading/unzipping. Please try again.") exit(0) if fileExists: dirtyChunk = pandas.read_table('predb_dump-062714.csv.gz', compression='gzip', sep='\t', header=None, na_values='\\N', usecols=[0, 8, 10, 14, 16, 18, 20, 22], names=COLNAMES, chunksize=10000, engine='c', error_bad_lines=False, warn_bad_lines=False) else: print("pre-import: File predb_dump-062714.csv not found, please try again.") exit(0) i = 0 for chunk in dirtyChunk: process(chunk) print("pre-import: Imported chunk {}".format(i)) i += 1
class Downloader: def __init__(self, url): self.url = url self.dest = '~/Downloads/' self.dloader = SmartDL(self.url, self.dest) def start(self): self.dloader.start()
def run(self): while dlQueue.not_empty: index = dlQueue.get() logging.info('Downloader : Grabbed an item. {0} remaining'.format(dlQueue.qsize())) path = ".%s%s" % (os.sep, '{title}.mp4'.format(title=foundEpTitles[index])) if os.path.isfile(path): logging.info("Downloader : The file at %s already exists. Skipping..." % (path)) foundEpFileStatus[index] = "Grabbed" dlQueue.task_done() else: logging.info('Downloader : Getting {file}'.format(file=foundEpTitles[index])) obj = SmartDL(foundEpFilelinks[index], path, progress_bar=False) try: obj.start(blocking=True) if obj.isSuccessful(): foundEpFileStatus[index] = "Grabbed" logging.info("Downloader : Grabbed '%s' in %s" % (obj.get_dest(), obj.get_dl_time(human=True))) dlQueue.task_done() else: foundEpFilelinks[index] = 'new' logging.info("Downloader : Error grabbing '%s'" % obj.get_dest()) dlQueue.task_done() for e in obj.get_errors(): logging.error(str(e)) except KeyboardInterrupt: obj.stop() time.sleep(self.interval)
def download(url, name, quiet=False): path = ".%s%s" % (os.sep, name) if os.path.isfile(path): if not quiet: print "Skipping %s" % name return else: obj = SmartDL(url, path) try: obj.start() except KeyboardInterrupt: obj.stop()
def lunch(rsqt,filename,appname,execuable): import os,os.path d='%s%s\\'%(getTempDir('app'),filename.replace('.','_')) if execu(d,execuable): return filePath='%s%s'%(d,filename) if not os.path.exists(filePath): url='http://%s/blaze/download/%s'%(remoteHost,filename) from pySmartDL import SmartDL sdl = SmartDL(url, d,progress_bar=True) sdl.start() filePath = sdl.get_dest() import zip zip.extract(filePath, d) execu(d,execuable)
def start_component_update(self): if not os.path.exists(config.ext_bin_path): os.makedirs(config.ext_bin_path) d = Main.WebParser.WebServices.get_components_data() for i, component in enumerate(self.components): urls, archive_hash, file_to_extract, file_hash = d[component] fn = urls[0].split('/')[-1] log.debug("Downloading Component %s [%d/%d]..." % (component, i+1, len(self.components))) self.label1.setText(tr("Downloading %s...") % component) self.label2.setText(tr("File: <i>%s</i> [%d/%d]") % (fn, i+1, len(self.components))) obj = SmartDL(urls, logger=log) obj.add_hash_verification('sha256', archive_hash) obj.start(blocking=False) b = True while not obj.isFinished(): if b: self.label1.setText(tr("Downloading %s (%.2f MB)...") % (component, obj.filesize/1024.0**2)) b = False QtGui.QApplication.processEvents() self.prg_bar.setValue(int(obj.get_progress()*100)) time.sleep(0.1) if obj._failed: QtGui.QMessageBox.critical(self, tr("Error"), tr("The download has failed. It may be a network connection problem. Please try to rerun this application and try again."), QtGui.QMessageBox.Ok) self.close() self.prg_bar.setValue(100) self.label1.setText(tr("Unpacking %s...") % component) ext = os.path.splitext(obj.get_dest())[1].lower() if ext == '.zip': zipObj = zipfile.ZipFile(obj.get_dest()) zipObj.extract(file_to_extract, config.ext_bin_path) elif ext == '.7z': cmd = r'"%s\7za.exe" e "%s" -ir!%s -y -o"%s"' % (config.ext_bin_path, obj.get_dest(), file_to_extract, config.ext_bin_path) subprocess.check_call(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) else: log.error('could not extract %s archive.' % ext) self.close()
def audios(link): print("Enter the Minimum size of file to be downloaded\n") size = input('> ') size = int(size) url = urllib.request.urlopen(link) content = url.read() soup = BeautifulSoup(content) links = [a['href'] for a in soup.find_all('a',href=re.compile('http.*\.(mp3|wav|ogg|wma|flac)'))] print (str(len(links)) + " Audios Found ") # print (links) print("\n".join(links)) #For Downloading dest = "~/Downloads/" # or '~/Downloads/' on linux for i in range(len(links)): #a_link = urllib.request.Request(links[i]) #a_link2 = int(round((links[i].length / 1024),2)) / 1024 #req = urllib.request.Request(a_link, method='HEAD') #resp = urllib.request.urlopen(req) #resp = urllib.request.urlopen(a_link) #size = int(resp.headers['Content-Length']) #size = int(a_link.length) #a_link2 = urllib.request.urlopen(a_link) #site = urllib.request.urlopen(a_link) #size2 = int((a_link.length / 1024) / 1024) a_link = links[i] fix_link = utils.url_fix(a_link) b =(utils.get_filesize(fix_link, timeout=15)) print (utils.sizeof_human(b)) #if size >= b: obj = SmartDL(fix_link, dest) obj.start() path = obj.get_dest()
def docs(link): print("Enter the Minimum size of file to be downloaded\n") u_size = input('> ') u_size = int(u_size) url = urllib.request.urlopen(link) #link = Request(url, headers={'User-Agent': 'Mozilla/5.0'}) content = url.read() soup = BeautifulSoup(content) links = [a['href'] for a in soup.find_all('a',href=re.compile('http.*\.(pdf|doc|docx|odt|xls|ppt)'))] print (str(len(links)) + " Documents Found ") # print (links) print("\n".join(links)) dest = "~/Downloads/" for i in range(len(links)): a_link = links[i] fix_link = utils.url_fix(a_link) #b =(utils.get_filesize(fix_link, timeout=200000)) b =(utils.get_filesize(fix_link)) print (utils.sizeof_human(b)) c_size =(utils.get_filesize(fix_link, timeout=15)) c_size = (b / 1024) #print (round(c_size,2)) if u_size <= c_size: obj = SmartDL(fix_link, dest) obj.start() path = obj.get_dest() main();
def test_get_components_data(): d = Main.WebParser.WebServices.get_components_data() assert d for name, t in d.items(): urls, archive_hash, file_to_extract, file_hash = t for url in urls: obj = SmartDL(url) obj.add_hash_verification('sha256', archive_hash) obj.start() assert obj.isSuccessful() os.unlink(obj.get_dest())
def test_get_packages_data(): d = Main.WebParser.WebServices.get_packages_data() assert d for name, t in d.items(): urls, file_hash, install_param = t for url in urls: obj = SmartDL(url) obj.add_hash_verification('sha256', file_hash) obj.start() assert obj.isSuccessful() os.unlink(obj.get_dest())
def start_package_install(self): d = Main.WebParser.WebServices.get_packages_data() for i, component in enumerate(self.components): urls, file_hash, install_param = d[component] fn = urls[0].split('/')[-1] log.debug("Downloading Component %s [%d/%d]..." % (component, i+1, len(self.components))) self.label1.setText(tr("Downloading %s...") % component) self.label2.setText(tr("File: <i>%s</i> [%d/%d]") % (fn, i+1, len(self.components))) for j in range(self.retries): obj = SmartDL(urls, logger=log) obj.start(blocking=False) b = True while not obj.isFinished(): if b: self.label1.setText(tr("Downloading %s (%.2f MB)...") % (component, obj.filesize/1024.0**2)) b = False QtGui.QApplication.processEvents() self.prg_bar.setValue(int(obj.get_progress()*100)) time.sleep(0.1) if obj._failed: QtGui.QMessageBox.critical(self, tr("Error"), tr("The download has failed. It may be a network connection problem. Please try to rerun this application and try again."), QtGui.QMessageBox.Ok) self.close() self.prg_bar.setValue(100) computed_hash = utils.calc_sha256(obj.get_dest()) if file_hash == computed_hash: log.debug('Hash for %s is valid.' % component) break else: log.warning('Hash for %s is NOT valid (%s != %s). Retrying (%d/%d)...' % (component, file_hash, computed_hash, j+1, self.retries)) if file_hash != computed_hash: log.error('Hash for %s is NOT valid (%s != %s).' % (component, file_hash, computed_hash)) QtGui.QMessageBox.warning(self, tr("Warning"), tr("Hash check failed for %s. Please contact with the program's developer.") % component, QtGui.QMessageBox.Ok) self.close() return path = obj.get_dest() install_params = [path] + install_param self.label1.setText(tr("Installing %s...") % component) subprocess.call(install_params, shell=True) QtGui.QApplication.processEvents() self.close()
def download_file(task, full_path, url): logger.info('Downloading file from: %s', full_path) global downloader downloader = SmartDL(url, full_path, progress_bar=False, logger=logger) stat_job = scheduler.scheduler.add_job(get_download_stats, args=(task,), trigger='interval', seconds=1, max_instances=1, next_run_time=datetime.datetime.now()) downloader.start(blocking=True) while not downloader.isFinished(): print('wrong! waiting for downloader before finished') stat_job.remove() if downloader.isSuccessful(): global total_size_downloaded total_size_downloaded += downloader.get_dl_size() logger.info('Finished downloading file from: %s', full_path) else: logger.error('Error while downloading file from: %s', full_path) for e in downloader.get_errors(): logger.error(str(e))
async def autopic(event): await event.edit("colour profile pic have been enabled") downloaded_file_name = "./FRIDAY/original_pic.png" downloader = SmartDL(Var.DOWNLOAD_PFP_URL_CLOCK, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) photo = "photo_pfp.png" while not downloader.isFinished(): place_holder = None while True: #RIP Danger zone Here no editing here plox R = random.randint(0, 256) B = random.randint(0, 256) G = random.randint(0, 256) FR = (256 - R) FB = (256 - B) FG = (256 - G) shutil.copy(downloaded_file_name, photo) image = Image.open(photo) image.paste((R, G, B), [0, 0, image.size[0], image.size[1]]) image.save(photo) #Edit only Below part ð Or esle u will be responsible ð¤·ââ current_time = datetime.now().strftime( "\n\n Time: %H:%M:%S \n \n Date: %d/%m/%y") img = Image.open(photo) drawn_text = ImageDraw.Draw(img) fnt = ImageFont.truetype(FONT_FILE_TO_USE, 40) ofnt = ImageFont.truetype(FONT_FILE_TO_USE, 40) drawn_text.text((200, 400), current_time, font=fnt, fill=(FR, FG, FB)) drawn_text.text((250, 250), f"{DEFAULTUSER}", font=ofnt, fill=(FR, FG, FB)) img.save(photo) file = await event.client.upload_file(photo) # pylint:disable=E0602 try: await event.client( functions.photos.DeletePhotosRequest( await event.client.get_profile_photos("me", limit=1))) await event.client( functions.photos.UploadProfilePhotoRequest( # pylint:disable=E0602 file)) os.remove(photo) await asyncio.sleep(60) except: return
import time from pySmartDL import SmartDL url_100mb_file = ['http://www.debian.co.il/debian-cd/7.5.0/i386/iso-cd/debian-7.5.0-i386-netinst.iso'] # url_100mb_file = "http://httpbin.org/basic-auth/user/passwd" # url_100mb_file = "http://cachefly.cachefly.net/100mb.test" url_100mb_file = 'https://r1---sn-ivuoxu-ua8l.googlevideo.com/videoplayback?requiressl=yes&sver=3&signature=B08C02FDEDC76633D28EA9F72121F341BD471250.CD791E123F116CE2E480BCDEED4268DE35934249&itag=84&id=o-ALsVuxK7RU-9cWXebyXGLBf3xiFZN7N6aMkvkpevG9Jm&sparams=id%2Cip%2Cipbits%2Citag%2Cpcm2%2Cratebypass%2Crequiressl%2Csource%2Cupn%2Cexpire&ms=au&upn=k-0bari8bTI&mt=1399282666&expire=1399304082&mv=m&pcm2=yes&source=youtube&fexp=933905%2C935501%2C939936%2C945033%2C929305%2C932936%2C937417%2C913434%2C923341%2C936923%2C902408%2C945044&ipbits=0&ratebypass=yes&ip=37.142.247.11&key=yt5&mws=yes' obj = SmartDL(url_100mb_file, progress_bar=False, connect_default_logger=True) # obj.add_basic_authentication('user', 'passwd') # obj.fetch_hash_sums() # import pdb; pdb.set_trace() obj.start(blocking=False) import pdb; pdb.set_trace() while not obj.isFinished(): print "Speed: %s" % obj.get_speed(human=True) print "Already downloaded: %s" % obj.get_dl_size(human=True) print "Eta: %s" % obj.get_eta(human=True) print "Progress: %d%%" % (obj.get_progress()*100) print "Progress bar: %s" % obj.get_progress_bar() print "Status: %s" % obj.get_status() print "\n"*2+"="*50+"\n"*2 time.sleep(0.2) if obj.isSuccessful(): print "downloaded file to '%s'" % obj.get_dest() print "download task took %ss" % obj.get_dl_time(human=True) print "File hashes:" print " * MD5: %s" % obj.get_data_hash('md5') print " * SHA1: %s" % obj.get_data_hash('sha1') print " * SHA256: %s" % obj.get_data_hash('sha256')
async def download(target_file): """For .download command, download files to the userbot's server.""" await target_file.edit("`Sedang memproses...`") input_str = target_file.pattern_match.group(1) replied = await target_file.get_reply_message() if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY): os.makedirs(TEMP_DOWNLOAD_DIRECTORY) if input_str: url = input_str file_name = unquote_plus(os.path.basename(url)) if "|" in input_str: url, file_name = input_str.split("|") url = url.strip() # https://stackoverflow.com/a/761825/4723940 file_name = file_name.strip() head, tail = os.path.split(file_name) if head: if not os.path.isdir( os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)): os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)) file_name = os.path.join(head, tail) downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) c_time = time.time() display_message = None while not downloader.isFinished(): status = downloader.get_status().capitalize() total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() now = time.time() diff = now - c_time percentage = downloader.get_progress() * 100 speed = downloader.get_speed() progress_str = "[{0}{1}] `{2}%`".format( "".join(["■" for i in range(math.floor(percentage / 10))]), "".join(["▨" for i in range(10 - math.floor(percentage / 10))]), round(percentage, 2), ) estimated_total_time = downloader.get_eta(human=True) try: current_message = ( f"`Nama` : `{file_name}`\n" "Status" f"\n**{status}**... | {progress_str}" f"\n{humanbytes(downloaded)} dari {humanbytes(total_length)}" f" @ {humanbytes(speed)}" f"\n`Perkiraan` -> {estimated_total_time}") if round(diff % 15.00) == 0 and current_message != display_message: await target_file.edit(current_message) display_message = current_message except Exception as e: LOGS.info(str(e)) if downloader.isSuccessful(): await target_file.edit( "Berhasil diunduh ke `{}`!".format(downloaded_file_name)) else: await target_file.edit("**URL salah**\n{}".format(url)) elif replied: if not replied.media: return await target_file.edit("`Balas file atau media`") try: media = replied.media if hasattr(media, "document"): file = media.document mime_type = file.mime_type filename = replied.file.name if not filename: if "audio" in mime_type: filename = ("audio_" + datetime.now().isoformat("_", "seconds") + ".ogg") elif "video" in mime_type: filename = ("video_" + datetime.now().isoformat("_", "seconds") + ".mp4") outdir = TEMP_DOWNLOAD_DIRECTORY + filename c_time = time.time() start_time = datetime.now() with open(outdir, "wb") as f: result = await download_file( client=target_file.client, location=file, out=f, progress_callback=lambda d, t: asyncio.get_event_loop( ).create_task( progress(d, t, target_file, c_time, "[UNDUH]", input_str)), ) else: start_time = datetime.now() result = await target_file.client.download_media( media, TEMP_DOWNLOAD_DIRECTORY) dl_time = (datetime.now() - start_time).seconds except Exception as e: # pylint:disable=C0103,W0703 await target_file.edit(str(e)) else: try: await target_file.edit( "Berhasil diunduh ke `{}` dalam `{}` detik.".format( result.name, dl_time)) except AttributeError: await target_file.edit( "Berhasil diunduh ke `{}` dalam `{}` detik.".format( result, dl_time)) else: await target_file.edit( "Lihat `“.help download”` untuk info lebih lanjut.")
async def download(target_file): """ .download komutu userbot sunucusuna dosya indirmenizi sağlar. """ await target_file.edit("İşleniyor...") input_str = target_file.pattern_match.group(1) if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY): os.makedirs(TEMP_DOWNLOAD_DIRECTORY) if "|" in input_str: url, file_name = input_str.split("|") url = url.strip() # https://stackoverflow.com/a/761825/4723940 file_name = file_name.strip() head, tail = os.path.split(file_name) if head: if not os.path.isdir(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)): os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)) file_name = os.path.join(head, tail) downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) c_time = time.time() display_message = None while not downloader.isFinished(): status = downloader.get_status().capitalize() total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() now = time.time() diff = now - c_time percentage = downloader.get_progress() * 100 progress_str = "[{0}{1}] {2}%".format( ''.join(["▰" for i in range(math.floor(percentage / 10))]), ''.join(["▱" for i in range(10 - math.floor(percentage / 10))]), round(percentage, 2)) estimated_total_time = downloader.get_eta(human=True) try: current_message = f"{status}..\ \nBağlantı: {url}\ \nDosya adı: {file_name}\ \n{progress_str}\ \n{humanbytes(downloaded)} of {humanbytes(total_length)}\ \nTahmini bitiş: {estimated_total_time}" if round(diff % 10.00) == 0 and current_message != display_message: await target_file.edit(current_message) display_message = current_message except Exception as e: LOGS.info(str(e)) if downloader.isSuccessful(): await target_file.edit( "`{}` konumuna indirme başarılı.".format(downloaded_file_name)) else: await target_file.edit("Geçersiz bağlantı\n{}".format(url)) elif target_file.reply_to_msg_id: try: c_time = time.time() downloaded_file_name = await target_file.client.download_media( await target_file.get_reply_message(), TEMP_DOWNLOAD_DIRECTORY, progress_callback=lambda d, t: asyncio.get_event_loop( ).create_task( progress(d, t, target_file, c_time, "İndiriliyor..."))) except Exception as e: # pylint:disable=C0103,W0703 await target_file.edit(str(e)) else: await target_file.edit( "`{}` konumuna indirme başarılı.".format(downloaded_file_name)) else: await target_file.edit("Sunucuma indirmek için bir mesajı yanıtlayın.")
def __init__(self, url): self.url = url self.dest = '~/Downloads/' self.dloader = SmartDL(self.url, self.dest)
def downloadMe(url): dest = "./" obj = SmartDL(url, dest) obj.start() return obj.get_dest()
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) count = 0 while not downloader.isFinished(): if message.process_is_canceled: downloader.stop() raise ProcessCanceled 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) count += 1 if count >= Config.EDIT_SLEEP_TIMEOUT: count = 0 await message.try_to_edit(progress_str, disable_web_page_preview=True) await asyncio.sleep(1) return dl_loc, (datetime.now() - start_t).seconds
async def uploadtotg(message: Message): flags = message.flags path_ = message.filtered_input_str if not path_: await message.edit("invalid input!, check `.help .upload`", del_in=5) return is_url = re.search(r"(?:https?|ftp)://[^|\s]+\.[^|\s]+", path_) del_path = False if is_url: del_path = True await message.edit("`Downloading From URL...`") if not os.path.isdir(Config.DOWN_PATH): os.mkdir(Config.DOWN_PATH) url = is_url[0] file_name = os.path.basename(url) if "|" in path_: file_name = path_.split("|")[1].strip() path_ = os.path.join(Config.DOWN_PATH, file_name) try: downloader = SmartDL(url, path_, progress_bar=False) downloader.start(blocking=False) count = 0 while not downloader.isFinished(): if 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(["■" for i in range(math.floor(percentage / 10))]), ''.join([ "▨" for i in range(10 - math.floor(percentage / 10)) ]), round(percentage, 2), url, file_name, humanbytes(downloaded), humanbytes(total_length), speed, estimated_total_time) count += 1 if count >= 5: count = 0 await message.try_to_edit(progress_str, disable_web_page_preview=True) await asyncio.sleep(1) except Exception as d_e: await message.err(d_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.edit("wrong syntax\n`.upload [path]`") else: await message.delete() await explorer(string, message.chat.id, flags, del_path)
def download(self, parent_path, filename, url): obj = SmartDL(url, parent_path) obj.start()
async def imdb_query(event): # sourcery no-metrics """To fetch imdb data about the given movie or series.""" catevent = await edit_or_reply(event, "`searching........`") reply_to = await reply_id(event) try: movie_name = event.pattern_match.group(1) movies = imdb.search_movie(movie_name) movieid = movies[0].movieID movie = imdb.get_movie(movieid) moviekeys = list(movie.keys()) for i in mov_titles: if i in moviekeys: mov_title = movie[i] break for j in reversed(mov_titles): if j in moviekeys: mov_ltitle = movie[j] break mov_runtime = movie["runtimes"][0] + " min" if "runtimes" in movie else "" if "original air date" in moviekeys: mov_airdate = movie["original air date"] elif "year" in moviekeys: mov_airdate = movie["year"] else: mov_airdate = "" mov_genres = ", ".join(movie["genres"]) if "genres" in moviekeys else "Not Data" mov_rating = str(movie["rating"]) if "rating" in moviekeys else "Not Data" mov_rating += ( " (by " + str(movie["votes"]) + ")" if "votes" in moviekeys and "rating" in moviekeys else "" ) mov_countries = ( ", ".join(movie["countries"]) if "countries" in moviekeys else "Not Data" ) mov_languages = ( ", ".join(movie["languages"]) if "languages" in moviekeys else "Not Data" ) mov_plot = ( str(movie["plot outline"]) if "plot outline" in moviekeys else "Not Data" ) mov_director = await get_cast("director", movie) mov_composers = await get_cast("composers", movie) mov_writer = await get_cast("writer", movie) mov_cast = await get_cast("cast", movie) mov_box = await get_moviecollections(movie) resulttext = f""" <b>Title : </b><code>{mov_title}</code> <b>Imdb Url : </b><a href='https://www.imdb.com/title/tt{movieid}'>{mov_ltitle}</a> <b>Info : </b><code>{mov_runtime} | {mov_airdate}</code> <b>Genres : </b><code>{mov_genres}</code> <b>Rating : </b><code>{mov_rating}</code> <b>Country : </b><code>{mov_countries}</code> <b>Language : </b><code>{mov_languages}</code> <b>Director : </b><code>{mov_director}</code> <b>Music Director : </b><code>{mov_composers}</code> <b>Writer : </b><code>{mov_writer}</code> <b>Stars : </b><code>{mov_cast}</code> <b>Box Office : </b>{mov_box} <b>Story Outline : </b><i>{mov_plot}</i>""" if "full-size cover url" in moviekeys: imageurl = movie["full-size cover url"] else: imageurl = None soup = BeautifulSoup(resulttext, features="html.parser") rtext = soup.get_text() if len(rtext) > 1024: extralimit = len(rtext) - 1024 climit = len(resulttext) - extralimit - 20 resulttext = resulttext[:climit] + "...........</i>" if imageurl: downloader = SmartDL(imageurl, moviepath, progress_bar=False) downloader.start(blocking=False) while not downloader.isFinished(): pass if os.path.exists(moviepath): await event.client.send_file( event.chat_id, moviepath, caption=resulttext, reply_to=reply_to, parse_mode="HTML", ) os.remove(moviepath) return await catevent.delete() await catevent.edit( resulttext, link_preview=False, parse_mode="HTML", ) except IndexError: await catevent.edit(f"__No movie found with name {movie_name}.__") except Exception as e: await catevent.edit(f"**Error:**\n__{e}__")
async def download(dryb): """ For .gdrive command, upload files to google drive. """ if not dryb.text[0].isalpha() and dryb.text[0] not in ("/", "#", "@", "!"): if dryb.fwd_from: return await dryb.edit("Processing ...") input_str = dryb.pattern_match.group(1) if CLIENT_ID is None or CLIENT_SECRET is None: return false if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY): os.makedirs(TEMP_DOWNLOAD_DIRECTORY) required_file_name = None if "|" in input_str: start = datetime.now() url, file_name = input_str.split("|") url = url.strip() # https://stackoverflow.com/a/761825/4723940 file_name = file_name.strip() head, tail = os.path.split(file_name) if head: if not os.path.isdir(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)): os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)) file_name = os.path.join(head, tail) downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) c_time = time.time() while not downloader.isFinished(): display_message = "" total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() now = time.time() diff = now - c_time percentage = downloader.get_progress()*100 speed = downloader.get_speed() elapsed_time = round(diff) * 1000 progress_str = "[{0}{1}]\nProgress: {2}%".format( ''.join(["█" for i in range(math.floor(percentage / 5))]), ''.join(["░" for i in range(20 - math.floor(percentage / 5))]), round(percentage, 2)) estimated_total_time = downloader.get_eta(human=True) try: current_message = f"Downloading...\nURL: {url}\nFile Name: {file_name}\n{progress_str}\n{humanbytes(downloaded)} of {humanbytes(total_length)}\nETA: {estimated_total_time}" if current_message != display_message: await dryb.edit(current_message) display_message = current_message except Exception as e: LOGS.info(str(e)) pass end = datetime.now() duration = (end - start).seconds if downloader.isSuccessful(): await dryb.edit( "Downloaded to `{}` in {} seconds.\nNow uploading to GDrive...".format( downloaded_file_name, duration) ) required_file_name = downloaded_file_name else: await dryb.edit( "Incorrect URL\n{}".format(url) ) elif input_str: input_str = input_str.strip() if os.path.exists(input_str): start = datetime.now() end = datetime.now() duration = (end - start).seconds required_file_name = input_str await dryb.edit("Found `{}` in {} seconds, uploading to Google Drive !!".format(input_str, duration)) else: await dryb.edit("File not found in local server. Give me a valid file path !!") return False elif dryb.reply_to_msg_id: start = datetime.now() try: c_time = time.time() downloaded_file_name = await dryb.client.download_media( await dryb.get_reply_message(), TEMP_DOWNLOAD_DIRECTORY, progress_callback=lambda d, t: asyncio.get_event_loop().create_task( progress(d, t, dryb, c_time, "Downloading...") ) ) except Exception as e: # pylint:disable=C0103,W0703 await dryb.edit(str(e)) else: end = datetime.now() required_file_name = downloaded_file_name duration = (end - start).seconds await dryb.edit( "Downloaded to `{}` in {} seconds.\nNow uploading to GDrive...".format( downloaded_file_name, duration) ) if required_file_name: # if G_DRIVE_AUTH_TOKEN_DATA is not None: with open(G_DRIVE_TOKEN_FILE, "w") as t_file: t_file.write(G_DRIVE_AUTH_TOKEN_DATA) # Check if token file exists, if not create it by requesting authorization code if not os.path.isfile(G_DRIVE_TOKEN_FILE): storage = await create_token_file(G_DRIVE_TOKEN_FILE, dryb) http = authorize(G_DRIVE_TOKEN_FILE, storage) # Authorize, get file parameters, upload file and print out result URL for download http = authorize(G_DRIVE_TOKEN_FILE, None) file_name, mime_type = file_ops(required_file_name) # required_file_name will have the full path # Sometimes API fails to retrieve starting URI, we wrap it. try: g_drive_link = await upload_file(http, required_file_name, file_name, mime_type, dryb) await dryb.edit(f"File:`{required_file_name}`\nwas successfully uploaded to [Google Drive]({g_drive_link})!") except Exception as e: await dryb.edit(f"Error while uploading to Google Drive\nError Code:\n`{e}`")
async def gdrive_upload_function(dryb): """ For .gdrive command, upload files to google drive. """ await dryb.edit("Processing ...") if not get_parent_id(): parent_id = None else: catparent_id = get_parent_id() if len(catparent_id) == 1: parent_id = catparent_id[0].cat elif len(catparent_id) > 1: for fid in catparent_id: rmparent_id(fid.cat) parent_id = None input_str = dryb.pattern_match.group(1) if CLIENT_ID is None or CLIENT_SECRET is None: return if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY): os.makedirs(TEMP_DOWNLOAD_DIRECTORY) required_file_name = None if "|" in input_str: url, file_name = input_str.split("|") url = url.strip() # https://stackoverflow.com/a/761825/4723940 file_name = file_name.strip() head, tail = os.path.split(file_name) if head: if not os.path.isdir(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)): os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)) file_name = os.path.join(head, tail) downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) c_time = time.time() display_message = None while not downloader.isFinished(): status = downloader.get_status().capitalize() total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() now = time.time() diff = now - c_time percentage = downloader.get_progress() * 100 speed = downloader.get_speed() elapsed_time = round(diff) * 1000 progress_str = "[{0}{1}] {2}%".format( ''.join(["█" for i in range(math.floor(percentage / 10))]), ''.join(["░" for i in range(10 - math.floor(percentage / 10))]), round(percentage, 2)) estimated_total_time = downloader.get_eta(human=True) try: current_message = f"{status}...\ \nURL: {url}\ \nFile Name: {file_name}\ \n{progress_str}\ \n{humanbytes(downloaded)} of {humanbytes(total_length)}\ \nETA: {estimated_total_time}" if round(diff % 10.00) == 0 and current_message != display_message: await dryb.edit(current_message) display_message = current_message except Exception as e: LOGS.info(str(e)) if downloader.isSuccessful(): await dryb.edit( "Downloaded to `{}` successfully !!\nInitiating Upload to Google Drive.." .format(downloaded_file_name)) required_file_name = downloaded_file_name else: await dryb.edit("Incorrect URL\n{}".format(url)) elif input_str: input_str = input_str.strip() if os.path.exists(input_str): required_file_name = input_str await dryb.edit( "Found `{}` in local server, Initiating Upload to Google Drive.." .format(input_str)) else: await dryb.edit( "File not found in local server. Give me a valid file path !") return False elif dryb.reply_to_msg_id: try: c_time = time.time() downloaded_file_name = await dryb.client.download_media( await dryb.get_reply_message(), TEMP_DOWNLOAD_DIRECTORY, progress_callback=lambda d, t: asyncio.get_event_loop( ).create_task(progress(d, t, dryb, c_time, "Downloading..."))) except Exception as e: await dryb.edit(str(e)) else: required_file_name = downloaded_file_name await dryb.edit( "Downloaded to `{}` Successfully !!\nInitiating Upload to Google Drive.." .format(downloaded_file_name)) if required_file_name: if G_DRIVE_AUTH_TOKEN_DATA is not None: with open(G_DRIVE_TOKEN_FILE, "w") as t_file: t_file.write(G_DRIVE_AUTH_TOKEN_DATA) # Check if token file exists, if not create it by requesting # authorization code if not os.path.isfile(G_DRIVE_TOKEN_FILE): storage = await create_token_file(G_DRIVE_TOKEN_FILE, dryb) http = authorize(G_DRIVE_TOKEN_FILE, storage) # Authorize, get file parameters, upload file and print out result URL # for download http = authorize(G_DRIVE_TOKEN_FILE, None) file_name, mime_type = file_ops(required_file_name) # required_file_name will have the full path # Sometimes API fails to retrieve starting URI, we wrap it. try: g_drive_link = await upload_file(http, required_file_name, file_name, mime_type, dryb, parent_id) await dryb.edit( f"File:`{required_file_name}`\nwas Successfully Uploaded to [Google Drive]({g_drive_link})!" ) except Exception as e: await dryb.edit( f"Error while Uploading to Google Drive\nError Code:\n`{e}`")
async def down_load_media(message: Message): await message.edit("`Trying to Download...`") if message.reply_to_message and message.reply_to_message.media: start_t = datetime.now() dl_loc = await message.client.download_media( message=message.reply_to_message, file_name=Config.DOWN_PATH, progress=progress, progress_args=(message, "trying to download")) if message.process_is_canceled: await message.edit("`Process Canceled!`", del_in=5) else: dl_loc = os.path.join(Config.DOWN_PATH, os.path.basename(dl_loc)) end_t = datetime.now() m_s = (end_t - start_t).seconds await message.edit(f"Downloaded to `{dl_loc}` in {m_s} seconds") elif message.input_str: start_t = datetime.now() url = message.input_str custom_file_name = unquote_plus(os.path.basename(url)) if "|" in url: url, custom_file_name = url.split("|") url = url.strip() custom_file_name = custom_file_name.strip() download_file_path = os.path.join(Config.DOWN_PATH, custom_file_name) try: downloader = SmartDL(url, download_file_path, progress_bar=False) downloader.start(blocking=False) count = 0 while not downloader.isFinished(): if 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, custom_file_name, humanbytes(downloaded), humanbytes(total_length), speed, estimated_total_time) count += 1 if count >= 5: count = 0 await message.try_to_edit(progress_str, disable_web_page_preview=True) await asyncio.sleep(1) except Exception as e: await message.err(e) else: end_t = datetime.now() m_s = (end_t - start_t).seconds await message.edit( f"Downloaded to `{download_file_path}` in {m_s} seconds") else: await message.edit("Please read `.help download`", del_in=5)
async def download(target_file): """ For .download command, download files to the userbot's server. """ await target_file.edit("`Sedang memproses...`") input_str = target_file.pattern_match.group(1) if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY): os.makedirs(TEMP_DOWNLOAD_DIRECTORY) if "|" in input_str: url, file_name = input_str.split("|") url = url.strip() # https://stackoverflow.com/a/761825/4723940 file_name = file_name.strip() head, tail = os.path.split(file_name) if head: if not os.path.isdir(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)): os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)) file_name = os.path.join(head, tail) downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) c_time = time.time() display_message = None while not downloader.isFinished(): status = downloader.get_status().capitalize() total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() now = time.time() diff = now - c_time percentage = downloader.get_progress() * 100 speed = downloader.get_speed() progress_str = "[{0}{1}] `{2}%`".format( "".join(["■" for i in range(math.floor(percentage / 10))]), "".join(["▨" for i in range(10 - math.floor(percentage / 10))]), round(percentage, 2), ) estimated_total_time = downloader.get_eta(human=True) try: current_message = ( f"`Nama` : `{file_name}`\n" "Status" f"\n**{status}**... | {progress_str}" f"\n{humanbytes(downloaded)} dari {humanbytes(total_length)}" f" @ {humanbytes(speed)}" f"\n`Perkiraan` -> {estimated_total_time}") if round(diff % 10.00) == 0 and current_message != display_message: await target_file.edit(current_message) display_message = current_message except Exception as e: LOGS.info(str(e)) if downloader.isSuccessful(): await target_file.edit( "Berhasil diunduh ke `{}`!".format(downloaded_file_name)) else: await target_file.edit("URL salah.\n{}".format(url)) elif target_file.reply_to_msg_id: try: replied = await target_file.get_reply_message() file = replied.document file_name = replied.document.attributes[-1].file_name outdir = TEMP_DOWNLOAD_DIRECTORY + file_name c_time = time.time() with open(outdir, "wb") as f: result = await download_file( client=target_file.client, location=file, out=f, progress_callback=lambda d, t: asyncio.get_event_loop(). create_task( progress(d, t, target_file, c_time, "[UNDUH]", input_str)), ) except Exception as e: # pylint:disable=C0103,W0703 await target_file.edit(str(e)) else: await target_file.edit("Berhasil diunduh ke `{}`!".format( result.name)) else: await target_file.edit("`Balas pesan untuk diunduh ke server lokal.`")
async def lul(event): if event.fwd_from: return input_str = event.raw_text.split(" ", maxsplit=1)[1] mone = await event.edit("**Processing..**") start = datetime.now() url = input_str a = urlparse(input_str) file_name = os.path.basename(a.path) to_download_directory = Config.TMP_DOWNLOAD_DIRECTORY downloaded_file_name = os.path.join(to_download_directory, file_name) downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) display_message = "" c_time = time.time() while not downloader.isFinished(): total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() now = time.time() diff = now - c_time percentage = downloader.get_progress() * 100 speed = downloader.get_speed() elapsed_time = round(diff) * 1000 progress_str = "[{0}{1}]\nProgress: {2}%".format( ''.join(["▰" for i in range(math.floor(percentage / 5))]), ''.join(["▱" for i in range(20 - math.floor(percentage / 5))]), round(percentage, 2)) estimated_total_time = downloader.get_eta(human=True) try: current_message = f"trying to download\n" current_message += f"URL: {url}\n" current_message += f"File Name: {file_name}\n" current_message += f"{progress_str}\n" current_message += f"{humanbytes(downloaded)} of {humanbytes(total_length)}\n" current_message += f"ETA: {estimated_total_time}" if round(diff % 10.00) == 0 and current_message != display_message: await mone.edit(current_message) display_message = current_message except Exception as e: logger.info(str(e)) end = datetime.now() ms = (end - start).seconds if downloader.isSuccessful(): c_time = time.time() lul = await mone.edit("Downloaded to `{}` in {} seconds.".format( downloaded_file_name, ms)) lol_m = await upload_file( file_name=file_name, client=borg, file=open(downloaded_file_name, 'rb'), progress_callback=lambda d, t: asyncio.get_event_loop(). create_task( progress(d, t, event, c_time, "Uploading This File.", downloaded_file_name)), ) await borg.send_file( event.chat_id, lol_m, caption=file_name, force_document=False, allow_cache=False, ) await lul.delete() os.remove(downloaded_file_name) else: await mone.edit("Incorrect URL\n {}".format(input_str))
async def mega_downloader(megadl): await megadl.edit("`Collecting information...`") if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY): os.makedirs(TEMP_DOWNLOAD_DIRECTORY) msg_link = await megadl.get_reply_message() link = megadl.pattern_match.group(1) if link: pass elif msg_link: link = msg_link.text else: return await megadl.edit("Usage: `.mega` **<MEGA.nz link>**") try: link = re.findall(r"\bhttps?://.*mega.*\.nz\S+", link)[0] """ - Mega changed their URL again - """ if "file" in link: link = link.replace("#", "!").replace("file/", "#!") elif "folder" in link or "#F" in link or "#N" in link: await megadl.edit("`folder download support are removed...`") return except IndexError: await megadl.edit("`MEGA.nz link not found...`") return None cmd = f"bin/megadown -q -m {link}" result = await subprocess_run(megadl, cmd) try: data = json.loads(result[0]) except json.JSONDecodeError: await megadl.edit("**JSONDecodeError**: `failed to extract link...`") return None except (IndexError, TypeError): return file_name = data["file_name"] file_url = data["url"] hex_key = data["hex_key"] hex_raw_key = data["hex_raw_key"] temp_file_name = file_name + ".temp" temp_file_path = TEMP_DOWNLOAD_DIRECTORY + temp_file_name file_path = TEMP_DOWNLOAD_DIRECTORY + file_name if os.path.isfile(file_path): try: raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), file_path) except FileExistsError as e: await megadl.edit(f"`{str(e)}`") return None downloader = SmartDL(file_url, temp_file_path, progress_bar=False) display_message = None try: downloader.start(blocking=False) except HTTPError as e: await megadl.edit(f"**HTTPError**: `{str(e)}`") return None start = time.time() while not downloader.isFinished(): status = downloader.get_status().capitalize() total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() percentage = int(downloader.get_progress() * 100) speed = downloader.get_speed(human=True) estimated_total_time = round(downloader.get_eta()) progress_str = "`{}` | [{}{}] `{}%`".format( status, "".join(["●" for i in range(math.floor(percentage / 10))]), "".join(["○" for i in range(10 - math.floor(percentage / 10))]), round(percentage, 2), ) diff = time.time() - start try: current_message = ( f"`{file_name}`\n\n" "Status\n" f"{progress_str}\n" f"`{humanbytes(downloaded)} of {humanbytes(total_length)}" f" @ {speed}`\n" f"`ETA` -> {time_formatter(estimated_total_time)}\n" f"`Duration` -> {time_formatter(round(diff))}") if round(diff % 15.00) == 0 and (display_message != current_message or total_length == downloaded): await megadl.edit(current_message) await asyncio.sleep(0.2) display_message = current_message except Exception: pass finally: if status == "Combining": wait = round(downloader.get_eta()) await asyncio.sleep(wait) if downloader.isSuccessful(): download_time = round(downloader.get_dl_time() + wait) try: P = multiprocessing.Process( target=await decrypt_file(megadl, file_path, temp_file_path, hex_key, hex_raw_key), name="Decrypt_File", ) P.start() P.join() except FileNotFoundError as e: await megadl.edit(f"`{str(e)}`") return None else: await megadl.edit( f"`{file_name}`\n\n" f"Successfully downloaded in: `{file_path}`.\n" f"Download took: {time_formatter(download_time)}.", ) msg = await megadl.respond("`Uploading to GDrive...`") service = await create_app(msg) if service is False: await asyncio.sleep(2.5) await msg.delete() return mime_type = await get_mimeType(file_path) try: resultgd = await upload(msg, service, file_path, file_name, mime_type) except CancelProcess: msg.edit("`[FILE - CANCELLED]`\n\n" "`Status` : **OK** - received signal cancelled.") if resultgd: result_output = f"**GDrive Upload**\n\n📄 [{file_name}]({resultgd[1]})" if G_DRIVE_INDEX_URL: index_url = G_DRIVE_INDEX_URL.rstrip("/") + "/" + quote( file_name) result_output += f"\n👥 [Index URL]({index_url})" result_output += f"\n__Size : {humanbytes(resultgd[0])}__" await msg.edit( result_output, link_preview=False, ) else: await megadl.edit("`Failed to download, " "check heroku Logs for more details.`") for e in downloader.get_errors(): LOGS.info(str(e)) return
"./downloads") else: # Put your ppe vars here if you are using local hosting PLACEHOLDER = None # Setting Up CloudMail.ru and MEGA.nz extractor binaries, # and giving them correct perms to work properly. if not os.path.exists('bin'): os.mkdir('bin') binaries = { "https://raw.githubusercontent.com/yshalsager/megadown/master/megadown": "bin/megadown", "https://raw.githubusercontent.com/yshalsager/cmrudl.py/master/cmrudl.py": "bin/cmrudl" } for binary, path in binaries.items(): downloader = SmartDL(binary, path, progress_bar=False) downloader.start() os.chmod(path, 0o755) # Global Variables COUNT_MSG = 0 USERS = {} COUNT_PM = {} LASTMSG = {} CMD_HELP = {} ISAFK = False AFKREASON = None
def test_hash(self): obj = SmartDL(self.default_7za920_mirrors, progress_bar=False) obj.add_hash_verification('sha256' ,'2a3afe19c180f8373fa02ff00254d5394fec0349f5804e0ad2f6067854ff28ac') # good hash obj.start(blocking=False) # no exceptions obj.wait() self.assertTrue(obj.isSuccessful()) obj = SmartDL(self.default_7za920_mirrors, progress_bar=False) obj.add_hash_verification('sha256' ,'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa') # bad hash obj.start(blocking=False) # no exceptions obj.wait() self.assertFalse(obj.isSuccessful()) self.assertTrue(isinstance(obj.get_errors()[-1], HashFailedException))
def download(__url__): url = __url__ self.destination = str(self.destination) stopButton['command'] = lambda: terminate(self.downloadObject) stopButton['state'] = NORMAL pauseButton['command'] = lambda: pauseResume(self.downloadObject) pauseButton['state'] = NORMAL def doDownload(sem): with sem: try: if self.downloadObject: self.downloadObject.start() except Exception as e: print(f"------> {e}") print( f"object error ---> {self.downloadObject.get_errors()}" ) self.statusMessage.set(f" Status: {e}") root.update_idletasks() def showProgress(sem): with sem: time.sleep(1) startTime = time.perf_counter() if self.downloadObject: while not self.downloadObject.isFinished() and len( self.downloadObject.get_errors()) == 0: self.statusMessage.set( f" Status: {self.downloadObject.get_status().capitalize()}" ) self.speedMessage.set( f" Speed: {self.downloadObject.get_speed(human=True)}" ) self.destinationMessage.set( f" Working directory: {self.destination}") self.sizeMessage.set( f" Downloaded so far: {self.downloadObject.get_dl_size(human=True)}" ) self.timeMessage.set( f" Elapsed Time: {round(time.perf_counter() - startTime, 1)}" if self.downloadObject.get_status() != 'paused' else ' Elapsed Time: . . . ') progress[ 'value'] = 100 * self.downloadObject.get_progress( ) time.sleep(0.2) root.update_idletasks() if len(self.downloadObject.get_errors()) == 0: startPoint = time.perf_counter() while time.perf_counter() - startPoint < 2: self.statusMessage.set( f" Status: {self.downloadObject.get_status().capitalize()}" ) self.speedMessage.set( f" Speed: {self.downloadObject.get_speed(human=True)}" ) self.destinationMessage.set( f" Saved at: {self.downloadObject.get_dest()}" ) self.sizeMessage.set( f" Total File Size: {self.downloadObject.get_final_filesize(human=True)}" ) self.timeMessage.set( f" Total Time: {str(self.downloadObject.get_dl_time(human=True))}" ) progress[ 'value'] = 100 * self.downloadObject.get_progress( ) time.sleep(0.2) root.update_idletasks() if progress['value'] == 100: speak('File Downloaded') else: self.statusMessage.set( f" Status: Download Failed") self.speedMessage.set( f" Reason: {self.downloadObject.get_errors()[0]}" ) root.update_idletasks() speak('Download Failed') if len(url) == 0: downloadButton.flash() else: try: self.downloadObject = SmartDL(url, self.destination) except Exception as e: print(f"Error in {e}") self.statusMessage.set(f" Status: {e}") root.update_idletasks() semaphore = threading.Semaphore(2) threading.Thread(target=doDownload, args=(semaphore, )).start() threading.Thread(target=showProgress, args=(semaphore, )).start()
async def mega_downloader(megadl): await megadl.edit("`Bilgi toplanıyor...`") if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY): os.makedirs(TEMP_DOWNLOAD_DIRECTORY) msg_link = await megadl.get_reply_message() link = megadl.pattern_match.group(1) if link: pass elif msg_link: link = msg_link.text else: return await megadl.edit("Kullanımı: `.mega` **<MEGA.nz link>**") try: link = re.findall(r'\bhttps?://.*mega.*\.nz\S+', link)[0] # - Mega changed their URL again - if "file" in link: link = link.replace("#", "!").replace("file/", "#!") elif "folder" in link or "#F" in link or "#N" in link: await megadl.edit("`klasör indirme desteği kaldırıldı...`") return except IndexError: await megadl.edit("`MEGA.nz bağlantısı bulunamadı...`") return None cmd = f'bin/megadown -q -m {link}' result = await subprocess_run(megadl, cmd) try: data = json.loads(result[0]) except json.JSONDecodeError: await megadl.edit("**JSONDecodeError**: `bağlantı çıkarılamadı...`") return None except (IndexError, TypeError): return file_name = data["file_name"] file_url = data["url"] hex_key = data["hex_key"] hex_raw_key = data["hex_raw_key"] temp_file_name = file_name + ".temp" temp_file_path = os.path.join(TEMP_DOWNLOAD_DIRECTORY, temp_file_name) file_path = os.path.join(TEMP_DOWNLOAD_DIRECTORY, file_name) if os.path.isfile(file_path): try: raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), file_path) except FileExistsError as e: await megadl.edit(f"`{str(e)}`") return None downloader = SmartDL(file_url, temp_file_path, progress_bar=False) display_message = None try: downloader.start(blocking=False) except HTTPError as e: await megadl.edit(f"**HTTPError**: `{str(e)}`") return None start = time.time() while not downloader.isFinished(): status = downloader.get_status().capitalize() total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() percentage = int(downloader.get_progress() * 100) speed = downloader.get_speed(human=True) estimated_total_time = round(downloader.get_eta()) progress_str = "`{0}` | [{1}{2}] `{3}%`".format( status, ''.join(["▰" for i in range(math.floor(percentage / 10))]), ''.join(["▱" for i in range(10 - math.floor(percentage / 10))]), round(percentage, 2)) diff = time.time() - start try: current_message = ( f"**➥dosya adı : **`{file_name}`\n\n" "**➥Durum**\n" f"{progress_str}\n" f"`{humanbytes(downloaded)}` of `{humanbytes(total_length)}`" f" @ `{speed}`\n" f"**➥ETA -> **`{time_formatter(estimated_total_time)}`\n" f"**➥ Süresi -> **`{time_formatter(round(diff))}`") if round(diff % 15.00) == 0 and (display_message != current_message or total_length == downloaded): await megadl.edit(current_message) await asyncio.sleep(0.2) display_message = current_message except Exception: pass finally: if status == "Birleştirme": wait = round(downloader.get_eta()) await asyncio.sleep(wait) if downloader.isSuccessful(): download_time = round(downloader.get_dl_time() + wait) try: P = multiprocessing.Process(target=await decrypt_file(megadl, file_path, temp_file_path, hex_key, hex_raw_key), name="Decrypt_File") P.start() P.join() except FileNotFoundError as e: await megadl.edit(f"`{str(e)}`") return None else: await megadl.edit( f"**➥ Dosya adı : **`{file_name}`\n\n" f"**➥ Başarıyla indirildi : ** `{file_path}`.\n" f"**➥İndirme aracı:** {time_formatter(download_time)}.") return None else: await megadl.edit( "`İndirme başarısız, " "daha fazla ayrıntı için heroku Günlüklerine bakın..`") for e in downloader.get_errors(): LOGS.info(str(e)) return
async def upload(self) -> None: """Upload from file/folder/link/tg file to GDrive""" if not os.path.isdir(Config.DOWN_PATH): os.mkdir(Config.DOWN_PATH) 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...`") c_time = time.time() dl_loc = await userge.download_media( message=replied, file_name=Config.DOWN_PATH, progress=progress, progress_args=("trying to download", userge, self._message, c_time)) if self._message.process_is_canceled: await self._message.edit("`Process Canceled!`", del_in=5) return else: 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 = 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( ["■" for i in range(math.floor(percentage / 10))]), ''.join([ "▨" for i in range(10 - math.floor(percentage / 10)) ]), 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 upload_file_name = dl_loc if dl_loc else self._message.input_str if not os.path.exists(upload_file_name): await self._message.err("invalid file path provided?") return await self._message.edit("`Loading GDrive Upload...`") pool.submit_thread(self._upload, upload_file_name) 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()}`" elif self._output is not None and not self._is_canceled: out = f"**Uploaded Successfully** __in {m_s} seconds__\n\n{self._output}\n\n📂 Index link: <a href='{Config.INDEX_PATH_URL}/{file_name}'>Click here</a>" 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=True)
async def mega_downloader(megadl): await megadl.edit("`Collecting information...`") if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY): os.makedirs(TEMP_DOWNLOAD_DIRECTORY) msg_link = await megadl.get_reply_message() link = megadl.pattern_match.group(1) if link: pass elif msg_link: link = msg_link.text else: return await megadl.edit("Usage: `.mega` **<MEGA.nz link>**") try: link = re.findall(r'\bhttps?://.*mega.*\.nz\S+', link)[0] """ - Mega changed their URL again - """ if "file" in link: link = link.replace("#", "!").replace("file/", "#!") elif "folder" in link or "#F" in link or "#N" in link: await megadl.edit("`folder download support are removed...`") return except IndexError: return await megadl.edit("`MEGA.nz link not found...`") cmd = f'bin/megadown -q -m {link}' result = await subprocess_run(megadl, cmd) try: data = json.loads(result[0]) except json.JSONDecodeError: return await megadl.edit("`Err: failed to extract link...`\n") except (IndexError, TypeError): return file_name = data["file_name"] file_url = data["url"] hex_key = data["hex_key"] hex_raw_key = data["hex_raw_key"] temp_file_name = file_name + ".temp" temp_file_path = TEMP_DOWNLOAD_DIRECTORY + temp_file_name file_path = TEMP_DOWNLOAD_DIRECTORY + file_name if os.path.isfile(file_path): try: raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), file_path) except FileExistsError as e: return await megadl.edit(f"`{str(e)}`") downloader = SmartDL(file_url, temp_file_path, progress_bar=False) display_message = None try: downloader.start(blocking=False) except HTTPError as e: return await megadl.edit(f"`Err: {str(e)}`") start = time.time() while not downloader.isFinished(): status = downloader.get_status().capitalize() total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() percentage = int(downloader.get_progress() * 100) speed = downloader.get_speed(human=True) estimated_total_time = round(downloader.get_eta()) progress_str = "`{0}` | [{1}{2}] `{3}%`".format( status, ''.join(["■" for i in range(math.floor(percentage / 10))]), ''.join(["▨" for i in range(10 - math.floor(percentage / 10))]), round(percentage, 2)) diff = time.time() - start try: current_message = ( f"`{file_name}`\n\n" "Status\n" f"{progress_str}\n" f"`{humanbytes(downloaded)} of {humanbytes(total_length)}" f" @ {speed}`\n" f"`ETA` -> {time_formatter(estimated_total_time)}\n" f"`Duration` -> {time_formatter(round(diff))}") if round(diff % 10.00) == 0 and (display_message != current_message or total_length == downloaded): await megadl.edit(current_message) await asyncio.sleep(0.2) display_message = current_message except Exception: pass finally: if status == "Combining": wait = round(downloader.get_eta()) await asyncio.sleep(wait) if downloader.isSuccessful(): download_time = round(downloader.get_dl_time() + wait) try: P = multiprocessing.Process(target=await decrypt_file(megadl, file_path, temp_file_path, hex_key, hex_raw_key), name="Decrypt_File") P.start() P.join() except FileNotFoundError as e: return await megadl.edit(f"`{str(e)}`") else: return await megadl.edit( f"`{file_name}`\n\n" f"Successfully downloaded in: `{file_path}`.\n" f"Download took: {time_formatter(download_time)}.") else: await megadl.edit("`Failed to download, " "check heroku Logs for more details`.") for e in downloader.get_errors(): LOGS.info(str(e)) return
def run(self): # Called by Qt once the thread environment has been set up. while self.tasks: taskId, songObj, dl_dir = self.tasks.pop(0) self.startedTask.emit(taskId) isVideo = songObj.ext in ['mp4', 'avi', 'flv', 'webm', 'mkv'] isAudio = songObj.ext in ['mp3', 'm4a', 'wav'] isMultimediaFile = any([isVideo, isAudio]) convertNeeded = isMultimediaFile and songObj.ext != 'mp3' and config.downloadAudio encode_time = 0 url = songObj.url filesize = songObj.filesize audio_path = os.path.join(dl_dir, songObj.GetProperFilename('mp3')) # final path video_path = os.path.join(dl_dir, songObj.GetProperFilename()) # final path dest_audio_path = os.path.join(config.temp_dir, "%s.mp3" % utils.get_rand_string()) if not isMultimediaFile: dest_path = os.path.join(config.temp_dir, utils.get_rand_string()) elif songObj.ext == "mp3": # no convertion needed dest_path = dest_audio_path else: dest_path = os.path.join(config.temp_dir, "%s.%s" % (utils.get_rand_string(), songObj.ext)) dl_obj = SmartDL(url, dest_path, logger=log, fix_urls=False) dl_obj.start(blocking=False) while not dl_obj.isFinished(): if dl_obj.status == 'combining': self.status.emit(tr("Combining Parts...")) break self.downloadProgress.emit(int(dl_obj.get_progress()*100), dl_obj.get_speed(), dl_obj.get_eta(), dl_obj.get_dl_size(), filesize) time.sleep(0.1) while not dl_obj.isFinished(): # if we were breaking the last loop, we are waiting for # parts to get combined. we shall wait. time.sleep(0.1) if not dl_obj.isSuccessful: log.error("Got DownloadFailedException() for %s" % url) self.error.emit(IOError()) self.terminate() return self.downloadProgress.emit(100, dl_obj.get_speed(), dl_obj.get_eta(), filesize, filesize) if convertNeeded: t1 = time.time() log.debug("Encoding Audio...") self.status.emit(tr("Encoding Audio...")) est_final_filesize = songObj.final_filesize if est_final_filesize: print "Encoding: %s (%.2f MB) to %s" % (dest_audio_path, est_final_filesize / 1024.0 / 1024.0, dl_dir) else: print "Encoding: %s to %s" % (dest_audio_path, dl_dir) proc = Wrappers.FFMpeg(dest_path, dest_audio_path, config.itag_audio_bitrates[songObj.itag.quality]) self.encProgress.emit(0) for fs_counter in proc: if not est_final_filesize: continue status = r"Encoding: %.2f MB / %.2f MB %s [%3.2f%%]" % (fs_counter / 1024.0, est_final_filesize / 1024.0**2, utils.progress_bar(1.0*fs_counter*1024/est_final_filesize) , fs_counter*1024 * 100.0 / est_final_filesize) status = status + chr(8)*(len(status)+1) print status, self.encProgress.emit(int(fs_counter*1024 * 100.0 / est_final_filesize)) self.encProgress.emit(100) t2 = time.time() encode_time += t2-t1 if not config.downloadVideo or not isVideo: log.debug("Removing %s..." % dest_path) os.unlink(dest_path) else: dest_audio_path = dest_path if config.downloadAudio and config.trimSilence: t1 = time.time() log.debug("Trimming Silence...") self.status.emit(tr("Trimming Silence from edges...")) temp_audio_trimmed_path = "%s.tmp.mp3" % dest_audio_path if os.path.exists(temp_audio_trimmed_path): os.unlink(temp_audio_trimmed_path) os.rename(dest_audio_path, temp_audio_trimmed_path) est_final_filesize = songObj.final_filesize print "Trimming Silence: %s (%.2f MB) to %s" % (dest_audio_path, est_final_filesize / 1024.0**2, dl_dir) self.encProgress.emit(0) proc = Wrappers.SoX(temp_audio_trimmed_path, dest_audio_path) for progress in proc: status = r"Trimming Silence: %s" % utils.progress_bar(progress/100.0) status = status + chr(8)*(len(status)+1) print status, self.encProgress.emit(progress) self.encProgress.emit(100) t2 = time.time() encode_time += t2-t1 if not os.path.exists(dest_audio_path): log.error('SoX failed.') log.debug("Copying Files...") self.status.emit(tr("Copying Files...")) if isVideo: # IMPROVE: this crashes when a video is running in media player, os.unlink removes it, but it is still running in media player. if config.downloadAudio: log.debug("Moving %s to %s" % (dest_audio_path, audio_path)) shutil.move(dest_audio_path, audio_path) if config.downloadVideo: log.debug("Moving %s to %s" % (dest_path, video_path)) shutil.move(dest_path, video_path) if isAudio: log.debug("Moving %s to %s" % (dest_path, audio_path)) shutil.move(dest_path, audio_path) dl_time = dl_obj.get_dl_time() dl_time_s = int(dl_time)%60 dl_time_m = int(dl_time)/60 if filesize/dl_time/1024**2 > 1: # If dlRate is in MBs if dl_time_m: stats_str = tr('Download: %d:%.2d (%.2f MB/s)') % (dl_time_m, dl_time_s, filesize/dl_time/1024**2) else: stats_str = tr('Download: %ds (%.2f MB/s)') % (dl_time, filesize/dl_time/1024**2) else: if dl_time_m: stats_str = tr('Download: %d:%.2d (%.2f KB/s)') % (dl_time_m, dl_time_s, filesize/dl_time/1024) else: stats_str = tr('Download: %ds (%.2f KB/s)') % (dl_time, filesize/dl_time/1024) if encode_time: stats_str += tr('; Encoded: %ds') % encode_time self.status.emit(stats_str) self.finishedTask.emit(taskId, dl_time, encode_time)
async def _(event): if event.fwd_from: return mone = await edit_or_reply(event, "`Processing ...`") input_str = event.pattern_match.group(1) if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY): os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY) if event.reply_to_msg_id: start = datetime.now() reply_message = await event.get_reply_message() try: c_time = time.time() downloaded_file_name = await event.client.download_media( reply_message, Config.TMP_DOWNLOAD_DIRECTORY, progress_callback=lambda d, t: asyncio.get_event_loop( ).create_task( progress(d, t, mone, c_time, "trying to download")), ) except Exception as e: # pylint:disable=C0103,W0703 await mone.edit(str(e)) else: end = datetime.now() ms = (end - start).seconds await mone.edit( f"** • Downloaded in {ms} seconds.**\n** • Downloaded to :- ** `{downloaded_file_name}`\n** • Downloaded by :-** {DEFAULTUSER}" ) elif input_str: start = datetime.now() url = input_str file_name = os.path.basename(url) to_download_directory = Config.TMP_DOWNLOAD_DIRECTORY if "|" in input_str: url, file_name = input_str.split("|") url = url.strip() file_name = file_name.strip() downloaded_file_name = os.path.join(to_download_directory, file_name) downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) c_time = time.time() while not downloader.isFinished(): total_length = downloader.filesize or None downloaded = downloader.get_dl_size() display_message = "" now = time.time() diff = now - c_time percentage = downloader.get_progress() * 100 downloader.get_speed() progress_str = "`{0}{1} {2}`%".format( "".join(["▰" for i in range(math.floor(percentage / 5))]), "".join(["▱" for i in range(20 - math.floor(percentage / 5))]), round(percentage, 2), ) estimated_total_time = downloader.get_eta(human=True) try: current_message = f"Downloading the file\ \n\n**URL : **`{url}`\ \n**File Name :** `{file_name}`\ \n{progress_str}\ \n`{humanbytes(downloaded)} of {humanbytes(total_length)}`\ \n**ETA : **`{estimated_total_time}``" if round(diff % 10.00) == 0 and current_message != display_message: await mone.edit(current_message) display_message = current_message except Exception as e: logger.info(str(e)) end = datetime.now() ms = (end - start).seconds if downloader.isSuccessful(): await mone.edit( f"** • Downloaded in {ms} seconds.**\n** • Downloaded to :- ** `{downloaded_file_name}`" ) else: await mone.edit("Incorrect URL\n {}".format(input_str)) else: await mone.edit("Reply to a message to download to my local server.")
async def download(target_file): """ For .download command, download files to the userbot's server. """ await target_file.edit("Processing ...") input_str = target_file.pattern_match.group(1) if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY): os.makedirs(TEMP_DOWNLOAD_DIRECTORY) if "|" in input_str: url, file_name = input_str.split("|") url = url.strip() # https://stackoverflow.com/a/761825/4723940 file_name = file_name.strip() head, tail = os.path.split(file_name) if head: if not os.path.isdir(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)): os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)) file_name = os.path.join(head, tail) downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) c_time = time.time() display_message = None while not downloader.isFinished(): status = downloader.get_status().capitalize() total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() now = time.time() diff = now - c_time percentage = downloader.get_progress() * 100 speed = downloader.get_speed() progress_str = "[{0}{1}] `{2}%`".format( "".join(["●" for i in range(math.floor(percentage / 10))]), "".join(["○" for i in range(10 - math.floor(percentage / 10))]), round(percentage, 2), ) estimated_total_time = downloader.get_eta(human=True) try: current_message = ( f"`Name` : `{file_name}`\n" "Status" f"\n**{status}**... | {progress_str}" f"\n{humanbytes(downloaded)} of {humanbytes(total_length)}" f" @ {humanbytes(speed)}" f"\n`ETA` -> {estimated_total_time}") if round(diff % 10.00) == 0 and current_message != display_message: await target_file.edit(current_message) display_message = current_message except Exception as e: LOGS.info(str(e)) if downloader.isSuccessful(): await target_file.edit("Downloaded to `{}` successfully !!".format( downloaded_file_name)) else: await target_file.edit("Incorrect URL\n{}".format(url)) elif target_file.reply_to_msg_id: try: replied = await target_file.get_reply_message() file = replied.document attribs = replied.media.document.attributes for attr in attribs: if isinstance(attr, DocumentAttributeFilename): filename = attr.file_name outdir = TEMP_DOWNLOAD_DIRECTORY + filename c_time = time.time() start_time = datetime.now() with open(outdir, "wb") as f: result = await download_file( client=target_file.client, location=file, out=f, progress_callback=lambda d, t: asyncio.get_event_loop(). create_task( progress(d, t, target_file, c_time, "[DOWNLOAD]", input_str)), ) dl_time = (datetime.now() - start_time).seconds except Exception as e: # pylint:disable=C0103,W0703 await target_file.edit(str(e)) else: await target_file.edit( "Downloaded to `{}` in `{}` seconds.".format( result.name, dl_time)) else: await target_file.edit( "Reply to a message to download to my local server.")
async def mega_downloader(megadl): await megadl.edit("`Processing...`") msg_link = await megadl.get_reply_message() link = megadl.pattern_match.group(1) if link: pass elif msg_link: link = msg_link.text else: return await megadl.edit("Usage: `.mega <MEGA.nz link>`") try: link = re.findall(r'\bhttps?://.*mega.*\.nz\S+', link)[0] """ - Mega changed their URL again - """ if "file" in link: link = link.replace("#", "!").replace("file/", "#!") elif "folder" in link or "#F" in link or "#N" in link: await megadl.edit( "`Currently support folder download are removed`.") return except IndexError: return await megadl.edit("`No MEGA.nz link found`\n") cmd = f'bin/megadown -q -m {link}' result = await subprocess_run(megadl, cmd) try: data = json.loads(result[0]) except json.JSONDecodeError: return await megadl.edit("`Error: Can't extract the link`\n") except (IndexError, TypeError): return file_name = data["file_name"] file_url = data["url"] hex_key = data["hex_key"] hex_raw_key = data["hex_raw_key"] temp_file_name = file_name + ".temp" downloaded_file_name = "./" + "" + temp_file_name downloader = SmartDL(file_url, downloaded_file_name, progress_bar=False) display_message = None try: downloader.start(blocking=False) except HTTPError as e: return await megadl.edit("`" + str(e) + "`") while not downloader.isFinished(): status = downloader.get_status().capitalize() total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() percentage = int(downloader.get_progress() * 100) progress = downloader.get_progress_bar() speed = downloader.get_speed(human=True) estimated_total_time = downloader.get_eta(human=True) try: current_message = ( "File Name:" f"\n`{file_name}`\n\n" "Status:" f"\n**{status}** | {progress} `{percentage}%`" f"\n{humanbytes(downloaded)} of {humanbytes(total_length)}" f" @ {speed}" f"\nETA: {estimated_total_time}") if display_message != current_message: await megadl.edit(current_message) await asyncio.sleep(0.2) display_message = current_message except Exception: pass finally: if status == "Combining": await asyncio.sleep(float(downloader.get_eta())) if downloader.isSuccessful(): download_time = downloader.get_dl_time(human=True) try: P = multiprocessing.Process(target=await decrypt_file(megadl, file_name, temp_file_name, hex_key, hex_raw_key), name="Decrypt_File") P.start() P.join() except FileNotFoundError as e: return await megadl.edit(str(e)) else: return await megadl.edit(f"`{file_name}`\n\n" "Successfully downloaded\n" f"Download took: {download_time}") else: await megadl.edit("`Failed to download, " "check heroku Logs for more details`") for e in downloader.get_errors(): LOGS.info(str(e)) return
dest='dir', nargs='?', metavar='your Directory', help='Default = current directory') args = parser.parse_args() if args.url == None: print("Usage: < python3 Download_Manager.py -h/--help >") exit(0) else: url = str(args.url) if args.dir == None: dest = os.getcwd() else: dest = str(args.dir) obj = SmartDL(url, dest) print("\n" + "=" * 70 + "\n") file_name = url.split("/")[-1] obj.start() path = obj.get_dest() if obj.isSuccessful(): print("\n" + "=" * 70 + "\n") print("File Name: '%s'" % file_name) print("downloaded file to '%s'" % obj.get_dest()) print("Speed: %s" % obj.get_speed(human=True)) print("Already downloaded: %s" % obj.get_dl_size(human=True)) print("Eta: %s" % obj.get_eta(human=True)) print("Progress: %d%%" % (obj.get_progress() * 100)) print("Progress bar: %s" % obj.get_progress_bar()) print("Status: %s" % obj.get_status()) print("\n" * 2 + "=" * 70 + "\n")
async def mega_downloader(megadl): catevent = await edit_or_reply(megadl, "__Collecting information...__") if not os.path.isdir(TMP_DOWNLOAD_DIRECTORY): os.makedirs(TMP_DOWNLOAD_DIRECTORY) msg_link = await megadl.get_reply_message() link = megadl.pattern_match.group(1) if link: pass elif msg_link: link = msg_link.text else: return await catevent.edit("Usage: __.mega__ **<MEGA.nz link>**") try: link = re.findall(r"\bhttps?://.*mega.*\.nz\S+", link)[0] # - Mega changed their URL again - if "file" in link: link = link.replace("#", "!").replace("file/", "#!") elif "folder" in link or "#F" in link or "#N" in link: await catevent.edit("__folder download support are removed...__") return except IndexError: await catevent.edit("__MEGA.nz link not found...__") return None cmd = f"bin/megadown -q -m {link}" result = await subprocess_run(catevent, cmd) try: data = json.loads(result[0]) except json.JSONDecodeError: await catevent.edit("**JSONDecodeError**: __failed to extract link...__") return None except (IndexError, TypeError): return file_name = data["file_name"] file_url = data["url"] hex_key = data["hex_key"] hex_raw_key = data["hex_raw_key"] temp_file_name = file_name + ".temp" temp_file_path = os.path.join(TMP_DOWNLOAD_DIRECTORY, temp_file_name) file_path = os.path.join(TMP_DOWNLOAD_DIRECTORY, file_name) if os.path.isfile(file_path): try: raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), file_path) except FileExistsError as e: await catevent.edit(f"__{str(e)}__") return None downloader = SmartDL(file_url, temp_file_path, progress_bar=False) display_message = None try: downloader.start(blocking=False) except HTTPError as e: await catevent.edit(f"**HTTPError**: __{str(e)}__") return None start = time.time() while not downloader.isFinished(): status = downloader.get_status().capitalize() total_length = downloader.filesize or None downloaded = downloader.get_dl_size() percentage = int(downloader.get_progress() * 100) speed = downloader.get_speed(human=True) estimated_total_time = round(downloader.get_eta()) progress_str = "__{0}__ | [{1}{2}] __{3}%__".format( status, "".join(["▰" for i in range(math.floor(percentage / 10))]), "".join(["▱" for i in range(10 - math.floor(percentage / 10))]), round(percentage, 2), ) diff = time.time() - start try: current_message = ( f"**➥file name : **__{file_name}__\n\n" "**➥Status**\n" f"{progress_str}\n" f"__{humanbytes(downloaded)}__ of __{humanbytes(total_length)}__" f" @ __{speed}__\n" f"**➥ETA -> **__{time_formatter(estimated_total_time)}__\n" f"**➥ Duration -> **__{time_formatter(round(diff))}__" ) if round(diff % 15.00) == 0 and ( display_message != current_message or total_length == downloaded ): await catevent.edit(current_message) await asyncio.sleep(1) display_message = current_message except Exception as e: LOGS.info(str(e)) finally: if status == "Combining": wait = round(downloader.get_eta()) await asyncio.sleep(wait) if downloader.isSuccessful(): download_time = round(downloader.get_dl_time() + wait) try: P = multiprocessing.Process( target=await decrypt_file( catevent, file_path, temp_file_path, hex_key, hex_raw_key ), name="Decrypt_File", ) P.start() P.join() except FileNotFoundError as e: await catevent.edit(f"__{str(e)}__") return None else: await catevent.edit( f"**➥ file name : **__{file_name}__\n\n" f"**➥ Successfully downloaded in : ** __{file_path}__.\n" f"**➥ Download took :** {time_formatter(download_time)}." ) return None else: await megadl.edit( "__Failed to download, " "check heroku Logs for more details.__" ) for e in downloader.get_errors(): LOGS.info(str(e)) return
async def download(target_file): """ For .download command, download files to the userbot's server. """ await target_file.edit("**Processing...**") input_str = target_file.pattern_match.group(1) replied = await target_file.get_reply_message() if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY): os.makedirs(TEMP_DOWNLOAD_DIRECTORY) if input_str: url = input_str file_name = unquote_plus(os.path.basename(url)) if "|" in input_str: url, file_name = input_str.split("|") url = url.strip() # https://stackoverflow.com/a/761825/4723940 file_name = file_name.strip() head, tail = os.path.split(file_name) if head: if not os.path.isdir( os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)): os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)) file_name = os.path.join(head, tail) try: url = get(url).url except BaseException: return await target_file.edit("**This is not a valid link.**") downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) c_time = time.time() display_message = None while not downloader.isFinished(): status = downloader.get_status().capitalize() total_length = downloader.filesize or None downloaded = downloader.get_dl_size() now = time.time() diff = now - c_time percentage = downloader.get_progress() * 100 speed = downloader.get_speed() progress_str = "[{}{}] `{}%`".format( "".join("●" for _ in range(math.floor(percentage / 10))), "".join("○" for _ in range(10 - math.floor(percentage / 10))), round(percentage, 2), ) estimated_total_time = downloader.get_eta(human=True) try: current_message = ( f"**Name:** `{file_name}`\n" f"\n**{status}...** | {progress_str}" f"\n{humanbytes(downloaded)} of {humanbytes(total_length)}" f" @ {humanbytes(speed)}" f"\n**ETA:** {estimated_total_time}") if round(diff % 15.00) == 0 and current_message != display_message: await target_file.edit(current_message) display_message = current_message except Exception as e: LOGS.info(str(e)) if downloader.isSuccessful(): await target_file.edit( f"**Downloaded to** `{downloaded_file_name}` **successfully!**" ) else: await target_file.edit(f"**Incorrect URL**\n{url}") elif replied: if not replied.media: return await target_file.edit("**Reply to file or media.**") try: media = replied.media if hasattr(media, "document"): file = media.document mime_type = file.mime_type filename = replied.file.name if not filename: if "audio" in mime_type: filename = ("audio_" + datetime.now().isoformat("_", "seconds") + ".ogg") elif "video" in mime_type: filename = ("video_" + datetime.now().isoformat("_", "seconds") + ".mp4") outdir = TEMP_DOWNLOAD_DIRECTORY + filename c_time = time.time() start_time = datetime.now() with open(outdir, "wb") as f: result = await download_file( client=target_file.client, location=file, out=f, progress_callback=lambda d, t: asyncio.get_event_loop( ).create_task( progress( d, t, target_file, c_time, "Telegram - Download", input_str, )), ) else: start_time = datetime.now() result = await target_file.client.download_media( media, TEMP_DOWNLOAD_DIRECTORY) dl_time = (datetime.now() - start_time).seconds except Exception as e: # pylint:disable=C0103,W0703 await target_file.edit(str(e)) else: try: await target_file.edit( f"**Downloaded to** `{result.name}` **in {dl_time} seconds.**" ) except AttributeError: await target_file.edit( f"**Downloaded to** `{result}` **in {dl_time} seconds.**") else: await target_file.edit("**See** `.help download` **for more info.**")
async def _(event): if event.fwd_from: return if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY): os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY) thumb = None if os.path.exists(thumb_image_path): thumb = thumb_image_path start = datetime.now() input_str = event.pattern_match.group(1) url = input_str file_name = os.path.basename(url) to_download_directory = Config.TMP_DOWNLOAD_DIRECTORY if "|" in input_str: url, file_name = input_str.split("|") url = url.strip() file_name = file_name.strip() downloaded_file_name = os.path.join(to_download_directory, file_name) downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) display_message = "" c_time = time.time() while not downloader.isFinished(): total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() now = time.time() diff = now - c_time percentage = downloader.get_progress() * 100 speed = downloader.get_speed() elapsed_time = round(diff) * 1000 progress_str = "[{0}{1}]\nProgress: {2}%".format( ''.join(["█" for i in range(math.floor(percentage / 5))]), ''.join(["░" for i in range(20 - math.floor(percentage / 5))]), round(percentage, 2)) estimated_total_time = downloader.get_eta(human=True) try: current_message = f"trying to download\n" current_message += f"URL: {url}\n" current_message += f"File Name: {file_name}\n" current_message += f"{progress_str}\n" current_message += f"{humanbytes(downloaded)} of {humanbytes(total_length)}\n" current_message += f"ETA: {estimated_total_time}" if round(diff % 10.00) == 0 and current_message != display_message: await event.edit(current_message) display_message = current_message except Exception as e: logger.info(str(e)) end = datetime.now() ms_dl = (end - start).seconds if downloader.isSuccessful(): await event.edit("Downloaded to `{}` in {} seconds.".format( downloaded_file_name, ms_dl)) if os.path.exists(downloaded_file_name): c_time = time.time() await borg.send_file( event.chat_id, downloaded_file_name, force_document=True, supports_streaming=False, allow_cache=False, reply_to=event.message.id, thumb=thumb, progress_callback=lambda d, t: asyncio.get_event_loop(). create_task(progress(d, t, event, c_time, "trying to upload"))) end_two = datetime.now() os.remove(downloaded_file_name) ms_two = (end_two - end).seconds await event.edit( "Downloaded in {} seconds. Uploaded in {} seconds.".format( ms_dl, ms_two)) else: await event.edit("File Not Found {}".format(input_str)) else: await event.edit("Incorrect URL\n {}".format(input_str))
async def download_telegram(client, message): mone = await message.edit("Processing ...") # Reply url = message.text[10:] if message.reply_to_message: start = datetime.now() c_time = time.time() try: downloaded_file_name = await message.reply_to_message.download( file_name=DOWNLOAD_LOCATION, progress=progress_for_pyrogram, progress_args=( mone,c_time, "Downloading... " ) ) downloaded_file_name=downloaded_file_name[4:] downloaded_file_name="."+downloaded_file_name except Exception as e: await mone.edit(str(e)) else: end = datetime.now() ms = (end - start).seconds await mone.edit("Downloaded to `{}` in {} seconds.".format(downloaded_file_name, ms)) # time.sleep(100000) # await mone.delete() elif url: start = datetime.now() file_name = os.path.basename(url) to_download_directory = "./DOWNLOADS/" if "|" in url: url, file_name = url.split("|") url = url.strip() file_name = file_name.strip() downloaded_file_name = os.path.join(to_download_directory, file_name) downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) display_message = "" c_time = time.time() while not downloader.isFinished(): total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() now = time.time() diff = now - c_time percentage = downloader.get_progress() * 100 speed = downloader.get_speed() elapsed_time = round(diff) * 1000 progress_str = "[{0}{1}]\nProgress: {2}%".format( ''.join(["█" for i in range(math.floor(percentage / 5))]), ''.join(["░" for i in range(20 - math.floor(percentage / 5))]), round(percentage, 2)) estimated_total_time = downloader.get_eta(human=True) try: current_message = f"trying to download\n" current_message += f"URL: {url}\n" current_message += f"File Name: {file_name}\n" current_message += f"{progress_str}\n" current_message += f"{humanbytes(downloaded)} of {humanbytes(total_length)}\n" current_message += f"ETA: {estimated_total_time}" if round(diff % 10.00) == 0 and current_message != display_message: await mone.edit(current_message) display_message = current_message except Exception as e: await mone.edit(str(e)) end = datetime.now() ms = (end - start).seconds if downloader.isSuccessful(): await mone.edit("Downloaded to `{}` in {} seconds.".format(downloaded_file_name, ms)) else: await mone.edit("Incorrect URL\n {}".format(url)) else: await mone.edit("Reply to a message to download to my local server.") time.sleep(5) await mone.delete()
async def _(event): if event.fwd_from: return mone = await event.reply("Processing ...") input_str = event.pattern_match.group(1) if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY): os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY) if event.reply_to_msg_id: start = datetime.now() reply_message = await event.get_reply_message() try: c_time = time.time() downloaded_file_name = await event.client.download_media( reply_message, Config.TMP_DOWNLOAD_DIRECTORY, progress_callback=lambda d, t: asyncio.get_event_loop(). create_task(progress(d, t, mone, c_time, "trying to download")) ) except Exception as e: # pylint:disable=C0103,W0703 await mone.edit(str(e)) else: end = datetime.now() ms = (end - start).seconds await mone.edit("Downloaded to `{}` in {} seconds.".format( downloaded_file_name, ms)) elif input_str: start = datetime.now() url = input_str file_name = os.path.basename(url) to_download_directory = Config.TMP_DOWNLOAD_DIRECTORY if "|" in input_str: url, file_name = input_str.split("|") url = url.strip() file_name = file_name.strip() downloaded_file_name = os.path.join(to_download_directory, file_name) downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) c_time = time.time() while not downloader.isFinished(): total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() display_message = "" now = time.time() diff = now - c_time percentage = downloader.get_progress() * 100 speed = downloader.get_speed() elapsed_time = round(diff) * 1000 progress_str = "{0}{1}\nProgress: {2}%".format( ''.join(["█" for i in range(math.floor(percentage / 5))]), ''.join(["░" for i in range(20 - math.floor(percentage / 5))]), round(percentage, 2)) estimated_total_time = downloader.get_eta(human=True) try: current_message = f"trying to download\nURL: {url}\nFile Name: {file_name}\n{progress_str}\n{humanbytes(downloaded)} of {humanbytes(total_length)}\nETA: {estimated_total_time}" if round(diff % 10.00) == 0 and current_message != display_message: await mone.edit(current_message) display_message = current_message except Exception as e: logger.info(str(e)) end = datetime.now() ms = (end - start).seconds if downloader.isSuccessful(): await mone.edit("Downloaded to `{}` in {} seconds.".format( downloaded_file_name, ms)) else: await mone.edit("Incorrect URL\n {}".format(input_str)) else: await mone.edit("Reply to a message to download to my local server.")
def test_mirrors(self): urls = ["http://totally_fake_website/7za.zip" ,"http://mirror.ufs.ac.za/7zip/9.20/7za920.zip"] obj = SmartDL(urls, dest=self.dl_dir, progress_bar=False) obj.start() self.assertTrue(obj.isSuccessful())
async def download(target_file): """ For .dl command, download files to the userbot's server. """ await target_file.edit("Processing ...") input_str = target_file.pattern_match.group(1) if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY): os.makedirs(TEMP_DOWNLOAD_DIRECTORY) if "|" in input_str: url, file_name = input_str.split("|") url = url.strip() # https://stackoverflow.com/a/761825/4723940 file_name = file_name.strip() head, tail = os.path.split(file_name) if head: if not os.path.isdir(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)): os.makedirs(os.path.join(TEMP_DOWNLOAD_DIRECTORY, head)) file_name = os.path.join(head, tail) downloaded_file_name = TEMP_DOWNLOAD_DIRECTORY + "" + file_name downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) c_time = time.time() display_message = None while not downloader.isFinished(): status = downloader.get_status().capitalize() total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() now = time.time() diff = now - c_time percentage = downloader.get_progress() * 100 speed = downloader.get_speed() elapsed_time = round(diff) * 1000 progress_str = "[{0}{1}] {2}%".format( ''.join(["▰" for i in range(math.floor(percentage / 10))]), ''.join(["▱" for i in range(10 - math.floor(percentage / 10))]), round(percentage, 2)) estimated_total_time = downloader.get_eta(human=True) try: current_message = f"{status}..\ \nURL: {url}\ \nFile Name: {file_name}\ \n{progress_str}\ \n{humanbytes(downloaded)} of {humanbytes(total_length)}\ \nETA: {estimated_total_time}" if round(diff % 10.00) == 0 and current_message != display_message: await target_file.edit(current_message) display_message = current_message except Exception as e: LOGS.info(str(e)) if downloader.isSuccessful(): await target_file.edit("Downloaded to `{}` successfully !!".format( downloaded_file_name)) else: await target_file.edit("Incorrect URL\n{}".format(url)) elif target_file.reply_to_msg_id: try: c_time = time.time() downloaded_file_name = await target_file.client.download_media( await target_file.get_reply_message(), TEMP_DOWNLOAD_DIRECTORY, progress_callback=lambda d, t: asyncio.get_event_loop( ).create_task( progress(d, t, target_file, c_time, "Downloading..."))) except Exception as e: # pylint:disable=C0103,W0703 await target_file.edit(str(e)) else: await target_file.edit("Downloaded to `{}` successfully !!".format( downloaded_file_name)) else: await target_file.edit( "Reply to a message to download to my local server.")
def test_pause_unpause_stop(self): obj = SmartDL(self.default_7za920_mirrors, dest=self.dl_dir, progress_bar=False) obj.start(blocking=False) while not obj.get_dl_size(): time.sleep(0.2) time.sleep(1) obj.pause() time.sleep(0.5) dl_size = obj.get_dl_size() time.sleep(2.5) self.assertEqual(dl_size, obj.get_dl_size()) obj.unpause() time.sleep(0.5) self.assertNotEqual(dl_size, obj.get_dl_size()) obj.stop() obj.wait() self.assertFalse(obj.isSuccessful())
async def _(event): if event.fwd_from: return await event.delete() mone = await event.reply("Processing ...") input_str = event.pattern_match.group(1) sample_url = "https://www.scandit.com/wp-content/themes/bridge-child/wbq_barcode_gen.php?symbology=code128&value={}&size=100&ec=L".format(input_str.replace(" ","-")) link = sample_url.rstrip() start = datetime.now() url = link file_name = "barcode.webp" to_download_directory = Config.TMP_DOWNLOAD_DIRECTORY url = url.strip() file_name = file_name.strip() downloaded_file_name = os.path.join(to_download_directory, file_name) downloader = SmartDL(url, downloaded_file_name, progress_bar=False) downloader.start(blocking=False) c_time = time.time() while not downloader.isFinished(): # url # downloaded_file_name # mone # c_time total_length = downloader.filesize if downloader.filesize else None downloaded = downloader.get_dl_size() display_message = "" now = time.time() diff = now - c_time percentage = downloader.get_progress() * 100 speed = downloader.get_speed() elapsed_time = round(diff) * 1000 progress_str = "[{0}{1}]\nProgress: {2}%".format( ''.join(["●" for i in range(math.floor(percentage / 5))]), ''.join(["○" for i in range(20 - math.floor(percentage / 5))]), round(percentage, 2)) estimated_total_time = downloader.get_eta(human=True) try: current_message = f"SNAPDRAGON DOWNLOADER\n\nURL: {url}\nFile Name: {file_name}\n{progress_str}\n{humanbytes(downloaded)} of {humanbytes(total_length)}\nETA: {estimated_total_time}" if current_message != display_message: await mone.edit(current_message) display_message = current_message except Exception as e: logger.info(str(e)) input_str = Config.TMP_DOWNLOAD_DIRECTORY + file_name thumb = None if os.path.exists(thumb_image_path): thumb = thumb_image_path if os.path.exists(input_str): start = datetime.now() c_time = time.time() await borg.send_file( event.chat_id, input_str, force_document=True, supports_streaming=False, allow_cache=False, reply_to=event.message.id, thumb=thumb, progress_callback=lambda d, t: asyncio.get_event_loop().create_task( progress(d, t, mone, c_time, "trying to upload") ) ) end = datetime.now() os.remove("barcode.webp") ms = (end - start).seconds await mone.edit("Barcode generated in {} seconds.".format(ms))