def get_song_info(given_url="", local_dir=cur_dir, quality=1):
    """Returns song info for given YouTube url"""
    url = is_valid_youtube_url(given_url)
    yt = YouTube(url)
    raw_info = yt.get_video_data()
    if 'args' in raw_info:
        song_info = copy.copy(empty_record)
        song_info['url'] = url
        song_info['title'] = raw_info['args']['title']
        song_info['author'] = raw_info['args']['author']
        try:
            song_info['video_id'] = raw_info['args']['vid']
        except KeyError:
            song_info['video_id'] = url.replace(youtube_base_url, '')
        song_info['duration'] = int(raw_info['args']['length_seconds'])
        song_info['view_count'] = int(raw_info['args']['view_count'])
        song_info['thumbnail_url'] = raw_info['args']['thumbnail_url']
        filter_index = get_filter_index(quality, len(yt.filter()))
        video = yt.filter()[filter_index]
        local_file_name = "{0}.{1}".format(yt.filename, video.extension)
        local_file_path = os.path.join(local_dir, local_file_name)
        if os.path.exists(local_file_path):
            song_info['local_file_path'] = local_file_path
        return song_info
    else:
        return None
Beispiel #2
0
def get_video(video_info):
    save_path = os.path.join(settings["store_path"],
                             video_info["snippet"]["channelTitle"])
    mkdir(save_path)
    upload = YouTube("https://www.youtube.com/watch?v={0}".format(
        video_info["id"]["videoId"]))
    video = None
    res = ""
    i = 0
    while not video:
        if not res:
            resolution = video_resolutions[str(settings["max_quality"] - i)]
            if upload.filter(resolution=resolution):
                res = resolution
            else:
                i += 1
            if i > settings["max_quality"]:
                log("No upload candidate matches quality criteria.", "warn")
                return
        else:
            if len(upload.filter(resolution=res)) > 1:
                if upload.filter("mp4", resolution=res):
                    video = upload.get('mp4', res)
            else:
                video = upload.get(None, res)
    video.download(save_path)
    get_audio(
        video_info,
        os.path.join(save_path, (video.filename + "." + video.extension)))
Beispiel #3
0
def downloadFile(url):
    streams = YouTube(url).streams    
    streams.filter(progressive=True).desc().first()    
    name = streams.first().download()
    newname = name.replace(' ','_')
    os.rename(name,newname)
    return newname
Beispiel #4
0
def down(url, directory=None, skippable=False, ftype=None):
    if not directory:
        directory = os.getcwd()
    try:
        yt = YouTube(url)
    except:
        print('Could not get URL "{}"'.format(url))
        return
    yt.get_videos()
    print('Found "{}"'.format(yt.filename))
    if skippable and input("Download? [y]/n: ") not in ['','y']:
        return
    if len(yt.filter(resolution='480p')) == 0:
        if len(yt.filter(resolution='360p')) == 0:
            print("Can't find 480p or 360p: {}".format(yt.filename))
            return
        video = yt.get('mp4', '360p')
    else:
        video = yt.get('mp4', '480p')
    try:
        video.download(os.getcwd())
        print('...download finished')
    except OSError:
        print("Could not write file")
    if ftype == 'mp3':
        fname = video.filename
        mp4_to_mp3(fname, directory)
Beispiel #5
0
def download_video(video_id='', folder='.', progress=None, finish=None):
    url = 'http://www.youtube.com/watch?v={}'.format(video_id)

    try:
        yt = YouTube(url)
    except Exception as e:
        print('Failed to get video with url', url)
        return

    yt.set_filename(yt.filename + ' ' + str(video_id))

    if len(yt.filter('mp4')) > 0:
        if len(yt.filter('mp4', '720p')) > 0:
            video = yt.get('mp4', '720p')
        else:
            video = yt.filter('mp4')[-1]
    else:
        print('No mp4 formatted videos')
        return

    try:
        video.download(folder, on_progress=progress, on_finish=finish)
    except Exception as e:
        print('Failed to download file with exception:', e)
        return
 def _download_file(self, video_id):
     file_path = self._build_file_path(video_id)
     if not os.path.isfile(file_path):
         yt = YouTube()
         yt.from_url("http://youtube.com/watch?v=" + video_id)
         yt.filter('mp4')[0].download(file_path)  # downloads the mp4 with lowest quality
     return file_path
Beispiel #7
0
 def post(self, request):
     videoURL = request.POST.get('url')
     start = request.POST.get('start')
     end = request.POST.get('end')
     if videoURL is not None and start is not None and end is not None:
         try:
             if (int(end) - int(start)) > 10:
                 return HttpResponse(status=400)
         except:
             return HttpResponse(status=400)
         try:
             yt = YouTube(videoURL)
             print('ConverGIF - get video')
             yt.set_filename('video')
             print('ConverGIF - set filename')
             yt.filter('mp4')[-1].download('{}/youtube_video/'.format(
                 settings.MEDIA_ROOT))
             print('ConverGIF - download')
         except:
             return HttpResponse(status=404)
         try:
             video = VideoFileClip('{}/youtube_video/video.mp4'.format(
                 settings.MEDIA_ROOT)).subclip(int(start), int(end))
             video.write_videofile('{}/youtube_gif/gif.gif'.format(
                 settings.MEDIA_ROOT),
                                   fps=25,
                                   codec='gif')
             os.remove('{}/youtube_video/video.mp4'.format(
                 settings.MEDIA_ROOT))
         except:
             return HttpResponse(status=416)
     else:
         return HttpResponse(status=400)
     gifURL = '{}/youtube_gif/gif.gif'.format(settings.MEDIA_ROOT)
     return JsonResponse({'url': gifURL})
