import urllib
import urllib2
-std_headers = {
- 'User-Agent': 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.0.5) Gecko/2008120122 Firefox/3.0.5',
+std_headers = {
+ 'User-Agent': 'Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.0.8) Gecko/2009032609 Firefox/3.0.8',
'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
'Accept': 'text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5',
'Accept-Language': 'en-us,en;q=0.5',
File downloaders accept a lot of parameters. In order not to saturate
the object constructor with arguments, it receives a dictionary of
- options instead. These options are available through the get_params()
- method for the InfoExtractors to use. The FileDownloader also registers
- itself as the downloader in charge for the InfoExtractors that are
- added to it, so this is a "mutual registration".
+ options instead. These options are available through the params
+ attribute for the InfoExtractors to use. The FileDownloader also
+ registers itself as the downloader in charge for the InfoExtractors
+ that are added to it, so this is a "mutual registration".
Available options:
nooverwrites: Prevent overwriting files.
"""
- _params = None
+ params = None
_ies = []
_pps = []
"""Create a FileDownloader object with the given options."""
self._ies = []
self._pps = []
- self.set_params(params)
+ self.params = params
@staticmethod
def pmkdir(filename):
multiplier = 1024.0 ** 'bkmgtpezy'.index(matchobj.group(2).lower())
return long(round(number * multiplier))
- def set_params(self, params):
- """Sets parameters."""
- if type(params) != dict:
- raise ValueError('params: dictionary expected')
- self._params = params
-
- def get_params(self):
- """Get parameters."""
- return self._params
-
def add_info_extractor(self, ie):
"""Add an InfoExtractor object to the end of the list."""
self._ies.append(ie)
def to_stdout(self, message, skip_eol=False):
"""Print message to stdout if not in quiet mode."""
- if not self._params.get('quiet', False):
+ if not self.params.get('quiet', False):
print u'%s%s' % (message, [u'\n', u''][skip_eol]),
sys.stdout.flush()
def fixed_template(self):
"""Checks if the output template is fixed."""
- return (re.search(ur'(?u)%\(.+?\)s', self._params['outtmpl']) is None)
+ return (re.search(ur'(?u)%\(.+?\)s', self.params['outtmpl']) is None)
def trouble(self, message=None):
"""Determine action to take when a download problem appears.
"""
if message is not None:
self.to_stderr(message)
- if not self._params.get('ignoreerrors', False):
+ if not self.params.get('ignoreerrors', False):
raise DownloadError(message)
return 1
def slow_down(self, start_time, byte_counter):
"""Sleep if the download speed is over the rate limit."""
- rate_limit = self._params.get('ratelimit', None)
+ rate_limit = self.params.get('ratelimit', None)
if rate_limit is None or byte_counter == 0:
return
now = time.time()
"""Report download finished."""
self.to_stdout(u'')
+ def process_info(self, info_dict):
+ """Process a single dictionary returned by an InfoExtractor."""
+ # Forced printings
+ if self.params.get('forcetitle', False):
+ print info_dict['title']
+ if self.params.get('forceurl', False):
+ print info_dict['url']
+
+ # Do nothing else if in simulate mode
+ if self.params.get('simulate', False):
+ return 0
+
+ try:
+ filename = self.params['outtmpl'] % info_dict
+ self.report_destination(filename)
+ except (ValueError, KeyError), err:
+ return self.trouble('ERROR: invalid output template or system charset: %s' % str(err))
+ if self.params['nooverwrites'] and os.path.exists(filename):
+ self.to_stderr('WARNING: file exists: %s; skipping' % filename)
+ return 0
+ try:
+ self.pmkdir(filename)
+ except (OSError, IOError), err:
+ return self.trouble('ERROR: unable to create directories: %s' % str(err))
+ try:
+ outstream = open(filename, 'wb')
+ except (OSError, IOError), err:
+ return self.trouble('ERROR: unable to open for writing: %s' % str(err))
+ try:
+ self._do_download(outstream, info_dict['url'])
+ outstream.close()
+ except (OSError, IOError), err:
+ return self.trouble('ERROR: unable to write video data: %s' % str(err))
+ except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+ return self.trouble('ERROR: unable to download video data: %s' % str(err))
+ try:
+ self.post_process(filename, info_dict)
+ except (PostProcessingError), err:
+ return self.trouble('ERROR: postprocessing: %s' % str(err))
+
+ return 0
+
def download(self, url_list):
"""Download a given list of URLs."""
retcode = 0
if len(url_list) > 1 and self.fixed_template():
- raise SameFileError(self._params['outtmpl'])
+ raise SameFileError(self.params['outtmpl'])
for url in url_list:
suitable_found = False
for ie in self._ies:
+ # Go to next InfoExtractor if not suitable
if not ie.suitable(url):
continue
+
# Suitable InfoExtractor found
suitable_found = True
+
+ # Extract information from URL
all_results = ie.extract(url)
results = [x for x in all_results if x is not None]
+
+ # See if there were problems extracting any information
if len(results) != len(all_results):
retcode = self.trouble()
+ # Two results could go to the same file
if len(results) > 1 and self.fixed_template():
- raise SameFileError(self._params['outtmpl'])
+ raise SameFileError(self.params['outtmpl'])
+ # Process each result
for result in results:
- # Forced printings
- if self._params.get('forcetitle', False):
- print result['title']
- if self._params.get('forceurl', False):
- print result['url']
-
- # Do nothing else if in simulate mode
- if self._params.get('simulate', False):
- continue
-
- try:
- filename = self._params['outtmpl'] % result
- self.report_destination(filename)
- except (ValueError, KeyError), err:
- retcode = self.trouble('ERROR: invalid output template or system charset: %s' % str(err))
- continue
- if self._params['nooverwrites'] and os.path.exists(filename):
- self.to_stderr('WARNING: file exists: %s; skipping' % filename)
- continue
- try:
- self.pmkdir(filename)
- except (OSError, IOError), err:
- retcode = self.trouble('ERROR: unable to create directories: %s' % str(err))
- continue
- try:
- outstream = open(filename, 'wb')
- except (OSError, IOError), err:
- retcode = self.trouble('ERROR: unable to open for writing: %s' % str(err))
- continue
- try:
- self._do_download(outstream, result['url'])
- outstream.close()
- except (OSError, IOError), err:
- retcode = self.trouble('ERROR: unable to write video data: %s' % str(err))
- continue
- except (urllib2.URLError, httplib.HTTPException, socket.error), err:
- retcode = self.trouble('ERROR: unable to download video data: %s' % str(err))
- continue
- try:
- self.post_process(filename, result)
- except (PostProcessingError), err:
- retcode = self.trouble('ERROR: postprocessing: %s' % str(err))
- continue
+ result = self.process_info(result)
+ # Do not overwrite an error code with a success code
+ if result != 0:
+ retcode = result
+
+ # Suitable InfoExtractor had been found; go to next URL
break
+
if not suitable_found:
retcode = self.trouble('ERROR: no suitable InfoExtractor: %s' % url)
def to_stdout(self, message):
"""Print message to stdout if downloader is not in quiet mode."""
- if self._downloader is None or not self._downloader.get_params().get('quiet', False):
+ if self._downloader is None or not self._downloader.params.get('quiet', False):
print message
def to_stderr(self, message):
def suitable(url):
return (re.match(YoutubeIE._VALID_URL, url) is not None)
+ @staticmethod
+ def htmlentity_transform(matchobj):
+ """Transforms an HTML entity to a Unicode character."""
+ entity = matchobj.group(1)
+
+ # Known non-numeric HTML entity
+ if entity in htmlentitydefs.name2codepoint:
+ return unichr(htmlentitydefs.name2codepoint[entity])
+
+ # Unicode character
+ mobj = re.match(ur'(?u)#(x?\d+)', entity)
+ if mobj is not None:
+ numstr = mobj.group(1)
+ if numstr.startswith(u'x'):
+ base = 16
+ numstr = u'0%s' % numstr
+ else:
+ base = 10
+ return unichr(long(numstr, base))
+
+ # Unknown entity in name, return its literal representation
+ return (u'&%s;' % entity)
+
def report_lang(self):
"""Report attempt to set language."""
self.to_stdout(u'[youtube] Setting language')
def report_video_url(self, video_id, video_real_url):
"""Report extracted video URL."""
self.to_stdout(u'[youtube] %s: URL: %s' % (video_id, video_real_url))
-
+
def _real_initialize(self):
if self._downloader is None:
return
username = None
password = None
- downloader_params = self._downloader.get_params()
+ downloader_params = self._downloader.params
# Attempt to use provided username and password or .netrc data
if downloader_params.get('username', None) is not None:
# Downloader parameters
format_param = None
if self._downloader is not None:
- params = self._downloader.get_params()
+ params = self._downloader.params
format_param = params.get('format', None)
+ if format_param is None:
+ format_param = '34'
# Extension
- video_extension = {'18': 'mp4', '17': '3gp'}.get(format_param, 'flv')
+ video_extension = {
+ '17': '3gp',
+ '18': 'mp4',
+ '22': 'mp4',
+ }.get(format_param, 'flv')
# Normalize URL, including format
normalized_url = 'http://www.youtube.com/watch?v=%s&gl=US&hl=en' % video_id
if mobj is None:
self.to_stderr(u'ERROR: unable to extract "t" parameter')
return [None]
- video_real_url = 'http://www.youtube.com/get_video?video_id=%s&t=%s' % (video_id, mobj.group(1))
+ video_real_url = 'http://www.youtube.com/get_video?video_id=%s&t=%s&el=detailpage&ps=' % (video_id, mobj.group(1))
if format_param is not None:
video_real_url = '%s&fmt=%s' % (video_real_url, format_param)
self.report_video_url(video_id, video_real_url)
self.to_stderr(u'ERROR: unable to extract video title')
return [None]
video_title = mobj.group(1).decode('utf-8')
- video_title = re.sub(ur'(?u)&(.+?);', lambda x: unichr(htmlentitydefs.name2codepoint[x.group(1)]), video_title)
+ video_title = re.sub(ur'(?u)&(.+?);', self.htmlentity_transform, video_title)
video_title = video_title.replace(os.sep, u'%')
# simplified title
_VIDEO_INDICATOR = r'href="/watch\?v=.+?"'
_MORE_PAGES_INDICATOR = r'>Next</a>'
_youtube_ie = None
+ _max_youtube_results = 1000
- def __init__(self, youtube_ie, downloader=None):
+ def __init__(self, youtube_ie, downloader=None):
InfoExtractor.__init__(self, downloader)
self._youtube_ie = youtube_ie
prefix, query = query.split(':')
prefix = prefix[8:]
- if prefix == '':
+ if prefix == '':
return self._download_n_results(query, 1)
- elif prefix == 'all':
- return self._download_n_results(query, -1)
- else:
+ elif prefix == 'all':
+ return self._download_n_results(query, self._max_youtube_results)
+ else:
try:
n = int(prefix)
if n <= 0:
self.to_stderr(u'ERROR: invalid download number %s for query "%s"' % (n, query))
return [None]
+ elif n > self._max_youtube_results:
+ self.to_stderr(u'WARNING: ytsearch returns max %i results (you requested %i)' % (self._max_youtube_results, n))
+ n = self._max_youtube_results
return self._download_n_results(query, n)
except ValueError: # parsing prefix as int fails
return self._download_n_results(query, 1)
def to_stdout(self, message):
"""Print message to stdout if downloader is not in quiet mode."""
- if self._downloader is None or not self._downloader.get_params().get('quiet', False):
+ if self._downloader is None or not self._downloader.params.get('quiet', False):
print message
def to_stderr(self, message):
# Parse command line
parser = optparse.OptionParser(
usage='Usage: %prog [options] url...',
- version='2009.02.07',
+ version='INTERNAL',
conflict_handler='resolve',
)
parser.add_option('-h', '--help',
action='store_true', dest='gettitle', help='simulate, quiet but print title', default=False)
parser.add_option('-f', '--format',
dest='format', metavar='FMT', help='video format code')
- parser.add_option('-b', '--best-quality',
- action='store_const', dest='format', help='alias for -f 18', const='18')
parser.add_option('-m', '--mobile-version',
action='store_const', dest='format', help='alias for -f 17', const='17')
+ parser.add_option('-d', '--high-def',
+ action='store_const', dest='format', help='alias for -f 22', const='22')
parser.add_option('-i', '--ignore-errors',
action='store_true', dest='ignoreerrors', help='continue on download errors', default=False)
parser.add_option('-r', '--rate-limit',
projects / youtube-dl.git / blobdiff