Coverage for youtube_dl.InfoExtractors : 44%
Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
|
#!/usr/bin/env python # -*- coding: utf-8 -*-
"""Information Extractor class.
Information extractors are the classes that, given a URL, extract information about the video (or videos) the URL refers to. This information includes the real video URL, the video title, author and others. The information is stored in a dictionary which is then passed to the FileDownloader. The FileDownloader processes this information possibly downloading the video to the file system, among other possible outcomes.
The dictionaries must include the following fields:
id: Video identifier. url: Final video URL. title: Video title, unescaped. ext: Video filename extension. uploader: Full name of the video uploader. upload_date: Video upload date (YYYYMMDD).
The following fields are optional:
format: The video format, defaults to ext (used for --get-format) thumbnail: Full URL to a video thumbnail image. description: One-line video description. uploader_id: Nickname or id of the video uploader. player_url: SWF Player URL (used for rtmpdump). subtitles: The .srt file contents. urlhandle: [internal] The urlHandle to be used to download the file, like returned by urllib.request.urlopen
The fields should all be Unicode strings.
Subclasses of this one should re-define the _real_initialize() and _real_extract() methods and define a _VALID_URL regexp. Probably, they should also be added to the list of extractors.
_real_extract() must return a *list* of information dictionaries as described above.
Finally, the _WORKING attribute should be set to False for broken IEs in order to warn the users and skip the tests. """
"""Constructor. Receives an optional downloader."""
"""Receives a URL and returns True if suitable for this IE."""
"""Getter method for _WORKING."""
"""Initializes an instance (authentication, etc)."""
"""Extracts URL information and returns it in list of dicts."""
"""Sets the downloader for this IE."""
"""Real initialization process. Redefine in subclasses."""
"""Real extraction process. Redefine in subclasses.""" pass
def IE_NAME(self):
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: if errnote is None: errnote = u'Unable to download webpage' raise ExtractorError(u'%s: %s' % (errnote, compat_str(err)))
"""Information extractor for youtube.com."""
( (?:https?://)? # http(s):// (optional) (?:youtu\.be/|(?:\w+\.)?youtube(?:-nocookie)?\.com/| tube\.majestyc\.net/) # the various hostnames, with wildcard subdomains (?:.*?\#/)? # handle anchor (#/) redirect urls (?!view_play_list|my_playlists|artist|playlist) # ignore playlist URLs (?: # the various things that can precede the ID: (?:(?:v|embed|e)/) # v/ or embed/ or e/ |(?: # or the v= param in all its forms (?:watch(?:_popup)?(?:\.php)?)? # preceding watch(_popup|.php) or nothing (like /?v=xxxx) (?:\?|\#!?) # the params delimiter ? or # or #! (?:.*?&)? # any other preceding param (like /?s=tuff&v=xxxx) v= ) )? # optional -> youtube.com/xxxx is OK )? # all until now is optional -> you can pass the naked ID ([0-9A-Za-z_-]+) # here is it! the YouTube video ID (?(1).+)? # if we found the ID, everything can follow $""" # Listed in order of quality '13': '3gp', '17': 'mp4', '18': 'mp4', '22': 'mp4', '37': 'mp4', '38': 'video', # You actually don't know if this will be MOV, AVI or whatever '43': 'webm', '44': 'webm', '45': 'webm', '46': 'webm', } '5': '240x400', '6': '???', '13': '???', '17': '144x176', '18': '360x640', '22': '720x1280', '34': '360x640', '35': '480x854', '37': '1080x1920', '38': '3072x4096', '43': '360x640', '44': '480x854', '45': '720x1280', '46': '1080x1920', }
"""Receives a URL and returns True if suitable for this IE."""
"""Report attempt to set language."""
"""Report attempt to log in.""" self._downloader.to_screen(u'[youtube] Logging in')
"""Report attempt to confirm age.""" self._downloader.to_screen(u'[youtube] Confirming age')
"""Report attempt to download video webpage."""
"""Report attempt to download video info webpage."""
"""Report attempt to download video info webpage."""
"""Report attempt to extract video information."""
"""Report extracted video URL.""" self._downloader.to_screen(u'[youtube] %s: Format %s not available' % (video_id, format))
"""Indicate the download will use the RTMP protocol.""" self._downloader.to_screen(u'[youtube] RTMP download detected')
# TODO parse xml instead of regex
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: return (u'WARNING: unable to download video subtitles: %s' % compat_str(err), None) return (u'WARNING: video has no closed captions', None) else: srt_lang = list(srt_lang_list.keys())[0] return (u'WARNING: no closed captions found in the specified language', None) except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: return (u'WARNING: unable to download video subtitles: %s' % compat_str(err), None) return (u'WARNING: unable to download video subtitles', None)
print('Available formats:') for x in formats: print('%s\t:\t%s\t[%s]' %(x, self._video_extensions.get(x, 'flv'), self._video_dimensions.get(x, '???')))
return
# Attempt to use provided username and password or .netrc data username = downloader_params['username'] password = downloader_params['password'] try: info = netrc.netrc().authenticators(self._NETRC_MACHINE) if info is not None: username = info[0] password = info[2] else: raise netrc.NetrcParseError('No authenticators for %s' % self._NETRC_MACHINE) except (IOError, netrc.NetrcParseError) as err: self._downloader.to_stderr(u'WARNING: parsing .netrc: %s' % compat_str(err)) return
# Set language except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.to_stderr(u'WARNING: unable to set language: %s' % compat_str(err)) return
# No authentication to be performed
# Log in login_form = { 'current_form': 'loginForm', 'next': '/', 'action_login': 'Log In', 'username': username, 'password': password, } request = compat_urllib_request.Request(self._LOGIN_URL, compat_urllib_parse.urlencode(login_form)) try: self.report_login() login_results = compat_urllib_request.urlopen(request).read().decode('utf-8') if re.search(r'(?i)<form[^>]* name="loginForm"', login_results) is not None: self._downloader.to_stderr(u'WARNING: unable to log in: bad username or password') return except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.to_stderr(u'WARNING: unable to log in: %s' % compat_str(err)) return
# Confirm age age_form = { 'next_url': '/', 'action_confirm': 'Confirm', } request = compat_urllib_request.Request(self._AGE_URL, compat_urllib_parse.urlencode(age_form)) try: self.report_age_confirmation() age_results = compat_urllib_request.urlopen(request).read().decode('utf-8') except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to confirm age: %s' % compat_str(err)) return
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
# Extract original video URL from URL with redirection, like age verification, using next_url parameter url = 'http://www.youtube.com/' + compat_urllib_parse.unquote(mobj.group(1)).lstrip('/')
# Get video webpage except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download video webpage: %s' % compat_str(err)) return
# Attempt to extract SWF player URL player_url = re.sub(r'\\(.)', r'\1', mobj.group(1)) else:
# Get video info % (video_id, el_type)) except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download video info webpage: %s' % compat_str(err)) return if 'reason' in video_info: self._downloader.trouble(u'ERROR: YouTube said: %s' % video_info['reason'][0]) else: self._downloader.trouble(u'ERROR: "token" parameter not in video info for unknown reason') return
# Check for "rental" videos self._downloader.trouble(u'ERROR: "rental" videos not supported') return
# Start extracting information
# uploader self._downloader.trouble(u'ERROR: unable to extract uploader name') return
# uploader_id else: self._downloader.trouble(u'WARNING: unable to extract uploader nickname')
# title self._downloader.trouble(u'ERROR: unable to extract video title') return
# thumbnail image self._downloader.trouble(u'WARNING: unable to extract video thumbnail') video_thumbnail = '' else: # don't panic if we can't find it
# upload date
# description else: video_description = ''
# closed captions self._downloader.trouble(srt_error)
self._downloader.trouble(u'WARNING: unable to extract video duration') video_duration = '' else:
# token
# Decide which formats to download
self.report_rtmp_download() video_url_list = [(None, video_info['conn'][0])]
format_list = available_formats[available_formats.index(format_limit):] else: self._downloader.trouble(u'ERROR: no known formats available for video') return self._print_formats(existing_formats) return elif req_format == 'worst': video_url_list = [(existing_formats[len(existing_formats)-1], url_map[existing_formats[len(existing_formats)-1]])] # worst quality elif req_format in ('-1', 'all'): video_url_list = [(f, url_map[f]) for f in existing_formats] # All formats else: # Specific formats. We pick the first in a slash-delimeted sequence. # For example, if '1/2/3/4' is requested and '2' and '4' are available, we pick '2'. req_formats = req_format.split('/') video_url_list = None for rf in req_formats: if rf in url_map: video_url_list = [(rf, url_map[rf])] break if video_url_list is None: self._downloader.trouble(u'ERROR: requested format not available') return else: self._downloader.trouble(u'ERROR: no conn or url_encoded_fmt_stream_map information found in video info') return
# Extension
self._video_dimensions.get(format_param, '???'))
'id': video_id, 'url': video_real_url, 'uploader': video_uploader, 'uploader_id': video_uploader_id, 'upload_date': upload_date, 'title': video_title, 'ext': video_extension, 'format': video_format, 'thumbnail': video_thumbnail, 'description': video_description, 'player_url': player_url, 'subtitles': video_subtitles, 'duration': video_duration })
"""Information Extractor for metacafe.com."""
"""Report disclaimer retrieval."""
"""Report attempt to confirm age."""
"""Report webpage download.""" self._downloader.to_screen(u'[metacafe] %s: Downloading webpage' % video_id)
"""Report information extraction.""" self._downloader.to_screen(u'[metacafe] %s: Extracting information' % video_id)
# Retrieve disclaimer except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to retrieve disclaimer: %s' % compat_str(err)) return
# Confirm age 'filters': '0', 'submit': "Continue - I'm over 18", } except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to confirm age: %s' % compat_str(err)) return
# Extract id and simplified title from URL self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
# Check if video comes from YouTube
# Retrieve video webpage to extract further information request = compat_urllib_request.Request('http://www.metacafe.com/watch/%s/' % video_id) try: self.report_download_webpage(video_id) webpage = compat_urllib_request.urlopen(request).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable retrieve video webpage: %s' % compat_str(err)) return
# Extract URL, uploader and title from webpage self.report_extraction(video_id) mobj = re.search(r'(?m)&mediaURL=([^&]+)', webpage) if mobj is not None: mediaURL = compat_urllib_parse.unquote(mobj.group(1)) video_extension = mediaURL[-3:]
# Extract gdaKey if available mobj = re.search(r'(?m)&gdaKey=(.*?)&', webpage) if mobj is None: video_url = mediaURL else: gdaKey = mobj.group(1) video_url = '%s?__gda__=%s' % (mediaURL, gdaKey) else: mobj = re.search(r' name="flashvars" value="(.*?)"', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract media URL') return vardict = compat_parse_qs(mobj.group(1)) if 'mediaData' not in vardict: self._downloader.trouble(u'ERROR: unable to extract media URL') return mobj = re.search(r'"mediaURL":"(http.*?)","key":"(.*?)"', vardict['mediaData'][0]) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract media URL') return mediaURL = mobj.group(1).replace('\\/', '/') video_extension = mediaURL[-3:] video_url = '%s?__gda__=%s' % (mediaURL, mobj.group(2))
mobj = re.search(r'(?im)<title>(.*) - Video</title>', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract title') return video_title = mobj.group(1).decode('utf-8')
mobj = re.search(r'submitter=(.*?);', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract uploader nickname') return video_uploader = mobj.group(1)
return [{ 'id': video_id.decode('utf-8'), 'url': video_url.decode('utf-8'), 'uploader': video_uploader.decode('utf-8'), 'upload_date': None, 'title': video_title, 'ext': video_extension.decode('utf-8'), }]
"""Information Extractor for Dailymotion"""
"""Report information extraction."""
# Extract id and simplified title from URL self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
# Retrieve video webpage to extract further information
# Extract URL, uploader and title from webpage self._downloader.trouble(u'ERROR: unable to extract media URL') return
else: self._downloader.trouble(u'ERROR: unable to extract video URL') return
self._downloader.trouble(u'ERROR: unable to extract video URL') return
# TODO: support choosing qualities
self._downloader.trouble(u'ERROR: unable to extract title') return
# lookin for official user mobj_official = re.search(r'<span rel="author"[^>]+?>([^<]+?)</span>', webpage) if mobj_official is None: self._downloader.trouble(u'WARNING: unable to extract uploader nickname') else: video_uploader = mobj_official.group(1) else:
video_upload_date = mobj.group(3) + mobj.group(2) + mobj.group(1)
'id': video_id, 'url': video_url, 'uploader': video_uploader, 'upload_date': video_upload_date, 'title': video_title, 'ext': video_extension, }]
"""Information extractor for photobucket.com."""
InfoExtractor.__init__(self, downloader)
"""Report webpage download.""" self._downloader.to_screen(u'[photobucket] %s: Downloading webpage' % video_id)
"""Report information extraction.""" self._downloader.to_screen(u'[photobucket] %s: Extracting information' % video_id)
# Extract id from URL mobj = re.match(self._VALID_URL, url) if mobj is None: self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) return
video_id = mobj.group(1)
video_extension = 'flv'
# Retrieve video webpage to extract further information request = compat_urllib_request.Request(url) try: self.report_download_webpage(video_id) webpage = compat_urllib_request.urlopen(request).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err)) return
# Extract URL, uploader, and title from webpage self.report_extraction(video_id) mobj = re.search(r'<link rel="video_src" href=".*\?file=([^"]+)" />', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract media URL') return mediaURL = compat_urllib_parse.unquote(mobj.group(1))
video_url = mediaURL
mobj = re.search(r'<title>(.*) video by (.*) - Photobucket</title>', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract title') return video_title = mobj.group(1).decode('utf-8')
video_uploader = mobj.group(2).decode('utf-8')
return [{ 'id': video_id.decode('utf-8'), 'url': video_url.decode('utf-8'), 'uploader': video_uploader, 'upload_date': None, 'title': video_title, 'ext': video_extension.decode('utf-8'), }]
"""Information extractor for video.yahoo.com."""
# _VALID_URL matches all Yahoo! Video URLs # _VPAGE_URL matches only the extractable '/watch/' URLs
InfoExtractor.__init__(self, downloader)
"""Report webpage download.""" self._downloader.to_screen(u'[video.yahoo] %s: Downloading webpage' % video_id)
"""Report information extraction.""" self._downloader.to_screen(u'[video.yahoo] %s: Extracting information' % video_id)
# Extract ID from URL mobj = re.match(self._VALID_URL, url) if mobj is None: self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) return
video_id = mobj.group(2) video_extension = 'flv'
# Rewrite valid but non-extractable URLs as # extractable English language /watch/ URLs if re.match(self._VPAGE_URL, url) is None: request = compat_urllib_request.Request(url) try: webpage = compat_urllib_request.urlopen(request).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err)) return
mobj = re.search(r'\("id", "([0-9]+)"\);', webpage) if mobj is None: self._downloader.trouble(u'ERROR: Unable to extract id field') return yahoo_id = mobj.group(1)
mobj = re.search(r'\("vid", "([0-9]+)"\);', webpage) if mobj is None: self._downloader.trouble(u'ERROR: Unable to extract vid field') return yahoo_vid = mobj.group(1)
url = 'http://video.yahoo.com/watch/%s/%s' % (yahoo_vid, yahoo_id) return self._real_extract(url, new_video=False)
# Retrieve video webpage to extract further information request = compat_urllib_request.Request(url) try: self.report_download_webpage(video_id) webpage = compat_urllib_request.urlopen(request).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err)) return
# Extract uploader and title from webpage self.report_extraction(video_id) mobj = re.search(r'<meta name="title" content="(.*)" />', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract video title') return video_title = mobj.group(1).decode('utf-8')
mobj = re.search(r'<h2 class="ti-5"><a href="http://video\.yahoo\.com/(people|profile)/[0-9]+" beacon=".*">(.*)</a></h2>', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract video uploader') return video_uploader = mobj.group(1).decode('utf-8')
# Extract video thumbnail mobj = re.search(r'<link rel="image_src" href="(.*)" />', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract video thumbnail') return video_thumbnail = mobj.group(1).decode('utf-8')
# Extract video description mobj = re.search(r'<meta name="description" content="(.*)" />', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract video description') return video_description = mobj.group(1).decode('utf-8') if not video_description: video_description = 'No description available.'
# Extract video height and width mobj = re.search(r'<meta name="video_height" content="([0-9]+)" />', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract video height') return yv_video_height = mobj.group(1)
mobj = re.search(r'<meta name="video_width" content="([0-9]+)" />', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract video width') return yv_video_width = mobj.group(1)
# Retrieve video playlist to extract media URL # I'm not completely sure what all these options are, but we # seem to need most of them, otherwise the server sends a 401. yv_lg = 'R0xx6idZnW2zlrKP8xxAIR' # not sure what this represents yv_bitrate = '700' # according to Wikipedia this is hard-coded request = compat_urllib_request.Request('http://cosmos.bcst.yahoo.com/up/yep/process/getPlaylistFOP.php?node_id=' + video_id + '&tech=flash&mode=playlist&lg=' + yv_lg + '&bitrate=' + yv_bitrate + '&vidH=' + yv_video_height + '&vidW=' + yv_video_width + '&swf=as3&rd=video.yahoo.com&tk=null&adsupported=v1,v2,&eventid=1301797') try: self.report_download_webpage(video_id) webpage = compat_urllib_request.urlopen(request).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err)) return
# Extract media URL from playlist XML mobj = re.search(r'<STREAM APP="(http://.*)" FULLPATH="/?(/.*\.flv\?[^"]*)"', webpage) if mobj is None: self._downloader.trouble(u'ERROR: Unable to extract media URL') return video_url = compat_urllib_parse.unquote(mobj.group(1) + mobj.group(2)).decode('utf-8') video_url = unescapeHTML(video_url)
return [{ 'id': video_id.decode('utf-8'), 'url': video_url, 'uploader': video_uploader, 'upload_date': None, 'title': video_title, 'ext': video_extension.decode('utf-8'), 'thumbnail': video_thumbnail.decode('utf-8'), 'description': video_description, }]
"""Information extractor for vimeo.com."""
# _VALID_URL matches Vimeo URLs
"""Report webpage download."""
"""Report information extraction."""
# Extract ID from URL self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) return
# Retrieve video webpage to extract further information except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err)) return
# Now we begin extracting as much information as we can from what we # retrieved. First we extract the information common to all extractors, # and latter we extract those that are Vimeo specific.
# Extract the config JSON except: self._downloader.trouble(u'ERROR: unable to extract info section') return
# Extract title
# Extract uploader and uploader_id
# Extract video thumbnail
# Extract video description else: video_description = ''
# Extract upload date
# Vimeo specific: extract request signature and timestamp
# Vimeo specific: extract video codec and quality information # First consider quality, then codecs, then take everything # TODO bind to format param elif 'sd' in config["video"]["files"][codec_name]: files['sd'].append((codec_name, codec_extension, 'sd')) else: files['other'].append((codec_name, codec_extension, config["video"]["files"][codec_name][0]))
else: self._downloader.trouble(u'ERROR: no known codec found') return
%(video_id, sig, timestamp, video_quality, video_codec.upper())
'id': video_id, 'url': video_url, 'uploader': video_uploader, 'uploader_id': video_uploader_id, 'upload_date': video_upload_date, 'title': video_title, 'ext': video_extension, 'thumbnail': video_thumbnail, 'description': video_description, }]
"""arte.tv information extractor."""
InfoExtractor.__init__(self, downloader)
"""Report webpage download.""" self._downloader.to_screen(u'[arte.tv] %s: Downloading webpage' % video_id)
"""Report information extraction.""" self._downloader.to_screen(u'[arte.tv] %s: Extracting information' % video_id)
request = compat_urllib_request.Request(url) try: self.report_download_webpage(url) webpage = compat_urllib_request.urlopen(request).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err)) return except ValueError as err: self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) return return webpage
page = self.fetch_webpage(url) mobj = re.search(regex, page, regexFlags) info = {}
if mobj is None: self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) return
for (i, key, err) in matchTuples: if mobj.group(i) is None: self._downloader.trouble(err) return else: info[key] = mobj.group(i)
return info
video_lang = url.split('/')[-4] info = self.grep_webpage( url, r'src="(.*?/videothek_js.*?\.js)', 0, [ (1, 'url', u'ERROR: Invalid URL: %s' % url) ] ) http_host = url.split('/')[2] next_url = 'http://%s%s' % (http_host, compat_urllib_parse.unquote(info.get('url'))) info = self.grep_webpage( next_url, r'(s_artestras_scst_geoFRDE_' + video_lang + '.*?)\'.*?' + '(http://.*?\.swf).*?' + '(rtmp://.*?)\'', re.DOTALL, [ (1, 'path', u'ERROR: could not extract video path: %s' % url), (2, 'player', u'ERROR: could not extract video player: %s' % url), (3, 'url', u'ERROR: could not extract video url: %s' % url) ] ) video_url = u'%s/%s' % (info.get('url'), info.get('path'))
video_lang = url.split('/')[-3] info = self.grep_webpage( url, r'param name="movie".*?videorefFileUrl=(http[^\'"&]*)', 0, [ (1, 'url', u'ERROR: Invalid URL: %s' % url) ] ) next_url = compat_urllib_parse.unquote(info.get('url')) info = self.grep_webpage( next_url, r'<video lang="%s" ref="(http[^\'"&]*)' % video_lang, 0, [ (1, 'url', u'ERROR: Could not find <video> tag: %s' % url) ] ) next_url = compat_urllib_parse.unquote(info.get('url'))
info = self.grep_webpage( next_url, r'<video id="(.*?)".*?>.*?' + '<name>(.*?)</name>.*?' + '<dateVideo>(.*?)</dateVideo>.*?' + '<url quality="hd">(.*?)</url>', re.DOTALL, [ (1, 'id', u'ERROR: could not extract video id: %s' % url), (2, 'title', u'ERROR: could not extract video title: %s' % url), (3, 'date', u'ERROR: could not extract video date: %s' % url), (4, 'url', u'ERROR: could not extract video url: %s' % url) ] )
return { 'id': info.get('id'), 'url': compat_urllib_parse.unquote(info.get('url')), 'uploader': u'arte.tv', 'upload_date': info.get('date'), 'title': info.get('title').decode('utf-8'), 'ext': u'mp4', 'format': u'NA', 'player_url': None, }
video_id = url.split('/')[-1] self.report_extraction(video_id)
if re.search(self._LIVE_URL, video_id) is not None: self.extractLiveStream(url) return else: info = self.extractPlus7Stream(url)
return [info]
"""Generic last-resort information extractor."""
InfoExtractor.__init__(self, downloader)
"""Report webpage download.""" self._downloader.to_screen(u'WARNING: Falling back on generic information extractor.') self._downloader.to_screen(u'[generic] %s: Downloading webpage' % video_id)
"""Report information extraction.""" self._downloader.to_screen(u'[generic] %s: Extracting information' % video_id)
"""Report information extraction.""" self._downloader.to_screen(u'[redirect] Following redirect to %s' % new_url)
"""Check if it is a redirect, like url shorteners, in case restart chain.""" class HeadRequest(compat_urllib_request.Request): def get_method(self): return "HEAD"
class HEADRedirectHandler(compat_urllib_request.HTTPRedirectHandler): """ Subclass the HTTPRedirectHandler to make it use our HeadRequest also on the redirected URL """ def redirect_request(self, req, fp, code, msg, headers, newurl): if code in (301, 302, 303, 307): newurl = newurl.replace(' ', '%20') newheaders = dict((k,v) for k,v in req.headers.items() if k.lower() not in ("content-length", "content-type")) return HeadRequest(newurl, headers=newheaders, origin_req_host=req.get_origin_req_host(), unverifiable=True) else: raise compat_urllib_error.HTTPError(req.get_full_url(), code, msg, headers, fp)
class HTTPMethodFallback(compat_urllib_request.BaseHandler): """ Fallback to GET if HEAD is not allowed (405 HTTP error) """ def http_error_405(self, req, fp, code, msg, headers): fp.read() fp.close()
newheaders = dict((k,v) for k,v in req.headers.items() if k.lower() not in ("content-length", "content-type")) return self.parent.open(compat_urllib_request.Request(req.get_full_url(), headers=newheaders, origin_req_host=req.get_origin_req_host(), unverifiable=True))
# Build our opener opener = compat_urllib_request.OpenerDirector() for handler in [compat_urllib_request.HTTPHandler, compat_urllib_request.HTTPDefaultErrorHandler, HTTPMethodFallback, HEADRedirectHandler, compat_urllib_error.HTTPErrorProcessor, compat_urllib_request.HTTPSHandler]: opener.add_handler(handler())
response = opener.open(HeadRequest(url)) new_url = response.geturl()
if url == new_url: return False
self.report_following_redirect(new_url) self._downloader.download([new_url]) return True
if self._test_redirect(url): return
video_id = url.split('/')[-1] request = compat_urllib_request.Request(url) try: self.report_download_webpage(video_id) webpage = compat_urllib_request.urlopen(request).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err)) return except ValueError as err: # since this is the last-resort InfoExtractor, if # this error is thrown, it'll be thrown here self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) return
self.report_extraction(video_id) # Start with something easy: JW Player in SWFObject mobj = re.search(r'flashvars: [\'"](?:.*&)?file=(http[^\'"&]*)', webpage) if mobj is None: # Broaden the search a little bit mobj = re.search(r'[^A-Za-z0-9]?(?:file|source)=(http[^\'"&]*)', webpage) if mobj is None: self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) return
# It's possible that one of the regexes # matched, but returned an empty group: if mobj.group(1) is None: self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) return
video_url = compat_urllib_parse.unquote(mobj.group(1)) video_id = os.path.basename(video_url)
# here's a fun little line of code for you: video_extension = os.path.splitext(video_id)[1][1:] video_id = os.path.splitext(video_id)[0]
# it's tempting to parse this further, but you would # have to take into account all the variations like # Video Title - Site Name # Site Name | Video Title # Video Title - Tagline | Site Name # and so on and so forth; it's just not practical mobj = re.search(r'<title>(.*)</title>', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract title') return video_title = mobj.group(1)
# video uploader is domain name mobj = re.match(r'(?:https?://)?([^/]*)/.*', url) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract title') return video_uploader = mobj.group(1)
return [{ 'id': video_id, 'url': video_url, 'uploader': video_uploader, 'upload_date': None, 'title': video_title, 'ext': video_extension, }]
"""Information Extractor for YouTube search queries."""
InfoExtractor.__init__(self, downloader)
"""Report attempt to download search page with given number.""" query = query.decode(preferredencoding()) self._downloader.to_screen(u'[youtube] query "%s": Downloading page %s' % (query, pagenum))
mobj = re.match(self._VALID_URL, query) if mobj is None: self._downloader.trouble(u'ERROR: invalid search query "%s"' % query) return
prefix, query = query.split(':') prefix = prefix[8:] query = query.encode('utf-8') if prefix == '': self._download_n_results(query, 1) return elif prefix == 'all': self._download_n_results(query, self._max_youtube_results) return else: try: n = int(prefix) if n <= 0: self._downloader.trouble(u'ERROR: invalid download number %s for query "%s"' % (n, query)) return elif n > self._max_youtube_results: self._downloader.to_stderr(u'WARNING: ytsearch returns max %i results (you requested %i)' % (self._max_youtube_results, n)) n = self._max_youtube_results self._download_n_results(query, n) return except ValueError: # parsing prefix as integer fails self._download_n_results(query, 1) return
"""Downloads a specified number of results for a query"""
video_ids = [] pagenum = 0 limit = n
while (50 * pagenum) < limit: self.report_download_page(query, pagenum+1) result_url = self._API_URL % (compat_urllib_parse.quote_plus(query), (50*pagenum)+1) request = compat_urllib_request.Request(result_url) try: data = compat_urllib_request.urlopen(request).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download API page: %s' % compat_str(err)) return api_response = json.loads(data)['data']
new_ids = list(video['id'] for video in api_response['items']) video_ids += new_ids
limit = min(n, api_response['totalItems']) pagenum += 1
if len(video_ids) > n: video_ids = video_ids[:n] for id in video_ids: self._downloader.download(['http://www.youtube.com/watch?v=%s' % id]) return
"""Information Extractor for Google Video search queries."""
InfoExtractor.__init__(self, downloader)
"""Report attempt to download playlist page with given number.""" query = query.decode(preferredencoding()) self._downloader.to_screen(u'[video.google] query "%s": Downloading page %s' % (query, pagenum))
mobj = re.match(self._VALID_URL, query) if mobj is None: self._downloader.trouble(u'ERROR: invalid search query "%s"' % query) return
prefix, query = query.split(':') prefix = prefix[8:] query = query.encode('utf-8') if prefix == '': self._download_n_results(query, 1) return elif prefix == 'all': self._download_n_results(query, self._max_google_results) return else: try: n = int(prefix) if n <= 0: self._downloader.trouble(u'ERROR: invalid download number %s for query "%s"' % (n, query)) return elif n > self._max_google_results: self._downloader.to_stderr(u'WARNING: gvsearch returns max %i results (you requested %i)' % (self._max_google_results, n)) n = self._max_google_results self._download_n_results(query, n) return except ValueError: # parsing prefix as integer fails self._download_n_results(query, 1) return
"""Downloads a specified number of results for a query"""
video_ids = [] pagenum = 0
while True: self.report_download_page(query, pagenum) result_url = self._TEMPLATE_URL % (compat_urllib_parse.quote_plus(query), pagenum*10) request = compat_urllib_request.Request(result_url) try: page = compat_urllib_request.urlopen(request).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err)) return
# Extract video identifiers for mobj in re.finditer(self._VIDEO_INDICATOR, page): video_id = mobj.group(1) if video_id not in video_ids: video_ids.append(video_id) if len(video_ids) == n: # Specified n videos reached for id in video_ids: self._downloader.download(['http://video.google.com/videoplay?docid=%s' % id]) return
if re.search(self._MORE_PAGES_INDICATOR, page) is None: for id in video_ids: self._downloader.download(['http://video.google.com/videoplay?docid=%s' % id]) return
pagenum = pagenum + 1
"""Information Extractor for Yahoo! Video search queries."""
InfoExtractor.__init__(self, downloader)
"""Report attempt to download playlist page with given number.""" query = query.decode(preferredencoding()) self._downloader.to_screen(u'[video.yahoo] query "%s": Downloading page %s' % (query, pagenum))
mobj = re.match(self._VALID_URL, query) if mobj is None: self._downloader.trouble(u'ERROR: invalid search query "%s"' % query) return
prefix, query = query.split(':') prefix = prefix[8:] query = query.encode('utf-8') if prefix == '': self._download_n_results(query, 1) return elif prefix == 'all': self._download_n_results(query, self._max_yahoo_results) return else: try: n = int(prefix) if n <= 0: self._downloader.trouble(u'ERROR: invalid download number %s for query "%s"' % (n, query)) return elif n > self._max_yahoo_results: self._downloader.to_stderr(u'WARNING: yvsearch returns max %i results (you requested %i)' % (self._max_yahoo_results, n)) n = self._max_yahoo_results self._download_n_results(query, n) return except ValueError: # parsing prefix as integer fails self._download_n_results(query, 1) return
"""Downloads a specified number of results for a query"""
video_ids = [] already_seen = set() pagenum = 1
while True: self.report_download_page(query, pagenum) result_url = self._TEMPLATE_URL % (compat_urllib_parse.quote_plus(query), pagenum) request = compat_urllib_request.Request(result_url) try: page = compat_urllib_request.urlopen(request).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err)) return
# Extract video identifiers for mobj in re.finditer(self._VIDEO_INDICATOR, page): video_id = mobj.group(1) if video_id not in already_seen: video_ids.append(video_id) already_seen.add(video_id) if len(video_ids) == n: # Specified n videos reached for id in video_ids: self._downloader.download(['http://video.yahoo.com/watch/%s' % id]) return
if re.search(self._MORE_PAGES_INDICATOR, page) is None: for id in video_ids: self._downloader.download(['http://video.yahoo.com/watch/%s' % id]) return
pagenum = pagenum + 1
"""Information Extractor for YouTube playlists."""
"""Report attempt to download playlist page with given number."""
# Extract playlist id self._downloader.trouble(u'ERROR: invalid url: %s' % url) return
# Single video case self._downloader.download([mobj.group(3)]) return
# Download playlist pages # prefix is 'p' as default for playlists but there are other types that need extra care playlist_access = 'artist' else:
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err)) return
# Extract video identifiers
else: video_ids = video_ids[playliststart:playlistend]
else: self._downloader.to_screen(u'[youtube] PL %s: Found %i videos, downloading %i' % (playlist_id, total, len(video_ids)))
"""Information Extractor for YouTube channels."""
"""Report attempt to download channel page with given number.""" self._downloader.to_screen(u'[youtube] Channel %s: Downloading page #%s' % (channel_id, pagenum))
# Extract channel id mobj = re.match(self._VALID_URL, url) if mobj is None: self._downloader.trouble(u'ERROR: invalid url: %s' % url) return
# Download channel pages channel_id = mobj.group(1) video_ids = [] pagenum = 1
while True: self.report_download_page(channel_id, pagenum) url = self._TEMPLATE_URL % (channel_id, pagenum) request = compat_urllib_request.Request(url) try: page = compat_urllib_request.urlopen(request).read().decode('utf8') except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err)) return
# Extract video identifiers ids_in_page = [] for mobj in re.finditer(r'href="/watch\?v=([0-9A-Za-z_-]+)&', page): if mobj.group(1) not in ids_in_page: ids_in_page.append(mobj.group(1)) video_ids.extend(ids_in_page)
if self._MORE_PAGES_INDICATOR not in page: break pagenum = pagenum + 1
self._downloader.to_screen(u'[youtube] Channel %s: Found %i videos' % (channel_id, len(video_ids)))
for id in video_ids: self._downloader.download(['http://www.youtube.com/watch?v=%s' % id]) return
"""Information Extractor for YouTube users."""
"""Report attempt to download user page.""" (username, start_index, start_index + self._GDATA_PAGE_SIZE))
# Extract username self._downloader.trouble(u'ERROR: invalid url: %s' % url) return
# Download video ids using YouTube Data API. Result size per # query is limited (currently to 50 videos) so we need to query # page by page until there are no video ids - it means we got # all of them.
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err)) return
# Extract video identifiers
# A little optimization - if current page is not # "full", ie. does not contain PAGE_SIZE video ids then # we can assume that this page is the last one - there # are no more ids on further pages - no need to query # again.
else: video_ids = video_ids[playliststart:playlistend]
(username, all_ids_count, len(video_ids)))
"""Information Extractor for blip.tv users."""
InfoExtractor.__init__(self, downloader)
"""Report attempt to download user page.""" self._downloader.to_screen(u'[%s] user %s: Downloading video ids from page %d' % (self.IE_NAME, username, pagenum))
# Extract username mobj = re.match(self._VALID_URL, url) if mobj is None: self._downloader.trouble(u'ERROR: invalid url: %s' % url) return
username = mobj.group(1)
page_base = 'http://m.blip.tv/pr/show_get_full_episode_list?users_id=%s&lite=0&esi=1'
request = compat_urllib_request.Request(url)
try: page = compat_urllib_request.urlopen(request).read().decode('utf-8') mobj = re.search(r'data-users-id="([^"]+)"', page) page_base = page_base % mobj.group(1) except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err)) return
# Download video ids using BlipTV Ajax calls. Result size per # query is limited (currently to 12 videos) so we need to query # page by page until there are no video ids - it means we got # all of them.
video_ids = [] pagenum = 1
while True: self.report_download_page(username, pagenum)
request = compat_urllib_request.Request( page_base + "&page=" + str(pagenum) )
try: page = compat_urllib_request.urlopen(request).read().decode('utf-8') except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download webpage: %s' % str(err)) return
# Extract video identifiers ids_in_page = []
for mobj in re.finditer(r'href="/([^"]+)"', page): if mobj.group(1) not in ids_in_page: ids_in_page.append(unescapeHTML(mobj.group(1)))
video_ids.extend(ids_in_page)
# A little optimization - if current page is not # "full", ie. does not contain PAGE_SIZE video ids then # we can assume that this page is the last one - there # are no more ids on further pages - no need to query # again.
if len(ids_in_page) < self._PAGE_SIZE: break
pagenum += 1
all_ids_count = len(video_ids) playliststart = self._downloader.params.get('playliststart', 1) - 1 playlistend = self._downloader.params.get('playlistend', -1)
if playlistend == -1: video_ids = video_ids[playliststart:] else: video_ids = video_ids[playliststart:playlistend]
self._downloader.to_screen(u"[%s] user %s: Collected %d video ids (downloading %d of them)" % (self.IE_NAME, username, all_ids_count, len(video_ids)))
for video_id in video_ids: self._downloader.download([u'http://blip.tv/'+video_id])
"""Information extractor for depositfiles.com"""
"""Report webpage download.""" self._downloader.to_screen(u'[DepositFiles] %s: Downloading webpage' % file_id)
"""Report information extraction.""" self._downloader.to_screen(u'[DepositFiles] %s: Extracting information' % file_id)
file_id = url.split('/')[-1] # Rebuild url in english locale url = 'http://depositfiles.com/en/files/' + file_id
# Retrieve file webpage with 'Free download' button pressed free_download_indication = { 'gateway_result' : '1' } request = compat_urllib_request.Request(url, compat_urllib_parse.urlencode(free_download_indication)) try: self.report_download_webpage(file_id) webpage = compat_urllib_request.urlopen(request).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: Unable to retrieve file webpage: %s' % compat_str(err)) return
# Search for the real file URL mobj = re.search(r'<form action="(http://fileshare.+?)"', webpage) if (mobj is None) or (mobj.group(1) is None): # Try to figure out reason of the error. mobj = re.search(r'<strong>(Attention.*?)</strong>', webpage, re.DOTALL) if (mobj is not None) and (mobj.group(1) is not None): restriction_message = re.sub('\s+', ' ', mobj.group(1)).strip() self._downloader.trouble(u'ERROR: %s' % restriction_message) else: self._downloader.trouble(u'ERROR: unable to extract download URL from: %s' % url) return
file_url = mobj.group(1) file_extension = os.path.splitext(file_url)[1][1:]
# Search for file title mobj = re.search(r'<b title="(.*?)">', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract title') return file_title = mobj.group(1).decode('utf-8')
return [{ 'id': file_id.decode('utf-8'), 'url': file_url.decode('utf-8'), 'uploader': None, 'upload_date': None, 'title': file_title, 'ext': file_extension.decode('utf-8'), }]
"""Information Extractor for Facebook"""
'video': 'mp4', 'highqual': 'mp4', 'lowqual': 'mp4', }
InfoExtractor.__init__(self, downloader)
"""Add header and report message.""" self._downloader.to_screen(u'[facebook] %s' % message)
"""Report attempt to log in.""" self._reporter(u'Logging in')
"""Report attempt to download video webpage.""" self._reporter(u'%s: Downloading video webpage' % video_id)
"""Report attempt to extract video information.""" self._reporter(u'%s: Extracting video information' % video_id)
"""Extract video information from page""" # General data data = {'title': r'\("video_title", "(.*?)"\)', 'description': r'<div class="datawrap">(.*?)</div>', 'owner': r'\("video_owner_name", "(.*?)"\)', 'thumbnail': r'\("thumb_url", "(?P<THUMB>.*?)"\)', } video_info = {} for piece in data.keys(): mobj = re.search(data[piece], video_webpage) if mobj is not None: video_info[piece] = compat_urllib_parse.unquote_plus(mobj.group(1).decode("unicode_escape"))
# Video urls video_urls = {} for fmt in self._available_formats: mobj = re.search(r'\("%s_src\", "(.+?)"\)' % fmt, video_webpage) if mobj is not None: # URL is in a Javascript segment inside an escaped Unicode format within # the generally utf-8 page video_urls[fmt] = compat_urllib_parse.unquote_plus(mobj.group(1).decode("unicode_escape")) video_info['video_urls'] = video_urls
return video_info
if self._downloader is None: return
useremail = None password = None downloader_params = self._downloader.params
# Attempt to use provided username and password or .netrc data if downloader_params.get('username', None) is not None: useremail = downloader_params['username'] password = downloader_params['password'] elif downloader_params.get('usenetrc', False): try: info = netrc.netrc().authenticators(self._NETRC_MACHINE) if info is not None: useremail = info[0] password = info[2] else: raise netrc.NetrcParseError('No authenticators for %s' % self._NETRC_MACHINE) except (IOError, netrc.NetrcParseError) as err: self._downloader.to_stderr(u'WARNING: parsing .netrc: %s' % compat_str(err)) return
if useremail is None: return
# Log in login_form = { 'email': useremail, 'pass': password, 'login': 'Log+In' } request = compat_urllib_request.Request(self._LOGIN_URL, compat_urllib_parse.urlencode(login_form)) try: self.report_login() login_results = compat_urllib_request.urlopen(request).read() if re.search(r'<form(.*)name="login"(.*)</form>', login_results) is not None: self._downloader.to_stderr(u'WARNING: unable to log in: bad username/password, or exceded login rate limit (~3/min). Check credentials or wait.') return except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.to_stderr(u'WARNING: unable to log in: %s' % compat_str(err)) return
mobj = re.match(self._VALID_URL, url) if mobj is None: self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return video_id = mobj.group('ID')
# Get video webpage self.report_video_webpage_download(video_id) request = compat_urllib_request.Request('https://www.facebook.com/video/video.php?v=%s' % video_id) try: page = compat_urllib_request.urlopen(request) video_webpage = page.read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download video webpage: %s' % compat_str(err)) return
# Start extracting information self.report_information_extraction(video_id)
# Extract information video_info = self._parse_page(video_webpage)
# uploader if 'owner' not in video_info: self._downloader.trouble(u'ERROR: unable to extract uploader nickname') return video_uploader = video_info['owner']
# title if 'title' not in video_info: self._downloader.trouble(u'ERROR: unable to extract video title') return video_title = video_info['title'] video_title = video_title.decode('utf-8')
# thumbnail image if 'thumbnail' not in video_info: self._downloader.trouble(u'WARNING: unable to extract video thumbnail') video_thumbnail = '' else: video_thumbnail = video_info['thumbnail']
# upload date upload_date = None if 'upload_date' in video_info: upload_time = video_info['upload_date'] timetuple = email.utils.parsedate_tz(upload_time) if timetuple is not None: try: upload_date = time.strftime('%Y%m%d', timetuple[0:9]) except: pass
# description video_description = video_info.get('description', 'No description available.')
url_map = video_info['video_urls'] if url_map: # Decide which formats to download req_format = self._downloader.params.get('format', None) format_limit = self._downloader.params.get('format_limit', None)
if format_limit is not None and format_limit in self._available_formats: format_list = self._available_formats[self._available_formats.index(format_limit):] else: format_list = self._available_formats existing_formats = [x for x in format_list if x in url_map] if len(existing_formats) == 0: self._downloader.trouble(u'ERROR: no known formats available for video') return if req_format is None: video_url_list = [(existing_formats[0], url_map[existing_formats[0]])] # Best quality elif req_format == 'worst': video_url_list = [(existing_formats[len(existing_formats)-1], url_map[existing_formats[len(existing_formats)-1]])] # worst quality elif req_format == '-1': video_url_list = [(f, url_map[f]) for f in existing_formats] # All formats else: # Specific format if req_format not in url_map: self._downloader.trouble(u'ERROR: requested format not available') return video_url_list = [(req_format, url_map[req_format])] # Specific format
results = [] for format_param, video_real_url in video_url_list: # Extension video_extension = self._video_extensions.get(format_param, 'mp4')
results.append({ 'id': video_id.decode('utf-8'), 'url': video_real_url.decode('utf-8'), 'uploader': video_uploader.decode('utf-8'), 'upload_date': upload_date, 'title': video_title, 'ext': video_extension.decode('utf-8'), 'format': (format_param is None and u'NA' or format_param.decode('utf-8')), 'thumbnail': video_thumbnail.decode('utf-8'), 'description': video_description.decode('utf-8'), }) return results
"""Information extractor for blip.tv"""
"""Report information extraction."""
"""Report information extraction.""" self._downloader.to_screen(u'[%s] %s: Direct download detected' % (self.IE_NAME, title))
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
cchar = '&' else: basename = url.split('/')[-1] title,ext = os.path.splitext(basename) title = title.decode('UTF-8') ext = ext.replace('.', '') self.report_direct_download(title) info = { 'id': title, 'url': url, 'uploader': None, 'upload_date': None, 'title': title, 'ext': ext, 'urlhandle': urlh } except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download video info webpage: %s' % compat_str(err)) return except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to read video info webpage: %s' % compat_str(err)) return
else: data = json_data
raise ValueError('Can not determine filename extension')
'id': data['item_id'], 'url': video_url, 'uploader': data['display_name'], 'upload_date': upload_date, 'title': data['title'], 'ext': ext, 'format': data['media']['mimeType'], 'thumbnail': data['thumbnailUrl'], 'description': data['description'], 'player_url': data['embedUrl'] } except (ValueError,KeyError) as err: self._downloader.trouble(u'ERROR: unable to parse video information: %s' % repr(err)) return
"""Information Extractor for myvideo.de."""
"""Report information extraction."""
self._download.trouble(u'ERROR: invalid URL: %s' % url) return
# Get video webpage
webpage) self._downloader.trouble(u'ERROR: unable to extract media URL') return
self._downloader.trouble(u'ERROR: unable to extract title') return
'id': video_id, 'url': video_url, 'uploader': None, 'upload_date': None, 'title': video_title, 'ext': u'flv', }]
"""Information extractor for The Daily Show and Colbert Report """
# urls can be abbreviations like :thedailyshow or :colbert # urls for episodes like: # or urls for clips like: http://www.thedailyshow.com/watch/mon-december-10-2012/any-given-gun-day # or: http://www.colbertnation.com/the-colbert-report-videos/421667/november-29-2012/moon-shattering-news # or: http://www.colbertnation.com/the-colbert-report-collections/422008/festival-of-lights/79524 |(https?://)?(www\.)? (?P<showname>thedailyshow|colbertnation)\.com/ (full-episodes/(?P<episode>.*)| (?P<clip> (the-colbert-report-(videos|collections)/(?P<clipID>[0-9]+)/[^/]*/(?P<cntitle>.*?)) |(watch/(?P<date>[^/]*)/(?P<tdstitle>.*))))) $"""
'3500': 'mp4', '2200': 'mp4', '1700': 'mp4', '1200': 'mp4', '750': 'mp4', '400': 'mp4', } '3500': '1280x720', '2200': '960x540', '1700': '768x432', '1200': '640x360', '750': '512x288', '400': '384x216', }
"""Receives a URL and returns True if suitable for this IE.""" return re.match(self._VALID_URL, url, re.VERBOSE) is not None
self._downloader.to_screen(u'[comedycentral] %s: Extracting information' % episode_id)
self._downloader.to_screen(u'[comedycentral] %s: Downloading configuration' % episode_id)
self._downloader.to_screen(u'[comedycentral] %s: Downloading show index' % episode_id)
self._downloader.to_screen(u'[comedycentral] %s: Determining player URL' % episode_id)
print('Available formats:') for x in formats: print('%s\t:\t%s\t[%s]' %(x, self._video_extensions.get(x, 'mp4'), self._video_dimensions.get(x, '???')))
mobj = re.match(self._VALID_URL, url, re.VERBOSE) if mobj is None: self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
if mobj.group('shortname'): if mobj.group('shortname') in ('tds', 'thedailyshow'): url = u'http://www.thedailyshow.com/full-episodes/' else: url = u'http://www.colbertnation.com/full-episodes/' mobj = re.match(self._VALID_URL, url, re.VERBOSE) assert mobj is not None
if mobj.group('clip'): if mobj.group('showname') == 'thedailyshow': epTitle = mobj.group('tdstitle') else: epTitle = mobj.group('cntitle') dlNewest = False else: dlNewest = not mobj.group('episode') if dlNewest: epTitle = mobj.group('showname') else: epTitle = mobj.group('episode')
req = compat_urllib_request.Request(url) self.report_extraction(epTitle) try: htmlHandle = compat_urllib_request.urlopen(req) html = htmlHandle.read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err)) return if dlNewest: url = htmlHandle.geturl() mobj = re.match(self._VALID_URL, url, re.VERBOSE) if mobj is None: self._downloader.trouble(u'ERROR: Invalid redirected URL: ' + url) return if mobj.group('episode') == '': self._downloader.trouble(u'ERROR: Redirected URL is still not specific: ' + url) return epTitle = mobj.group('episode')
mMovieParams = re.findall('(?:<param name="movie" value="|var url = ")(http://media.mtvnservices.com/([^"]*(?:episode|video).*?:.*?))"', html)
if len(mMovieParams) == 0: # The Colbert Report embeds the information in a without # a URL prefix; so extract the alternate reference # and then add the URL prefix manually.
altMovieParams = re.findall('data-mgid="([^"]*(?:episode|video).*?:.*?)"', html) if len(altMovieParams) == 0: self._downloader.trouble(u'ERROR: unable to find Flash URL in webpage ' + url) return else: mMovieParams = [("http://media.mtvnservices.com/" + altMovieParams[0], altMovieParams[0])]
playerUrl_raw = mMovieParams[0][0] self.report_player_url(epTitle) try: urlHandle = compat_urllib_request.urlopen(playerUrl_raw) playerUrl = urlHandle.geturl() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to find out player URL: ' + compat_str(err)) return
uri = mMovieParams[0][1] indexUrl = 'http://shadow.comedycentral.com/feeds/video_player/mrss/?' + compat_urllib_parse.urlencode({'uri': uri}) self.report_index_download(epTitle) try: indexXml = compat_urllib_request.urlopen(indexUrl).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download episode index: ' + compat_str(err)) return
results = []
idoc = xml.etree.ElementTree.fromstring(indexXml) itemEls = idoc.findall('.//item') for itemEl in itemEls: mediaId = itemEl.findall('./guid')[0].text shortMediaId = mediaId.split(':')[-1] showId = mediaId.split(':')[-2].replace('.com', '') officialTitle = itemEl.findall('./title')[0].text officialDate = itemEl.findall('./pubDate')[0].text
configUrl = ('http://www.comedycentral.com/global/feeds/entertainment/media/mediaGenEntertainment.jhtml?' + compat_urllib_parse.urlencode({'uri': mediaId})) configReq = compat_urllib_request.Request(configUrl) self.report_config_download(epTitle) try: configXml = compat_urllib_request.urlopen(configReq).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download webpage: %s' % compat_str(err)) return
cdoc = xml.etree.ElementTree.fromstring(configXml) turls = [] for rendition in cdoc.findall('.//rendition'): finfo = (rendition.attrib['bitrate'], rendition.findall('./src')[0].text) turls.append(finfo)
if len(turls) == 0: self._downloader.trouble(u'\nERROR: unable to download ' + mediaId + ': No videos found') continue
if self._downloader.params.get('listformats', None): self._print_formats([i[0] for i in turls]) return
# For now, just pick the highest bitrate format,video_url = turls[-1]
# Get the format arg from the arg stream req_format = self._downloader.params.get('format', None)
# Select format if we can find one for f,v in turls: if f == req_format: format, video_url = f, v break
# Patch to download from alternative CDN, which does not # break on current RTMPDump builds broken_cdn = "rtmpe://viacomccstrmfs.fplive.net/viacomccstrm/gsp.comedystor/" better_cdn = "rtmpe://cp10740.edgefcs.net/ondemand/mtvnorigin/gsp.comedystor/"
if video_url.startswith(broken_cdn): video_url = video_url.replace(broken_cdn, better_cdn)
effTitle = showId + u'-' + epTitle info = { 'id': shortMediaId, 'url': video_url, 'uploader': showId, 'upload_date': officialDate, 'title': effTitle, 'ext': 'mp4', 'format': format, 'thumbnail': None, 'description': officialTitle, 'player_url': None #playerUrl }
results.append(info)
return results
"""Information extractor for The Escapist """
self._downloader.to_screen(u'[escapist] %s: Extracting information' % showName)
self._downloader.to_screen(u'[escapist] %s: Downloading configuration' % showName)
mobj = re.match(self._VALID_URL, url) if mobj is None: self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return showName = mobj.group('showname') videoId = mobj.group('episode')
self.report_extraction(showName) try: webPage = compat_urllib_request.urlopen(url) webPageBytes = webPage.read() m = re.match(r'text/html; charset="?([^"]+)"?', webPage.headers['Content-Type']) webPage = webPageBytes.decode(m.group(1) if m else 'utf-8') except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download webpage: ' + compat_str(err)) return
descMatch = re.search('<meta name="description" content="([^"]*)"', webPage) description = unescapeHTML(descMatch.group(1)) imgMatch = re.search('<meta property="og:image" content="([^"]*)"', webPage) imgUrl = unescapeHTML(imgMatch.group(1)) playerUrlMatch = re.search('<meta property="og:video" content="([^"]*)"', webPage) playerUrl = unescapeHTML(playerUrlMatch.group(1)) configUrlMatch = re.search('config=(.*)$', playerUrl) configUrl = compat_urllib_parse.unquote(configUrlMatch.group(1))
self.report_config_download(showName) try: configJSON = compat_urllib_request.urlopen(configUrl) m = re.match(r'text/html; charset="?([^"]+)"?', configJSON.headers['Content-Type']) configJSON = configJSON.read().decode(m.group(1) if m else 'utf-8') except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download configuration: ' + compat_str(err)) return
# Technically, it's JavaScript, not JSON configJSON = configJSON.replace("'", '"')
try: config = json.loads(configJSON) except (ValueError,) as err: self._downloader.trouble(u'ERROR: Invalid JSON in configuration file: ' + compat_str(err)) return
playlist = config['playlist'] videoUrl = playlist[1]['url']
info = { 'id': videoId, 'url': videoUrl, 'uploader': showName, 'upload_date': None, 'title': showName, 'ext': 'flv', 'thumbnail': imgUrl, 'description': description, 'player_url': playerUrl, }
return [info]
"""Information extractor for collegehumor.com"""
"""Report information extraction.""" self._downloader.to_screen(u'[%s] %s: Downloading XML manifest' % (self.IE_NAME, video_id))
"""Report information extraction.""" self._downloader.to_screen(u'[%s] %s: Extracting information' % (self.IE_NAME, video_id))
mobj = re.match(self._VALID_URL, url) if mobj is None: self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return video_id = mobj.group('videoid')
info = { 'id': video_id, 'uploader': None, 'upload_date': None, }
self.report_extraction(video_id) xmlUrl = 'http://www.collegehumor.com/moogaloop/video/' + video_id try: metaXml = compat_urllib_request.urlopen(xmlUrl).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download video info XML: %s' % compat_str(err)) return
mdoc = xml.etree.ElementTree.fromstring(metaXml) try: videoNode = mdoc.findall('./video')[0] info['description'] = videoNode.findall('./description')[0].text info['title'] = videoNode.findall('./caption')[0].text info['thumbnail'] = videoNode.findall('./thumbnail')[0].text manifest_url = videoNode.findall('./file')[0].text except IndexError: self._downloader.trouble(u'\nERROR: Invalid metadata XML file') return
manifest_url += '?hdcore=2.10.3' self.report_manifest(video_id) try: manifestXml = compat_urllib_request.urlopen(manifest_url).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download video info XML: %s' % compat_str(err)) return
adoc = xml.etree.ElementTree.fromstring(manifestXml) try: media_node = adoc.findall('./{http://ns.adobe.com/f4m/1.0}media')[0] node_id = media_node.attrib['url'] video_id = adoc.findall('./{http://ns.adobe.com/f4m/1.0}id')[0].text except IndexError as err: self._downloader.trouble(u'\nERROR: Invalid manifest file') return
url_pr = compat_urllib_parse_urlparse(manifest_url) url = url_pr.scheme + '://' + url_pr.netloc + '/z' + video_id[:-2] + '/' + node_id + 'Seg1-Frag1'
info['url'] = url info['ext'] = 'f4f' return [info]
"""Information extractor for xvideos.com"""
"""Report information extraction."""
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
# Extract video URL self._downloader.trouble(u'ERROR: unable to extract video url') return
# Extract title self._downloader.trouble(u'ERROR: unable to extract video title') return
# Extract video thumbnail self._downloader.trouble(u'ERROR: unable to extract video thumbnail') return
'id': video_id, 'url': video_url, 'uploader': None, 'upload_date': None, 'title': video_title, 'ext': 'flv', 'thumbnail': video_thumbnail, 'description': None, }
"""Information extractor for soundcloud.com To access the media, the uid of the song and a stream token must be extracted from the page source and the script must make a request to media.soundcloud.com/crossdomain.xml. Then the media can be grabbed by requesting from an url composed of the stream token and uid """
"""Report information extraction."""
"""Report information extraction."""
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
# extract uploader (which is in the url) # extract simple title (uploader + slug of song title)
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download video webpage: %s' % compat_str(err)) return
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download stream definitions: %s' % compat_str(err)) return
'id': info['id'], 'url': mediaURL, 'uploader': info['user']['username'], 'upload_date': info['created_at'], 'title': info['title'], 'ext': u'mp3', 'description': info['description'], }]
"""Information extractor for infoq.com"""
"""Report information extraction."""
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
# Extract video URL self._downloader.trouble(u'ERROR: unable to extract video url') return
# Extract title self._downloader.trouble(u'ERROR: unable to extract video title') return
# Extract description
'id': video_id, 'url': video_url, 'uploader': None, 'upload_date': None, 'title': video_title, 'ext': extension, # Extension is always(?) mp4, but seems to be flv 'thumbnail': None, 'description': video_description, }
"""Information extractor for www.mixcloud.com"""
InfoExtractor.__init__(self, downloader)
"""Report JSON download.""" self._downloader.to_screen(u'[%s] Downloading json' % self.IE_NAME)
"""Report information extraction.""" self._downloader.to_screen(u'[%s] %s: Extracting information' % (self.IE_NAME, file_id))
"""Get urls from 'audio_formats' section in json""" file_url = None try: bitrate_list = jsonData[fmt] if bitrate is None or bitrate == 'best' or bitrate not in bitrate_list: bitrate = max(bitrate_list) # select highest
url_list = jsonData[fmt][bitrate] except TypeError: # we have no bitrate info. url_list = jsonData[fmt] return url_list
"""Returns 1st active url from list""" for url in url_list: try: compat_urllib_request.urlopen(url) return url except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: url = None
return None
print('Available formats:') for fmt in formats.keys(): for b in formats[fmt]: try: ext = formats[fmt][b][0] print('%s\t%s\t[%s]' % (fmt, b, ext.split('.')[-1])) except TypeError: # we have no bitrate info ext = formats[fmt][0] print('%s\t%s\t[%s]' % (fmt, '??', ext.split('.')[-1])) break
mobj = re.match(self._VALID_URL, url) if mobj is None: self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return # extract uploader & filename from url uploader = mobj.group(1).decode('utf-8') file_id = uploader + "-" + mobj.group(2).decode('utf-8')
# construct API request file_url = 'http://www.mixcloud.com/api/1/cloudcast/' + '/'.join(url.split('/')[-3:-1]) + '.json' # retrieve .json file with links to files request = compat_urllib_request.Request(file_url) try: self.report_download_json(file_url) jsonData = compat_urllib_request.urlopen(request).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: Unable to retrieve file: %s' % compat_str(err)) return
# parse JSON json_data = json.loads(jsonData) player_url = json_data['player_swf_url'] formats = dict(json_data['audio_formats'])
req_format = self._downloader.params.get('format', None) bitrate = None
if self._downloader.params.get('listformats', None): self._print_formats(formats) return
if req_format is None or req_format == 'best': for format_param in formats.keys(): url_list = self.get_urls(formats, format_param) # check urls file_url = self.check_urls(url_list) if file_url is not None: break # got it! else: if req_format not in formats: self._downloader.trouble(u'ERROR: format is not available') return
url_list = self.get_urls(formats, req_format) file_url = self.check_urls(url_list) format_param = req_format
return [{ 'id': file_id.decode('utf-8'), 'url': file_url.decode('utf-8'), 'uploader': uploader.decode('utf-8'), 'upload_date': None, 'title': json_data['name'], 'ext': file_url.split('.')[-1].decode('utf-8'), 'format': (format_param is None and u'NA' or format_param.decode('utf-8')), 'thumbnail': json_data['thumbnail_url'], 'description': json_data['description'], 'player_url': player_url.decode('utf-8'), }]
"""Information extractor for Stanford's Open ClassRoom"""
"""Report information extraction.""" self._downloader.to_screen(u'[%s] %s: Downloading webpage' % (self.IE_NAME, objid))
"""Report information extraction."""
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
'id': course + '_' + video, 'uploader': None, 'upload_date': None, }
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download video info XML: %s' % compat_str(err)) return except IndexError: self._downloader.trouble(u'\nERROR: Invalid metadata XML file') return elif mobj.group('course'): # A course page course = mobj.group('course') info = { 'id': course, 'type': 'playlist', 'uploader': None, 'upload_date': None, }
self.report_download_webpage(info['id']) try: coursepage = compat_urllib_request.urlopen(url).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download course info page: ' + compat_str(err)) return
m = re.search('<h1>([^<]+)</h1>', coursepage) if m: info['title'] = unescapeHTML(m.group(1)) else: info['title'] = info['id']
m = re.search('<description>([^<]+)</description>', coursepage) if m: info['description'] = unescapeHTML(m.group(1))
links = orderedSet(re.findall('<a href="(VideoPage.php\?[^"]+)">', coursepage)) info['list'] = [ { 'type': 'reference', 'url': 'http://openclassroom.stanford.edu/MainFolder/' + unescapeHTML(vpage), } for vpage in links] results = [] for entry in info['list']: assert entry['type'] == 'reference' results += self.extract(entry['url']) return results
else: # Root page info = { 'id': 'Stanford OpenClassroom', 'type': 'playlist', 'uploader': None, 'upload_date': None, }
self.report_download_webpage(info['id']) rootURL = 'http://openclassroom.stanford.edu/MainFolder/HomePage.php' try: rootpage = compat_urllib_request.urlopen(rootURL).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download course info page: ' + compat_str(err)) return
info['title'] = info['id']
links = orderedSet(re.findall('<a href="(CoursePage.php\?[^"]+)">', rootpage)) info['list'] = [ { 'type': 'reference', 'url': 'http://openclassroom.stanford.edu/MainFolder/' + unescapeHTML(cpage), } for cpage in links]
results = [] for entry in info['list']: assert entry['type'] == 'reference' results += self.extract(entry['url']) return results
"""Information extractor for MTV.com"""
"""Report information extraction.""" self._downloader.to_screen(u'[%s] %s: Extracting information' % (self.IE_NAME, video_id))
mobj = re.match(self._VALID_URL, url) if mobj is None: self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return if not mobj.group('proto'): url = 'http://' + url video_id = mobj.group('videoid')
webpage = self._download_webpage(url, video_id)
mobj = re.search(r'<meta name="mtv_vt" content="([^"]+)"/>', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract song name') return song_name = unescapeHTML(mobj.group(1).decode('iso-8859-1')) mobj = re.search(r'<meta name="mtv_an" content="([^"]+)"/>', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract performer') return performer = unescapeHTML(mobj.group(1).decode('iso-8859-1')) video_title = performer + ' - ' + song_name
mobj = re.search(r'<meta name="mtvn_uri" content="([^"]+)"/>', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to mtvn_uri') return mtvn_uri = mobj.group(1)
mobj = re.search(r'MTVN.Player.defaultPlaylistId = ([0-9]+);', webpage) if mobj is None: self._downloader.trouble(u'ERROR: unable to extract content id') return content_id = mobj.group(1)
videogen_url = 'http://www.mtv.com/player/includes/mediaGen.jhtml?uri=' + mtvn_uri + '&id=' + content_id + '&vid=' + video_id + '&ref=www.mtvn.com&viewUri=' + mtvn_uri self.report_extraction(video_id) request = compat_urllib_request.Request(videogen_url) try: metadataXml = compat_urllib_request.urlopen(request).read() except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download video metadata: %s' % compat_str(err)) return
mdoc = xml.etree.ElementTree.fromstring(metadataXml) renditions = mdoc.findall('.//rendition')
# For now, always pick the highest quality. rendition = renditions[-1]
try: _,_,ext = rendition.attrib['type'].partition('/') format = ext + '-' + rendition.attrib['width'] + 'x' + rendition.attrib['height'] + '_' + rendition.attrib['bitrate'] video_url = rendition.find('./src').text except KeyError: self._downloader.trouble('Invalid rendition field.') return
info = { 'id': video_id, 'url': video_url, 'uploader': performer, 'upload_date': None, 'title': video_title, 'ext': ext, 'format': format, }
return [info]
"""Report webpage download."""
"""Report information extraction."""
#return ''.join(mixed)
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err)) return
format = 'hd2' else: elif format == 'worst': format = 'mp4' ext = u'mp4' else: format = 'flv' ext = u'flv'
except (UnicodeDecodeError, ValueError, KeyError): self._downloader.trouble(u'ERROR: unable to extract info section') return
#column 8,9 of fileid represent the segment number #fileid[7:9] should be changed
'id': '%s_part%02d' % (video_id, index), 'url': download_url, 'uploader': None, 'upload_date': None, 'title': video_title, 'ext': ext, }
"""Information extractor for xnxx.com"""
"""Report information extraction"""
"""Report information extraction""" self._downloader.to_screen(u'[%s] %s: Extracting information' % (self.IE_NAME, video_id))
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
# Get webpage content except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download video webpage: %s' % err) return
self._downloader.trouble(u'ERROR: unable to extract video url') return
self._downloader.trouble(u'ERROR: unable to extract video title') return
self._downloader.trouble(u'ERROR: unable to extract video thumbnail') return
'id': video_id, 'url': video_url, 'uploader': None, 'upload_date': None, 'title': video_title, 'ext': 'flv', 'thumbnail': video_thumbnail, 'description': None, }]
"""Information extractor for plus.google.com."""
"""Report downloading extry"""
"""Report downloading extry"""
"""Report downloading extry"""
"""Report downloading extry"""
"""Report information extraction."""
# Extract id from URL self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) return
# Step 1, Retrieve post webpage to extract further information except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: Unable to retrieve entry webpage: %s' % compat_str(err)) return
# Extract update date # Convert timestring to a format suitable for filename
# Extract uploader
# Extract title # Get the first line for title
# Step 2, Stimulate clicking the image box to launch video self._downloader.trouble(u'ERROR: unable to extract video page URL')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: Unable to retrieve video webpage: %s' % compat_str(err)) return
# Extract video links on video page """Extract video links of all sizes""" self._downloader.trouble(u'ERROR: unable to extract video links')
# Sort in resolution
# Choose the lowest of the sort, i.e. highest resolution # Only get the url. The resolution part in the tuple has no use anymore # Treat escaped \u0026 style hex except AttributeError: # Python 3 video_url = bytes(video_url, 'ascii').decode('unicode-escape')
'id': video_id, 'url': video_url, 'uploader': uploader, 'upload_date': upload_date, 'title': video_title, 'ext': video_extension, }]
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
else:
'id': shortened_video_id, 'url': video_url, 'ext': 'mp4', 'title': title, 'uploader_date': _findProp(r'<b>Date:</b> (.*?)</div>'), 'description': _findProp(r'<div class="description">(.*?)</h1>'), }
"""Information extractor for justin.tv and twitch.tv""" # TODO: One broadcast may be split into multiple videos. The key # 'broadcast_id' is the same for all parts, and 'broadcast_part' # starts at 1 and increases. Can we treat all parts as one video?
([^/]+)(?:/b/([^/]+))?/?(?:\#.*)?$"""
"""Report information extraction."""
"""Report attempt to download a single page of videos.""" self._downloader.to_screen(u'[%s] %s: Downloading video information from %d to %d' % (self.IE_NAME, channel, offset, offset + self._JUSTIN_PAGE_LIMIT))
# Return count of items, list of *valid* items except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: self._downloader.trouble(u'ERROR: unable to download video info JSON: %s' % compat_str(err)) return
'id': clip['id'], 'url': video_url, 'title': clip['title'], 'uploader': clip.get('user_id', clip.get('channel_id')), 'upload_date': video_date, 'ext': video_extension, })
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
paged = True api += '/channel/archives/%s.json' else:
self.report_download_page(video_id, offset) offset += limit
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
self._downloader.trouble(u'ERROR: unable to find video information')
self._downloader.trouble(u'Cannot find video title')
else: desc = None
'id': video_id, 'url': video_url, 'ext': 'mp4', 'title': title, 'description': desc, }
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) return
self._downloader.trouble(u'ERROR: Cannot find status ID')
self._downloader.trouble(u'WARNING: Cannot find description')
self._downloader.trouble(u'ERROR: Cannot find uploader')
self._downloader.trouble(u'ERROR: Cannot find upload date')
'id': video_id, 'url': video_url, 'ext': 'mov', 'title': title, 'description': desc, 'uploader': uploader, 'uploader_id': uploader_id, 'internal_id': status_id, 'upload_date': upload_date }
(?P<urltype>video|app)/ #If the page is only for videos or for a game (?P<gameID>\d+)/? (?P<videoID>\d*)(?P<extra>\??) #For urltype == video we sometimes get the videoID """
"""Receives a URL and returns True if suitable for this IE."""
self._downloader.trouble(u'ERROR: Cannot find video url for %s' % video_id) 'id':video_id, 'url':video_url, 'ext': 'flv', 'title': title }
'id':video_id, 'url':video_url, 'ext': 'flv', 'title': title, 'uploader': uploader }
""" Return a list of an instance of every supported extractor. The order does matter; the first extractor matched is the one handling the URL. """ return [ YoutubePlaylistIE(), YoutubeChannelIE(), YoutubeUserIE(), YoutubeSearchIE(), YoutubeIE(), MetacafeIE(), DailymotionIE(), GoogleSearchIE(), PhotobucketIE(), YahooIE(), YahooSearchIE(), DepositFilesIE(), FacebookIE(), BlipTVUserIE(), BlipTVIE(), VimeoIE(), MyVideoIE(), ComedyCentralIE(), EscapistIE(), CollegeHumorIE(), XVideosIE(), SoundcloudIE(), InfoQIE(), MixcloudIE(), StanfordOpenClassroomIE(), MTVIE(), YoukuIE(), XNXXIE(), GooglePlusIE(), ArteTvIE(), NBAIE(), JustinTVIE(), FunnyOrDieIE(), TweetReelIE(), SteamIE(), UstreamIE(), GenericIE() ]
|