def download(url, resolution, path, addOrder, numOfVideos, video_urls, completed):
	try:
		n = url[1]
		url = url[0]
		downloaded = listdir(path)
		resolutions = ['720p', '480p', '360p', '240p', '144p']
		yt = YouTube(url)
		if (yt.filename + '.mp4') in downloaded: return False
		if len(yt.filter('mp4', resolution=resolution)) == 0:
			resolutions.remove(resolution)
			for r in resolutions:
				if len(yt.filter('mp4', resolution=r)) != 0:
					resolution = r
					break
		if addOrder:
			length = int(math.log(numOfVideos,10)) + 1
			prefix = str(n)
			prefix = "0"*(length - len(str(n))) + prefix +'. '
			if (prefix + yt.filename + '.mp4') in downloaded: return False
			yt.set_filename(prefix + yt.filename)
		video = yt.get('mp4', resolution)
		print("downloading ", yt.filename, resolution)
		video.download(path)
		completed.put(1)
	except:
		print("downloading ", yt.filename, "failed")
		print("retry later")
		video_urls.put((url, n))
def yt_download(row, csv_w, idx):
    video_name = 'v_fight_' + '{:05d}'.format(idx)
    res = ['480p', '720p', '1080p']

    try:
        yt = YouTube(row.video_link).streams.filter(
            progressive=True, subtype='mp4')
    except Exception as e:
        print(idx, row.video_link, e)
        return

    try:
        for r in res:
            if yt.filter(res=r).count() != 0:
                yt = yt.filter(res=r).first()
                break
    except Exception as e:
        print(idx, e)
        return

    try:
        if random() < 0.8:
            yt.download('/home/uscc/train', video_name)
            csv_w.writerow([idx, video_name, yt.filesize, 'train'])
            print([video_name, yt.filesize, idx, 'train'])
        else:
            yt.download('/home/uscc/test', video_name)
            csv_w.writerow([idx, video_name, yt.filesize, 'test'])
            print([video_name, yt.filesize, idx, 'test'])
    except AttributeError as e:
        print(idx, e)
        return
Beispiel #10
0
def get_song_info(given_url="", local_dir=cur_dir, quality=1):
    """Returns song info for given YouTube url"""
    url = is_valid_youtube_url(given_url)
    yt = YouTube(url)
    raw_info = yt.get_video_data()
    if 'args' in raw_info:
        song_info = copy.copy(empty_record)
        song_info['url'] = url
        song_info['title'] = raw_info['args']['title']
        song_info['author'] = raw_info['args']['author']
        try:
            song_info['video_id'] = raw_info['args']['vid']
        except KeyError:
            song_info['video_id'] = url.replace(youtube_base_url, '')
        song_info['duration'] = int(raw_info['args']['length_seconds'])
        song_info['view_count'] = int(raw_info['args']['view_count'])
        song_info['thumbnail_url'] = raw_info['args']['thumbnail_url']
        filter_index = get_filter_index(quality, len(yt.filter()))
        video = yt.filter()[filter_index]
        local_file_name = "{0}.{1}".format(yt.filename, video.extension)
        local_file_path = os.path.join(local_dir, local_file_name)
        if os.path.exists(local_file_path):
            song_info['local_file_path'] = local_file_path
        return song_info
    else:
        return None
 def _download_file(self, video_id):
     file_path = self._build_file_path(video_id)
     if not os.path.isfile(file_path):
         yt = YouTube()
         yt.from_url("http://youtube.com/watch?v=" + video_id)
         yt.filter('mp4')[0].download(
             file_path)  # downloads the mp4 with lowest quality
     return file_path
Beispiel #12
0
def Download(songURI, bestQuality = False):
	filetype = "mp4"
	#Check if NAS is mounted
	nasDir = '/home/pi/music/yt/'
	bckDir = '/home/pi/musicBAK/'
	dirUse = nasDir
	if os.path.isdir(nasDir):
		#put bck files into nasDirs
		bakFiles = os.listdir(bckDir)
		for x in range(0,len(bakFiles)):
			shutil.copy(bckDir+bakFiles[x], nasDir+bakFiles[x])
			os.remove(bckDir+bakFiles[x])
	else:
		dirUse = bckDir

	#if input is null then return
	if songURI == "":
		return
	
	songURL = "https://www.youtube.com/watch?v="+songURI
	#use full url if that is given
	if  "youtube.com" in songURI:
		songURL = songURI
	try:
		yt = YouTube(songURL)
	except:
		print "ERROR: URL is not a video!"
	
	
	if bestQuality:
		video = yt.filter(filetype)[-1]
	else :
		video = yt.filter(filetype)[0]
	print "starting download to '" + dirUse + "'";
	
	try:
		video.download(dirUse);
		print "down succeeded"
	except:
		print "download failed:", sys.exc_info()
		

	if dirUse == nasDir:
		client = MPDClient()           # create client object
		client.connect("localhost", 6600)  # connect to localhost:6600
		#client.update("yt/"+yt.filename + "."+filetype)
		
		#Hack so that it will wait for the f*****g update.
		call(["mpc", "update",("yt/"+yt.filename+"."+filetype),"-w"])
		
		client.disconnect()
	
	time.sleep(0.1);
	
	return yt.filename + "."+filetype
Beispiel #13
0
def download(video_id):
    yt = YouTube()
    yt.from_url(construct_url(video_id))
    yt.set_filename(video_id)

    first_video = yt.filter(resolution='480p') + yt.filter(resolution='360p')
    if not len(first_video):
        return False

    first_video[0].download(MEDIA_URL)
    return True
def download(video_url_or_id, folder_path = "./"):
	if "youtube.com" in video_url_or_id:
		video_id = video_url_or_id.split("v=")[-1]
	elif "youtu.be" in video_url_or_id:
		video_id = video_url_or_id.split(".be/")[-1]
	else:
		video_id = video_url_or_id
	video_id = re.search("[\w-]+", video_id).group(0)

	yt = YouTube()
	yt.from_url("http://www.youtube.com/watch?v={}".format(video_id))
	yt.filter("mp4")[-1].download(path = folder_path, force_overwrite = True)
