wxcafe/youtube-dl
1
0
Fork 0
mirror of https://code.hackerspace.pl/q3k/youtube-dl synced 2025-03-16 11:43:02 +00:00
Code Releases Activity

Use report_error in InfoExtractors.py

Browse Source 
Some calls haven't been changed
This commit is contained in:
Jaime Marquínez Ferrándiz 2013-03-04 15:56:14 +01:00
parent 6622d22c79
commit e5f30ade10
1 changed files with 150 additions and 150 deletions

300
youtube_dl/InfoExtractors.py

@ -388,13 +388,13 @@ class YoutubeIE(InfoExtractor):
self.report_age_confirmation() self.report_age_confirmation()
age_results = compat_urllib_request.urlopen(request).read().decode('utf-8') age_results = compat_urllib_request.urlopen(request).read().decode('utf-8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to confirm age: %s' % compat_str(err))
return return
def _extract_id(self, url): def _extract_id(self, url):
mobj = re.match(self._VALID_URL, url, re.VERBOSE) mobj = re.match(self._VALID_URL, url, re.VERBOSE)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
video_id = mobj.group(2) video_id = mobj.group(2)
return video_id return video_id
@ -413,7 +413,7 @@ class YoutubeIE(InfoExtractor):
try: try:
video_webpage_bytes = compat_urllib_request.urlopen(request).read() video_webpage_bytes = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download video webpage: %s' % compat_str(err))
return return
video_webpage = video_webpage_bytes.decode('utf-8', 'ignore') video_webpage = video_webpage_bytes.decode('utf-8', 'ignore')
@ -438,18 +438,18 @@ class YoutubeIE(InfoExtractor):
if 'token' in video_info: if 'token' in video_info:
break break
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download video info webpage: %s' % compat_str(err))
return return
if 'token' not in video_info: if 'token' not in video_info:
if 'reason' in video_info: if 'reason' in video_info:
self._downloader.trouble(u'ERROR: YouTube said: %s' % video_info['reason'][0]) self._downloader.report_error(u'YouTube said: %s' % video_info['reason'][0])
else: else:
self._downloader.trouble(u'ERROR: "token" parameter not in video info for unknown reason') self._downloader.report_error(u'"token" parameter not in video info for unknown reason')
return return
# Check for "rental" videos # Check for "rental" videos
if 'ypc_video_rental_bar_text' in video_info and 'author' not in video_info: if 'ypc_video_rental_bar_text' in video_info and 'author' not in video_info:
self._downloader.trouble(u'ERROR: "rental" videos not supported') self._downloader.report_error(u'"rental" videos not supported')
return return
# Start extracting information # Start extracting information
@ -457,7 +457,7 @@ class YoutubeIE(InfoExtractor):
# uploader # uploader
if 'author' not in video_info: if 'author' not in video_info:
self._downloader.trouble(u'ERROR: unable to extract uploader name') self._downloader.report_error(u'unable to extract uploader name')
return return
video_uploader = compat_urllib_parse.unquote_plus(video_info['author'][0]) video_uploader = compat_urllib_parse.unquote_plus(video_info['author'][0])
@ -471,7 +471,7 @@ class YoutubeIE(InfoExtractor):
# title # title
if 'title' not in video_info: if 'title' not in video_info:
self._downloader.trouble(u'ERROR: unable to extract video title') self._downloader.report_error(u'unable to extract video title')
return return
video_title = compat_urllib_parse.unquote_plus(video_info['title'][0]) video_title = compat_urllib_parse.unquote_plus(video_info['title'][0])
@ -537,7 +537,7 @@ class YoutubeIE(InfoExtractor):
format_list = available_formats format_list = available_formats
existing_formats = [x for x in format_list if x in url_map] existing_formats = [x for x in format_list if x in url_map]
if len(existing_formats) == 0: if len(existing_formats) == 0:
self._downloader.trouble(u'ERROR: no known formats available for video') self._downloader.report_error(u'no known formats available for video')
return return
if self._downloader.params.get('listformats', None): if self._downloader.params.get('listformats', None):
self._print_formats(existing_formats) self._print_formats(existing_formats)
@ -558,10 +558,10 @@ class YoutubeIE(InfoExtractor):
video_url_list = [(rf, url_map[rf])] video_url_list = [(rf, url_map[rf])]
break break
if video_url_list is None: if video_url_list is None:
self._downloader.trouble(u'ERROR: requested format not available') self._downloader.report_error(u'requested format not available')
return return
else: else:
self._downloader.trouble(u'ERROR: no conn or url_encoded_fmt_stream_map information found in video info') self._downloader.report_error(u'no conn or url_encoded_fmt_stream_map information found in video info')
return return
results = [] results = []
@ -624,7 +624,7 @@ class MetacafeIE(InfoExtractor):
self.report_disclaimer() self.report_disclaimer()
disclaimer = compat_urllib_request.urlopen(request).read() disclaimer = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to retrieve disclaimer: %s' % compat_str(err))
return return
# Confirm age # Confirm age
@ -637,14 +637,14 @@ class MetacafeIE(InfoExtractor):
self.report_age_confirmation() self.report_age_confirmation()
disclaimer = compat_urllib_request.urlopen(request).read() disclaimer = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to confirm age: %s' % compat_str(err))
return return
def _real_extract(self, url): def _real_extract(self, url):
# Extract id and simplified title from URL # Extract id and simplified title from URL
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
video_id = mobj.group(1) video_id = mobj.group(1)
@ -661,7 +661,7 @@ class MetacafeIE(InfoExtractor):
self.report_download_webpage(video_id) self.report_download_webpage(video_id)
webpage = compat_urllib_request.urlopen(request).read() webpage = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable retrieve video webpage: %s' % compat_str(err))
return return
# Extract URL, uploader and title from webpage # Extract URL, uploader and title from webpage
@ -681,15 +681,15 @@ class MetacafeIE(InfoExtractor):
else: else:
mobj = re.search(r' name="flashvars" value="(.*?)"', webpage) mobj = re.search(r' name="flashvars" value="(.*?)"', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract media URL') self._downloader.report_error(u'unable to extract media URL')
return return
vardict = compat_parse_qs(mobj.group(1)) vardict = compat_parse_qs(mobj.group(1))
if 'mediaData' not in vardict: if 'mediaData' not in vardict:
self._downloader.trouble(u'ERROR: unable to extract media URL') self._downloader.report_error(u'unable to extract media URL')
return return
mobj = re.search(r'"mediaURL":"(http.*?)","key":"(.*?)"', vardict['mediaData'][0]) mobj = re.search(r'"mediaURL":"(http.*?)","key":"(.*?)"', vardict['mediaData'][0])
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract media URL') self._downloader.report_error(u'unable to extract media URL')
return return
mediaURL = mobj.group(1).replace('\\/', '/') mediaURL = mobj.group(1).replace('\\/', '/')
video_extension = mediaURL[-3:] video_extension = mediaURL[-3:]
@ -697,13 +697,13 @@ class MetacafeIE(InfoExtractor):
mobj = re.search(r'(?im)<title>(.*) - Video</title>', webpage) mobj = re.search(r'(?im)<title>(.*) - Video</title>', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract title') self._downloader.report_error(u'unable to extract title')
return return
video_title = mobj.group(1).decode('utf-8') video_title = mobj.group(1).decode('utf-8')
mobj = re.search(r'submitter=(.*?);', webpage) mobj = re.search(r'submitter=(.*?);', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract uploader nickname') self._downloader.report_error(u'unable to extract uploader nickname')
return return
video_uploader = mobj.group(1) video_uploader = mobj.group(1)
@ -735,7 +735,7 @@ class DailymotionIE(InfoExtractor):
# Extract id and simplified title from URL # Extract id and simplified title from URL
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
video_id = mobj.group(1).split('_')[0].split('?')[0] video_id = mobj.group(1).split('_')[0].split('?')[0]
@ -751,7 +751,7 @@ class DailymotionIE(InfoExtractor):
self.report_extraction(video_id) self.report_extraction(video_id)
mobj = re.search(r'\s*var flashvars = (.*)', webpage) mobj = re.search(r'\s*var flashvars = (.*)', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract media URL') self._downloader.report_error(u'unable to extract media URL')
return return
flashvars = compat_urllib_parse.unquote(mobj.group(1)) flashvars = compat_urllib_parse.unquote(mobj.group(1))
@ -761,12 +761,12 @@ class DailymotionIE(InfoExtractor):
self._downloader.to_screen(u'[dailymotion] Using %s' % key) self._downloader.to_screen(u'[dailymotion] Using %s' % key)
break break
else: else:
self._downloader.trouble(u'ERROR: unable to extract video URL') self._downloader.report_error(u'unable to extract video URL')
return return
mobj = re.search(r'"' + max_quality + r'":"(.+?)"', flashvars) mobj = re.search(r'"' + max_quality + r'":"(.+?)"', flashvars)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract video URL') self._downloader.report_error(u'unable to extract video URL')
return return
video_url = compat_urllib_parse.unquote(mobj.group(1)).replace('\\/', '/') video_url = compat_urllib_parse.unquote(mobj.group(1)).replace('\\/', '/')
@ -775,7 +775,7 @@ class DailymotionIE(InfoExtractor):
mobj = re.search(r'<meta property="og:title" content="(?P<title>[^"]*)" />', webpage) mobj = re.search(r'<meta property="og:title" content="(?P<title>[^"]*)" />', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract title') self._downloader.report_error(u'unable to extract title')
return return
video_title = unescapeHTML(mobj.group('title')) video_title = unescapeHTML(mobj.group('title'))
@ -827,7 +827,7 @@ class PhotobucketIE(InfoExtractor):
# Extract id from URL # Extract id from URL
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) self._downloader.report_error(u'Invalid URL: %s' % url)
return return
video_id = mobj.group(1) video_id = mobj.group(1)
@ -840,14 +840,14 @@ class PhotobucketIE(InfoExtractor):
self.report_download_webpage(video_id) self.report_download_webpage(video_id)
webpage = compat_urllib_request.urlopen(request).read() webpage = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
return return
# Extract URL, uploader, and title from webpage # Extract URL, uploader, and title from webpage
self.report_extraction(video_id) self.report_extraction(video_id)
mobj = re.search(r'<link rel="video_src" href=".*\?file=([^"]+)" />', webpage) mobj = re.search(r'<link rel="video_src" href=".*\?file=([^"]+)" />', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract media URL') self._downloader.report_error(u'unable to extract media URL')
return return
mediaURL = compat_urllib_parse.unquote(mobj.group(1)) mediaURL = compat_urllib_parse.unquote(mobj.group(1))
@ -855,7 +855,7 @@ class PhotobucketIE(InfoExtractor):
mobj = re.search(r'<title>(.*) video by (.*) - Photobucket</title>', webpage) mobj = re.search(r'<title>(.*) video by (.*) - Photobucket</title>', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract title') self._downloader.report_error(u'unable to extract title')
return return
video_title = mobj.group(1).decode('utf-8') video_title = mobj.group(1).decode('utf-8')
@ -896,7 +896,7 @@ class YahooIE(InfoExtractor):
# Extract ID from URL # Extract ID from URL
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) self._downloader.report_error(u'Invalid URL: %s' % url)
return return
video_id = mobj.group(2) video_id = mobj.group(2)
@ -909,18 +909,18 @@ class YahooIE(InfoExtractor):
try: try:
webpage = compat_urllib_request.urlopen(request).read() webpage = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
return return
mobj = re.search(r'\("id", "([0-9]+)"\);', webpage) mobj = re.search(r'\("id", "([0-9]+)"\);', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: Unable to extract id field') self._downloader.report_error(u'Unable to extract id field')
return return
yahoo_id = mobj.group(1) yahoo_id = mobj.group(1)
mobj = re.search(r'\("vid", "([0-9]+)"\);', webpage) mobj = re.search(r'\("vid", "([0-9]+)"\);', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: Unable to extract vid field') self._downloader.report_error(u'Unable to extract vid field')
return return
yahoo_vid = mobj.group(1) yahoo_vid = mobj.group(1)
@ -933,34 +933,34 @@ class YahooIE(InfoExtractor):
self.report_download_webpage(video_id) self.report_download_webpage(video_id)
webpage = compat_urllib_request.urlopen(request).read() webpage = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
return return
# Extract uploader and title from webpage # Extract uploader and title from webpage
self.report_extraction(video_id) self.report_extraction(video_id)
mobj = re.search(r'<meta name="title" content="(.*)" />', webpage) mobj = re.search(r'<meta name="title" content="(.*)" />', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract video title') self._downloader.report_error(u'unable to extract video title')
return return
video_title = mobj.group(1).decode('utf-8') 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) 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: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract video uploader') self._downloader.report_error(u'unable to extract video uploader')
return return
video_uploader = mobj.group(1).decode('utf-8') video_uploader = mobj.group(1).decode('utf-8')
# Extract video thumbnail # Extract video thumbnail
mobj = re.search(r'<link rel="image_src" href="(.*)" />', webpage) mobj = re.search(r'<link rel="image_src" href="(.*)" />', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract video thumbnail') self._downloader.report_error(u'unable to extract video thumbnail')
return return
video_thumbnail = mobj.group(1).decode('utf-8') video_thumbnail = mobj.group(1).decode('utf-8')
# Extract video description # Extract video description
mobj = re.search(r'<meta name="description" content="(.*)" />', webpage) mobj = re.search(r'<meta name="description" content="(.*)" />', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract video description') self._downloader.report_error(u'unable to extract video description')
return return
video_description = mobj.group(1).decode('utf-8') video_description = mobj.group(1).decode('utf-8')
if not video_description: if not video_description:
@ -969,13 +969,13 @@ class YahooIE(InfoExtractor):
# Extract video height and width # Extract video height and width
mobj = re.search(r'<meta name="video_height" content="([0-9]+)" />', webpage) mobj = re.search(r'<meta name="video_height" content="([0-9]+)" />', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract video height') self._downloader.report_error(u'unable to extract video height')
return return
yv_video_height = mobj.group(1) yv_video_height = mobj.group(1)
mobj = re.search(r'<meta name="video_width" content="([0-9]+)" />', webpage) mobj = re.search(r'<meta name="video_width" content="([0-9]+)" />', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract video width') self._downloader.report_error(u'unable to extract video width')
return return
yv_video_width = mobj.group(1) yv_video_width = mobj.group(1)
@ -991,13 +991,13 @@ class YahooIE(InfoExtractor):
self.report_download_webpage(video_id) self.report_download_webpage(video_id)
webpage = compat_urllib_request.urlopen(request).read() webpage = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
return return
# Extract media URL from playlist XML # Extract media URL from playlist XML
mobj = re.search(r'<STREAM APP="(http://.*)" FULLPATH="/?(/.*\.flv\?[^"]*)"', webpage) mobj = re.search(r'<STREAM APP="(http://.*)" FULLPATH="/?(/.*\.flv\?[^"]*)"', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: Unable to extract media URL') self._downloader.report_error(u'Unable to extract media URL')
return return
video_url = compat_urllib_parse.unquote(mobj.group(1) + mobj.group(2)).decode('utf-8') video_url = compat_urllib_parse.unquote(mobj.group(1) + mobj.group(2)).decode('utf-8')
video_url = unescapeHTML(video_url) video_url = unescapeHTML(video_url)
@ -1036,7 +1036,7 @@ class VimeoIE(InfoExtractor):
# Extract ID from URL # Extract ID from URL
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) self._downloader.report_error(u'Invalid URL: %s' % url)
return return
video_id = mobj.group('id') video_id = mobj.group('id')
@ -1052,7 +1052,7 @@ class VimeoIE(InfoExtractor):
webpage_bytes = compat_urllib_request.urlopen(request).read() webpage_bytes = compat_urllib_request.urlopen(request).read()
webpage = webpage_bytes.decode('utf-8') webpage = webpage_bytes.decode('utf-8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
return return
# Now we begin extracting as much information as we can from what we # Now we begin extracting as much information as we can from what we
@ -1065,7 +1065,7 @@ class VimeoIE(InfoExtractor):
config = webpage.split(' = {config:')[1].split(',assets:')[0] config = webpage.split(' = {config:')[1].split(',assets:')[0]
config = json.loads(config) config = json.loads(config)
except: except:
self._downloader.trouble(u'ERROR: unable to extract info section') self._downloader.report_error(u'unable to extract info section')
return return
# Extract title # Extract title
@ -1115,7 +1115,7 @@ class VimeoIE(InfoExtractor):
self._downloader.to_screen(u'[vimeo] %s: Downloading %s file at %s quality' % (video_id, video_codec.upper(), video_quality)) self._downloader.to_screen(u'[vimeo] %s: Downloading %s file at %s quality' % (video_id, video_codec.upper(), video_quality))
break break
else: else:
self._downloader.trouble(u'ERROR: no known codec found') self._downloader.report_error(u'no known codec found')
return return
video_url = "http://player.vimeo.com/play_redirect?clip_id=%s&sig=%s&time=%s&quality=%s&codecs=%s&type=moogaloop_local&embed_location=" \ video_url = "http://player.vimeo.com/play_redirect?clip_id=%s&sig=%s&time=%s&quality=%s&codecs=%s&type=moogaloop_local&embed_location=" \
@ -1159,10 +1159,10 @@ class ArteTvIE(InfoExtractor):
self.report_download_webpage(url) self.report_download_webpage(url)
webpage = compat_urllib_request.urlopen(request).read() webpage = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
return return
except ValueError as err: except ValueError as err:
self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) self._downloader.report_error(u'Invalid URL: %s' % url)
return return
return webpage return webpage
@ -1172,7 +1172,7 @@ class ArteTvIE(InfoExtractor):
info = {} info = {}
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) self._downloader.report_error(u'Invalid URL: %s' % url)
return return
for (i, key, err) in matchTuples: for (i, key, err) in matchTuples:
@ -1356,12 +1356,12 @@ class GenericIE(InfoExtractor):
self.report_download_webpage(video_id) self.report_download_webpage(video_id)
webpage = compat_urllib_request.urlopen(request).read() webpage = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
return return
except ValueError as err: except ValueError as err:
# since this is the last-resort InfoExtractor, if # since this is the last-resort InfoExtractor, if
# this error is thrown, it'll be thrown here # this error is thrown, it'll be thrown here
self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) self._downloader.report_error(u'Invalid URL: %s' % url)
return return
self.report_extraction(video_id) self.report_extraction(video_id)
@ -1374,13 +1374,13 @@ class GenericIE(InfoExtractor):
# Broaden the search a little bit: JWPlayer JS loader # Broaden the search a little bit: JWPlayer JS loader
mobj = re.search(r'[^A-Za-z0-9]?file:\s*["\'](http[^\'"&]*)', webpage) mobj = re.search(r'[^A-Za-z0-9]?file:\s*["\'](http[^\'"&]*)', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) self._downloader.report_error(u'Invalid URL: %s' % url)
return return
# It's possible that one of the regexes # It's possible that one of the regexes
# matched, but returned an empty group: # matched, but returned an empty group:
if mobj.group(1) is None: if mobj.group(1) is None:
self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) self._downloader.report_error(u'Invalid URL: %s' % url)
return return
video_url = compat_urllib_parse.unquote(mobj.group(1)) video_url = compat_urllib_parse.unquote(mobj.group(1))
@ -1398,14 +1398,14 @@ class GenericIE(InfoExtractor):
# and so on and so forth; it's just not practical # and so on and so forth; it's just not practical
mobj = re.search(r'<title>(.*)</title>', webpage) mobj = re.search(r'<title>(.*)</title>', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract title') self._downloader.report_error(u'unable to extract title')
return return
video_title = mobj.group(1) video_title = mobj.group(1)
# video uploader is domain name # video uploader is domain name
mobj = re.match(r'(?:https?://)?([^/]*)/.*', url) mobj = re.match(r'(?:https?://)?([^/]*)/.*', url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract title') self._downloader.report_error(u'unable to extract title')
return return
video_uploader = mobj.group(1) video_uploader = mobj.group(1)
@ -1437,7 +1437,7 @@ class YoutubeSearchIE(InfoExtractor):
def _real_extract(self, query): def _real_extract(self, query):
mobj = re.match(self._VALID_URL, query) mobj = re.match(self._VALID_URL, query)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid search query "%s"' % query) self._downloader.report_error(u'invalid search query "%s"' % query)
return return
prefix, query = query.split(':') prefix, query = query.split(':')
@ -1453,7 +1453,7 @@ class YoutubeSearchIE(InfoExtractor):
try: try:
n = int(prefix) n = int(prefix)
if n <= 0: if n <= 0:
self._downloader.trouble(u'ERROR: invalid download number %s for query "%s"' % (n, query)) self._downloader.report_error(u'invalid download number %s for query "%s"' % (n, query))
return return
elif n > self._max_youtube_results: elif n > self._max_youtube_results:
self._downloader.report_warning(u'ytsearch returns max %i results (you requested %i)' % (self._max_youtube_results, n)) self._downloader.report_warning(u'ytsearch returns max %i results (you requested %i)' % (self._max_youtube_results, n))
@ -1478,7 +1478,7 @@ class YoutubeSearchIE(InfoExtractor):
try: try:
data = compat_urllib_request.urlopen(request).read().decode('utf-8') data = compat_urllib_request.urlopen(request).read().decode('utf-8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download API page: %s' % compat_str(err))
return return
api_response = json.loads(data)['data'] api_response = json.loads(data)['data']
@ -1519,7 +1519,7 @@ class GoogleSearchIE(InfoExtractor):
def _real_extract(self, query): def _real_extract(self, query):
mobj = re.match(self._VALID_URL, query) mobj = re.match(self._VALID_URL, query)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid search query "%s"' % query) self._downloader.report_error(u'invalid search query "%s"' % query)
return return
prefix, query = query.split(':') prefix, query = query.split(':')
@ -1535,7 +1535,7 @@ class GoogleSearchIE(InfoExtractor):
try: try:
n = int(prefix) n = int(prefix)
if n <= 0: if n <= 0:
self._downloader.trouble(u'ERROR: invalid download number %s for query "%s"' % (n, query)) self._downloader.report_error(u'invalid download number %s for query "%s"' % (n, query))
return return
elif n > self._max_google_results: elif n > self._max_google_results:
self._downloader.report_warning(u'gvsearch returns max %i results (you requested %i)' % (self._max_google_results, n)) self._downloader.report_warning(u'gvsearch returns max %i results (you requested %i)' % (self._max_google_results, n))
@ -1559,7 +1559,7 @@ class GoogleSearchIE(InfoExtractor):
try: try:
page = compat_urllib_request.urlopen(request).read() page = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
return return
# Extract video identifiers # Extract video identifiers
@ -1603,7 +1603,7 @@ class YahooSearchIE(InfoExtractor):
def _real_extract(self, query): def _real_extract(self, query):
mobj = re.match(self._VALID_URL, query) mobj = re.match(self._VALID_URL, query)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid search query "%s"' % query) self._downloader.report_error(u'invalid search query "%s"' % query)
return return
prefix, query = query.split(':') prefix, query = query.split(':')
@ -1619,7 +1619,7 @@ class YahooSearchIE(InfoExtractor):
try: try:
n = int(prefix) n = int(prefix)
if n <= 0: if n <= 0:
self._downloader.trouble(u'ERROR: invalid download number %s for query "%s"' % (n, query)) self._downloader.report_error(u'invalid download number %s for query "%s"' % (n, query))
return return
elif n > self._max_yahoo_results: elif n > self._max_yahoo_results:
self._downloader.report_warning(u'yvsearch returns max %i results (you requested %i)' % (self._max_yahoo_results, n)) self._downloader.report_warning(u'yvsearch returns max %i results (you requested %i)' % (self._max_yahoo_results, n))
@ -1644,7 +1644,7 @@ class YahooSearchIE(InfoExtractor):
try: try:
page = compat_urllib_request.urlopen(request).read() page = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
return return
# Extract video identifiers # Extract video identifiers
@ -1706,7 +1706,7 @@ class YoutubePlaylistIE(InfoExtractor):
# Extract playlist id # Extract playlist id
mobj = re.match(self._VALID_URL, url, re.VERBOSE) mobj = re.match(self._VALID_URL, url, re.VERBOSE)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid url: %s' % url) self._downloader.report_error(u'invalid url: %s' % url)
return return
# Download playlist videos from API # Download playlist videos from API
@ -1721,17 +1721,17 @@ class YoutubePlaylistIE(InfoExtractor):
try: try:
page = compat_urllib_request.urlopen(url).read().decode('utf8') page = compat_urllib_request.urlopen(url).read().decode('utf8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
return return
try: try:
response = json.loads(page) response = json.loads(page)
except ValueError as err: except ValueError as err:
self._downloader.trouble(u'ERROR: Invalid JSON in API response: ' + compat_str(err)) self._downloader.report_error(u'Invalid JSON in API response: ' + compat_str(err))
return return
if not 'feed' in response or not 'entry' in response['feed']: if not 'feed' in response or not 'entry' in response['feed']:
self._downloader.trouble(u'ERROR: Got a malformed response from YouTube API') self._downloader.report_error(u'Got a malformed response from YouTube API')
return return
videos += [ (entry['yt$position']['$t'], entry['content']['src']) videos += [ (entry['yt$position']['$t'], entry['content']['src'])
for entry in response['feed']['entry'] for entry in response['feed']['entry']
@ -1777,7 +1777,7 @@ class YoutubeChannelIE(InfoExtractor):
# Extract channel id # Extract channel id
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid url: %s' % url) self._downloader.report_error(u'invalid url: %s' % url)
return return
# Download channel pages # Download channel pages
@ -1792,7 +1792,7 @@ class YoutubeChannelIE(InfoExtractor):
try: try:
page = compat_urllib_request.urlopen(request).read().decode('utf8') page = compat_urllib_request.urlopen(request).read().decode('utf8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
return return
# Extract video identifiers # Extract video identifiers
@ -1835,7 +1835,7 @@ class YoutubeUserIE(InfoExtractor):
# Extract username # Extract username
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid url: %s' % url) self._downloader.report_error(u'invalid url: %s' % url)
return return
username = mobj.group(1) username = mobj.group(1)
@ -1857,7 +1857,7 @@ class YoutubeUserIE(InfoExtractor):
try: try:
page = compat_urllib_request.urlopen(request).read().decode('utf-8') page = compat_urllib_request.urlopen(request).read().decode('utf-8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
return return
# Extract video identifiers # Extract video identifiers
@ -1915,7 +1915,7 @@ class BlipTVUserIE(InfoExtractor):
# Extract username # Extract username
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid url: %s' % url) self._downloader.report_error(u'invalid url: %s' % url)
return return
username = mobj.group(1) username = mobj.group(1)
@ -1929,7 +1929,7 @@ class BlipTVUserIE(InfoExtractor):
mobj = re.search(r'data-users-id="([^"]+)"', page) mobj = re.search(r'data-users-id="([^"]+)"', page)
page_base = page_base % mobj.group(1) page_base = page_base % mobj.group(1)
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
return return
@ -1948,7 +1948,7 @@ class BlipTVUserIE(InfoExtractor):
try: try:
page = compat_urllib_request.urlopen(request).read().decode('utf-8') page = compat_urllib_request.urlopen(request).read().decode('utf-8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download webpage: %s' % str(err))
return return
# Extract video identifiers # Extract video identifiers
@ -2012,7 +2012,7 @@ class DepositFilesIE(InfoExtractor):
self.report_download_webpage(file_id) self.report_download_webpage(file_id)
webpage = compat_urllib_request.urlopen(request).read() webpage = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'Unable to retrieve file webpage: %s' % compat_str(err))
return return
# Search for the real file URL # Search for the real file URL
@ -2022,9 +2022,9 @@ class DepositFilesIE(InfoExtractor):
mobj = re.search(r'<strong>(Attention.*?)</strong>', webpage, re.DOTALL) mobj = re.search(r'<strong>(Attention.*?)</strong>', webpage, re.DOTALL)
if (mobj is not None) and (mobj.group(1) is not None): if (mobj is not None) and (mobj.group(1) is not None):
restriction_message = re.sub('\s+', ' ', mobj.group(1)).strip() restriction_message = re.sub('\s+', ' ', mobj.group(1)).strip()
self._downloader.trouble(u'ERROR: %s' % restriction_message) self._downloader.report_error(u'%s' % restriction_message)
else: else:
self._downloader.trouble(u'ERROR: unable to extract download URL from: %s' % url) self._downloader.report_error(u'unable to extract download URL from: %s' % url)
return return
file_url = mobj.group(1) file_url = mobj.group(1)
@ -2033,7 +2033,7 @@ class DepositFilesIE(InfoExtractor):
# Search for file title # Search for file title
mobj = re.search(r'<b title="(.*?)">', webpage) mobj = re.search(r'<b title="(.*?)">', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract title') self._downloader.report_error(u'unable to extract title')
return return
file_title = mobj.group(1).decode('utf-8') file_title = mobj.group(1).decode('utf-8')
@ -2106,7 +2106,7 @@ class FacebookIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
video_id = mobj.group('ID') video_id = mobj.group('ID')
@ -2162,7 +2162,7 @@ class BlipTVIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
urlp = compat_urllib_parse_urlparse(url) urlp = compat_urllib_parse_urlparse(url)
@ -2209,7 +2209,7 @@ class BlipTVIE(InfoExtractor):
json_code_bytes = urlh.read() json_code_bytes = urlh.read()
json_code = json_code_bytes.decode('utf-8') json_code = json_code_bytes.decode('utf-8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to read video info webpage: %s' % compat_str(err))
return return
try: try:
@ -2240,7 +2240,7 @@ class BlipTVIE(InfoExtractor):
'user_agent': 'iTunes/10.6.1', 'user_agent': 'iTunes/10.6.1',
} }
except (ValueError,KeyError) as err: except (ValueError,KeyError) as err:
self._downloader.trouble(u'ERROR: unable to parse video information: %s' % repr(err)) self._downloader.report_error(u'unable to parse video information: %s' % repr(err))
return return
return [info] return [info]
@ -2262,7 +2262,7 @@ class MyVideoIE(InfoExtractor):
def _real_extract(self,url): def _real_extract(self,url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._download.trouble(u'ERROR: invalid URL: %s' % url) self._download.report_error(u'invalid URL: %s' % url)
return return
video_id = mobj.group(1) video_id = mobj.group(1)
@ -2275,13 +2275,13 @@ class MyVideoIE(InfoExtractor):
mobj = re.search(r'<link rel=\'image_src\' href=\'(http://is[0-9].myvideo\.de/de/movie[0-9]+/[a-f0-9]+)/thumbs/.*?\.jpg\' />', mobj = re.search(r'<link rel=\'image_src\' href=\'(http://is[0-9].myvideo\.de/de/movie[0-9]+/[a-f0-9]+)/thumbs/.*?\.jpg\' />',
webpage) webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract media URL') self._downloader.report_error(u'unable to extract media URL')
return return
video_url = mobj.group(1) + ('/%s.flv' % video_id) video_url = mobj.group(1) + ('/%s.flv' % video_id)
mobj = re.search('<title>([^<]+)</title>', webpage) mobj = re.search('<title>([^<]+)</title>', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract title') self._downloader.report_error(u'unable to extract title')
return return
video_title = mobj.group(1) video_title = mobj.group(1)
@ -2354,7 +2354,7 @@ class ComedyCentralIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url, re.VERBOSE) mobj = re.match(self._VALID_URL, url, re.VERBOSE)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
if mobj.group('shortname'): if mobj.group('shortname'):
@ -2385,16 +2385,16 @@ class ComedyCentralIE(InfoExtractor):
html = htmlHandle.read() html = htmlHandle.read()
webpage = html.decode('utf-8') webpage = html.decode('utf-8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
return return
if dlNewest: if dlNewest:
url = htmlHandle.geturl() url = htmlHandle.geturl()
mobj = re.match(self._VALID_URL, url, re.VERBOSE) mobj = re.match(self._VALID_URL, url, re.VERBOSE)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: Invalid redirected URL: ' + url) self._downloader.report_error(u'Invalid redirected URL: ' + url)
return return
if mobj.group('episode') == '': if mobj.group('episode') == '':
self._downloader.trouble(u'ERROR: Redirected URL is still not specific: ' + url) self._downloader.report_error(u'Redirected URL is still not specific: ' + url)
return return
epTitle = mobj.group('episode') epTitle = mobj.group('episode')
@ -2407,7 +2407,7 @@ class ComedyCentralIE(InfoExtractor):
altMovieParams = re.findall('data-mgid="([^"]*(?:episode|video).*?:.*?)"', webpage) altMovieParams = re.findall('data-mgid="([^"]*(?:episode|video).*?:.*?)"', webpage)
if len(altMovieParams) == 0: if len(altMovieParams) == 0:
self._downloader.trouble(u'ERROR: unable to find Flash URL in webpage ' + url) self._downloader.report_error(u'unable to find Flash URL in webpage ' + url)
return return
else: else:
mMovieParams = [("http://media.mtvnservices.com/" + altMovieParams[0], altMovieParams[0])] mMovieParams = [("http://media.mtvnservices.com/" + altMovieParams[0], altMovieParams[0])]
@ -2418,7 +2418,7 @@ class ComedyCentralIE(InfoExtractor):
try: try:
indexXml = compat_urllib_request.urlopen(indexUrl).read() indexXml = compat_urllib_request.urlopen(indexUrl).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download episode index: ' + compat_str(err))
return return
results = [] results = []
@ -2439,7 +2439,7 @@ class ComedyCentralIE(InfoExtractor):
try: try:
configXml = compat_urllib_request.urlopen(configReq).read() configXml = compat_urllib_request.urlopen(configReq).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download webpage: %s' % compat_str(err))
return return
cdoc = xml.etree.ElementTree.fromstring(configXml) cdoc = xml.etree.ElementTree.fromstring(configXml)
@ -2506,7 +2506,7 @@ class EscapistIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
showName = mobj.group('showname') showName = mobj.group('showname')
videoId = mobj.group('episode') videoId = mobj.group('episode')
@ -2518,7 +2518,7 @@ class EscapistIE(InfoExtractor):
m = re.match(r'text/html; charset="?([^"]+)"?', webPage.headers['Content-Type']) m = re.match(r'text/html; charset="?([^"]+)"?', webPage.headers['Content-Type'])
webPage = webPageBytes.decode(m.group(1) if m else 'utf-8') webPage = webPageBytes.decode(m.group(1) if m else 'utf-8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download webpage: ' + compat_str(err))
return return
descMatch = re.search('<meta name="description" content="([^"]*)"', webPage) descMatch = re.search('<meta name="description" content="([^"]*)"', webPage)
@ -2536,7 +2536,7 @@ class EscapistIE(InfoExtractor):
m = re.match(r'text/html; charset="?([^"]+)"?', configJSON.headers['Content-Type']) m = re.match(r'text/html; charset="?([^"]+)"?', configJSON.headers['Content-Type'])
configJSON = configJSON.read().decode(m.group(1) if m else 'utf-8') 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: 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)) self._downloader.report_error(u'unable to download configuration: ' + compat_str(err))
return return
# Technically, it's JavaScript, not JSON # Technically, it's JavaScript, not JSON
@ -2545,7 +2545,7 @@ class EscapistIE(InfoExtractor):
try: try:
config = json.loads(configJSON) config = json.loads(configJSON)
except (ValueError,) as err: except (ValueError,) as err:
self._downloader.trouble(u'ERROR: Invalid JSON in configuration file: ' + compat_str(err)) self._downloader.report_error(u'Invalid JSON in configuration file: ' + compat_str(err))
return return
playlist = config['playlist'] playlist = config['playlist']
@ -2583,7 +2583,7 @@ class CollegeHumorIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
video_id = mobj.group('videoid') video_id = mobj.group('videoid')
@ -2598,7 +2598,7 @@ class CollegeHumorIE(InfoExtractor):
try: try:
metaXml = compat_urllib_request.urlopen(xmlUrl).read() metaXml = compat_urllib_request.urlopen(xmlUrl).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download video info XML: %s' % compat_str(err))
return return
mdoc = xml.etree.ElementTree.fromstring(metaXml) mdoc = xml.etree.ElementTree.fromstring(metaXml)
@ -2617,7 +2617,7 @@ class CollegeHumorIE(InfoExtractor):
try: try:
manifestXml = compat_urllib_request.urlopen(manifest_url).read() manifestXml = compat_urllib_request.urlopen(manifest_url).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download video info XML: %s' % compat_str(err))
return return
adoc = xml.etree.ElementTree.fromstring(manifestXml) adoc = xml.etree.ElementTree.fromstring(manifestXml)
@ -2650,7 +2650,7 @@ class XVideosIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
video_id = mobj.group(1) video_id = mobj.group(1)
@ -2662,7 +2662,7 @@ class XVideosIE(InfoExtractor):
# Extract video URL # Extract video URL
mobj = re.search(r'flv_url=(.+?)&', webpage) mobj = re.search(r'flv_url=(.+?)&', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract video url') self._downloader.report_error(u'unable to extract video url')
return return
video_url = compat_urllib_parse.unquote(mobj.group(1)) video_url = compat_urllib_parse.unquote(mobj.group(1))
@ -2670,7 +2670,7 @@ class XVideosIE(InfoExtractor):
# Extract title # Extract title
mobj = re.search(r'<title>(.*?)\s+-\s+XVID', webpage) mobj = re.search(r'<title>(.*?)\s+-\s+XVID', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract video title') self._downloader.report_error(u'unable to extract video title')
return return
video_title = mobj.group(1) video_title = mobj.group(1)
@ -2678,7 +2678,7 @@ class XVideosIE(InfoExtractor):
# Extract video thumbnail # Extract video thumbnail
mobj = re.search(r'http://(?:img.*?\.)xvideos.com/videos/thumbs/[a-fA-F0-9]+/[a-fA-F0-9]+/[a-fA-F0-9]+/[a-fA-F0-9]+/([a-fA-F0-9.]+jpg)', webpage) mobj = re.search(r'http://(?:img.*?\.)xvideos.com/videos/thumbs/[a-fA-F0-9]+/[a-fA-F0-9]+/[a-fA-F0-9]+/[a-fA-F0-9]+/([a-fA-F0-9.]+jpg)', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract video thumbnail') self._downloader.report_error(u'unable to extract video thumbnail')
return return
video_thumbnail = mobj.group(0) video_thumbnail = mobj.group(0)
@ -2722,7 +2722,7 @@ class SoundcloudIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
# extract uploader (which is in the url) # extract uploader (which is in the url)
@ -2740,7 +2740,7 @@ class SoundcloudIE(InfoExtractor):
info_json_bytes = compat_urllib_request.urlopen(request).read() info_json_bytes = compat_urllib_request.urlopen(request).read()
info_json = info_json_bytes.decode('utf-8') info_json = info_json_bytes.decode('utf-8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download video webpage: %s' % compat_str(err))
return return
info = json.loads(info_json) info = json.loads(info_json)
@ -2753,7 +2753,7 @@ class SoundcloudIE(InfoExtractor):
stream_json_bytes = compat_urllib_request.urlopen(request).read() stream_json_bytes = compat_urllib_request.urlopen(request).read()
stream_json = stream_json_bytes.decode('utf-8') stream_json = stream_json_bytes.decode('utf-8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download stream definitions: %s' % compat_str(err))
return return
streams = json.loads(stream_json) streams = json.loads(stream_json)
@ -2781,7 +2781,7 @@ class InfoQIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
webpage = self._download_webpage(url, video_id=url) webpage = self._download_webpage(url, video_id=url)
@ -2790,7 +2790,7 @@ class InfoQIE(InfoExtractor):
# Extract video URL # Extract video URL
mobj = re.search(r"jsclassref='([^']*)'", webpage) mobj = re.search(r"jsclassref='([^']*)'", webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract video url') self._downloader.report_error(u'unable to extract video url')
return return
real_id = compat_urllib_parse.unquote(base64.b64decode(mobj.group(1).encode('ascii')).decode('utf-8')) real_id = compat_urllib_parse.unquote(base64.b64decode(mobj.group(1).encode('ascii')).decode('utf-8'))
video_url = 'rtmpe://video.infoq.com/cfx/st/' + real_id video_url = 'rtmpe://video.infoq.com/cfx/st/' + real_id
@ -2798,7 +2798,7 @@ class InfoQIE(InfoExtractor):
# Extract title # Extract title
mobj = re.search(r'contentTitle = "(.*?)";', webpage) mobj = re.search(r'contentTitle = "(.*?)";', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract video title') self._downloader.report_error(u'unable to extract video title')
return return
video_title = mobj.group(1) video_title = mobj.group(1)
@ -2881,7 +2881,7 @@ class MixcloudIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
# extract uploader & filename from url # extract uploader & filename from url
uploader = mobj.group(1).decode('utf-8') uploader = mobj.group(1).decode('utf-8')
@ -2895,7 +2895,7 @@ class MixcloudIE(InfoExtractor):
self.report_download_json(file_url) self.report_download_json(file_url)
jsonData = compat_urllib_request.urlopen(request).read() jsonData = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'Unable to retrieve file: %s' % compat_str(err))
return return
# parse JSON # parse JSON
@ -2919,7 +2919,7 @@ class MixcloudIE(InfoExtractor):
break # got it! break # got it!
else: else:
if req_format not in formats: if req_format not in formats:
self._downloader.trouble(u'ERROR: format is not available') self._downloader.report_error(u'format is not available')
return return
url_list = self.get_urls(formats, req_format) url_list = self.get_urls(formats, req_format)
@ -2973,7 +2973,7 @@ class StanfordOpenClassroomIE(InfoExtractor):
try: try:
metaXml = compat_urllib_request.urlopen(xmlUrl).read() metaXml = compat_urllib_request.urlopen(xmlUrl).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download video info XML: %s' % compat_str(err))
return return
mdoc = xml.etree.ElementTree.fromstring(metaXml) mdoc = xml.etree.ElementTree.fromstring(metaXml)
try: try:
@ -3032,7 +3032,7 @@ class StanfordOpenClassroomIE(InfoExtractor):
try: try:
rootpage = compat_urllib_request.urlopen(rootURL).read() rootpage = compat_urllib_request.urlopen(rootURL).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download course info page: ' + compat_str(err))
return return
info['title'] = info['id'] info['title'] = info['id']
@ -3064,7 +3064,7 @@ class MTVIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
if not mobj.group('proto'): if not mobj.group('proto'):
url = 'http://' + url url = 'http://' + url
@ -3074,25 +3074,25 @@ class MTVIE(InfoExtractor):
mobj = re.search(r'<meta name="mtv_vt" content="([^"]+)"/>', webpage) mobj = re.search(r'<meta name="mtv_vt" content="([^"]+)"/>', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract song name') self._downloader.report_error(u'unable to extract song name')
return return
song_name = unescapeHTML(mobj.group(1).decode('iso-8859-1')) song_name = unescapeHTML(mobj.group(1).decode('iso-8859-1'))
mobj = re.search(r'<meta name="mtv_an" content="([^"]+)"/>', webpage) mobj = re.search(r'<meta name="mtv_an" content="([^"]+)"/>', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract performer') self._downloader.report_error(u'unable to extract performer')
return return
performer = unescapeHTML(mobj.group(1).decode('iso-8859-1')) performer = unescapeHTML(mobj.group(1).decode('iso-8859-1'))
video_title = performer + ' - ' + song_name video_title = performer + ' - ' + song_name
mobj = re.search(r'<meta name="mtvn_uri" content="([^"]+)"/>', webpage) mobj = re.search(r'<meta name="mtvn_uri" content="([^"]+)"/>', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to mtvn_uri') self._downloader.report_error(u'unable to mtvn_uri')
return return
mtvn_uri = mobj.group(1) mtvn_uri = mobj.group(1)
mobj = re.search(r'MTVN.Player.defaultPlaylistId = ([0-9]+);', webpage) mobj = re.search(r'MTVN.Player.defaultPlaylistId = ([0-9]+);', webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract content id') self._downloader.report_error(u'unable to extract content id')
return return
content_id = mobj.group(1) content_id = mobj.group(1)
@ -3102,7 +3102,7 @@ class MTVIE(InfoExtractor):
try: try:
metadataXml = compat_urllib_request.urlopen(request).read() metadataXml = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download video metadata: %s' % compat_str(err))
return return
mdoc = xml.etree.ElementTree.fromstring(metadataXml) mdoc = xml.etree.ElementTree.fromstring(metadataXml)
@ -3174,7 +3174,7 @@ class YoukuIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
video_id = mobj.group('ID') video_id = mobj.group('ID')
@ -3185,7 +3185,7 @@ class YoukuIE(InfoExtractor):
self.report_download_webpage(video_id) self.report_download_webpage(video_id)
jsondata = compat_urllib_request.urlopen(request).read() jsondata = compat_urllib_request.urlopen(request).read()
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
return return
self.report_extraction(video_id) self.report_extraction(video_id)
@ -3216,7 +3216,7 @@ class YoukuIE(InfoExtractor):
fileid = config['data'][0]['streamfileids'][format] fileid = config['data'][0]['streamfileids'][format]
keys = [s['k'] for s in config['data'][0]['segs'][format]] keys = [s['k'] for s in config['data'][0]['segs'][format]]
except (UnicodeDecodeError, ValueError, KeyError): except (UnicodeDecodeError, ValueError, KeyError):
self._downloader.trouble(u'ERROR: unable to extract info section') self._downloader.report_error(u'unable to extract info section')
return return
files_info=[] files_info=[]
@ -3263,7 +3263,7 @@ class XNXXIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
video_id = mobj.group(1) video_id = mobj.group(1)
@ -3274,24 +3274,24 @@ class XNXXIE(InfoExtractor):
webpage_bytes = compat_urllib_request.urlopen(url).read() webpage_bytes = compat_urllib_request.urlopen(url).read()
webpage = webpage_bytes.decode('utf-8') webpage = webpage_bytes.decode('utf-8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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) self._downloader.report_error(u'unable to download video webpage: %s' % err)
return return
result = re.search(self.VIDEO_URL_RE, webpage) result = re.search(self.VIDEO_URL_RE, webpage)
if result is None: if result is None:
self._downloader.trouble(u'ERROR: unable to extract video url') self._downloader.report_error(u'unable to extract video url')
return return
video_url = compat_urllib_parse.unquote(result.group(1)) video_url = compat_urllib_parse.unquote(result.group(1))
result = re.search(self.VIDEO_TITLE_RE, webpage) result = re.search(self.VIDEO_TITLE_RE, webpage)
if result is None: if result is None:
self._downloader.trouble(u'ERROR: unable to extract video title') self._downloader.report_error(u'unable to extract video title')
return return
video_title = result.group(1) video_title = result.group(1)
result = re.search(self.VIDEO_THUMB_RE, webpage) result = re.search(self.VIDEO_THUMB_RE, webpage)
if result is None: if result is None:
self._downloader.trouble(u'ERROR: unable to extract video thumbnail') self._downloader.report_error(u'unable to extract video thumbnail')
return return
video_thumbnail = result.group(1) video_thumbnail = result.group(1)
@ -3340,7 +3340,7 @@ class GooglePlusIE(InfoExtractor):
# Extract id from URL # Extract id from URL
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: Invalid URL: %s' % url) self._downloader.report_error(u'Invalid URL: %s' % url)
return return
post_url = mobj.group(0) post_url = mobj.group(0)
@ -3354,7 +3354,7 @@ class GooglePlusIE(InfoExtractor):
try: try:
webpage = compat_urllib_request.urlopen(request).read().decode('utf-8') webpage = compat_urllib_request.urlopen(request).read().decode('utf-8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'Unable to retrieve entry webpage: %s' % compat_str(err))
return return
# Extract update date # Extract update date
@ -3389,14 +3389,14 @@ class GooglePlusIE(InfoExtractor):
pattern = '"(https\://plus\.google\.com/photos/.*?)",,"image/jpeg","video"\]' pattern = '"(https\://plus\.google\.com/photos/.*?)",,"image/jpeg","video"\]'
mobj = re.search(pattern, webpage) mobj = re.search(pattern, webpage)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract video page URL') self._downloader.report_error(u'unable to extract video page URL')
video_page = mobj.group(1) video_page = mobj.group(1)
request = compat_urllib_request.Request(video_page) request = compat_urllib_request.Request(video_page)
try: try:
webpage = compat_urllib_request.urlopen(request).read().decode('utf-8') webpage = compat_urllib_request.urlopen(request).read().decode('utf-8')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'Unable to retrieve video webpage: %s' % compat_str(err))
return return
self.report_extract_vid_page(video_page) self.report_extract_vid_page(video_page)
@ -3406,7 +3406,7 @@ class GooglePlusIE(InfoExtractor):
pattern = '\d+,\d+,(\d+),"(http\://redirector\.googlevideo\.com.*?)"' pattern = '\d+,\d+,(\d+),"(http\://redirector\.googlevideo\.com.*?)"'
mobj = re.findall(pattern, webpage) mobj = re.findall(pattern, webpage)
if len(mobj) == 0: if len(mobj) == 0:
self._downloader.trouble(u'ERROR: unable to extract video links') self._downloader.report_error(u'unable to extract video links')
# Sort in resolution # Sort in resolution
links = sorted(mobj) links = sorted(mobj)
@ -3438,7 +3438,7 @@ class NBAIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
video_id = mobj.group(1) video_id = mobj.group(1)
@ -3494,13 +3494,13 @@ class JustinTVIE(InfoExtractor):
webpage_bytes = urlh.read() webpage_bytes = urlh.read()
webpage = webpage_bytes.decode('utf-8', 'ignore') webpage = webpage_bytes.decode('utf-8', 'ignore')
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err: 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)) self._downloader.report_error(u'unable to download video info JSON: %s' % compat_str(err))
return return
response = json.loads(webpage) response = json.loads(webpage)
if type(response) != list: if type(response) != list:
error_text = response.get('error', 'unknown error') error_text = response.get('error', 'unknown error')
self._downloader.trouble(u'ERROR: Justin.tv API: %s' % error_text) self._downloader.report_error(u'Justin.tv API: %s' % error_text)
return return
info = [] info = []
for clip in response: for clip in response:
@ -3525,7 +3525,7 @@ class JustinTVIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
api = 'http://api.justin.tv' api = 'http://api.justin.tv'
@ -3560,7 +3560,7 @@ class FunnyOrDieIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
video_id = mobj.group('id') video_id = mobj.group('id')
@ -3568,7 +3568,7 @@ class FunnyOrDieIE(InfoExtractor):
m = re.search(r'<video[^>]*>\s*<source[^>]*>\s*<source src="(?P<url>[^"]+)"', webpage, re.DOTALL) m = re.search(r'<video[^>]*>\s*<source[^>]*>\s*<source src="(?P<url>[^"]+)"', webpage, re.DOTALL)
if not m: if not m:
self._downloader.trouble(u'ERROR: unable to find video information') self._downloader.report_error(u'unable to find video information')
video_url = unescapeHTML(m.group('url')) video_url = unescapeHTML(m.group('url'))
m = re.search(r"class='player_page_h1'>\s+<a.*?>(?P<title>.*?)</a>", webpage) m = re.search(r"class='player_page_h1'>\s+<a.*?>(?P<title>.*?)</a>", webpage)
@ -3621,7 +3621,7 @@ class SteamIE(InfoExtractor):
video_url = vid.group('videoURL') video_url = vid.group('videoURL')
video_thumb = thumb.group('thumbnail') video_thumb = thumb.group('thumbnail')
if not video_url: if not video_url:
self._downloader.trouble(u'ERROR: Cannot find video url for %s' % video_id) self._downloader.report_error(u'Cannot find video url for %s' % video_id)
info = { info = {
'id':video_id, 'id':video_id,
'url':video_url, 'url':video_url,
@ -3711,7 +3711,7 @@ class YouPornIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
video_id = mobj.group('videoid') video_id = mobj.group('videoid')
@ -3803,7 +3803,7 @@ class YouPornIE(InfoExtractor):
else: else:
format = self._specific( req_format, formats ) format = self._specific( req_format, formats )
if result is None: if result is None:
self._downloader.trouble(u'ERROR: requested format not available') self._downloader.report_error(u'requested format not available')
return return
return [format] return [format]
@ -3816,7 +3816,7 @@ class PornotubeIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
video_id = mobj.group('videoid') video_id = mobj.group('videoid')
@ -3829,7 +3829,7 @@ class PornotubeIE(InfoExtractor):
VIDEO_URL_RE = r'url: "(?P<url>http://video[0-9].pornotube.com/.+\.flv)",' VIDEO_URL_RE = r'url: "(?P<url>http://video[0-9].pornotube.com/.+\.flv)",'
result = re.search(VIDEO_URL_RE, webpage) result = re.search(VIDEO_URL_RE, webpage)
if result is None: if result is None:
self._downloader.trouble(u'ERROR: unable to extract video url') self._downloader.report_error(u'unable to extract video url')
return return
video_url = compat_urllib_parse.unquote(result.group('url')) video_url = compat_urllib_parse.unquote(result.group('url'))
@ -3837,7 +3837,7 @@ class PornotubeIE(InfoExtractor):
VIDEO_UPLOADED_RE = r'<div class="video_added_by">Added (?P<date>[0-9\/]+) by' VIDEO_UPLOADED_RE = r'<div class="video_added_by">Added (?P<date>[0-9\/]+) by'
result = re.search(VIDEO_UPLOADED_RE, webpage) result = re.search(VIDEO_UPLOADED_RE, webpage)
if result is None: if result is None:
self._downloader.trouble(u'ERROR: unable to extract video title') self._downloader.report_error(u'unable to extract video title')
return return
upload_date = result.group('date') upload_date = result.group('date')
@ -3858,7 +3858,7 @@ class YouJizzIE(InfoExtractor):
def _real_extract(self, url): def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url) mobj = re.match(self._VALID_URL, url)
if mobj is None: if mobj is None:
self._downloader.trouble(u'ERROR: invalid URL: %s' % url) self._downloader.report_error(u'invalid URL: %s' % url)
return return
video_id = mobj.group('videoid') video_id = mobj.group('videoid')
@ -4059,13 +4059,13 @@ class MySpassIE(InfoExtractor):
# extract values from metadata # extract values from metadata
url_flv_el = metadata.find('url_flv') url_flv_el = metadata.find('url_flv')
if url_flv_el is None: if url_flv_el is None:
self._downloader.trouble(u'ERROR: unable to extract download url') self._downloader.report_error(u'unable to extract download url')
return return
video_url = url_flv_el.text video_url = url_flv_el.text
extension = os.path.splitext(video_url)[1][1:] extension = os.path.splitext(video_url)[1][1:]
title_el = metadata.find('title') title_el = metadata.find('title')
if title_el is None: if title_el is None:
self._downloader.trouble(u'ERROR: unable to extract title') self._downloader.report_error(u'unable to extract title')
return return
title = title_el.text title = title_el.text
format_id_el = metadata.find('format_id') format_id_el = metadata.find('format_id')