Python YoutubeDL.extract_info方法代码示例

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
 def extract_info(self):
     opts = {
         'simulate': True
     }
     opts.update(YTDL_PLAYER_OPTS)
     ydl = YoutubeDL(opts)
     return ydl.extract_info(self.resource)

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
class DownloadProcess(multiprocessing.Process):
    """
    Actual download process which calls youtube-dl. You should never need to interact with this directly.
    """

    def __init__(self, url, status_queue, output_writer):
        super(DownloadProcess, self).__init__()

        self.url = url
        self.status_queue = status_queue

        self.info = {}

        sys.stdout = output_writer
        sys.stderr = output_writer

        self.downloader = YoutubeDL({"progress_hooks": [self.update_status]})
        self.downloader.add_default_info_extractors()

    def update_status(self, status):
        self.status_queue.put(status)

    def run(self):
        self.info = self.downloader.extract_info(self.url)

    def stop(self):
        # Kill any child processes that may have spawned (e.g. ffmpeg)
        import psutil, signal

        s = psutil.Process()
        for child in s.children(recursive=True):
            child.send_signal(signal.SIGINT)

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
class YoutubeDLDownloader(DownloaderBase):
    scheme = "ytdl"

    def __init__(self, extractor, output):
        DownloaderBase.__init__(self, extractor, output)

        options = {
            "format": self.config("format") or None,
            "ratelimit": text.parse_bytes(self.config("rate"), None),
            "retries": self.config("retries", extractor._retries),
            "socket_timeout": self.config("timeout", extractor._timeout),
            "nocheckcertificate": not self.config("verify", extractor._verify),
            "nopart": not self.part,
        }
        options.update(self.config("raw-options") or {})

        if self.config("logging", True):
            options["logger"] = self.log

        self.ytdl = YoutubeDL(options)

    def download(self, url, pathfmt):
        try:
            info_dict = self.ytdl.extract_info(url[5:], download=False)
        except Exception:
            return False

        if "entries" in info_dict:
            index = pathfmt.keywords.get("_ytdl_index")
            if index is None:
                return self._download_playlist(pathfmt, info_dict)
            else:
                info_dict = info_dict["entries"][index]
        return self._download_video(pathfmt, info_dict)

    def _download_video(self, pathfmt, info_dict):
        pathfmt.set_extension(info_dict["ext"])
        if pathfmt.exists():
            pathfmt.temppath = ""
            return True
        if self.part and self.partdir:
            pathfmt.temppath = os.path.join(
                self.partdir, pathfmt.filename)
        self.ytdl.params["outtmpl"] = pathfmt.temppath.replace("%", "%%")

        self.out.start(pathfmt.path)
        try:
            self.ytdl.process_info(info_dict)
        except Exception:
            self.log.debug("Traceback", exc_info=True)
            return False
        return True

    def _download_playlist(self, pathfmt, info_dict):
        pathfmt.set_extension("%(playlist_index)s.%(ext)s")
        self.ytdl.params["outtmpl"] = pathfmt.realpath

        for entry in info_dict["entries"]:
            self.ytdl.process_info(entry)
        return True

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
class PyJizzParser(object):
	def __init__(self, model):
		self.model = model
		self.model.parser = self
		self.ydl = YoutubeDL()
		self.ydl.add_default_info_extractors()
		
	def parseCategories(self):
		c = PornHubCategoryParser(self.model)
		c.run()
	
	def parseCategoryPage(self, category, page = 1):
		if page == 0 or page == 1:
			url = self.model.categories_url[category]
		else:
			url = "{site}{page_url}{page}".format(
				site = self.model.site,
				page_url = self.model.porn[category]['page_url'],
				page = page)
		print("page parser creating for page", page)
		p = PornHubPageParser(self.model, url, category, page)
		p.run()
		print("page parser exit for page", page)
		
	def getInfo(self, vkey):
		info = self.ydl.extract_info('http://www.pornhub.com/view_video.php?viewkey={v}'.format(v = vkey), download=False)
		return info

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
class InfoParser():
    def __init__(self, url=None, ydl_opt={}):
        self.__url = url
        self.__ydl = YoutubeDL(ydl_opt)
        self.__ydl_obj = YDLObject()

    @property
    def url(self):
        return self.__url

    @url.setter
    def url(self, url):
        self.__url = url

    @property
    def ydl_object(self):
        return self.__ydl_obj

    def generate_info(self):
        try:
            info_dict = self.__ydl.extract_info(self.__url, download=False)
            self.__ydl_obj.title = info_dict['title']
            self.__ydl_obj.url = self.__url
            for format in info_dict['formats']:
                filesize = format.get('filesize') if format.get('filesize') else format.get('filesize_approx')
                self.__ydl_obj.format_info.append({
                    'format_id': format['format'],
                    'extension': format['ext'],
                    'resolution': self.__ydl.format_resolution(format),
                    'filesize': format_bytes(filesize)
                })
            return True
        except Exception as e:
            print(e)
            return False

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
	def getVideoUrl(self):
		VIDEO_FMT_PRIORITY_MAP = {
			1 : '38', #MP4 Original (HD)
			2 : '37', #MP4 1080p (HD)
			3 : '22', #MP4 720p (HD)
			4 : '18', #MP4 360p
			5 : '35', #FLV 480p
			6 : '34', #FLV 360p
		}
		KEY_FORMAT_ID = u"format_id"
		KEY_URL = u"url"
		KEY_ENTRIES = u"entries"
		KEY_FORMATS = u"formats"

		video_url = None
		video_id = str(self.getTubeId())

		# Getting video webpage
		#URLs for YouTube video pages will change from the format http://www.youtube.com/watch?v=ylLzyHk54Z0 to http://www.youtube.com/watch#!v=ylLzyHk54Z0.
		watch_url = 'http://www.youtube.com/watch?v=%s' % video_id
		format_prio = "/".join(VIDEO_FMT_PRIORITY_MAP.itervalues())
		ytdl = YoutubeDL(params={"youtube_include_dash_manifest": False, "format" : format_prio})
		result = ytdl.extract_info(watch_url, download=False)
		if KEY_ENTRIES in result: # Can be a playlist or a list of videos
			entry = result[KEY_ENTRIES][0] #TODO handle properly
		else:# Just a video
			entry = result

		video_url = entry.get(KEY_URL)
		return str(video_url)

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
def get_video_url(params):
    """Get video URL and start video player"""
    url_selected = ''
    all_datas_videos_quality = []
    all_datas_videos_path = []
    videos_html = utils.get_webcontent(params.video_url)
    videos_soup = bs(videos_html, 'html.parser')

    list_videos = videos_soup.find(
        'ul', class_='nav nav-tabs').find_all('a')

    for video in list_videos:
        if '#video-' in video.get('href'):
            # Find a better solution to strip
            all_datas_videos_quality.append(video.get_text().strip())
            # Get link
            value_jwplayer_id = video.get('data-jwplayer-id')
            # Case mp4
            if value_jwplayer_id != '':
                list_streams = videos_soup.find_all(
                    'div', class_='jwplayer')
                for stream in list_streams:
                    if stream.get('id') == value_jwplayer_id:
                        url = stream.get('data-source')
            # Cas Yt
            else:
                video_id = re.compile(
                    'youtube.com/embed/(.*?)\?').findall(videos_html)[0]
                url = resolver.get_stream_youtube(video_id, False)
            all_datas_videos_path.append(url)
        # Get link from FranceTV
        elif '#ftv-player-' in video.get('href'):
            # Find a better solution to strip
            all_datas_videos_quality.append(video.get_text().strip())
            # Get link
            value_ftvlayer_id = video.get('data-ftvplayer-id')
            list_streams = videos_soup.find_all(
                'iframe', class_='embed-responsive-item')
            for stream in list_streams:
                if stream.get('id') == value_ftvlayer_id:
                    url_id = stream.get('src')
            ydl = YoutubeDL()
            ydl.add_default_info_extractors()
            with ydl:
                result = ydl.extract_info(
                    url_id, download=False)
                for format_video in result['formats']:
                    url = format_video['url']
            all_datas_videos_path.append(url)

    if len(all_datas_videos_quality) > 1:
        seleted_item = common.sp.xbmcgui.Dialog().select(
            common.GETTEXT('Choose video quality'),
            all_datas_videos_quality)
        if seleted_item == -1:
            return ''
        url_selected = all_datas_videos_path[seleted_item]
        return url_selected
    else:
        return all_datas_videos_path[0]

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
class YoutubeDLWrapper(object):
    """ Used to wrap youtubedl import, since youtubedl currently overrides
    global HTMLParser.locatestarttagend regex with a different regex
    that doesn't quite work.

    This wrapper ensures that this regex is only set for YoutubeDL and unset
    otherwise
    """
    def __init__(self):
        import HTMLParser as htmlparser
        self.htmlparser = htmlparser

        self.orig_tagregex = htmlparser.locatestarttagend

        from youtube_dl import YoutubeDL as YoutubeDL

        self.ydl_tagregex = htmlparser.locatestarttagend

        htmlparser.locatestarttagend = self.orig_tagregex

        self.ydl = YoutubeDL(dict(simulate=True,
                                  youtube_include_dash_manifest=False))
        self.ydl.add_default_info_extractors()

    def extract_info(self, url):
        info = None
        try:
            self.htmlparser.locatestarttagend = self.ydl_tagregex
            info = self.ydl.extract_info(url)
        finally:
            self.htmlparser.locatestarttagend = self.orig_tagregex

        return info

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
    def test_unicode_path_redirection(self):
        # XXX: Python 3 http server does not allow non-ASCII header values
        if sys.version_info[0] == 3:
            return

        ydl = YoutubeDL({'logger': FakeLogger()})
        r = ydl.extract_info('http://127.0.0.1:%d/302' % self.port)
        self.assertEqual(r['entries'][0]['url'], 'http://127.0.0.1:%d/vid.mp4' % self.port)

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
def get_info(url):
    ydl = YoutubeDL({
        'forceurl': True,
        'quiet': True
    })

    ydl.add_default_info_extractors()
    return ydl.extract_info(url, download=False)

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
def v_info_url(url):
    url = urllib.parse.unquote(url)  # workaround
    format = request.forms.get('format', 'best')
    ytdl = YoutubeDL({'format': format, 'source_address': '0.0.0.0'})
    info = ytdl.extract_info(url, download=False)

    response.set_header('Access-Control-Allow-Origin', '*')
    return info

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
def get_youtube_info(url):
    ydl = YoutubeDL()
    ydl.add_default_info_extractors()
    try:
        info = ydl.extract_info(url, download=False)
    except:
        return None
    return info

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
    def test_nocheckcertificate(self):
        if sys.version_info >= (2, 7, 9):  # No certificate checking anyways
            ydl = YoutubeDL({'logger': FakeLogger()})
            self.assertRaises(
                Exception,
                ydl.extract_info, 'https://127.0.0.1:%d/video.html' % self.port)

        ydl = YoutubeDL({'logger': FakeLogger(), 'nocheckcertificate': True})
        r = ydl.extract_info('https://127.0.0.1:%d/video.html' % self.port)
        self.assertEqual(r['entries'][0]['url'], 'https://127.0.0.1:%d/vid.mp4' % self.port)

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
def get_video_data(video_id):
   data={}
   video_url = 'https://www.youtube.com/watch?v='+video_id
   ydl_opts = {
    'format': 'bestaudio/mp3',
    
    }
   ydl = YoutubeDL(ydl_opts)
   r = ydl.extract_info(video_url, download=False)
   data['aud_url']=r['url']
   

   ydl = YoutubeDL()
   r = ydl.extract_info(video_url, download=False)
   data['vid_url']=r['url']
   data['title']=r['title']
   data['thumbnail']=r['thumbnails'][0]['url']

   return data

# 需要导入模块: from youtube_dl import YoutubeDL [as 别名]
# 或者: from youtube_dl.YoutubeDL import extract_info [as 别名]
	def viceLink(self, callback, url):
		video_url = None
		m = re.search('share_url=(.+)("|&)*', url)
		if m:
			url = m.group(1)
			#print 'url:',url
			try:
				ytdl = YoutubeDL()
				result = ytdl.extract_info(url, download=False)
				#print 'result:',result
				video_url = str(result["url"])
			except Exception, e:
				printl(str(e),self,"E")