Beispiel #15
0
def Download(songURI, bestQuality=False):
    filetype = "mp4"
    #Check if NAS is mounted
    nasDir = '/home/pi/music/yt/'
    bckDir = '/home/pi/musicBAK/'
    dirUse = nasDir
    if os.path.isdir(nasDir):
        #put bck files into nasDirs
        bakFiles = os.listdir(bckDir)
        for x in range(0, len(bakFiles)):
            shutil.copy(bckDir + bakFiles[x], nasDir + bakFiles[x])
            os.remove(bckDir + bakFiles[x])
    else:
        dirUse = bckDir

    #if input is null then return
    if songURI == "":
        return

    songURL = "https://www.youtube.com/watch?v=" + songURI
    #use full url if that is given
    if "youtube.com" in songURI:
        songURL = songURI
    try:
        yt = YouTube(songURL)
    except:
        print "ERROR: URL is not a video!"

    if bestQuality:
        video = yt.filter(filetype)[-1]
    else:
        video = yt.filter(filetype)[0]
    print "starting download to '" + dirUse + "'"

    try:
        video.download(dirUse)
        print "down succeeded"
    except:
        print "download failed:", sys.exc_info()

    if dirUse == nasDir:
        client = MPDClient()  # create client object
        client.connect("localhost", 6600)  # connect to localhost:6600
        #client.update("yt/"+yt.filename + "."+filetype)

        #Hack so that it will wait for the f*****g update.
        call(["mpc", "update", ("yt/" + yt.filename + "." + filetype), "-w"])

        client.disconnect()

    time.sleep(0.1)

    return yt.filename + "." + filetype
def dl_video(link):
    print("Downloading [" + link + "]")

    try:
        yt = YouTube(link)
        yt.filter('mp4')[-1].download('./')
        print("Done [" + link + "] (" + yt.filename + ")")
        return yt.filename
    except:
        print("Could not download: " + link)
        print(sys.exc_info()[0])
        return False
def dl_video(link):
    print("Downloading [" + link + "]")

    try:
        yt = YouTube(link)
        yt.filter('mp4')[-1].download('./')
        print("Done [" + link + "] (" + yt.filename + ")")
        return yt.filename
    except:
        print("Could not download: " + link)
        print(sys.exc_info()[0])
        return False
def download(video_url_or_id, folder_path="./"):
    if "youtube.com" in video_url_or_id:
        video_id = video_url_or_id.split("v=")[-1]
    elif "youtu.be" in video_url_or_id:
        video_id = video_url_or_id.split(".be/")[-1]
    else:
        video_id = video_url_or_id
    video_id = re.search("[\w-]+", video_id).group(0)

    yt = YouTube()
    yt.from_url("http://www.youtube.com/watch?v={}".format(video_id))
    yt.filter("mp4")[-1].download(path=folder_path, force_overwrite=True)
Beispiel #19
0
def download_song(given_url="", local_dir=cur_dir, quality=1):
    """
    Downloads the video song for given YouTube URL
    to the given local_dir (default os.getcwd()) of given quality
    """
    url = is_valid_youtube_url(given_url)
    yt = YouTube(url)
    filter_index = get_filter_index(quality, len(yt.filter()))
    video = yt.filter()[filter_index]
    local_file_name = "{0}.{1}".format(yt.filename, video.extension)
    local_file_path = os.path.join(local_dir, local_file_name)
    if not os.path.exists(local_file_path):
        video.download(local_dir)
    return local_file_path
def download_song(given_url="", local_dir=cur_dir, quality=1):
    """
    Downloads the video song for given YouTube URL
    to the given local_dir (default os.getcwd()) of given quality
    """
    url = is_valid_youtube_url(given_url)
    yt = YouTube(url)
    filter_index = get_filter_index(quality, len(yt.filter()))
    video = yt.filter()[filter_index]
    local_file_name = "{0}.{1}".format(yt.filename, video.extension)
    local_file_path = os.path.join(local_dir, local_file_name)
    if not os.path.exists(local_file_path):
        video.download(local_dir)
    return local_file_path
Beispiel #21
0
def downloadFisicalFile(youtubeId, idName):
	yt = YouTube()
	yt.url = ("http://www.youtube.com/watch?v=" + youtubeId)
	yt.filename = idName
	video = 0
	if len(yt.filter('mp4')) > 0:
		if len(yt.filter(resolution='720p')) > 0:
			video = yt.get('mp4','720p')
		else:
			video = yt.get('mp4')

		video.download("tempvideo/")
	else:
		cocomo.printJson("no se puede descargar el archivo", "error")
Beispiel #22
0
def download_Video_Audio(path, vid_url, file_no):
    try:
        yt = YouTube(vid_url)
    except Exception as e:
        print("Error:", str(e), "- Skipping Video with url '" + vid_url + "'.")
        return

    new_filename, author = produceNewName(yt.filename)

    pathslash = path + "/"

    try:

        if os.path.isfile(pathslash + new_filename + ".mp3"):
            raise FileNotFoundError()

        try:  # Tries to find the video in 720p
            video = yt.get('mp4', '720p')
        except Exception:  # Sorts videos by resolution and picks the highest quality video if a 720p video doesn't exist
            video = sorted(yt.filter("mp4"),
                           key=lambda video: int(video.resolution[:-1]),
                           reverse=True)[0]
        print("downloading", yt.filename + " Video and Audio...")

        bar = progressBar()
        video.download(path,
                       on_progress=bar.print_progress,
                       on_finish=bar.print_end,
                       force_overwrite=True)

        print("successfully downloaded", new_filename, "!")

        try:
            os.system("sacad '{}' '{}' 480 '{}'".format(
                author, new_filename, pathslash + str(file_no) + ".png"))

            aud = 'ffmpeg -i \"{}.mp4\" \"{}.wav\"'.format(
                pathslash + str(yt.filename), pathslash + str(file_no))
            final_audio = 'lame --tt \"{}\" --ta \"{}\" --ty {} \"{}.wav\" \"{}.mp3\"'.format(
                new_filename, author, getPublishingYear(vid_url),
                pathslash + str(file_no), pathslash + str(new_filename))
            if os.path.isfile(pathslash + str(file_no) + ".png"):
                final_audio += "--ti \"{}.png\"".format(pathslash +
                                                        str(file_no))

            os.system(aud)
            os.system(final_audio)
            os.remove(pathslash + str(yt.filename) + '.mp4')
            os.remove(pathslash + str(file_no) + '.wav')

            if os.path.isfile(pathslash + str(file_no) + ".png"):
                os.remove(pathslash + str(file_no) + '.png')

            print("sucessfully converted", new_filename, "into audio!")
        except OSError as e:
            print(yt.filename, "Looks like we got an error:", str(e))

    except FileNotFoundError:
        print(new_filename,
              "already exists in this directory! Skipping video...")
