#-*- encoding:utf-8 -*- __author__ = '' import sys import os from pySmartDL import SmartDL dirs = "E:\\coral reefs data\\reef genome sumup\\" urls = "http://mirror.ufs.ac.za/7zip/9.20/7za920.zip" #sys.path.append('../') # from my_lib import download_kits # state_d = download_kits.download(urls,dirs) obj = SmartDL(urls, dirs) obj.start() path = obj.get_dest()
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 borg.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( "lapnlbot has downloaded it 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 for lapnlbot to download to your 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() media = replied.media if hasattr(media, "document"): file = media.document mime_type = file.mime_type attribs = file.attributes for attr in attribs: if isinstance(attr, DocumentAttributeFilename): filename = attr.file_name elif "audio" in mime_type: filename = "audio-" + str(datetime.now()) + ".ogg" elif "video" in mime_type: filename = "video-" + str(datetime.now()) + ".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, "[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( "Downloaded to `{}` in `{}` seconds.".format( result.name, dl_time)) except AttributeError: await target_file.edit( "Downloaded to `{}` in `{}` seconds.".format( result, dl_time)) else: await target_file.edit( "Reply to a message to download to my local server.")
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 / 5))]), ''.join([ "░" for i in range(20 - math.floor(percentage / 5)) ]), round(percentage, 2), url, file_name, humanbytes(downloaded), humanbytes(total_length), speed, estimated_total_time) count += 1 if count >= 5: count = 0 await self._message.try_to_edit( progress_str, disable_web_page_preview=True) await asyncio.sleep(1) except Exception as d_e: await self._message.err(d_e) return 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}" 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)
def savndl(update, context): global res global input_url update.message.reply_text(text="⏳ Wait a beet...") # context.bot.send_message(chat_id= update.message.chat_id,text= '⏳ Wait a beet...') rawurl = update.message.text.strip() rawurl = rawurl.split() input_url = rawurl[-1] try: proxies, headers = setProxy() res = requests.get(input_url, proxies=proxies, headers=headers) # context.bot.send_message(chat_id= update.message.chat_id,text= 'Enter req Try .') except Exception as e: logger.error('Error accessing website error: ' + e) soup = BeautifulSoup(res.text, "lxml") #Not Working For single song try: getPlayListID = soup.select(".flip-layout")[0]["data-listid"] if getPlayListID is not None: print("Initiating PlayList Downloading") # context.bot.send_message(chat_id= update.message.chat_id,text= 'Initiating PlayList Downloading') downloadSongs(getPlayList(getPlayListID), update, context) try: # context.bot.send_message(chat_id= update.message.chat_id,text= 'Uploading Your File.....') context.bot.send_document(chat_id=update.message.chat_id, document=open(location, 'rb'), caption=filename) print("Trying To Remove File...") # try: # os.remove(location) # print("Playlist cleaned") # except Exception as e: # print("ERROR REMOVING : ",e) except Exception as e: context.bot.send_message(chat_id=update.message.chat_id, text="Uploaing Fail : \n" + e) print("done", filename) context.bot.send_message(chat_id=update.message.chat_id, text=filename) except Exception as e: print( 'Download Error code 132x Playlist Id not received (May Be its a single song):', e) #NoT WORKING FOR SINGLE SONG try: getAlbumID = soup.select(".play")[0]["onclick"] getAlbumID = ast.literal_eval( re.search("\[(.*?)\]", getAlbumID).group())[1] if getAlbumID is not None: print("Initiating Album Downloading") # context.bot.send_message(chat_id= update.message.chat_id,text= 'Initiating Album Downloading') try: downloadSongs(getAlbum(getAlbumID), update, context) except Exception as e: print("ENTING DOWNLOADING Fun :" + e) downloadSongs(getAlbum(getAlbumID)) # context.bot.send_message(chat_id=update.message.chat_id,text ="Downloading YoUr file : "+location+filename) try: ####uploading single file (now this uploading moved to download function)###### # context.bot.send_message(chat_id = update.message.chat_id,message ="Uploading your Song") # context.bot.send_document(chat_id =update.message.chat_id,document=open(location, 'rb'),caption = filename) try: os.remove(location) print("File Clean") except Exception as e: print("ERROR REMOVING : ", e) except Exception as e: print("UPLOADING ERROR : ", e) print(location) context.bot.send_message(chat_id=update.message.chat_id, text=e) # sys.exit() # context.bot.send_message(chat_id= update.message.chat_id,text= 'entered playlist 1 if DONE PART.') except Exception as e: print('ERROR 112X AlbumId not received (Its may Be a single song):', e) proxy_ip = '' # set http_proxy from environment if ('http_proxy' in os.environ): proxy_ip = os.environ['http_proxy'] proxies = { 'http': proxy_ip, 'https': proxy_ip, } # proxy setup end here headers = { 'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:49.0) Gecko/20100101 Firefox/49.0' } base_url = 'http://h.saavncdn.com' json_decoder = JSONDecoder() # Key and IV are coded in plaintext in the app when decompiled # and its preety insecure to decrypt urls to the mp3 at the client side # these operations should be performed at the server side. des_cipher = des(b"38346591", ECB, b"\0\0\0\0\0\0\0\0", pad=None, padmode=PAD_PKCS5) # raw_input =input # input_url = raw_input('Enter the song url:').strip() print(update.message.text) input_url = update.message.text.strip() try: res = requests.get(input_url, proxies=proxies, headers=headers) except Exception as e: print('Error accesssing website error: ' + e) sys.exit() soup = BeautifulSoup(res.text, "lxml") # Encrypted url to the mp3 are stored in the webpage songs_json = soup.find_all('div', {'class': 'hide song-json'}) for song in songs_json: obj = json_decoder.decode(song.text) print(obj['album'], '-', obj['title']) filename = obj['title'] + '.mp3' filename = filename.replace("\"", "'") # print("ENC URL :",obj['url']) enc_url = base64.b64decode(obj['url'].strip()) print("DEC URL :", enc_url) dec_url = des_cipher.decrypt(enc_url, padmode=PAD_PKCS5).decode('utf-8') print("DEC :", dec_url) dec_url = base_url + dec_url.replace('mp3:audios', '') + '.mp3' print(dec_url, '\n') # context.bot.send_message(chat_id=update.message.chat_id, text=dec_url) print("Downloading %s" % filename) location = os.path.join(os.path.sep, os.getcwd(), "songs", filename) obj = SmartDL(dec_url, location) obj.start() context.bot.send_document(chat_id=update.message.chat_id, document=open(location, 'rb'), caption=filename) os.remove(location) break
async def download(target_file): """ For .download command, download files to the userbot's server. """ if not target_file.text[0].isalpha() and target_file.text[0] not in ("/", "#", "@", "!"): if target_file.fwd_from: return 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: 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() 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}]\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"{status}..\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 target_file.edit(current_message) display_message = current_message await asyncio.sleep(1) except Exception as e: LOGS.info(str(e)) pass end = datetime.now() duration = (end - start).seconds if downloader.isSuccessful(): await target_file.edit( "Downloaded to `{}` in {} seconds.".format( downloaded_file_name, duration) ) else: await target_file.edit( "Incorrect URL\n{}".format(url) ) elif target_file.reply_to_msg_id: start = datetime.now() 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: end = datetime.now() duration = (end - start).seconds await target_file.edit( "Downloaded to `{}` in {} seconds.".format( downloaded_file_name, duration) ) else: await target_file.edit("Reply to a message to download to my local server.")
def UPLOAD(update, context): url = update.message.text url = url.split()[-1] sent_message = context.bot.send_message(chat_id=update.message.chat_id, text=TEXT.PROCESSING) ID = update.message.chat_id ID = str(ID) os.path.isfile(ID) if os.path.isfile(ID): # Openlaod Stuffs # I will Add This Later if "openload" in url or "oload" in url: DownloadStatus = False sent_message.edit_text("Openload No longer avalible") return # Here is DropBox Stuffs elif 'dropbox.com' in url: url = DPBOX(url) filename = url.split("/")[-1] print("Dropbox link Downloading Started : {}".format( url.split("/")[-1])) sent_message.edit_text(TEXT.DP_DOWNLOAD) # filename = wget.download(url) filename = wget_dl(str(url)) print("Downloading Complete : {}".format(filename)) sent_message.edit_text(TEXT.DOWN_COMPLETE) DownloadStatus = True # Here IS Mega Links stuffs elif 'mega.nz' in url: try: print("Downlaoding Started") sent_message.edit_text(TEXT.DOWN_MEGA) m = Mega.from_credentials(TEXT.MEGA_EMAIL, TEXT.MEGA_PASSWORD) filename = m.download_from_url(url) print("Downloading Complete Mega :", filename) sent_message.edit_text(TEXT.DOWN_COMPLETE) DownloadStatus = True except Exception as e: print("Mega Downloding Error :", e) sent_message.edit_text("Mega Downloading Error !!") else: try: filename = url.split("/")[-1] print("Downloading Started : {}".format(url.split("/")[-1])) sent_message.edit_text(TEXT.DOWNLOAD) # filename = wget.download(url) filename = wget_dl(str(url)) print("Downloading Complete : {}".format(filename)) sent_message.edit_text(TEXT.DOWN_COMPLETE) DownloadStatus = True except Exception as e: # switch To second download(SmartDl Downloader) `You can activate it throungh TEXT file` if TEXT.DOWN_TWO: print(TEXT.DOWN_TWO) try: sent_message.edit_text( "Downloader 1 Error:{} \n\n Downloader 2 :Downloading Started..." .format(e)) obj = SmartDL(url) obj.start() filename = obj.get_dest() DownloadStatus = True except Exception as e: print(e) sent_message.edit_text( "Downloading error :{}".format(e)) DownloadStatus = False else: print(e) sent_message.edit_text("Downloading error :{}".format(e)) DownloadStatus = False # Checking Error Filename if "error" in filename: # print(filename) # print(filename[0],filename[-1],filename[1]) sent_message.edit_text("Downloading Error !! ") os.remove(filename[-1]) ##########Uploading part ################### try: if DownloadStatus: sent_message.edit_text(TEXT.UPLOADING) SIZE = (os.path.getsize(filename)) / 1048576 SIZE = round(SIZE) FILENAME = filename.split("/")[-1] try: FILELINK = upload(filename, update, context, TEXT.drive_folder_name) except Exception as e: print("error Code : UPX11", e) sent_message.edit_text("Uploading fail :{}".format(e)) sent_message.edit_text(TEXT.DOWNLOAD_URL.format( FILENAME, SIZE, FILELINK), parse_mode=ParseMode.HTML) print(filename) try: os.remove(filename) except Exception as e: print(e) except Exception as e: print("Error code UXP12", e) if DownloadStatus: sent_message.edit_text("Uploading fail : {}".format(e)) try: os.remove(filename) except Exception as e: print("Error code UXP13", e) else: sent_message.edit_text("Uploading fail :", e) else: context.bot.send_message(chat_id=update.message.chat_id, text=TEXT.NOT_AUTH)
async def mega_downloader(_client, megadl): args = megadl.text.split(None, 1) await megadl.edit("`Processing...`") msg_link = await megadl.reply_to_message.text link = args[1] if link: pass elif msg_link: link = msg_link.text else: await megadl.edit("Usage: `.mega <mega url>`") return try: link = re.findall(r'\bhttps?://.*mega.*\.nz\S+', link)[0] except IndexError: await megadl.edit("`No MEGA.nz link found`\n") return cmd = f'bin/megadown -q -m {link}' result = await subprocess_run(cmd, megadl) try: data = json.loads(result[0]) except json.JSONDecodeError: await megadl.edit("`Error: Can't extract the link`\n") return except TypeError: return except IndexError: 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: await megadl.edit("`" + str(e) + "`") return 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 = ( f"**{status}**..." f"\nFile Name: `{file_name}`\n" f"\n{progress} `{percentage}%`" f"\n{humanbytes(downloaded)} of {humanbytes(total_length)}" f" @ {speed}" f"\nETA: {estimated_total_time}") if status == "Downloading": await megadl.edit(current_message) time.sleep(0.2) elif status == "Combining": if display_message != current_message: await megadl.edit(current_message) display_message = current_message except Exception: pass if downloader.isSuccessful(): download_time = downloader.get_dl_time(human=True) if exists(temp_file_name): await decrypt_file(file_name, temp_file_name, hex_key, hex_raw_key, megadl) 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 Log for details") for e in downloader.get_errors(): megadl.edit(str(e)) return
async def download(target_file): """ For .download command, download files to the userbot's server. """ await target_file.edit("Processando ...") 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"`Nome` : `{file_name}`\n" "Status" f"\n**{status}**... | {progress_str}" f"\n{humanbytes(downloaded)} of {humanbytes(total_length)}" f" @ {speed}" f"\n`Tempo Estimado` -> {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( "Baixado para `{}` com sucesso !!".format(downloaded_file_name) ) else: await target_file.edit("URL incorreto\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, "[DOWNLOAD]")), ) except Exception as e: # pylint:disable=C0103,W0703 await target_file.edit(str(e)) else: await target_file.edit( "Baixado para `{}` com sucesso !!".format(downloaded_file_name) ) else: await target_file.edit( "Responda a uma mensagem para fazer o download no meu servidor local." )
async def mega_downloader(megadl): await megadl.edit("`Mengumpulkan informasi...`") 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("`dukungan unduhan folder dihapus...`") return except IndexError: await megadl.edit("`Tautan MEGA.nz tidak ditemukan...`") 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**: `gagal mengekstrak tautan...`") 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 = "`{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" f"{progress_str}\n" f"`Ukuran:` {humanbytes(downloaded)} of {humanbytes(total_length)}\n" f"`Kecepatan:` {speed}\n" f"`ETA:` {time_formatter(estimated_total_time)}\n" f"`Durasi:` {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"Berhasil diunduh di: '`{file_path}`'.\n" f"Durasi download: {time_formatter(download_time)}." ) return None else: await megadl.edit( "`Failed to download, " "periksa Log heroku untuk lebih jelasnya.`" ) for e in downloader.get_errors(): LOGS.info(str(e)) return
async def mega_download(url, megadl): try: link = re.findall(r'\bhttps?://.*mega.*\.nz\S+', url)[0] except IndexError: await megadl.edit("`No MEGA.nz link found`\n") return cmd = f'bin/megadirect {link}' result = subprocess_run(cmd) try: data = json.loads(result[0]) except json.JSONDecodeError: await megadl.edit("`Error: Can't extract the link`\n") return file_name = data['file_name'] file_url = data['url'] file_hex = data['hex'] file_raw_hex = data['raw_hex'] if exists(file_name): os.remove(file_name) if not exists(file_name): 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: await megadl.edit("`" + str(e) + "`") LOGS.info(str(e)) return 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 = ( f"**{status}**..." f"\nFile Name: `{file_name}`\n" f"\n{progress} `{percentage}%`" f"\n{humanbytes(downloaded)} of {humanbytes(total_length)}" f" @ {speed}" f"\nETA: {estimated_total_time}" ) if status == "Downloading": await megadl.edit(current_message) time.sleep(0.2) elif status == "Combining": if display_message != current_message: await megadl.edit(current_message) display_message = current_message except Exception as e: LOGS.info(str(e)) if downloader.isSuccessful(): download_time = downloader.get_dl_time(human=True) if exists(temp_file_name): await megadl.edit("Decrypting file...") decrypt_file(file_name, temp_file_name, file_hex, file_raw_hex) await megadl.edit(f"`{file_name}`\n\n" "Successfully downloaded\n" f"Download took: {download_time}") else: await megadl.edit("Failed to download...") for e in downloader.get_errors(): LOGS.info(str(e)) return
print('Fetched links from the root : ' + str(links)) links = links[: -1] # removing the last link which points to some twitter page or sth # print(links) for i in range(len(links)): """ The final download link is of the form https://books.goalkicker.com/DotNETFrameworkBook/DotNETFrameworkNotesForProfessionals.pdf we get that by combining root_url : https://books.goalkicker.com/ links[i] : DotNETFrameworkBook/ The DotNETFrameworkNotesForProfessionals.pdf/ link is present in the page : root_url + links[i] : https://books.goalkicker.com/DotNETFrameworkBook/ """ suburl = root_url + links[i] bookname = links[i][:-1] + '.pdf' # remove the last character which is '/' pdflink = suburl + getLinks( suburl, count=1)[0] # first link points to the pdf link if os.path.isfile(bookname): print(bookname + ' file already exists') continue print('Downloading ' + pdflink + ' ....') obj = SmartDL( pdflink, './' + bookname) # download and save in the current working directory obj.start()
async def down_load_media(message: Message): await message.edit("Trying to Download...") if not os.path.isdir(Config.DOWN_PATH): os.mkdir(Config.DOWN_PATH) if message.reply_to_message and message.reply_to_message.media: start_t = datetime.now() c_time = time.time() dl_loc = await userge.download_media( message=message.reply_to_message, file_name=Config.DOWN_PATH, progress=progress, progress_args=("trying to download", userge, message, c_time)) 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): 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 and 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 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 = "[{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"{file_name} - {status}\n" f"{progress_str}" f"`Size:` {humanbytes(downloaded)} of {humanbytes(total_length)}" f"`Speed:` {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: 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, "[DOWNLOAD]")), ) 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.")
async def mega_downloader(megadl): await megadl.edit("`Mengumpulkan informasi...`") 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 link_msg_id = msg_link.id 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 dihapus...`") return except IndexError: await megadl.edit("`MEGA.nz link Tidak Ditemukan...`") 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**: `Gagal Mengekstrak 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 mimeType = await get_mimeType(file_path) service = await create_app(megadl) if service is False: return None 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"`{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"Berhasil didownload di: '`{file_path}`'.\n" f"Download took: {time_formatter(download_time)}.", ) try: resultgd = await upload(megadl, service, file_path, file_name, mimeType) except CancelProcess: megadl.respond( "`[FILE - CANCELLED]`\n\n" "`Status` : **OK** - Sinyal yang diterima dibatalkan." ) if resultgd and msg_link: await megadl.respond( "`[FILE - UPLOAD]`\n\n" f"`Name :` `{file_name}`\n" f"`Size :` `{humanbytes(resultgd[0])}`\n" f"`Link :` [{file_name}]({resultgd[1]})\n" "`Status :` **OK** - Berhasil diupload.\n", link_preview=False, reply_to=link_msg_id, ) await megadl.delete() elif resultgd and link: await megadl.respond( "`[FILE - UPLOAD]`\n\n" f"`Name :` `{file_name}`\n" f"`Size :` `{humanbytes(resultgd[0])}`\n" f"`Link :` [{file_name}]({resultgd[1]})\n" "`Status :` **OK** - Berhasil diupload.\n", link_preview=False, ) await megadl.delete() if os.path.exists(file_path): os.remove(file_path) else: pass else: await megadl.edit( "`Gagal Mendownload, " "Check Log heroku untuk lebih jelasnya.`" ) 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 """ replied = self._message.reply_to_message is_url = re.search( r"(?:https?|ftp)://[^\|\s]+\.[^\|\s]+", self._message.input_str) dl_loc = None if replied and replied.media: await self._message.edit("`Downloading From TG...`") file_name = Config.DOWN_PATH if self._message.input_str: file_name = os.path.join(Config.DOWN_PATH, self._message.input_str) dl_loc = await self._message.client.download_media( message=replied, file_name=file_name, progress=progress, progress_args=(self._message, "trying to download") ) if self._message.process_is_canceled: await self._message.edit("`Process Canceled!`", del_in=5) return dl_loc = os.path.join(Config.DOWN_PATH, os.path.basename(dl_loc)) elif is_url: await self._message.edit("`Downloading From URL...`") url = is_url[0] file_name = unquote_plus(os.path.basename(url)) if "|" in self._message.input_str: file_name = self._message.input_str.split("|")[1].strip() dl_loc = os.path.join(Config.DOWN_PATH, file_name) try: downloader = SmartDL(url, dl_loc, progress_bar=False) downloader.start(blocking=False) count = 0 while not downloader.isFinished(): if self._message.process_is_canceled: downloader.stop() raise Exception('Process Canceled!') total_length = downloader.filesize if downloader.filesize else 0 downloaded = downloader.get_dl_size() percentage = downloader.get_progress() * 100 speed = downloader.get_speed(human=True) estimated_total_time = downloader.get_eta(human=True) progress_str = \ "__{}__\n" + \ "```[{}{}]```\n" + \ "**Progress** : `{}%`\n" + \ "**URL** : `{}`\n" + \ "**FILENAME** : `{}`\n" + \ "**Completed** : `{}`\n" + \ "**Total** : `{}`\n" + \ "**Speed** : `{}`\n" + \ "**ETA** : `{}`" progress_str = progress_str.format( "trying to download", ''.join((Config.FINISHED_PROGRESS_STR for i in range(math.floor(percentage / 5)))), ''.join((Config.UNFINISHED_PROGRESS_STR for i in range(20 - math.floor(percentage / 5)))), round(percentage, 2), url, file_name, humanbytes(downloaded), humanbytes(total_length), speed, estimated_total_time) count += 1 if count >= Config.EDIT_SLEEP_TIMEOUT: count = 0 await self._message.try_to_edit( progress_str, disable_web_page_preview=True) await asyncio.sleep(1) except Exception as d_e: await self._message.err(d_e) return file_path = dl_loc if dl_loc else self._message.input_str if not os.path.exists(file_path): await self._message.err("invalid file path provided?") return if "|" in file_path: file_path, file_name = file_path.split("|") new_path = os.path.join(os.path.dirname(file_path.strip()), file_name.strip()) os.rename(file_path.strip(), new_path) file_path = new_path await self._message.edit("`Loading GDrive Upload...`") pool.submit_thread(self._upload, file_path) start_t = datetime.now() count = 0 while not self._is_finished: count += 1 if self._message.process_is_canceled: self._cancel() if self._progress is not None and count >= Config.EDIT_SLEEP_TIMEOUT: count = 0 await self._message.try_to_edit(self._progress) await asyncio.sleep(1) if dl_loc and os.path.exists(dl_loc): os.remove(dl_loc) end_t = datetime.now() m_s = (end_t - start_t).seconds if isinstance(self._output, HttpError): out = f"**ERROR** : `{self._output._get_reason()}`" # pylint: disable=protected-access elif self._output is not None and not self._is_canceled: out = f"**Uploaded Successfully** __in {m_s} seconds__\n\n{self._output}\n\n📂 Index link: <a href='{Config.INDEX_LINK}/{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=__name__)
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] except IndexError: return await megadl.edit("`No MEGA.nz link found`\n") if "#F" in link: await megadl.edit('`MEGA.nz link is a folder...`') await asyncio.sleep(2) return await mega_downloader_fallback(megadl, link) 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
async def _(event): # sourcery no-metrics "To download the replied telegram file" mone = await edit_or_reply(event, "`Downloading....`") input_str = event.pattern_match.group(3) name = NAME path = None if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY): os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY) reply = await event.get_reply_message() if reply: start = datetime.now() for attr in getattr(reply.document, "attributes", []): if isinstance(attr, types.DocumentAttributeFilename): name = attr.file_name if input_str: path = pathlib.Path(os.path.join(downloads, input_str.strip())) else: path = pathlib.Path(os.path.join(downloads, name)) ext = get_extension(reply.document) if path and not path.suffix and ext: path = path.with_suffix(ext) if name == NAME: name += "_" + str(getattr(reply.document, "id", reply.id)) + ext if path and path.exists(): if path.is_file(): newname = f"{str(path.stem)}_OLD" path.rename(path.with_name(newname).with_suffix(path.suffix)) file_name = path else: file_name = path / name elif path and not path.suffix and ext: file_name = downloads / path.with_suffix(ext) elif path: file_name = path else: file_name = downloads / name file_name.parent.mkdir(parents=True, exist_ok=True) c_time = time.time() if ( not reply.document and reply.photo and file_name and file_name.suffix or not reply.document and not reply.photo ): await reply.download_media( file=file_name.absolute(), progress_callback=lambda d, t: asyncio.get_event_loop().create_task( progress(d, t, mone, c_time, "trying to download") ), ) elif not reply.document: file_name = await reply.download_media( file=downloads, progress_callback=lambda d, t: asyncio.get_event_loop().create_task( progress(d, t, mone, c_time, "trying to download") ), ) else: dl = io.FileIO(file_name.absolute(), "a") await event.client.fast_download_file( location=reply.document, out=dl, progress_callback=lambda d, t: asyncio.get_event_loop().create_task( progress(d, t, mone, c_time, "trying to download") ), ) dl.close() end = datetime.now() ms = (end - start).seconds await mone.edit( f"**• Downloaded in {ms} seconds.**\n**• Downloaded to :- ** `{os.path.relpath(file_name,os.getcwd())}`\n " ) elif input_str: start = datetime.now() if "|" in input_str: url, file_name = input_str.split("|") else: url = input_str file_name = None url = url.strip() file_name = os.path.basename(url) if file_name is None else file_name.strip() downloaded_file_name = pathlib.Path(os.path.join(downloads, file_name)) if not downloaded_file_name.suffix: ext = os.path.splitext(url)[1] downloaded_file_name = downloaded_file_name.with_suffix(ext) downloader = SmartDL(url, str(downloaded_file_name), progress_bar=False) downloader.start(blocking=False) c_time = time.time() delay = 0 oldmsg = "" while not downloader.isFinished(): total_length = downloader.filesize or None downloaded = downloader.get_dl_size() now = time.time() delay = now - c_time percentage = downloader.get_progress() * 100 dspeed = downloader.get_speed() progress_str = "`{0}{1} {2}`%".format( "".join("▰" for _ in range(math.floor(percentage / 5))), "".join("▱" for _ in range(20 - math.floor(percentage / 5))), round(percentage, 2), ) estimated_total_time = downloader.get_eta(human=True) 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)} @ {humanbytes(dspeed)}`\ \n**ETA : **`{estimated_total_time}`" if oldmsg != current_message and delay > 5: await mone.edit(current_message) delay = 0 c_time = time.time() oldmsg = current_message await asyncio.sleep(1) end = datetime.now() ms = (end - start).seconds if downloader.isSuccessful(): await mone.edit( f"**• Downloaded in {ms} seconds.**\n**• Downloaded file location :- ** `{os.path.relpath(downloaded_file_name,os.getcwd())}`" ) 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 .dl command, download files to the userbot's server. """ await target_file.edit("Processing using userbot server ( ◜‿◝ )♡") 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 downloader.get_speed() 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}..\ \nFOR : F.R.I.D.A.Y™ AND INDIANBOT™\ \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.")
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 _(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: 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 down_load_media(message: Message): await message.edit("Trying to Download...") if message.reply_to_message is not None: start_t = datetime.now() c_time = time.time() the_real_download_location = await userge.download_media( message=message.reply_to_message, file_name=Config.DOWN_PATH, progress=progress, progress_args=("trying to download", userge, message, c_time)) # await userge.send_chat_action(message.chat.id, "cancel") if message.process_is_canceled: await message.edit("`Process Canceled!`", del_in=5) else: end_t = datetime.now() ms = (end_t - start_t).seconds await message.edit( f"Downloaded to `{the_real_download_location}` in {ms} seconds" ) elif message.input_str: start_t = datetime.now() url = message.input_str custom_file_name = 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) downloader = SmartDL(url, download_file_path, 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\n" current_message += f"URL: {url}\n" current_message += f"File Name: {custom_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 message.try_to_edit(text=current_message, disable_web_page_preview=True) # display_message = current_message await asyncio.sleep(10) except Exception as e: LOGGER.info(e) if os.path.exists(download_file_path): end_t = datetime.now() ms = (end_t - start_t).seconds await message.edit( f"Downloaded to `{download_file_path}` in {ms} seconds") else: await message.edit(f"`Something went wrong!`", del_in=3) else: await message.edit( "Reply to a Telegram Media, to download it to local server.", del_in=3)
async def gdrive_upload_function(dryb): """ For .gdrive command, upload files to google drive. """ await dryb.edit("Processing ...") 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)) pass 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}`")
def UPLOAD(update, context): url = update.message.text url = url.split()[-1] sent_message = context.bot.send_message(chat_id=update.message.chat_id, text=TEXT.PROCESSING) ID = update.message.chat_id ID = str(ID) os.path.isfile(ID) if os.path.isfile(ID): try: filename = url.split("/")[-1] print("Downloading Started : {}".format(url.split("/")[-1])) sent_message.edit_text(TEXT.DOWNLOAD) # filename = wget.download(url) filename = wget_dl(str(url)) print("Downloading Complete : {}".format(filename)) sent_message.edit_text(TEXT.DOWN_COMPLETE) DownloadStatus = True except Exception as e: # switch To second download(SmartDl Downloader) `You can activate it throungh TEXT file` if TEXT.DOWN_TWO: print(TEXT.DOWN_TWO) try: sent_message.edit_text( "Downloader 1 Error:{} \n\n Downloader 2 :Downloading Started..." .format(e)) obj = SmartDL(url) obj.start() filename = obj.get_dest() DownloadStatus = True except Exception as e: print(e) sent_message.edit_text("Downloading error :{}".format(e)) DownloadStatus = False else: print(e) sent_message.edit_text("Downloading error :{}".format(e)) DownloadStatus = False # Checking Error Filename if "error" in filename: # print(filename) # print(filename[0],filename[-1],filename[1]) sent_message.edit_text("Downloading Error !! ") os.remove(filename[-1]) ##########Uploading part ################### try: if DownloadStatus: sent_message.edit_text(TEXT.UPLOADING) SIZE = (os.path.getsize(filename)) / 1048576 SIZE = round(SIZE) FILENAME = filename.split("/")[-1] try: FILELINK = upload(filename, update, context, TEXT.drive_folder_name) except Exception as e: print("error Code : UPX11", e) sent_message.edit_text("Uploading fail :{}".format(e)) sent_message.edit_text(TEXT.DOWNLOAD_URL.format( FILENAME, SIZE, FILELINK), parse_mode=ParseMode.HTML) print(filename) try: os.remove(filename) except Exception as e: print(e) except Exception as e: print("Error code UXP12", e) if DownloadStatus: sent_message.edit_text("Uploading fail : {}".format(e)) try: os.remove(filename) except Exception as e: print("Error code UXP13", e) else: sent_message.edit_text("Uploading fail :", e) else: context.bot.send_message(chat_id=update.message.chat_id, text=TEXT.NOT_AUTH)
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\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
async def gdrive_upload_function(dryb): """ .gdrive komutu dosyalarınızı Google Drive'a uploadlar. """ await dryb.edit("İşleniyor ...") 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}\ \nDosya adı: {file_name}\ \n{progress_str}\ \n{humanbytes(downloaded)} of {humanbytes(total_length)}\ \nBitiş: {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)) pass if downloader.isSuccessful(): await dryb.edit( "`{}` dizinine indirme başarılı. \nGoogle Drive'a yükleme başlatılıyor.." .format(downloaded_file_name)) required_file_name = downloaded_file_name else: await dryb.edit("Geçersiz 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( "`{}` dosyası sunucuda bulundu. Google Drive'a yükleme başlatılıyor.." .format(input_str)) else: await dryb.edit( "Sunucuda dosya bulunamadı. Lütfen doğru dosya konumunu belirtin." ) 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, "İndiriliyor..."))) except Exception as e: await dryb.edit(str(e)) else: required_file_name = downloaded_file_name await dryb.edit( "`{}` dizinine indirme başarrılı. \nGoogle Drive'a yükleme başlatılıyor.." .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) # Token dosyasının olup olmadığını kontrol eder, eğer yoksa yetkilendirme kodu ile oluşturur. 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) # Yetkilendirir, dosya parametrelerini edinir, dosyayı uploadlar ve URL'yi indirme için paylaşır. http = authorize(G_DRIVE_TOKEN_FILE, None) file_name, mime_type = file_ops(required_file_name) # required_file_name tam dosya yoluna sahiptir. # Bazen API başlangıç URI'sini geri alırken hatayla karşılaşır. try: g_drive_link = await upload_file(http, required_file_name, file_name, mime_type, dryb, parent_id) await dryb.edit( f"Dosya :`{required_file_name}`\nUpload başarılı! \nİndirme linki: [Google Drive]({g_drive_link})!" ) except Exception as e: await dryb.edit( f"Google Drive'a yükleme başarısız.\nHata kodu:\n`{e}`")
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 SUDO_LIST = {} from userbot.helpers import * from userbot.helpers import functions as helldef
async def download(target_file): """ .download komutu userbot sunucusuna dosya indirmenizi sağlar. """ await target_file.edit(LANG['DOWNLOADING']) 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}..\ \n{LANG['URL']}: {url}\ \n{LANG['FILENAME']}: {file_name}\ \n{progress_str}\ \n{humanbytes(downloaded)} of {humanbytes(total_length)}\ \n{LANG['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( LANG['SUCCESSFULLY'].format(downloaded_file_name)) else: await target_file.edit(LANG['INVALID_URL'].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, LANG['DOWNLOADING']))) except Exception as e: # pylint:disable=C0103,W0703 await target_file.edit(str(e)) else: await target_file.edit( LANG['SUCCESSFULLY'].format(downloaded_file_name)) else: await target_file.edit(LANG['NEED_REPLY'])
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(Config.TMP_DOWNLOAD_DIRECTORY): os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY) required_file_name = None elif input_str: start = datetime.now() url = input_str file_name = os.path.basename(url) if "|" in input_str: url, file_name = input_str.split("|") url = url.strip() file_name = file_name.strip() downloaded_file_name = Config.TMP_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 downloader.get_speed() 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"{status}...\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 await asyncio.sleep(3) except Exception as e: logger.info(str(e)) end = datetime.now() ms = (end - start).seconds if downloader.isSuccessful(): await dryb.edit( "Downloaded to `{}` in {} seconds.\nNow Uploading to Google Drive...".format( downloaded_file_name, ms ) ) required_file_name = downloaded_file_name else: await dryb.edit("Incorrect URL\n{}".format(url)) 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(), Config.TMP_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 ms = (end - start).seconds await dryb.edit( "Downloaded to `{}` in {} seconds.\nNow Uploading to GDrive...".format( required_file_name, ms ) ) if required_file_name: # if Config.G_DRIVE_AUTH_TOKEN_DATA is not None: with open(G_DRIVE_TOKEN_FILE, "w") as t_file: t_file.write(Config.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}`\nHas 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 uploadtotg(message: Message): """ upload to telegram """ 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 = unquote_plus(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( (Config.FINISHED_PROGRESS_STR for i in range(math.floor(percentage / 5)))), ''.join((Config.UNFINISHED_PROGRESS_STR for i in range(20 - math.floor(percentage / 5)))), round(percentage, 2), url, file_name, humanbytes(downloaded), humanbytes(total_length), speed, estimated_total_time) count += 1 if count >= 5: count = 0 await 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)