Add --mobile-version program option

[youtube-dl] / youtube-dl

diff --git a/youtube-dl b/youtube-dl
index 45773fda2480257a7cf42b5907118ee9664d629b..2c1d1aa3b84b5e3cda680e22fe0a6a39dc91c777 100755 (executable)
--- a/youtube-dl
+++ b/youtube-dl
@@ -17,7 +17,7 @@ import urllib
 import urllib2
 
 std_headers = {        
 import urllib2
 
 std_headers = {        

-       'User-Agent': 'UserAgent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9) Gecko/2008052906 Firefox/3.0',
+       'User-Agent': 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.0.1) Gecko/2008070208 Firefox/3.0.1',

        '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',
        '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',


@@ -25,6 +25,23 @@ std_headers = {
 
 simple_title_chars = string.ascii_letters.decode('ascii') + string.digits.decode('ascii')
 
 
 simple_title_chars = string.ascii_letters.decode('ascii') + string.digits.decode('ascii')
 

+class DownloadError(Exception):
+       """Download Error exception.
+       
+       This exception may be thrown by FileDownloader objects if they are not
+       configured to continue on errors. They will contain the appropriate
+       error message.
+       """
+       pass
+
+class SameFileError(Exception):
+       """Same File exception.
+
+       This exception will be thrown by FileDownloader objects if they detect
+       multiple files would have to be downloaded to the same file on disk.
+       """
+       pass
+

 class FileDownloader(object):
        """File Downloader class.
 
 class FileDownloader(object):
        """File Downloader class.
 


@@ -38,7 +55,7 @@ class FileDownloader(object):
        For this, file downloader objects have a method that allows
        InfoExtractors to be registered in a given order. When it is passed
        a URL, the file downloader handles it to the first InfoExtractor it
        For this, file downloader objects have a method that allows
        InfoExtractors to be registered in a given order. When it is passed
        a URL, the file downloader handles it to the first InfoExtractor it

-       finds that reports it's able to handle it. The InfoExtractor returns
+       finds that reports being able to handle it. The InfoExtractor returns

        all the information to the FileDownloader and the latter downloads the
        file or does whatever it's instructed to do.
 
        all the information to the FileDownloader and the latter downloads the
        file or does whatever it's instructed to do.
 


@@ -55,14 +72,19 @@ class FileDownloader(object):
        password:       Password for authentication purposes.
        usenetrc:       Use netrc for authentication instead.
        quiet:          Do not print messages to stdout.
        password:       Password for authentication purposes.
        usenetrc:       Use netrc for authentication instead.
        quiet:          Do not print messages to stdout.

+       forceurl:       Force printing final URL.
+       forcetitle:     Force printing title.
+       simulate:       Do not download the video files.

        format:         Video format code.
        outtmpl:        Template for output names.
        format:         Video format code.
        outtmpl:        Template for output names.

+       ignoreerrors:   Do not stop on download errors.

        """
 
        _params = None
        _ies = []
 
        def __init__(self, params):
        """
 
        _params = None
        _ies = []
 
        def __init__(self, params):

+               """Create a FileDownloader object with the given options."""

                self._ies = []
                self.set_params(params)
        
                self._ies = []
                self.set_params(params)
        


@@ -84,8 +106,6 @@ class FileDownloader(object):
                else:
                        exponent = long(math.log(float(bytes), 1024.0))
                suffix = 'bkMGTPEZY'[exponent]
                else:
                        exponent = long(math.log(float(bytes), 1024.0))
                suffix = 'bkMGTPEZY'[exponent]

-               if exponent == 0:
-                       return '%s%s' % (bytes, suffix)

                converted = float(bytes) / float(1024**exponent)
                return '%.2f%s' % (converted, suffix)
 
                converted = float(bytes) / float(1024**exponent)
                return '%.2f%s' % (converted, suffix)
 


@@ -113,7 +133,7 @@ class FileDownloader(object):
        def calc_speed(start, now, bytes):
                dif = now - start
                if bytes == 0 or dif < 0.001: # One millisecond
        def calc_speed(start, now, bytes):
                dif = now - start
                if bytes == 0 or dif < 0.001: # One millisecond

-                       return '%9s' % 'N/A b/s'
+                       return '%10s' % '---b/s'

                return '%10s' % ('%s/s' % FileDownloader.format_bytes(float(bytes) / dif))
 
        @staticmethod
                return '%10s' % ('%s/s' % FileDownloader.format_bytes(float(bytes) / dif))
 
        @staticmethod


@@ -144,8 +164,41 @@ class FileDownloader(object):
                self._ies.append(ie)
                ie.set_downloader(self)
        
                self._ies.append(ie)
                ie.set_downloader(self)
        

+       def to_stdout(self, message, skip_eol=False):
+               """Print message to stdout if not in quiet mode."""
+               if not self._params.get('quiet', False):
+                       sys.stdout.write('%s%s' % (message, ['\n', ''][skip_eol]))
+                       sys.stdout.flush()
+       
+       def to_stderr(self, message):
+               """Print message to stderr."""
+               sys.stderr.write('%s\n' % message)
+       
+       def fixed_template(self):
+               """Checks if the output template is fixed."""
+               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.
+
+               Depending on if the downloader has been configured to ignore
+               download errors or not, this method may throw an exception or
+               not when errors are found, after printing the message. If it
+               doesn't raise, it returns an error code suitable to be returned
+               later as a program exit code to indicate error.
+               """
+               if message is not None:
+                       self.to_stderr(message)
+               if not self._params.get('ignoreerrors', False):
+                       raise DownloadError(message)
+               return 1
+

        def download(self, url_list):
                """Download a given list of URLs."""
        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'])
+

                for url in url_list:
                        suitable_found = False
                        for ie in self._ies:
                for url in url_list:
                        suitable_found = False
                        for ie in self._ies:


@@ -153,36 +206,56 @@ class FileDownloader(object):
                                        continue
                                # Suitable InfoExtractor found
                                suitable_found = True
                                        continue
                                # Suitable InfoExtractor found
                                suitable_found = True

-                               for result in ie.extract(url):
-                                       if result is None:
+                               all_results = ie.extract(url)
+                               results = [x for x in all_results if x is not None]
+                               if len(results) != len(all_results):
+                                       retcode = self.trouble()
+
+                               if len(results) > 1 and self.fixed_template():
+                                       raise SameFileError(self._params['outtmpl'])
+
+                               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
                                                continue

+

                                        try:
                                                filename = self._params['outtmpl'] % result
                                        try:
                                                filename = self._params['outtmpl'] % result

-                                       except (KeyError), err:
-                                               sys.stderr.write('ERROR: invalid output template: %s\n' % str(err))
+                                               self.to_stdout('[download] Destination: %s' % filename)
+                                       except (ValueError, KeyError), err:
+                                               retcode = self.trouble('ERROR: invalid output template: %s' % str(err))

                                                continue
                                        try:
                                                self.pmkdir(filename)
                                        except (OSError, IOError), err:
                                                continue
                                        try:
                                                self.pmkdir(filename)
                                        except (OSError, IOError), err:

-                                               sys.stderr.write('ERROR: unable to create directories: %s\n' % str(err))
+                                               retcode = self.trouble('ERROR: unable to create directories: %s' % str(err))

                                                continue
                                        try:
                                                outstream = open(filename, 'wb')
                                        except (OSError, IOError), err:
                                                continue
                                        try:
                                                outstream = open(filename, 'wb')
                                        except (OSError, IOError), err:

-                                               sys.stderr.write('ERROR: unable to open for writing: %s\n' % str(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:
                                                continue
                                        try:
                                                self._do_download(outstream, result['url'])
                                                outstream.close()
                                        except (OSError, IOError), err:

-                                               sys.stderr.write('ERROR: unable to write video data: %s\n' % str(err))
+                                               retcode = self.trouble('ERROR: unable to write video data: %s' % str(err))

                                                continue
                                        except (urllib2.URLError, httplib.HTTPException, socket.error), err:
                                                continue
                                        except (urllib2.URLError, httplib.HTTPException, socket.error), err:

-                                               sys.stderr.write('ERROR: unable to download video data: %s\n' % str(err))
+                                               retcode = self.trouble('ERROR: unable to download video data: %s' % str(err))

                                                continue
                                break
                        if not suitable_found:
                                                continue
                                break
                        if not suitable_found:

-                               sys.stderr.write('ERROR: no suitable InfoExtractor: %s\n' % url)
+                               retcode = self.trouble('ERROR: no suitable InfoExtractor: %s' % url)
+
+               return retcode

        
        def _do_download(self, stream, url):
                request = urllib2.Request(url, None, std_headers)
        
        def _do_download(self, stream, url):
                request = urllib2.Request(url, None, std_headers)


@@ -196,11 +269,8 @@ class FileDownloader(object):
                        percent_str = self.calc_percent(byte_counter, data_len)
                        eta_str = self.calc_eta(start, time.time(), data_len, byte_counter)
                        speed_str = self.calc_speed(start, time.time(), byte_counter)
                        percent_str = self.calc_percent(byte_counter, data_len)
                        eta_str = self.calc_eta(start, time.time(), data_len, byte_counter)
                        speed_str = self.calc_speed(start, time.time(), byte_counter)

-
-                       if not self._params.get('quiet', False):
-                               sys.stdout.write('\r[download] %s of %s at %s ETA %s' %
-                                               (percent_str, data_len_str, speed_str, eta_str))
-                               sys.stdout.flush()
+                       self.to_stdout('\r[download] %s of %s at %s ETA %s' %
+                                       (percent_str, data_len_str, speed_str, eta_str), skip_eol=True)

 
                        before = time.time()
                        data_block = data.read(block_size)
 
                        before = time.time()
                        data_block = data.read(block_size)


@@ -212,9 +282,7 @@ class FileDownloader(object):
                        stream.write(data_block)
                        block_size = self.best_block_size(after - before, data_block_len)
 
                        stream.write(data_block)
                        block_size = self.best_block_size(after - before, data_block_len)
 

-               if not self._params.get('quiet', False):
-                       print
-
+               self.to_stdout('')

                if data_len is not None and str(byte_counter) != data_len:
                        raise ValueError('Content too short: %s/%s bytes' % (byte_counter, data_len))
 
                if data_len is not None and str(byte_counter) != data_len:
                        raise ValueError('Content too short: %s/%s bytes' % (byte_counter, data_len))
 


@@ -256,7 +324,7 @@ class InfoExtractor(object):
                return True
 
        def initialize(self):
                return True
 
        def initialize(self):

-               """Initializes an instance (login, etc)."""
+               """Initializes an instance (authentication, etc)."""

                if not self._ready:
                        self._real_initialize()
                        self._ready = True
                if not self._ready:
                        self._real_initialize()
                        self._ready = True


@@ -271,10 +339,12 @@ class InfoExtractor(object):
                self._downloader = downloader
        
        def to_stdout(self, message):
                self._downloader = downloader
        
        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):
                        print message
        
        def to_stderr(self, message):
                if self._downloader is None or not self._downloader.get_params().get('quiet', False):
                        print message
        
        def to_stderr(self, message):

+               """Print message to stderr."""

                sys.stderr.write('%s\n' % message)
 
        def _real_initialize(self):
                sys.stderr.write('%s\n' % message)
 
        def _real_initialize(self):


@@ -316,41 +386,47 @@ class YoutubeIE(InfoExtractor):
                                self.to_stderr('WARNING: parsing .netrc: %s' % str(err))
                                return
 
                                self.to_stderr('WARNING: parsing .netrc: %s' % str(err))
                                return
 

+               # No authentication to be performed

                if username is None:
                        return
 
                # Log in
                if username is None:
                        return
 
                # Log in

-               login_form = {  'current_form': 'loginForm',
+               login_form = {
+                               'current_form': 'loginForm',

                                'next':         '/',
                                'action_login': 'Log In',
                                'username':     username,
                                'next':         '/',
                                'action_login': 'Log In',
                                'username':     username,

-                               'password':     password,       }
+                               'password':     password,
+                               }

                request = urllib2.Request(self._LOGIN_URL, urllib.urlencode(login_form), std_headers)
                try:
                        self.to_stdout('[youtube] Logging in')
                        login_results = urllib2.urlopen(request).read()
                        if re.search(r'(?i)<form[^>]* name="loginForm"', login_results) is not None:
                request = urllib2.Request(self._LOGIN_URL, urllib.urlencode(login_form), std_headers)
                try:
                        self.to_stdout('[youtube] Logging in')
                        login_results = urllib2.urlopen(request).read()
                        if re.search(r'(?i)<form[^>]* name="loginForm"', login_results) is not None:

-                               self.to_stderr('WARNING: Unable to log in: bad username or password')
+                               self.to_stderr('WARNING: unable to log in: bad username or password')

                                return
                except (urllib2.URLError, httplib.HTTPException, socket.error), err:
                                return
                except (urllib2.URLError, httplib.HTTPException, socket.error), err:

-                       self.to_stderr('WARNING: Unable to log in: %s' % str(err))
+                       self.to_stderr('WARNING: unable to log in: %s' % str(err))

                        return
        
                # Confirm age
                        return
        
                # Confirm age

-               age_form = {    'next_url':             '/',
-                               'action_confirm':       'Confirm',      }
+               age_form = {
+                               'next_url':             '/',
+                               'action_confirm':       'Confirm',
+                               }

                request = urllib2.Request(self._AGE_URL, urllib.urlencode(age_form), std_headers)
                try:
                        self.to_stdout('[youtube] Confirming age')
                        age_results = urllib2.urlopen(request).read()
                except (urllib2.URLError, httplib.HTTPException, socket.error), err:
                request = urllib2.Request(self._AGE_URL, urllib.urlencode(age_form), std_headers)
                try:
                        self.to_stdout('[youtube] Confirming age')
                        age_results = urllib2.urlopen(request).read()
                except (urllib2.URLError, httplib.HTTPException, socket.error), err:

-                       sys.exit('ERROR: Unable to confirm age: %s' % str(err))
+                       self.to_stderr('ERROR: unable to confirm age: %s' % str(err))
+                       return

 
        def _real_extract(self, url):
                # Extract video id from URL
                mobj = re.match(r'^((?:http://)?(?:\w+\.)?youtube\.com/(?:(?:v/)|(?:(?:watch(?:\.php)?)?\?(?:.+&)?v=)))?([0-9A-Za-z_-]+)(?(1).+)?$', url)
                if mobj is None:
 
        def _real_extract(self, url):
                # Extract video id from URL
                mobj = re.match(r'^((?:http://)?(?:\w+\.)?youtube\.com/(?:(?:v/)|(?:(?:watch(?:\.php)?)?\?(?:.+&)?v=)))?([0-9A-Za-z_-]+)(?(1).+)?$', url)
                if mobj is None:

-                       self.to_stderr('ERROR: Invalid URL: %s' % url)
+                       self.to_stderr('ERROR: invalid URL: %s' % url)

                        return [None]
                video_id = mobj.group(2)
 
                        return [None]
                video_id = mobj.group(2)
 


@@ -361,7 +437,7 @@ class YoutubeIE(InfoExtractor):
                        format_param = params.get('format', None)
 
                # Extension
                        format_param = params.get('format', None)
 
                # Extension

-               video_extension = {18: 'mp4'}.get(format_param, 'flv')
+               video_extension = {'18': 'mp4', '17': '3gp'}.get(format_param, 'flv')

 
                # Normalize URL, including format
                normalized_url = 'http://www.youtube.com/watch?v=%s' % video_id
 
                # Normalize URL, including format
                normalized_url = 'http://www.youtube.com/watch?v=%s' % video_id


@@ -372,67 +448,141 @@ class YoutubeIE(InfoExtractor):
                        self.to_stdout('[youtube] %s: Downloading video webpage' % video_id)
                        video_webpage = urllib2.urlopen(request).read()
                except (urllib2.URLError, httplib.HTTPException, socket.error), err:
                        self.to_stdout('[youtube] %s: Downloading video webpage' % video_id)
                        video_webpage = urllib2.urlopen(request).read()
                except (urllib2.URLError, httplib.HTTPException, socket.error), err:

-                       sys.exit('ERROR: Unable to download video: %s' % str(err))
+                       self.to_stderr('ERROR: unable to download video webpage: %s' % str(err))
+                       return [None]

                self.to_stdout('[youtube] %s: Extracting video information' % video_id)
                
                # "t" param
                mobj = re.search(r', "t": "([^"]+)"', video_webpage)
                if mobj is None:
                self.to_stdout('[youtube] %s: Extracting video information' % video_id)
                
                # "t" param
                mobj = re.search(r', "t": "([^"]+)"', video_webpage)
                if mobj is None:

-                       self.to_stderr('ERROR: Unable to extract "t" parameter')
+                       self.to_stderr('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))
                if format_param is not None:
                        video_real_url = '%s&fmt=%s' % (video_real_url, format_param)
                        return [None]
                video_real_url = 'http://www.youtube.com/get_video?video_id=%s&t=%s' % (video_id, mobj.group(1))
                if format_param is not None:
                        video_real_url = '%s&fmt=%s' % (video_real_url, format_param)

+               self.to_stdout('[youtube] %s: URL: %s' % (video_id, video_real_url))

 
                # uploader
                mobj = re.search(r'More From: ([^<]*)<', video_webpage)
                if mobj is None:
 
                # uploader
                mobj = re.search(r'More From: ([^<]*)<', video_webpage)
                if mobj is None:

-                       self.to_stderr('ERROR: Unable to extract uploader nickname')
+                       self.to_stderr('ERROR: unable to extract uploader nickname')

                        return [None]
                video_uploader = mobj.group(1)
 
                # title
                mobj = re.search(r'(?im)<title>YouTube - ([^<]*)</title>', video_webpage)
                if mobj is None:
                        return [None]
                video_uploader = mobj.group(1)
 
                # title
                mobj = re.search(r'(?im)<title>YouTube - ([^<]*)</title>', video_webpage)
                if mobj is None:

-                       self.to_stderr('ERROR: Unable to extract video title')
+                       self.to_stderr('ERROR: unable to extract video title')

                        return [None]
                video_title = mobj.group(1).decode('utf-8')
                        return [None]
                video_title = mobj.group(1).decode('utf-8')

-               video_title = re.sub(u'&(.+?);', lambda x: unichr(htmlentitydefs.name2codepoint[x.group(1)]), video_title)
+               video_title = re.sub(ur'(?u)&(.+?);', lambda x: unichr(htmlentitydefs.name2codepoint[x.group(1)]), video_title)
+               video_title = video_title.replace(os.sep, u'%')

 
                # simplified title
 
                # simplified title

-               simple_title = re.sub(u'([^%s]+)' % simple_title_chars, u'_', video_title)
-               simple_title = simple_title.strip(u'_')
+               simple_title = re.sub(ur'(?u)([^%s]+)' % simple_title_chars, ur'_', video_title)
+               simple_title = simple_title.strip(ur'_')

 
                # Return information
 
                # Return information

-               return [{       'id':           video_id,
-                               'url':          video_real_url,
-                               'uploader':     video_uploader,
-                               'title':        video_title,
-                               'stitle':       simple_title,
-                               'ext':          video_extension,
-                               }]
+               return [{
+                       'id':           video_id,
+                       'url':          video_real_url,
+                       'uploader':     video_uploader,
+                       'title':        video_title,
+                       'stitle':       simple_title,
+                       'ext':          video_extension,
+                       }]

 
 if __name__ == '__main__':
        try:
 
 if __name__ == '__main__':
        try:

+               # Modules needed only when running the main program
+               import getpass
+               import optparse
+

                # General configuration
                urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler()))
                urllib2.install_opener(urllib2.build_opener(urllib2.HTTPCookieProcessor()))
                # General configuration
                urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler()))
                urllib2.install_opener(urllib2.build_opener(urllib2.HTTPCookieProcessor()))

+               socket.setdefaulttimeout(300) # 5 minutes should be enough (famous last words)
+
+               # Parse command line
+               parser = optparse.OptionParser(
+                               usage='Usage: %prog [options] url...',
+                               version='INTERNAL',
+                               conflict_handler='resolve',
+                               )
+               parser.add_option('-h', '--help',
+                               action='help', help='print this help text and exit')
+               parser.add_option('-v', '--version',
+                               action='version', help='print program version and exit')
+               parser.add_option('-u', '--username',
+                               dest='username', metavar='UN', help='account username')
+               parser.add_option('-p', '--password',
+                               dest='password', metavar='PW', help='account password')
+               parser.add_option('-o', '--output',
+                               dest='outtmpl', metavar='TPL', help='output filename template')
+               parser.add_option('-q', '--quiet',
+                               action='store_true', dest='quiet', help='activates quiet mode', default=False)
+               parser.add_option('-s', '--simulate',
+                               action='store_true', dest='simulate', help='do not download video', default=False)
+               parser.add_option('-t', '--title',
+                               action='store_true', dest='usetitle', help='use title in file name', default=False)
+               parser.add_option('-l', '--literal',
+                               action='store_true', dest='useliteral', help='use literal title in file name', default=False)
+               parser.add_option('-n', '--netrc',
+                               action='store_true', dest='usenetrc', help='use .netrc authentication data', default=False)
+               parser.add_option('-g', '--get-url',
+                               action='store_true', dest='geturl', help='simulate, quiet but print URL', default=False)
+               parser.add_option('-e', '--get-title',
+                               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='video_format', help='alias for -f 18', const='18')
+               parser.add_option('-m', '--mobile-version',
+                               action='store_const', dest='video_format', help='alias for -f 17', const='17')
+               parser.add_option('-i', '--ignore-errors',
+                               action='store_true', dest='ignoreerrors', help='continue on download errors', default=False)
+               (opts, args) = parser.parse_args()
+
+               # Conflicting, missing and erroneous options
+               if len(args) < 1:
+                       sys.exit('ERROR: you must provide at least one URL')
+               if opts.usenetrc and (opts.username is not None or opts.password is not None):
+                       sys.exit('ERROR: using .netrc conflicts with giving username/password')
+               if opts.password is not None and opts.username is None:
+                       sys.exit('ERROR: account username missing')
+               if opts.outtmpl is not None and (opts.useliteral or opts.usetitle):
+                       sys.exit('ERROR: using output template conflicts with using title or literal title')
+               if opts.usetitle and opts.useliteral:
+                       sys.exit('ERROR: using title conflicts with using literal title')
+               if opts.username is not None and opts.password is None:
+                       opts.password = getpass.getpass('Type account password and press return:')

 
                # Information extractors
                youtube_ie = YoutubeIE()
 
                # File downloader
 
                # Information extractors
                youtube_ie = YoutubeIE()
 
                # File downloader

-               fd = FileDownloader({   'usenetrc': False,
-                                       'username': None,
-                                       'password': None,
-                                       'quiet': False,
-                                       'format': None,
-                                       'outtmpl': '%(id)s.%(ext)s'
-                                       })
+               fd = FileDownloader({
+                       'usenetrc': opts.usenetrc,
+                       'username': opts.username,
+                       'password': opts.password,
+                       'quiet': (opts.quiet or opts.geturl or opts.gettitle),
+                       'forceurl': opts.geturl,
+                       'forcetitle': opts.gettitle,
+                       'simulate': (opts.simulate or opts.geturl or opts.gettitle),
+                       'format': opts.format,
+                       'outtmpl': ((opts.outtmpl is not None and opts.outtmpl)
+                               or (opts.usetitle and '%(stitle)s-%(id)s.%(ext)s')
+                               or (opts.useliteral and '%(title)s-%(id)s.%(ext)s')
+                               or '%(id)s.%(ext)s'),
+                       'ignoreerrors': opts.ignoreerrors,
+                       })

                fd.add_info_extractor(youtube_ie)
                fd.add_info_extractor(youtube_ie)

-               fd.download([   'http://www.youtube.com/watch?v=t7qdwI7TVe8',
-                               'http://www.youtube.com/watch?v=IJyn3pRcy_Q',
-                               'http://www.youtube.com/watch?v=DZRXe1wtC-M',   ])
+               retcode = fd.download(args)
+               sys.exit(retcode)

 
 

+       except DownloadError:
+               sys.exit(1)
+       except SameFileError:
+               sys.exit('ERROR: fixed output name but more than one file to download')

        except KeyboardInterrupt:
                sys.exit('\nERROR: Interrupted by user')
        except KeyboardInterrupt:
                sys.exit('\nERROR: Interrupted by user')