Beispiel #23
0
    def fetch_video_by_url(self, url):
        '''Fetch video by url

        :param [str] url:
            The url linked to a YouTube video
        '''
        yt = YouTube(url)
        if(self.resolution == 'highest' or self.resolution == 'lowest'):
            video_list = yt.filter(self.extension)
            if(len(video_list) == 0):
                raise DoesNotExist("No videos met this criteria.")
            if(self.resolution == 'highest'):
                video = video_list[-1]
            else:
                video = video_list[0]
        else:
            result = []
            for v in yt.get_videos():
                if self.extension and v.extension != self.extension:
                    continue
                elif self.resolution and v.resolution != self.resolution:
                    continue
                else:
                    result.append(v)
            matches = len(result)
            if matches <= 0:
                raise DoesNotExist("No videos met this criteria.")
            elif matches == 1:
                video = result[0]
            else:
                raise MultipleObjectsReturned("Multiple videos met this criteria.")
        return video
def download_single_video(save_dir, video_url):

    yt = YouTube(video_url)
    try:
        video = min(yt.filter('mp4'))
    except:
        video = min(yt.get_videos())
     
    # save_dir = "video/" + label + "/"
    if not (os.path.isdir(save_dir)):
        os.mkdir(save_dir)

    valid_chars = "-_ %s%s" % (string.ascii_letters, string.digits)
    filename = ''.join(c for c in yt.filename if c in valid_chars)

    filename = filename.replace('-','_')
    filename = filename.replace(' ','_')
    while(filename[-1] == '_'):
        filename = filename[:-1]

    if(os.path.isfile(save_dir + filename + '.' + video.extension)):
        return

    yt.set_filename(filename)
    video.download(save_dir)
Beispiel #25
0
def getVideoFname(videoId):
    try:
        fname = DIR+"/"+videoId+".mp4"
        # Caching
        if os.path.isfile(fname):
            print("Used cached video file %s " % fname)
            return fname
        url = _videos[videoId]['url']
        print("Fetching info from %s " % url)
        yt = YouTube(url)
        v = yt.filter('mp4')[0]
        # For Non mp4, NOT SUPPORTED for now
        # if v is None:
        #     v = yt.videos()[0]
        dfname = DIR+"/"+v.filename+".mp4"
        if v:
            print("Video Downloading %s " % videoId)
            v.download(DIR)
            print("Moving %s to %s " % (dfname,fname))
            os.rename(dfname,fname)
            print("Video Downloaded")
            return fname
        else: 
            print("Video not Found for %s " % videoId)
            return None
    except Exception as e:
        print(str(e))
        return None
Beispiel #26
0
    def download(self, url):
        try:
            yt = YouTube(url)
        except Exception as e:
            print(e)
            raise SystemExit

        filename = "{}\\{}.mp4".format(os.getcwd(), yt.filename)

        # Remove non-ascii characters so that the filename works!!!
        # Also removes some self-defined characters
        forbidden = ["[", "]", "(", ")", " ", "&", "%", "#"]
        filename = u"{}".format(filename)
        filename = "".join(i for i in filename if i in string.printable)
        for char in forbidden:
            filename = filename.replace(char, "")

        # Finds best quality for the video
        resolutions = ["1080p", "720p", "480p", "360p", "240p"]
        video_info = yt.filter("mp4")
        for resolution in resolutions:
            if resolution in str(video_info):
                res = resolution
                break

        # Downloads the video
        try:
            video = yt.get("mp4", res)
            video.download(filename)
        except Exception as e:
            print(e)
            raise SystemExit

        return filename
Beispiel #27
0
def fetch_video(url):

    global FILENAME
    yt = YouTube(url)
    FILENAME = yt.filename

    (yt.filter('mp4')[-1]).download(pA_path)
Beispiel #28
0
def download_Video_Audio(path, vid_url, file_no):
    try:
        yt = YouTube(vid_url)
    except Exception as e:
        print("Error:", str(e), "- Skipping Video with url '"+vid_url+"'.")
        return

    try:  # Tries to find the video in 720p
        video = yt.get('mp4', '720p')
    except Exception:  # Sorts videos by resolution and picks the highest quality video if a 720p video doesn't exist
        video = sorted(yt.filter("mp4"), key=lambda video: int(video.resolution[:-1]), reverse=True)[0]

    print("downloading", yt.filename+" Video and Audio...")
    try:
        bar = progressBar()
        video.download(path, on_progress=bar.print_progress, on_finish=bar.print_end)
        print("successfully downloaded", yt.filename, "!")
    except OSError:
        print(yt.filename, "already exists in this directory! Skipping video...")

    try:
        os.rename(yt.filename+'.mp4',str(file_no)+'.mp4')
        aud= 'ffmpeg -i '+str(file_no)+'.mp4'+' '+str(file_no)+'.wav'
        final_audio='lame '+str(file_no)+'.wav'+' '+str(file_no)+'.mp3'
        os.system(aud)
        os.system(final_audio)
        os.remove(str(file_no)+'.wav')
        print("sucessfully converted",yt.filename, "into audio!")
    except OSError:
        print(yt.filename, "There is some problem with the file names...")
Beispiel #29
0
def downloadSong(url):
    video = pafy.new(url)
    best = video.getbest(preftype="mp4")
    yt = YouTube()
    yt.url = url
    os.system('cls') # os.system('clear') for linux.
    print "Download URL fetched successfully!\n"
    print "1. Get the list of available streams"
    print "2. Get the highest resolution available"
    print "3. Start download the video\n"

    while True:
        print "Select an action: "
        action = raw_input("> ")

        if action == str(1):
            print "Availabile streams for the URL: \n"
            pprint(yt.videos)
            print "\n"

        elif action == str(2):
            print "Highest resolution is:"
            pprint(yt.filter('mp4')[-1])
            print "\n"

        elif action == str(3):
            print "Starting download: \n"
            best.download(quiet=False)
            print "Download finished!, the file has been downloaded to the same folder where the script is located."
            sys.exit(0)

        else:
            print "Not a valid option!\n"
