async def add_to_queue(self, query_string: str) -> Song: song = Song() # Check if query string is YT link if query_string.startswith('https://www.youtube.com/'): song.page_url = query_string # Or search with youtube_dlc otherwise else: options = { 'format': 'bestaudio/best', 'default_search': 'auto', 'noplaylist': True } with youtube_dlc.YoutubeDL(options) as ydl: yt_entry = ydl.extract_info(query_string, download=False) video_id = yt_entry['entries'][0]['id'] song.page_url = 'https://www.youtube.com/watch?v={}'.format( video_id) downloader = youtube_dlc.YoutubeDL({ 'format': 'bestaudio', 'title': True }) yt_entry = downloader.extract_info(song.page_url, download=False) song.file_url = yt_entry.get('url') song.uploader = yt_entry.get('uploader') song.title = yt_entry.get('title') song.duration = yt_entry.get('duration') song.page_url = yt_entry.get('webpage_url') self.queue.append(song) if self.current_song is None: self.try_play_next_song() return song
async def process_playlist(self, playlist_type, url): if playlist_type == linkutils.Playlist_Types.YouTube_Playlist: if ("playlist?list=" in url): listid = url.split('=')[1] else: video = url.split('&')[0] await self.process_song(video) return options = { 'format': 'bestaudio/best', 'extract_flat': True, "cookiefile": config.COOKIE_PATH } with youtube_dlc.YoutubeDL(options) as ydl: r = ydl.extract_info(url, download=False) for entry in r['entries']: link = "https://www.youtube.com/watch?v={}".format( entry['id']) song = Song(linkutils.Origins.Playlist, linkutils.Sites.YouTube, webpage_url=link) self.playlist.add(song) if playlist_type == linkutils.Playlist_Types.Spotify_Playlist: links = linkutils.get_spotify_playlist(url) for link in links: song = Song(linkutils.Origins.Playlist, linkutils.Sites.Spotify, webpage_url=link) self.playlist.add(song) if playlist_type == linkutils.Playlist_Types.BandCamp_Playlist: options = {'format': 'bestaudio/best', 'extract_flat': True} with youtube_dlc.YoutubeDL(options) as ydl: r = ydl.extract_info(url, download=False) for entry in r['entries']: link = entry.get('url') song = Song(linkutils.Origins.Playlist, linkutils.Sites.Bandcamp, webpage_url=link) self.playlist.add(song)
def update_db(): ydl = youtube_dlc.YoutubeDL({"ignoreerrors": True}) with sql.connect(db_name) as conn: for query in queries: r = ydl.extract_info("ytsearchdate20:{}".format(query), download=False) video_list = r['entries'] for video in video_list: if video is None: continue p = compute_prediction(video) # pegando a tag com o link do video video_id = video['webpage_url'] watch_title = video['title'].replace("'", "") data_front = {"title": watch_title, "score": float(p), "video_id": video_id} data_front['update_time'] = time.time_ns() print(video_id, json.dumps(data_front)) c = conn.cursor() c.execute("INSERT INTO videos VALUES ('{title}', '{video_id}', {score}, {update_time})".format(**data_front)) conn.commit() return True
def get_video_title(download_url): try: with youtube_dlc.YoutubeDL(config.ydl_options) as ydl: return ydl.extract_info(download_url, download=False)['title'] except Exception as e: print('error', e)
def fetch_metadata(url): stdout = io.StringIO() stderr = io.StringIO() info = None with youtube_dlc.YoutubeDL({'extract_flat': 'in_playlist'}) as ydl: ydl.params['extract_flat'] = 'in_playlist' return ydl.extract_info(url, download=False)
def download_video(download_opts, urlnum, urllist): with youtube_dlc.YoutubeDL(download_opts) as ydl: i = 0 for url in urllist: while True: try: ydl.extract_info(url, download=True) wait_time(5, 20) except KeyboardInterrupt: print("\nKeyboardInterrupt") exit(1) except youtube_dlc.utils.YoutubeDLError: youtube_dlc.utils.std_headers[ 'User-Agent'] = youtube_dlc.utils.random_user_agent() wait_time(1, 10) except: print("\nother error") exit(1) else: youtube_dlc.utils.std_headers[ 'User-Agent'] = youtube_dlc.utils.random_user_agent() i += 1 print( "\n\nDownloaded Items " + str(i) + "/" + str(urlnum) + "\n\n" "--------------------------------------------------------------" ) break
def download(self): try: with youtube_dl.YoutubeDL(self.options) as ydl: ydl.download([self.url]) except: log.warning("Playlist at {} could not be downloaded.".format( id(self)))
async def get(session: CommandSession): args = session.current_arg_text.strip().split() if len(args) == 1: try: with youtube_dlc.YoutubeDL() as yt_dlc: info_dict = yt_dlc.extract_info(args[0], download=False) if is_duplicated(info_dict): session.send('视频:“' + info_dict["title"] + '”已在队列中,请勿重复下载') return info_dict['status'] = '等待中' info_dict['now_time'] = datetime.datetime.now().strftime( '%Y-%m-%d_%H:%M:%S.%f') download_list[info_dict['now_time']] = info_dict download_thread = threading.Thread(target=download_video, args=(session, info_dict['now_time'])) download_thread.start() session.send('视频:“' + info_dict["title"] + '”加入下载队列') except youtube_dlc.utils.UnsupportedError: exception_handler(f'解析失败:视频地址不受支持,请确认地址是否正确后再试。', logging.WARNING, False, session.event.group_id) except youtube_dlc.utils.DownloadError as dl_error: exception_handler(f'解析失败:{dl_error.exc_info}', logging.ERROR) except Exception as e: exception_handler(f'解析失败:未知错误,请查看运行日志。', logging.ERROR, False, session.event.group_id) return else: session.send("参数个数错误,仅支持一个参数,请检查后再试。")
def download(self): if self.downloaded: return self.file_path out_template = str(self.file_path).replace(".mp3", ".%(ext)s") params = { "format": "bestaudio/best", "outtmpl": out_template, "noplaylist": True, "writethumbnail": True, "updatetime": False, "postprocessors": [ { "key": "FFmpegExtractAudio", "preferredcodec": "mp3", "preferredquality": "192", }, { "key": "FFmpegMetadata" }, ], } with youtube_dlc.YoutubeDL(params) as ydl: ydl.extract_info(self.url) return self.file_path
async def play_song(self, song): """Plays a song object""" if song.origin == linkutils.Origins.Playlist: if song.host == linkutils.Sites.Spotify: conversion = await self.search_youtube( linkutils.convert_spotify(song.info.webpage_url)) song.info.webpage_url = conversion downloader = youtube_dlc.YoutubeDL({ 'format': 'bestaudio', 'title': True, "cookiefile": config.COOKIE_PATH }) r = downloader.extract_info(song.info.webpage_url, download=False) song.base_url = r.get('url') song.info.uploader = r.get('uploader') song.info.title = r.get('title') song.info.duration = r.get('duration') song.info.webpage_url = r.get('webpage_url') song.info.thumbnail = r.get('thumbnails')[0]['url'] self.playlist.add_name(song.info.title) self.current_song = song self.voice_client.play(discord.FFmpegPCMAudio( song.base_url, before_options= '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5'), after=lambda e: self.next_song(e)) self.voice_client.source = discord.PCMVolumeTransformer( self.guild.voice_client.source) self.voice_client.source.volume = float(self.volume) / 100.0
def write_from_link(download_url): try: with youtube_dlc.YoutubeDL(config.ydl_options) as ydl: meta = ydl.extract_info(download_url, download=True) return meta['id'], meta['title'], meta['duration'] except Exception as e: print('error', e)
def addSong(url, artistOverride, albumOverride, copyToItunes): # download mp3 with youtube_dlc.YoutubeDL(ydl_opts) as ydl: try: info = ydl.extract_info(url) except Exception as e: return [1, e] videoTitle = info['title'] songName = info['track'] or 'NA' meta = MP4("song/" + songName + '.m4a') meta['\xa9cmt'] = '' meta['\xa9day'] = meta['\xa9day'][0][0:4] if songName == 'NA': meta['\xa9ART'] = '' if artistOverride != '': meta['\xa9ART'] = artistOverride if albumOverride != '': meta['\xa9alb'] = albumOverride meta.save() fileName = songName + '.m4a' if songName == 'NA': os.rename("song/" + fileName, localMusicFolder + videoTitle + ".m4a") fileName = videoTitle + ".m4a" else: os.rename("song/" + fileName, localMusicFolder + fileName) if copyToItunes: copyfile(localMusicFolder + fileName, itunesAutoImportFolder + fileName) print("Completed successfully") return [0, fileName]
def download_video(session, time): bot = nonebot.get_bot() video_info = download_list[time] logging.info("Start Downloading...") class Logger(object): @staticmethod def debug(msg): if 'Deleting' in msg: if '.flv' in msg or '.m4a' in msg: if video_info['status'] != '上传中': video_info['status'] = '上传中' # send_message_auto(session, '成功转码视频:“' + video_info['title'] + '”,开始上传到OneDrive') upload_video(session, video_info) if download_list: download_list.pop(time) else: print("[WARN]Download List not exist.") @staticmethod def warning(msg): exception_handler(f'YoutubeDLC:{msg}', logging.WARNING) @staticmethod def error(msg): exception_handler(f'YoutubeDLC:{msg}', logging.ERROR) def tracker(data): nonlocal video_info if data['status'] == 'downloading': video_info['status'] = '已下载' + data['_percent_str'] if data['status'] == 'finished' and ('.flv' in data['filename'] or '.m4a' in data['filename']): if video_info['status'] != '转码中': video_info['status'] = '转码中' # send_message_auto(session, '成功下载视频:“' + video_info['title'] + '”,开始转码') options = { 'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best', 'progress_hooks': [tracker], 'logger': Logger(), 'merge_output_format': 'mp4', 'postprocessors': [{ 'key': 'FFmpegVideoConvertor', 'preferedformat': 'mp4' }], 'outtmpl': f'{CACHE_PATH}{time}.%(ext)s', } try: with youtube_dlc.YoutubeDL(options) as yt_dlc: yt_dlc.download([video_info['webpage_url']]) except Exception: exception_handler(f'下载失败:下载过程中出现错误,请排除队列错误后再试。', logging.ERROR, False, session.event.group_id)
def getData(self, base_url, tag, query_filter, max_pages, pagesize, num_videos): ''' returns a dataframe with information from youtube and satckoverflow or stackexchenge that was scrapped. Paramaters ---------- base_url: url path to all question filter by a tag >> parameter to stackScrape class - stackexchange: https://stats.stackexchange.com/questions/tagged/ - stackoverflow: https://stackoverflow.com/questions/tagged/ tag: tag to be filtered (e.g.: 'python', 'r', 'javascript', ...) >> parameter to stackScrape class query_filter: filter to perform a query ('Newest', 'Active', 'Bounties', 'Unanswered', 'Frequent', Votes') >> parameter to stackScrape class max_pages: the maximum number of pages to be scraped >> parameter to stackScrape class pagesize: the number of records per page (the maximum number is 50) >> parameter to stackScrape class num_videos: Number of videos in each query for youtube scrapping Return ------ A DataFrame ''' # YoutubeDL class initialization ydl = youtube_dlc.YoutubeDL({'ignoreerrors':True}) # Getting Stack data dfStack = self.stack.TagsStack(base_url, tag, query_filter, max_pages, pagesize) # Rename columns of Stack DataFrame dfStack = YoutubeData.renameStackColumns(self, dfStack) # Array of tags for the youtube query arrayQuery = dfStack['TagStack'].to_list() results = list() # loop in each tag of the array of tags for query in arrayQuery: # Append string python for getting video with python relation queryConcat = query + ' python' # Extract info from Youtube r = ydl.extract_info('ytsearchdate{}:\{}'.format(num_videos, queryConcat), download=False) # loop in each result of the extraction for entry in r['entries']: # Add the Query Column into Dataframe if entry is not None: entry['Query'] = query # Append all the videos of each tag into a list results += r['entries'] # Exclude None results = [e for e in results if e is not None] # DataFrame dfYoutube = pd.DataFrame(results) # Merge Stack and Youtube Dataframe dfResult = YoutubeData.mergeYotubeStackData(self, dfYoutube, dfStack) return dfResult
def get_info_dict(self) -> None: with youtube_dl.YoutubeDL(self.options) as ydl: try: self.info_dict = ydl.extract_info(self.url, download=False) log.debug(f"Populated metadata for {self.url} successfully.") # TODO make the error handling here better except: log.error(f"Populating metadata for {self.url} failed") self.error = True
def write_from_link(download_url): try: with youtube_dlc.YoutubeDL(config.ydl_options) as ydl: meta = ydl.extract_info(download_url, download=True) if meta['formats'][0]['filesize'] > config.max_file_size: raise Exception("File too large") return meta['id'], meta['title'], meta['duration'] except Exception as e: print('error', e)
def download_video(download_opts, urlnum, urllist, out_path, ext_str): file_list = [] with youtube_dlc.YoutubeDL(download_opts) as ydl: downloaded_count = 0 skiped_count = 0 count = 1 max_retry_count = 3 for url in urllist: while True: try: info_dict = ydl.extract_info(url, download=True) o = json.loads(json.dumps(info_dict, ensure_ascii=False)) title_byte = o['title'].encode('cp932', 'ignore') title_str = title_byte.decode('cp932') uploader_byte = o['uploader'].encode('cp932', 'ignore') uploader_str = uploader_byte.decode('cp932') file_path = out_path + '/' + uploader_str + '/' + title_str + ext_str file_list.append(file_path) wait_time(3, 6) except KeyboardInterrupt: logger.info("\nKeyboardInterrupt") return file_list # exit(1) except youtube_dlc.utils.YoutubeDLError as you_err: logger.error(you_err) logger.error('url:' + url) count += 1 if count >= max_retry_count: skiped_count += 1 logger.debug("Skipped Items " + str(skiped_count) + "/" + str(urlnum)) break youtube_dlc.utils.std_headers['User-Agent']=youtube_dlc.utils.random_user_agent() wait_time(1, 6) except Exception as err: logger.error(err) logger.error('url:' + url) skiped_count += 1 logger.debug("Skipped Items " + str(skiped_count) + "/" + str(urlnum)) break except: logger.error("Other error") logger.error('url:' + url) skiped_count += 1 logger.debug("Skipped Items " + str(skiped_count) + "/" + str(urlnum)) break # exit(1) else: youtube_dlc.utils.std_headers['User-Agent']=youtube_dlc.utils.random_user_agent() downloaded_count += 1 # UnicodeDecodeErrorの回避 logger.debug("Downloaded: " + title_str) logger.debug("Downloaded Items " + str(downloaded_count) + "/" + str(urlnum)) break return file_list
def youtube_dl_func(url, ydl_opts, queue=None): ydl = youtube_dl.YoutubeDL(ydl_opts) try: ydl.download([url]) except Exception as exc: ydl_status = 1, str(exc) # ydl_status = exc #TODO: pass and re-raise original Exception else: ydl_status = 0, "OK" if queue: queue.put(ydl_status) else: return ydl_status
def flat_playlist(flat_list): with youtube_dlc.YoutubeDL(flat_list) as ydl: try: info_dict = ydl.extract_info(playlist, download=False) except youtube_dlc.utils.YoutubeDLError: print("\nNot get playlist. Check playlist-id and retry") exit(1) except: print("\nother error") exit(1) o = json.loads(json.dumps(info_dict, ensure_ascii=False)) urllist = [] for items in o["entries"]: urllist.append("https://www.youtube.com/watch?v=" + items["id"]) urlnum = len(urllist) return urlnum, urllist
def flat_channel(flat_list, channel_url): with youtube_dlc.YoutubeDL(flat_list) as ydl: try: info_dict = ydl.extract_info(channel_url, download=False) except youtube_dlc.utils.YoutubeDLError as youtube_err: logger.info("\nNot get playlist. Check playlist-id and retry") raise youtube_err # exit(1) except: logger.error("\nother error") raise Exception # exit(1) o = json.loads(json.dumps(info_dict, ensure_ascii=False)) url = "" url = o["url"] return url
def download_video(vidlink, start_sec, end_sec): ydl = youtube_dlc.YoutubeDL({'format': 'best/best'}, ) with ydl: video = ydl.extract_info(vidlink, download=False) url = video['url'] fps = video['fps'] start_time = sec_to_time(start_sec) duration_time = sec_to_time(end_sec - start_sec) if os.path.exists('vid.mp4'): os.remove('vid.mp4') os.system("ffmpeg -i '%s' -ss %s -t %s -async 1 -strict -2 'vid.mp4'" % (url, start_time, duration_time))
def predict_api(id_video): ydl = youtube_dlc.YoutubeDL({"ignoreerrors": True}) video_json_data = ydl.extract_info( "https://www.youtube.com/watch?v={}".format(id_video), download=False) if video_json_data is None: return "not found" p = ml_utils.compute_prediction(video_json_data) output = { "title": video_json_data['title'], "score": p, "link": "https://www.youtube.com/watch?v={}".format(id_video) } return output
def download(url, request_options, output, job_id): with youtube_dlc.YoutubeDL(get_ydl_options(request_options)) as ydl: ydl.params['extract_flat'] = 'in_playlist' ydl_opts = ChainMap(os.environ, app_defaults) info = ydl.extract_info(url, download=False) if 'title' in info and info['title']: jobshandler.put((Actions.SET_NAME, (job_id, info['title']))) if '_type' in info and info['_type'] == 'playlist' \ and 'YDL_OUTPUT_TEMPLATE_PLAYLIST' in ydl_opts: ydl.params['outtmpl'] = ydl_opts['YDL_OUTPUT_TEMPLATE_PLAYLIST'] ydl.params['extract_flat'] = False # Swap out sys.stdout as ydl's output so we can capture it ydl._screen_file = output ydl._err_file = ydl._screen_file ydl.download([url]) return ydl._screen_file.getvalue()
def downloadVideo(self): with open('links.txt', 'r') as file: links = file.readlines() if links == []: self.dw.show() self.LinksNotFound() else: ydl_opts = {'format': 'bestvideo/best', 'outtmpl': f"{self.directory}\%(title)s.%(ext)s", 'progress_hooks': [self.progressHook], 'postprocessors': [{ 'key': 'FFmpegExtractAudio', 'preferredcodec': 'mp4', 'preferredquality': '192',}]} for link in links: with youtube_dlc.YoutubeDL(ydl_opts) as ydl: ydl.download([link])
def download(vid): '''Downloads the video specified by the video id''' #Search could not find anything if vid == None: return None #Downloads the video with the url url = YT_VIDEO_BASE.format(vid) data = {} try: with youtube_dlc.YoutubeDL(YDL_OPTIONS) as ydl: info = ydl.extract_info(url, download=False) download_target = ydl.prepare_filename(info) #Setup file name targ = download_target.split('.') targ[-1] = 'wav' targ = '.'.join(targ) config = Path(targ) #Only download if it doesn't already exist if not config.is_file(): #If the folder is too full songs = Path("songs") files = glob.glob("songs/*") n = sum(os.stat(f).st_size for f in files) if n > MAX_ALLOCATION: print("Currently deleting songs in cache") files.sort(key=os.path.getmtime, reverse=True) for i in range(len(files)//2): os.remove(files[i]) ydl.download([url]) data['target'] = targ data['url'] = url data['title'] = html.unescape(info['title']) data['thumbnail'] = info['thumbnails'][0]['url'] data['downloaded'] = True #DIAGNOSTIC print statements (WOOHOO) print(f'Downloading: {info["title"]}') return data except: return None
async def search_youtube(self, title): """Searches youtube for the video title and returns the first results video link""" # if title is already a link if linkutils.get_url(title) is not None: return title options = { 'format': 'bestaudio/best', 'default_search': 'auto', 'noplaylist': True, "cookiefile": config.COOKIE_PATH } with youtube_dlc.YoutubeDL(options) as ydl: r = ydl.extract_info(title, download=False) videocode = r['entries'][0]['id'] return "https://www.youtube.com/watch?v={}".format(videocode)
def video_from_url(self, bot: Bot, update: Update): """Download video from URL Args: bot (:obj:`telegram.bot.Bot`): Telegram Api Bot Object. update (:obj:`telegram.update.Update`): Telegram Api Update Object """ user_id = update.message.from_user.id if self.video_information.get(user_id, None): self.abort(bot, update) chat_id = update.message.chat_id url = urldefrag(update.message.text).url # Remove potential playlist argument from url url = re.sub('([&?])list=.*(&|$)', '\g<1>', url) with youtube_dlc.YoutubeDL({}) as ydl: try: info = ydl.extract_info(url, download=False) except DownloadError: return info['short_description'] = re.sub(r'\n\s*\n', '\n', (info.get('description', '') or '')) self.video_information[user_id] = info keyboard = self.get_keyboard('format', info) self.current_menu[user_id] = 'format' self.keyboard_message_id[user_id] = bot.send_message( chat_id=chat_id, text='<a href="{webpage_url}">‍</a>' '{extractor_key:-^20}\n' '<b>{uploader} - {title}</b>\n' '{short_description:.150}...'.format(**info), parse_mode=ParseMode.HTML, disable_web_page_preview=False, reply_markup=keyboard ).result()
def download(self): with youtube_dl.YoutubeDL(self.options) as ydl: ydl.download([self.url])
def download(self, bot: Bot, update: Update): """Download video from URL Args: bot (:obj:`telegram.bot.Bot`): Telegram Api Bot Object. update (:obj:`telegram.update.Update`): Telegram Api Update Object """ user_id = update.effective_user.id chat_id = update.effective_chat.id url = self.video_information[user_id]['webpage_url'] data = update.callback_query.data.split(' ') message = update.effective_message class DownloadHook: progress_bar = None can_send_status = True def hook(self, download_event: dict): """Hook for download Args: download_event (:obj:`dict`): Dictionary with information about the event and the file """ if download_event['status'] == 'downloading' and self.can_send_status: total_amount = download_event.get('total_bytes', None) downloaded = download_event['downloaded_bytes'] fragments = False if not total_amount: fragments = True total_amount = download_event.get('fragment_count', None) downloaded = download_event.get('fragment_index', None) if total_amount is not None: if self.progress_bar is None: self.progress_bar = TelegramProgressBar( bot=bot, chat_id=chat_id, full_amount=total_amount if fragments else total_amount / 1000000, pre_message='Downloading Video\n{current} / {total} %s' % ( 'fragments' if fragments else 'MB') ) self.progress_bar.start() return self.progress_bar.update( new_amount=downloaded if fragments else downloaded / 1000000, new_full_amount=total_amount if fragments else total_amount / 1000000 ) else: self.can_send_status = False bot.send_message(chat_id=chat_id, text='Downloading Video\nNo download status available.') format_id = data[2] if format_id == 'best': if data[1] == 'video': format_id = 'bestvideo/best' elif data[1] == 'audio': format_id = 'bestaudio' elif data[1] == 'video_audio': format_id = 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best' # best mp4 wiht best m4a with TemporaryDirectory() as temp_dir: download_hook = DownloadHook() options = { 'outtmpl': os.path.join(temp_dir, '%(uploader)s - %(title)s [%(id)s].%(ext)s'), 'restrictfilenames': True, 'progress_hooks': [download_hook.hook], } if format_id: options['format'] = format_id if data[1] == 'audio' and data[2] == 'best': options['postprocessors'] = [{ 'key': 'FFmpegExtractAudio', 'preferredcodec': 'mp3', 'preferredquality': '192', }] # Remove buttons message.edit_text(text=message.text_html, parse_mode=ParseMode.HTML) with youtube_dlc.YoutubeDL(options) as ydl: ydl.download([url, ]) filename = os.listdir(temp_dir)[0] file_path = os.path.join(temp_dir, filename) file_size = os.path.getsize(file_path) sent = False if file_size < 5e+7: try: bot.send_chat_action(chat_id=chat_id, action=ChatAction.UPLOAD_VIDEO) bot.send_message(chat_id=chat_id, text='Depending on the filesize the upload could take some ' 'time') bot.send_document(chat_id=chat_id, document=open(file_path, mode='rb'), filename=filename, timeout=60) sent = True except (NetworkError, TimedOut, BadRequest): pass if not sent: bot.send_chat_action(chat_id=chat_id, action=ChatAction.UPLOAD_VIDEO) uploader.connect() uploader.upload(file_path, remove_after=1800) uploader.close() path = UPLOADER.get('url', None) or UPLOADER['configuration'].get('path', None) or '' url_path = os.path.join(path, filename) if os.path.isfile(url_path): # Can not send a download link to the user if the file is stored locally without url config bot.send_message( chat_id=update.effective_chat.id, text='The file was to big to sent or for some reason could not be sent directly. Another ' 'way of sending the file was not configured by the adminstrator. You can use /support ' 'to contact the admins.') return keyboard = InlineKeyboardMarkup([[InlineKeyboardButton('Download', url=url_path), ], ]) bot.send_message( chat_id=update.effective_chat.id, text='File was either too big for Telegram or could for some reason not be sent directly, ' 'please use this download button', reply_markup=keyboard) self.current_menu.pop(user_id, None) self.keyboard_message_id.pop(user_id, None) self.video_information.pop(user_id, None)
if artistOverride != '': meta['\xa9ART'] = artistOverride if albumOverride != '': meta['\xa9alb'] = albumOverride meta.save() fileName = songName + '.m4a' if songName == 'NA': os.rename("song/" + fileName, localMusicFolder + videoTitle + ".m4a") fileName = videoTitle + ".m4a" else: os.rename("song/" + fileName, localMusicFolder + fileName) if copyToItunes: copyfile(localMusicFolder + fileName, itunesAutoImportFolder + fileName) print("Completed successfully") return [0, fileName] if __name__ == "__main__": url = 'https://www.youtube.com/watch?v=wW80mkZaYxY' with youtube_dlc.YoutubeDL(ydl_opts) as ydl: pass ret = ydl.extract_info(url) name = ret['track'] + '.m4a' print(ret['title']) meta = MP4("song/" + name) meta['\xa9cmt'] = '' meta['\xa9day'] = meta['\xa9day'][0][0:4] meta.save()