def _request_webpage(self, url_or_request, video_id, note=None, errnote=None):
""" Returns the response handle """
if note is None:
- note = u'Downloading video webpage'
- if note is not False:
+ self.report_download_webpage(video_id)
+ elif note is not False:
self.to_screen(u'%s: %s' % (video_id, note))
try:
return compat_urllib_request.urlopen(url_or_request)
"""Report information extraction."""
self.to_screen(u'%s: Extracting information' % id_or_name)
+ def report_download_webpage(self, video_id):
+ """Report webpage download."""
+ self.to_screen(u'%s: Downloading webpage' % video_id)
+
def report_age_confirmation(self):
"""Report attempt to confirm age."""
self.to_screen(u'Confirming age')
if video_description:
video_description = clean_html(video_description)
else:
- video_description = ''
+ fd_mobj = re.search(r'<meta name="description" content="([^"]+)"', video_webpage)
+ if fd_mobj:
+ video_description = unescapeHTML(fd_mobj.group(1))
+ else:
+ video_description = u''
# subtitles
video_subtitles = None
_FILTER_POST = 'http://www.metacafe.com/f/index.php?inputType=filter&controllerGroup=user'
IE_NAME = u'metacafe'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
def report_disclaimer(self):
"""Report disclaimer retrieval."""
self.to_screen(u'Retrieving disclaimer')
- def report_download_webpage(self, video_id):
- """Report webpage download."""
- self.to_screen(u'%s: Downloading webpage' % video_id)
-
def _real_initialize(self):
# Retrieve disclaimer
request = compat_urllib_request.Request(self._DISCLAIMER)
IE_NAME = u'dailymotion'
_WORKING = False
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
def _real_extract(self, url):
# Extract id and simplified title from URL
mobj = re.match(self._VALID_URL, url)
_VALID_URL = r'(?:http://)?(?:[a-z0-9]+\.)?photobucket\.com/.*[\?\&]current=(.*\.flv)'
IE_NAME = u'photobucket'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
- def report_download_webpage(self, video_id):
- """Report webpage download."""
- self.to_screen(u'%s: Downloading webpage' % video_id)
-
def _real_extract(self, url):
# Extract id from URL
mobj = re.match(self._VALID_URL, url)
_VPAGE_URL = r'(?:http://)?video\.yahoo\.com/watch/([0-9]+)/([0-9]+)(?:[#\?].*)?'
IE_NAME = u'video.yahoo'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
- def report_download_webpage(self, video_id):
- """Report webpage download."""
- self.to_screen(u'%s: Downloading webpage' % video_id)
-
def _real_extract(self, url, new_video=True):
# Extract ID from URL
mobj = re.match(self._VALID_URL, url)
_VALID_URL = r'(?P<proto>https?://)?(?:(?:www|player)\.)?vimeo\.com/(?:(?:groups|album)/[^/]+/)?(?P<direct_link>play_redirect_hls\?clip_id=)?(?:videos?/)?(?P<id>[0-9]+)'
IE_NAME = u'vimeo'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
- def report_download_webpage(self, video_id):
- """Report webpage download."""
- self.to_screen(u'%s: Downloading webpage' % video_id)
-
def _real_extract(self, url, new_video=True):
# Extract ID from URL
mobj = re.match(self._VALID_URL, url)
config = webpage.split(' = {config:')[1].split(',assets:')[0]
config = json.loads(config)
except:
- self._downloader.report_error(u'unable to extract info section')
+ if re.search('The creator of this video has not given you permission to embed it on this domain.', webpage):
+ self._downloader.report_error(u'The author has restricted the access to this video, try with the "--referer" option')
+ else:
+ self._downloader.report_error(u'unable to extract info section')
return
# Extract title
IE_NAME = u'arte.tv'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
- def report_download_webpage(self, video_id):
- """Report webpage download."""
- self.to_screen(u'%s: Downloading webpage' % video_id)
-
def fetch_webpage(self, url):
request = compat_urllib_request.Request(url)
try:
for (i, key, err) in matchTuples:
if mobj.group(i) is None:
- self._downloader.trouble(err)
+ self._downloader.report_error(err)
return
else:
info[key] = mobj.group(i)
r'src="(.*?/videothek_js.*?\.js)',
0,
[
- (1, 'url', u'ERROR: Invalid URL: %s' % url)
+ (1, 'url', u'Invalid URL: %s' % url)
]
)
http_host = url.split('/')[2]
'(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)
+ (1, 'path', u'could not extract video path: %s' % url),
+ (2, 'player', u'could not extract video player: %s' % url),
+ (3, 'url', u'could not extract video url: %s' % url)
]
)
video_url = u'%s/%s' % (info.get('url'), info.get('path'))
r'param name="movie".*?videorefFileUrl=(http[^\'"&]*)',
0,
[
- (1, 'url', u'ERROR: Invalid URL: %s' % url)
+ (1, 'url', u'Invalid URL: %s' % url)
]
)
next_url = compat_urllib_parse.unquote(info.get('url'))
r'<video lang="%s" ref="(http[^\'"&]*)' % video_lang,
0,
[
- (1, 'url', u'ERROR: Could not find <video> tag: %s' % url)
+ (1, 'url', u'Could not find <video> tag: %s' % url)
]
)
next_url = compat_urllib_parse.unquote(info.get('url'))
'<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)
+ (1, 'id', u'could not extract video id: %s' % url),
+ (2, 'title', u'could not extract video title: %s' % url),
+ (3, 'date', u'could not extract video date: %s' % url),
+ (4, 'url', u'could not extract video url: %s' % url)
]
)
_VALID_URL = r'.*'
IE_NAME = u'generic'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
def report_download_webpage(self, video_id):
"""Report webpage download."""
if not self._downloader.params.get('test', False):
self._downloader.report_warning(u'Falling back on generic information extractor.')
- self.to_screen(u'%s: Downloading webpage' % video_id)
+ super(GenericIE, self).report_download_webpage(video_id)
def report_following_redirect(self, new_url):
"""Report information extraction."""
_max_youtube_results = 1000
IE_NAME = u'youtube:search'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
def report_download_page(self, query, pagenum):
"""Report attempt to download search page with given number."""
query = query.decode(preferredencoding())
api_response = json.loads(data)['data']
if not 'items' in api_response:
- self._downloader.trouble(u'[youtube] No video results')
+ self._downloader.report_error(u'[youtube] No video results')
return
new_ids = list(video['id'] for video in api_response['items'])
_max_google_results = 1000
IE_NAME = u'video.google:search'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
def report_download_page(self, query, pagenum):
"""Report attempt to download playlist page with given number."""
query = query.decode(preferredencoding())
_max_yahoo_results = 1000
IE_NAME = u'video.yahoo:search'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
def report_download_page(self, query, pagenum):
"""Report attempt to download playlist page with given number."""
query = query.decode(preferredencoding())
_MAX_RESULTS = 50
IE_NAME = u'youtube:playlist'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
@classmethod
def suitable(cls, url):
"""Receives a URL and returns True if suitable for this IE."""
_VIDEO_INDICATOR = r'/watch\?v=(.+?)[\<&]'
IE_NAME = u'youtube:user'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
def report_download_page(self, username, start_index):
"""Report attempt to download user page."""
self._downloader.to_screen(u'[youtube] user %s: Downloading video ids from %d to %d' %
_PAGE_SIZE = 12
IE_NAME = u'blip.tv:user'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
def report_download_page(self, username, pagenum):
"""Report attempt to download user page."""
self.to_screen(u'user %s: Downloading video ids from page %d' %
_VALID_URL = r'(?:http://)?(?:\w+\.)?depositfiles\.com/(?:../(?#locale))?files/(.+)'
- def report_download_webpage(self, file_id):
- """Report webpage download."""
- self.to_screen(u'%s: Downloading webpage' % file_id)
-
def _real_extract(self, url):
file_id = url.split('/')[-1]
# Rebuild url in english locale
_VALID_URL = r'(?:http://)?(?:www\.)?myvideo\.de/watch/([0-9]+)/([^?/]+).*'
IE_NAME = u'myvideo'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
def _real_extract(self,url):
mobj = re.match(self._VALID_URL, url)
if mobj is None:
_VALID_URL = r'^(?:https?://)?(?:www\.)?soundcloud\.com/([\w\d-]+)/([\w\d-]+)'
IE_NAME = u'soundcloud'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
def report_resolve(self, video_id):
"""Report information extraction."""
self.to_screen(u'%s: Resolving id' % video_id)
_VALID_URL = r'^(?:https?://)?(?:www\.)?soundcloud\.com/([\w\d-]+)/sets/([\w\d-]+)'
IE_NAME = u'soundcloud'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
def report_resolve(self, video_id):
"""Report information extraction."""
self.to_screen(u'%s: Resolving id' % video_id)
def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url)
if mobj is None:
- self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+ self._downloader.report_error(u'invalid URL: %s' % url)
return
# extract uploader (which is in the url)
info_json_bytes = compat_urllib_request.urlopen(request).read()
info_json = info_json_bytes.decode('utf-8')
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
videos = []
info = json.loads(info_json)
if 'errors' in info:
for err in info['errors']:
- self._downloader.trouble(u'ERROR: unable to download video webpage: %s' % compat_str(err['error_message']))
+ self._downloader.report_error(u'unable to download video webpage: %s' % compat_str(err['error_message']))
return
for track in info['tracks']:
stream_json_bytes = compat_urllib_request.urlopen(request).read()
stream_json = stream_json_bytes.decode('utf-8')
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
streams = json.loads(stream_json)
self.report_extraction(url)
# Extract video URL
- mobj = re.search(r"jsclassref='([^']*)'", webpage)
+ mobj = re.search(r"jsclassref ?= ?'([^']*)'", webpage)
if mobj is None:
self._downloader.report_error(u'unable to extract video url')
return
_VALID_URL = r'^(?:https?://)?(?:www\.)?mixcloud\.com/([\w\d-]+)/([\w\d-]+)'
IE_NAME = u'mixcloud'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
def report_download_json(self, file_id):
"""Report JSON download."""
self.to_screen(u'Downloading json')
_VALID_URL = r'^(?:https?://)?openclassroom.stanford.edu(?P<path>/?|(/MainFolder/(?:HomePage|CoursePage|VideoPage)\.php([?]course=(?P<course>[^&]+)(&video=(?P<video>[^&]+))?(&.*)?)?))$'
IE_NAME = u'stanfordoc'
- def report_download_webpage(self, objid):
- """Report information extraction."""
- self.to_screen(u'%s: Downloading webpage' % objid)
-
def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url)
if mobj is None:
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.')
+ self._downloader.report_error('Invalid rendition field.')
return
info = {
class YoukuIE(InfoExtractor):
_VALID_URL = r'(?:http://)?v\.youku\.com/v_show/id_(?P<ID>[A-Za-z0-9]+)\.html'
- def report_download_webpage(self, file_id):
- """Report webpage download."""
- self.to_screen(u'%s: Downloading webpage' % file_id)
-
def _gen_sid(self):
nowTime = int(time.time() * 1000)
random1 = random.randint(1000,1998)
VIDEO_TITLE_RE = r'<title>(.*?)\s+-\s+XNXX.COM'
VIDEO_THUMB_RE = r'url_bigthumb=(.*?)&'
- def report_webpage(self, video_id):
- """Report information extraction"""
- self.to_screen(u'%s: Downloading webpage' % video_id)
-
def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url)
if mobj is None:
return
video_id = mobj.group(1)
- self.report_webpage(video_id)
+ self.report_download_webpage(video_id)
# Get webpage content
try:
_VALID_URL = r'(?:https://)?plus\.google\.com/(?:[^/]+/)*?posts/(\w+)'
IE_NAME = u'plus.google'
- def __init__(self, downloader=None):
- InfoExtractor.__init__(self, downloader)
-
def report_extract_entry(self, url):
"""Report downloading extry"""
self.to_screen(u'Downloading entry: %s' % url)
if not m:
m = re.search(r'<title>(?P<title>[^<]+?)</title>', webpage)
if not m:
- self._downloader.trouble(u'Cannot find video title')
+ self._downloader.report_error(u'Cannot find video title')
title = clean_html(m.group('title'))
m = re.search(r'<meta property="og:description" content="(?P<desc>.*?)"', webpage)
else:
ext = 'flv'
else:
- 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)
return
_title = r"""<title>(.*)</title>"""
def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url)
if mobj is None:
- self._downloader.trouble(u'ERROR: invalid URL: %s' % url)
+ self._downloader.report_error(u'invalid URL: %s' % url)
return
video_id = mobj.group('video_id')
m = re.search(r'<meta property="og:title" content="(?P<title>.*?)"', webpage)
if not m:
- self._downloader.trouble(u'Cannot find video title')
+ self._downloader.report_error(u'Cannot find video title')
title = unescapeHTML(m.group('title')).replace('LiveLeak.com -', '').strip()
m = re.search(r'<meta property="og:description" content="(?P<desc>.*?)"', webpage)
projects / youtube-dl / blobdiff