Beispiel #30
0
def download_video(url, save_in=None, filename_out=None, verbose=False):
    ''' Descarga un vídeo de youtube, se necesita instalar pytube '''
    from pytube import YouTube
    y = YouTube(url)

    original_name = YoutubeApi().search_video(url)['title']
    
    if verbose == True:
        print('Downloading: ' + str(original_name))
        print('Please, wait...')
    
    if filename_out:
        y.set_filename(filename_out)
    else:
        filename_out = original_name
        y.set_filename(filename_out)
        
    video = y.filter('mp4')[-1]
    
    if save_in == None:
        video.download(config.PATH)
    else:
        video.download(save_in)

    if verbose == True:
        print('Video downloaded and saved as ' + filename_out)
    return filename_out + '.mp4'
Beispiel #31
0
def download_videos(links, loc, quality):
    """ Download the video in the lowest mp4 quality available and store it in a folder.
        Age-restricted videos are ignored.
        
        The Downloading resumes if there was any interruption last time.
        
        links   : list of the links in the Youtube Playlist
        loc     : file location for the downloading of videos
        quality : 1 for best quality & 2 for minimum quality
    """
    print "\nPress Ctrl+Z for stopping downloads at any moment.\n"
    print "DOWNLOADING " + str(len(links)) + " VIDEOS \n"
    video_count=0
    for link in links:
        try:
            video_count=video_count+1
            yt = YouTube(link)
            yt.set_filename(yt.filename)
            print "Video #" + str(video_count) + ": \t"+ str(yt.filename.encode('ascii','ignore'))
            if downloaded(loc,yt.filename):
                print "\t\tAlready Downloaded \n"
                continue
            quality_idx=0
            if quality==1:
                quality_idx=-1
            video = yt.filter('mp4')[quality_idx] 
            print "\t\tDownloading ........"
            video.download(loc)
            print "\t\tDownload Done \n"
        except:
            print "Video #" + str(video_count) + ": \t" + "Could Not Download" + "\n"
    def downloadytVideo(self, song, dldir = "."):
        # If video file exists, remove it. Only the case if program crashed,
        # therefore integrety of file cannot be guaranteed or reset option
        # specified.
        if os.path.isfile(dldir + "/" + song.name + ".mp4") and not song.mp4exists:
            os.remove(dldir + "/" + song.name + ".mp4")
        try:
            # Get the video
            yt = YouTube(song.url)
            yt.set_filename(song.name)
            # Select the mp4 video in the highest resolution
            data = yt.filter('mp4')[-1]
            video = yt.get('mp4', data.resolution)
            # Download the video
            video.download(dldir)
        except Exception as e:
            print("Something went wrong:")
            print(e)
            print("Ignoring...")
            return None

        song.mp4exists = True
        videoFilePath_nofe = dldir + "/" + song.name

        return videoFilePath_nofe
Beispiel #33
0
def download_by_id(vid_id):
    """
    Download a YouTube video given the video's ID, and return the path to the
    video. If the video has already been downloaded, then return the path to
    that file without redownloading.
    """
    if not os.path.isdir(MP4_DIR):
        os.mkdir(MP4_DIR)
    if not os.path.isdir(MP3_DIR):
        os.mkdir(MP3_DIR)

    url = "https://www.youtube.com/watch?v=%s" % vid_id
    yt = YouTube(url)
    yt.filename = vid_id

    # Check if the mp3 already exists
    mp3_output = os.path.join(MP3_DIR, yt.filename + ".mp3")
    if os.path.exists(mp3_output):
        return mp3_output

    # Download full video
    mp4_output = os.path.join(MP4_DIR, yt.filename + ".mp4")
    if not os.path.exists(mp4_output):
        vid = yt.filter('mp4')[-1]
        vid.download(MP4_DIR)

    # Extract audio from video
    mp3_output = os.path.join(MP3_DIR, vid_id + ".mp3")
    if not os.path.exists(mp3_output):
        command = "ffmpeg -i \"%s\" -ab 160k -ac 2 -ar 44100 -vn \"%s\"" % (
            mp4_output, mp3_output)
        subprocess.call(command, shell=True)

    return mp3_output
def Playlist(playlist):
    playlist_url = urlopen(playlist)
    page = playlist_url.read()
    page_soup = soup(page, 'lxml')
    count = 0
    for i in page_soup.find_all('td', {'class': 'pl-video-title'}):
        count += 1
    print('\n There are total', count,
          'videos in Playlist to be downloaded \n')
    video_quality = quality()
    print('Enter Complete Path - ', end=' ')
    path = input()
    os.system('cls')
    Downloading = 0
    for i in page_soup.find_all('td', {'class': 'pl-video-title'}):
        Downloading += 1
        print('Downloaded - ', end=' ')
        print(int(((Downloading - 1) * 100) / count), '%')
        video = i.a["href"]
        URL = "http://www.youtube.com%s" % video
        yt = YouTube(URL)
        video = yt.filter('mp4')[video_quality]
        print('Downloading', Downloading, '/', count, '- ', end=' ')
        print(i.a.text)
        video.download(path)
    print('\nCongrats :-) You have Downloaded the Playlist Effortlessly! \n')
Beispiel #35
0
def downloadVideo(url, codec):
    try:
	yt = YouTube(url)
	vidName = str(yt.filename)
	start_time = time.time()
	if codec == 0:
	    print "(+) Codec: MP4"
            allVidFormat = yt.get_videos()
            higMp4Res = str(yt.filter('mp4')[-1]).split()[-3]
            print "\n(+) Name: %s" %vidName
            print "(+) URL: %s" %url
            print "(+) Resolution: %s" %higMp4Res
            video = yt.get('mp4', higMp4Res)
            print "(+) Downloading video"
            video.download('.')
            print "(+) Download complete"
	if codec == 1:
	    print "[youtube] Codec: MP3"
	    ydl = youtube_dl.YoutubeDL()
	    r = ydl.extract_info(url, download=False)	
	    options = {'format': 'bestaudio/best', 'extractaudio' : True, 'audioformat' : "best", 'outtmpl': r['title'], 'noplaylist' : True,} 
	    print "[youtube] Name: %s" % (vidName)
	    print "[youtube] Uploaded by: %s" % (r['uploader'])
	    print "[youtube] Likes: %s | Dislikes: %s" % (r['like_count'], r['dislike_count'])
	    print "[youtube] Views: %s" % (r['view_count']) 
	    with youtube_dl.YoutubeDL(options) as ydl:
	        ydl.download([url])
	    print("[youtube] Download Time: %s sec" % round((time.time() - start_time), 2))
	    print ""	
    except Exception as e:
        print "(-) Error: %s" %e
Beispiel #36
0
def get_slit_scans(video_id):
    yt = YouTube("https://www.youtube.com/watch?v=" + video_id)
    youtube_video = sorted(yt.filter('mp4'),
                           key=lambda x: int(x.resolution[:-1]))[-1]
    video_filename = youtube_video.filename + ".mp4"
    youtube_video.download(".")

    def get_row(gf, frame):
        row = frame % clip.h
        return gf(frame / clip.fps)[row]

    def slitscan(gf, t):
        frame = int(clip.fps * t)
        min_frame = int(frame - frame % clip.h)
        max_frame = int(frame + (clip.h - frame % clip.h))
        return np.array([get_row(gf, x) for x in range(min_frame, max_frame)])

    clip = mpy.VideoFileClip(video_filename)
    clip = clip.fl(slitscan, apply_to="mask")
    scans = [
        clip.get_frame(t / clip.fps)
        for t in range(0, int(clip.duration * clip.fps), clip.h)
    ]
    os.remove(video_filename)
    return scans
Beispiel #37
0
def youtube_download(url,
                     save_in='',
                     max_quality=True,
                     extension='mp4',
                     name='default'):
    from pytube import YouTube
    y = YouTube(url)
    if name != 'default':
        y.set_filename(name)
    if max_quality == True:
        video = y.filter(extension)[-1]
    try:
        video.download(save_in)
    except OSError:
        num = 0
        error = True
        while error == True:
            y.set_filename(name + '_' + str(num))
            try:
                video.download(save_in)
                error == False
            except OSError:
                num += 1
                error == True
    return 'Descarga finalizada'
Beispiel #38
0
def youtube_links_info(linklist):

    with open('links.txt', 'r') as f:
        old_links = f.readlines()

    print(" ")
    for link in linklist:
        if link not in old_links:
            try:
                link_info = YouTube(link)

                #check if the video is still available for downloading ex. blocked videos for copyright issues

                codec, resolution, quality = str(
                    link_info.filter("mp4")[-1]).split("-")

                video = link_info.get(codec[-5:-2], resolution.strip())

                link_info.set_filename(
                    str(randint(0, 10000)) + "_" + str(link_info.filename))
                print("Downloading:", link_info.title)

                if not os.path.exists(os.getcwd() + '/videos/'):
                    os.makedirs('videos')

                video.download(os.path.join(os.getcwd()) + '/videos/')

                used_links(link)

            except exceptions.PytubeError:
                print("Wrong link")
                continue
            except exceptions.AgeRestricted:
                print("Wrong link - need to be logged in to download!")
                continue
def download_youtube_video(video_url):
    '''
    Signed woodworksio Aug 13, 2017

    Takes in a video URL to a youtube video, outputs the relative path to the downloaded mp3 

    Usage: download_youtube_video(video_url) --> returns mp3 filepath
    '''
    vid = Youtube_Video(video_url)
    vid.set_filename(re.sub('[^a-zA-Z]','',vid.filename).lower())
    saved_to = vid.filename
    if os.path.exists('static/'+saved_to+'.mp4'):
        print("[=] Video exists...")
        return 'static/'+saved_to+'.mp4'
    mp4_vids = vid.filter('mp4')
    if not len(mp4_vids)>0:
        return -1
    vid = mp4_vids[0] #who gives a f**k about resolution
    ### UNCOMMENT BELOW FOR PROGRESS
    # vid.download('static/',on_progress=lambda x,y: print(int(x/y*100)))
    vid.download('static/')
    mp4 = 'static/'+saved_to+'.mp4'
    mp3 = 'static/'+saved_to+'.mp3'
    # TODO open pipe on init to mass convert videos while keeping ffmpeg open
    cmd = "ffmpeg -i \"" + mp4 + "\" -vn -ar 44100 -ac 2 -ab 192k -f mp3 \"" + mp3 + "\""
    os.system(cmd)
    try:
        os.remove(mp4)
    except Exception as e:
        print(e)
        print("-"*60)
        print("\nFailed to remove "+mp4)
    return 'static/'+saved_to+'.mp3'
 def _download_file(self, video_id):
     file_path = self._build_file_path(video_id)
     if not os.path.isfile(file_path):
         yt = YouTube()
         yt.from_url("http://youtube.com/watch?v=" + video_id)
         video = yt.filter('mp4')[0]
         video.download(file_path)
     return file_path
 def _download_file(self, video_id):
     file_path = self._build_file_path(video_id)
     if not os.path.isfile(file_path):
         yt = YouTube()
         yt.from_url("http://youtube.com/watch?v=" + video_id)
         video = yt.filter('mp4')[0]
         video.download(file_path)
     return file_path
Beispiel #42
0
def down(url,qual,loc):
    if "youtube" in url and "http" in url:
        url=url
    else:
        url="http://www.youtube.com%s"%url
    obj=YouTube(url)
    video=obj.filter('mp4')[qual]
    video.download(loc)
Beispiel #43
0
def setup_audio(config):

    while True:
        link = input("Link to YouTube video: ")
        try:
            streams = YouTube(link).streams
        except RegexMatchError:
            print("Invalid YouTube link")
        else:
            break

    ffmpeg_path = input("path to ffmpeg.exe: ")
    AudioSegment.converter = ffmpeg_path
    file = streams.filter(only_audio=True)[0].download()
    audio = AudioSegment.from_file(file)

    adjust_dB = 0
    while True:
        # play sound to see if volume needs to be turned down
        play(audio[:2000])
        adjust = input("Adjust dB of volume? (y,n): ")
        if adjust == "y":
            db_str = input("How much? (can be negative to lower the volume): ")
            try:
                adjust_dB = float(db_str)
            except ValueError:
                print(
                    f"{db_str} cannot be converted to floating point number.")
            else:
                audio += adjust_dB
        else:
            break

    while True:
        how_long_s = input(
            "How long to play is sec? (number or blank to play the whole duration): "
        )
        if not how_long_s:
            how_long_s = None
            break
        try:
            how_long_ms = int(how_long_s * 1000)
        except ValueError:
            print(
                f"{how_long_s} cannnot be converted to a floating point number."
            )
        else:
            break

    # save config
    config["audio_file"] = file
    config["adjust_dB"] = adjust_dB
    config["play_dur_sec"] = how_long_s
    config["ffmpeg_path"] = ffmpeg_path
    with open(CONFIG_FILE, 'w') as f:
        json.dump(config, f)

    print("You can modify the audio in " + CONFIG_FILE + '.')
Beispiel #44
0
	def download_now(self, url, codec='mp4', location='/tmp/'):
		try:
			yt = YouTube(self.url)
			yt.get_videos()
			video = yt.filter(codec)[0]
			video.download(location)
		except Exception, e:
			print e
			print "Error: Invalid URL or network problem"
Beispiel #45
0
	def download_now(self, url, codec='mp4', location='/tmp/'):
		try:
			yt = YouTube(url)
			yt.get_videos()
			video = yt.filter(codec)[0]
			print 'file name:', video.filename
			video.download(location, on_progress=utils.print_status)
		except Exception, e:
			print "Error: Invalid URL or network problem or file exist"
Beispiel #46
0
 def download_video(self, url):
     yt = YouTube(url)
     #~ video = yt.get('mp4')
     
     video = yt.filter('mp4')[-1]
     
     try:
         video.download(self.project_dir)
     except OSError:
         pass
     return self
 def downloadVideo(self, videoList):
     ytVideo = videoList[0]
     yt = Ytdwn("http://www.youtube.com/watch?v=%s"%ytVideo._ident)
     filename = 'YT_%s' % ytVideo._ident
     yt.set_filename(filename)
     video = yt.filter(resolution='360p')[0]
     filepath = "%s/%s.%s" % (YOUTUBE_VIDEOS_LOCATION, filename, video.extension)
     if os.path.exists(filepath):
         os.remove(filepath)
     video.download(YOUTUBE_VIDEOS_LOCATION)
     ytVideo._file_path = filepath
     ytVideo.save()
Beispiel #48
0
 def download(self):
     """
     Downloads the YouTube video and sets the video's title.
     """
     yt = YouTube('https://www.youtube.com/watch?v={0}'.format(self.youtube_id))
     video = yt.filter('mp4')[-1]
     self.title = video.filename
     self.file_path = '{0}.mp4'.format(self.youtube_id)
     yt.set_filename(self.youtube_id)
     video.download(settings.YOUTUBE_DOWNLOAD_ROOT)
     self.downloaded = True
     self.save()
Beispiel #49
0
def download(link, path="video_index/"):
    yt = YouTube(link)
    file_name = re.sub(r'\W+', '',
                       yt.filename.replace(" ", "_"))  # Ugly ass solution to fix encoding errors later on...
    yt.set_filename(file_name)
    video_path = os.path.join(path, yt.filename)

    print "Downloading video: " + yt.filename
    # Below downloads the video in the lowest resolution available.
    # Change the '0' to '-1' to get the highest instead
    video = yt.filter('mp4')[VIDEO_RESOLUTION]
    video.download(path)
    return video_path
Beispiel #50
0
  def download(self, url):
    storage = self.config.get('youtube', 'storage')
    yt = YouTube(url)
    video = yt.filter('mp4')[-1] # This will get us the highest res version.
    lockFile = '%s/%s.mp4.lck' % (storage, video.filename)

    try:
      open(lockFile, 'a').close()
      video.download(storage)
      os.remove(lockFile)
      return True
    except:
      return False
Beispiel #51
0
class TestYouTube(unittest.TestCase):
	'''Test all methods of Youtube class'''

	def setUp(self):
		'''Set up the all attributes required for a particular video'''

		self.url="https://www.youtube.com/watch?v=Ik-RsDGPI5Y"
		self.video_id = 'Ik-RsDGPI5Y'
		self.filename = 'Pulp Fiction - Dancing Scene'
		self.yt = YouTube(self.url)
		#: don't hard code, make is universal
		self.videos = ['<Video: MPEG-4 Visual (.3gp) - 144p - Simple>',
 					   '<Video: MPEG-4 Visual (.3gp) - 240p - Simple>',
					   '<Video: Sorenson H.263 (.flv) - 240p - N/A>',
					   '<Video: H.264 (.mp4) - 360p - Baseline>',
				       '<Video: H.264 (.mp4) - 720p - High>',
					   '<Video: VP8 (.webm) - 360p - N/A>']
		# using flv since it has only once video
		self.flv = '<Video: Sorenson H.263 (.flv) - 240p - N/A>'

	def test_url(self):

		self.assertEqual(self.yt.url ,self.url)

	def test_video_id(self):

		self.assertEqual(self.yt.video_id, self.video_id )

	def test_filename(self):

		self.assertEqual(self.yt.filename, self.filename)

	def test_get_videos(self):

		self.assertEqual ( map( str, self.yt.get_videos() ), self.videos )

	def test_get_video_data(self):

		self.assertEqual((self.yt.get_video_data()['args']['loaderUrl']),
						  self.url)
		                                        
	def test_get_false(self):
	    with self.assertRaises(MultipleObjectsReturned):
	        self.yt.get()

	def test_get_true(self):
		self.assertEqual( str( self.yt.get('flv') ), self.flv )

	def test_filter(self):
		self.assertEqual( str( self.yt.filter('flv')[0] ), self.flv )
Beispiel #52
0
 def default(self, *args, **kwargs):
     url = cherrypy.url(qs=cherrypy.request.query_string)
     print url
     if '/watch?' in url:
         error = False
         url = url.replace('youtubell','youtube')
         try:
             yt = YouTube(url)
         except:
             error = True
         if not error:
             video = yt.filter('mp4')[-1]
             raise cherrypy.HTTPRedirect(video.url)
         else:
             return 'Invalid URL or the video is private or requires login.'
     else:
         return 'Incorrect input.'
def main(input, output, limit):

	random.seed(42)

	baseurl = "https://www.youtube.com/oembed?format=json&url="
	validurls = []

	# get links to validate
	with open(input) as f:
		links = f.readlines()

	# shuffle to have videos from various categories
	random.shuffle(links)

	for link in links:
		try:
			# make request
			response = requests.get(baseurl + link)

			# url is valid and video exists if we got 200 in response
			if response.status_code == 200:
				data = response.json()
				title = data['title']

				isEnglish = detect(title) == 'en'
				yt = YouTube(link)
				canDownload = len(yt.filter('mp4')) > 0

				if isEnglish and canDownload:
					print title
					print link
					validurls.append(link.strip())

			# break if we reached given limit
			if len(validurls) >= limit:
				break

		except Exception as e:
			print e

	# write resulting list to the output file
	with open(output, mode="w+") as f:
		for vl in validurls:
			f.write("%s\n" % vl)
Beispiel #54
0
    def download_video(self,url):
        # Settings
        yt = YouTube(url)
        print("Found video: " + yt.filename)
        filename = yt.filename.replace("!", "").replace("&","").replace(" ","-")

        # Finds the correct resolution
        res_info = yt.filter("mp4")[-1]
        res_settings = ["1080p", "720p", "480p", "360p", "240p", "144p"]
        for i in res_settings:
            if i in str(res_info): res = i
        print("Found video resolution: " + res)    
        video = yt.get("mp4", res)
        
        # Downloads the video in the correct resolution
        video.download("Video/"+filename+".mp4")
        
        # Gets the audio
        self.audio_convert(filename)
def download_yt_video(yt_url, filename, path, sim=False):
    global needs
    global gots
    yt = YouTube()
    yt.url = yt_url
    yt.filename = u'{}'.format(filename.replace('/', '-').replace(':', ','))
    if os.path.isfile(os.path.join(path, u'{}.mp4'.format(yt.filename))):
        print('              Got it!')
        gots += 1
    else:
        if sim:
            print('              Need It!')
            needs += 1
        else:
            print('              Downloading... ', end='')
            max_res = yt.filter('mp4')[-1].resolution
            video = yt.get('mp4', max_res)
            video.download(path, verbose=False)
            print('Done!')
            gots += 1
Beispiel #56
0
def download_video(url, folder):
    try:
        yt = YouTube(url)

    except Exception as e:
        print ("Error:", e, "- skipping video with url:",url)
        return

    #video should be downloaded in 720p
    try:
        vid = yt.get("mp4","720p")

    #else tries to get the highest resolution available
    except Exception:
        vid = yt.filter("mp4")[-1]

    #download video
    try:
        bar = progress_bar()#init progress_bar
        vid.download(folder,on_progress = bar.print_progress, on_finish = bar.print_end)
        print("Successfully downloaded", yt.filename, " !")

    except OSError:
        print(yt.filename, "already exists in the directory. Skipping video...")
        return
    
    #converts video to audio
    try:

            aud = "ffmpeg -i " + folder + "/" +  "\"" +  str(yt.filename) + "\"" + ".mp4 " + folder + "/" + "\""  + str(yt.filename) + "\"" + ".mp3"
            print (aud)
            os.system(aud)

            if os.path.exists(folder +"\\" + yt.filename + ".mp4"):
                os.remove(folder +"\\" + yt.filename + ".mp4")

            print("Succesfully converted",yt.filename, "to mp3!")

    except OSError:
        print("There are some problems with the file name(s), skipping video..")
        return
def lambda_handler(event, context):    
    youtube_url = event.get('url', None)
    if youtube_url is None:
        # TODO: Raise exception
        return   
    # Get youtube video
    yt = YouTube(youtube_url)
    video = yt.filter('mp4')[-1]
    if not video:
        # TODO: Raise exception
        return          
    file_name = event.get('filename', video.filename + '.mp4') or 'youtube_video.mp4'
    # store to S3
    bucket_name = 'dsotr_youtube_downloader'
    s3 = boto3.resource('s3')
    s3.create_bucket(Bucket=bucket_name)
    obj = s3.Object(bucket_name, file_name)
    obj.put(Body=urllib2.urlopen(video.url).read(), ACL='public-read') 
    client = boto3.client('s3')
    presigned_url = client.generate_presigned_url('get_object', Params={'Bucket': bucket_name, 'Key': obj.key})
    result = presigned_url
    return result
Beispiel #58
-1
def download_videos(test=True):
    manually_download = []
    positions = Week.objects.all()[0].position_set.all().order_by('position')
    songs = [p.song for p in positions][50:]
    for song in songs:
        if song.youtube_link:
            link = 'http://www.youtube.com/watch?v=' + song.youtube_link
            try:
                yt = YouTube(link)
                yt.set_filename("{} - {}".format(song.name, song.artist.name))
            except AgeRestricted:
                manually_download.append(link)
                print 'Song is age restricted, adding to manually_download list.'
                continue
            try:
                video_type = yt.filter('mp4')[-1]
                video = yt.get(video_type.extension, video_type.resolution)
            except Exception:
                traceback.print_exc()
                continue

            if not os.path.exists(os.path.abspath(os.path.join(settings.RAW_VIDEOS, video.filename + ".mp4"))):
                print 'Downloading video: {} - {}'.format(song, video_type.resolution)
                video.download(settings.RAW_VIDEOS)
            else:
                print 'Video: {} already downlaoded. Skipping.'.format(song)

    print 'Manually download these songs: %s' % manually_download