[sinthgunt] r198 committed - Updating youtube-dl to most recent version (2010.11.19)
sint...@googlecode.com
Author: kare1234
Date: Mon Nov 22 11:11:02 2010
Log: Updating youtube-dl to most recent version (2010.11.19)
http://code.google.com/p/sinthgunt/source/detail?r=198
Modified:
/trunk/youtube-dl-sinthgunt
=======================================
--- /trunk/youtube-dl-sinthgunt Mon Nov 22 10:27:50 2010
+++ /trunk/youtube-dl-sinthgunt Mon Nov 22 11:11:02 2010
@@ -4,6 +4,7 @@
# Author: Danny Colligan
# Author: Benjamin Johnson
# License: Public domain code
+import cookielib
import htmlentitydefs
import httplib
import locale
@@ -27,7 +28,7 @@
from cgi import parse_qs
std_headers = {
- 'User-Agent': 'Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.8)
Gecko/20100723 Firefox/3.6.8',
+ 'User-Agent': 'Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.12)
Gecko/20101028 Firefox/3.6.12',
'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'en-us,en;q=0.5',
@@ -35,6 +36,21 @@
simple_title_chars = string.ascii_letters.decode('ascii') +
string.digits.decode('ascii')
+month_name_to_number = {
+ 'January': '01',
+ 'February': '02',
+ 'March': '03',
+ 'April': '04',
+ 'May': '05',
+ 'June': '06',
+ 'July': '07',
+ 'August': '08',
+ 'September': '09',
+ 'October': '10',
+ 'November': '11',
+ 'December': '12',
+}
+
def preferredencoding():
"""Get preferred encoding.
@@ -94,6 +110,9 @@
"""
try:
if filename == u'-':
+ if sys.platform == 'win32':
+ import msvcrt
+ msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
return (sys.stdout, filename)
stream = open(filename, open_mode)
return (stream, filename)
@@ -181,22 +200,27 @@
Available options:
- username: Username for authentication purposes.
- 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.
- format_limit: Highest quality format to try.
- outtmpl: Template for output names.
- ignoreerrors: Do not stop on download errors.
- ratelimit: Download speed limit, in bytes/sec.
- nooverwrites: Prevent overwriting files.
- retries: Number of times to retry for HTTP error 503
- continuedl: Try to continue downloads if possible.
- noprogress: Do not print the progress bar.
+ username: Username for authentication purposes.
+ 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.
+ forcethumbnail: Force printing thumbnail URL.
+ forcedescription: Force printing description.
+ simulate: Do not download the video files.
+ format: Video format code.
+ format_limit: Highest quality format to try.
+ outtmpl: Template for output names.
+ ignoreerrors: Do not stop on download errors.
+ ratelimit: Download speed limit, in bytes/sec.
+ nooverwrites: Prevent overwriting files.
+ retries: Number of times to retry for HTTP error 5xx
+ continuedl: Try to continue downloads if possible.
+ noprogress: Do not print the progress bar.
+ playliststart: Playlist item to start at.
+ playlistend: Playlist item to end at.
+ logtostderr: Log messages to stderr instead of stdout.
"""
params = None
@@ -204,6 +228,7 @@
_pps = []
_download_retcode = None
_num_downloads = None
+ _screen_file = None
def __init__(self, params):
"""Create a FileDownloader object with the given options."""
@@ -211,6 +236,7 @@
self._pps = []
self._download_retcode = 0
self._num_downloads = 0
+ self._screen_file = [sys.stdout, sys.stderr][params.get('logtostderr',
False)]
self.params = params
@staticmethod
@@ -297,12 +323,13 @@
self._pps.append(pp)
pp.set_downloader(self)
- def to_stdout(self, message, skip_eol=False,
ignore_encoding_errors=False):
+ def to_screen(self, message, skip_eol=False,
ignore_encoding_errors=False):
"""Print message to stdout if not in quiet mode."""
try:
if not self.params.get('quiet', False):
- print (u'%s%s' % (message, [u'\n',
u''][skip_eol])).encode(preferredencoding()),
- sys.stdout.flush()
+ terminator = [u'\n', u''][skip_eol]
+ print >>self._screen_file, (u'%s%s' % (message,
terminator)).encode(preferredencoding()),
+ self._screen_file.flush()
except (UnicodeEncodeError), err:
if not ignore_encoding_errors:
raise
@@ -343,40 +370,40 @@
def report_destination(self, filename):
"""Report destination filename."""
- self.to_stdout(u'[download] Destination: %s' % filename,
ignore_encoding_errors=True)
+ self.to_screen(u'[download] Destination: %s' % filename,
ignore_encoding_errors=True)
def report_progress(self, percent_str, data_len_str, speed_str, eta_str):
"""Report download progress."""
if self.params.get('noprogress', False):
return
- self.to_stdout(u'\r[download] %s of %s at %s ETA %s' %
+ self.to_screen(u'\r[download] %s of %s at %s ETA %s' %
(percent_str, data_len_str, speed_str, eta_str), skip_eol=True)
def report_resuming_byte(self, resume_len):
- """Report attemtp to resume at given byte."""
- self.to_stdout(u'[download] Resuming download at byte %s' % resume_len)
+ """Report attempt to resume at given byte."""
+ self.to_screen(u'[download] Resuming download at byte %s' % resume_len)
def report_retry(self, count, retries):
- """Report retry in case of HTTP error 503"""
- self.to_stdout(u'[download] Got HTTP error 503. Retrying (attempt %d
of %d)...' % (count, retries))
+ """Report retry in case of HTTP error 5xx"""
+ self.to_screen(u'[download] Got server HTTP error. Retrying (attempt %d
of %d)...' % (count, retries))
def report_file_already_downloaded(self, file_name):
"""Report file has already been fully downloaded."""
try:
- self.to_stdout(u'[download] %s has already been downloaded' % file_name)
+ self.to_screen(u'[download] %s has already been downloaded' % file_name)
except (UnicodeEncodeError), err:
- self.to_stdout(u'[download] The file has already been downloaded')
+ self.to_screen(u'[download] The file has already been downloaded')
def report_unable_to_resume(self):
"""Report it was impossible to resume download."""
- self.to_stdout(u'[download] Unable to resume')
+ self.to_screen(u'[download] Unable to resume')
def report_finish(self):
"""Report download finished."""
if self.params.get('noprogress', False):
- self.to_stdout(u'[download] Download completed')
+ self.to_screen(u'[download] Download completed')
else:
- self.to_stdout(u'')
+ self.to_screen(u'')
def increment_downloads(self):
"""Increment the ordinal that assigns a number to each file."""
@@ -401,18 +428,19 @@
try:
template_dict = dict(info_dict)
template_dict['epoch'] = unicode(long(time.time()))
- template_dict['ord'] = unicode('%05d' % self._num_downloads)
+ template_dict['autonumber'] = unicode('%05d' % self._num_downloads)
filename = self.params['outtmpl'] % template_dict
except (ValueError, KeyError), err:
- self.trouble('ERROR: invalid output template or system charset: %s' %
str(err))
+ self.trouble(u'ERROR: invalid system charset or erroneous output
template')
+ return
if self.params.get('nooverwrites', False) and os.path.exists(filename):
- self.to_stderr(u'WARNING: file exists: %s; skipping' % filename)
+ self.to_stderr(u'WARNING: file exists and will be skipped')
return
try:
self.pmkdir(filename)
except (OSError, IOError), err:
- self.trouble('ERROR: unable to create directories: %s' % str(err))
+ self.trouble(u'ERROR: unable to create directories: %s' % str(err))
return
try:
@@ -420,17 +448,17 @@
except (OSError, IOError), err:
raise UnavailableVideoError
except (urllib2.URLError, httplib.HTTPException, socket.error), err:
- self.trouble('ERROR: unable to download video data: %s' % str(err))
+ self.trouble(u'ERROR: unable to download video data: %s' % str(err))
return
except (ContentTooShortError, ), err:
- self.trouble('ERROR: content too short (expected %s bytes and
served %s)' % (err.expected, err.downloaded))
+ self.trouble(u'ERROR: content too short (expected %s bytes and
served %s)' % (err.expected, err.downloaded))
return
if success:
try:
self.post_process(filename, info_dict)
except (PostProcessingError), err:
- self.trouble('ERROR: postprocessing: %s' % str(err))
+ self.trouble(u'ERROR: postprocessing: %s' % str(err))
return
def download(self, url_list):
@@ -455,7 +483,7 @@
break
if not suitable_found:
- self.trouble('ERROR: no suitable InfoExtractor: %s' % url)
+ self.trouble(u'ERROR: no suitable InfoExtractor: %s' % url)
return self._download_retcode
@@ -485,17 +513,17 @@
retval = subprocess.call(basic_args + [[],
['-e', '-k', '1']][self.params.get('continuedl', False)])
while retval == 2 or retval == 1:
prevsize = os.path.getsize(filename)
- self.to_stdout(u'\r[rtmpdump] %s bytes' % prevsize, skip_eol=True)
+ self.to_screen(u'\r[rtmpdump] %s bytes' % prevsize, skip_eol=True)
time.sleep(5.0) # This seems to be needed
retval = subprocess.call(basic_args + ['-e'] + [[], ['-k', '1']][retval
== 1])
cursize = os.path.getsize(filename)
if prevsize == cursize and retval == 1:
break
if retval == 0:
- self.to_stdout(u'\r[rtmpdump] %s bytes' % os.path.getsize(filename))
+ self.to_screen(u'\r[rtmpdump] %s bytes' % os.path.getsize(filename))
return True
else:
- self.trouble('\nERROR: rtmpdump exited with code %d' % retval)
+ self.trouble(u'\nERROR: rtmpdump exited with code %d' % retval)
return False
def _do_download(self, filename, url, player_url):
@@ -528,7 +556,7 @@
data = urllib2.urlopen(request)
break
except (urllib2.HTTPError, ), err:
- if err.code != 503 and err.code != 416:
+ if (err.code < 500 or err.code >= 600) and err.code != 416:
# Unexpected HTTP error
raise
elif err.code == 416:
@@ -538,7 +566,7 @@
data = urllib2.urlopen(basic_request)
content_length = data.info()['Content-Length']
except (urllib2.HTTPError, ), err:
- if err.code != 503:
+ if err.code < 500 or err.code >= 600:
raise
else:
# Examine the reported length
@@ -588,12 +616,13 @@
(stream, filename) = sanitize_open(filename, open_mode)
self.report_destination(filename)
except (OSError, IOError), err:
- self.trouble('ERROR: unable to open for writing: %s' % str(err))
+ self.trouble(u'ERROR: unable to open for writing: %s' % str(err))
return False
try:
stream.write(data_block)
except (IOError, OSError), err:
- self.trouble('\nERROR: unable to write data: %s' % str(err))
+ self.trouble(u'\nERROR: unable to write data: %s' % str(err))
+ return False
block_size = self.best_block_size(after - before, data_block_len)
# Progress message
@@ -684,9 +713,9 @@
class YoutubeIE(InfoExtractor):
"""Information extractor for youtube.com."""
- _VALID_URL = r'^((?:http://)?(?:youtu\.be/|
(?:\w+\.)?youtube\.com/(?:(?:v/)|
(?:(?:watch(?:_popup)?(?:\.php)?)?[\?#](?:.+&)?v=))))?([0-9A-Za-z_-]+)(?(1).+)?$'
+ _VALID_URL = r'^((?:https?://)?(?:youtu\.be/|
(?:\w+\.)?youtube(?:-nocookie)?\.com/(?:(?:v/)|
(?:(?:watch(?:_popup)?(?:\.php)?)?(?:\?|
#!?)(?:.+&)?v=))))?([0-9A-Za-z_-]+)(?(1).+)?$'
_LANG_URL =
r'http://www.youtube.com/?hl=en&persist_hl=1&gl=US&persist_gl=1&opt_out_ackd=1'
- _LOGIN_URL = 'http://www.youtube.com/signup?next=/&gl=US&hl=en'
+ _LOGIN_URL = 'https://www.youtube.com/signup?next=/&gl=US&hl=en'
_AGE_URL = 'http://www.youtube.com/verify_age?next_url=/&gl=US&hl=en'
_NETRC_MACHINE = 'youtube'
# Listed in order of quality
@@ -708,35 +737,35 @@
def report_lang(self):
"""Report attempt to set language."""
- self._downloader.to_stdout(u'[youtube] Setting language')
+ self._downloader.to_screen(u'[youtube] Setting language')
def report_login(self):
"""Report attempt to log in."""
- self._downloader.to_stdout(u'[youtube] Logging in')
+ self._downloader.to_screen(u'[youtube] Logging in')
def report_age_confirmation(self):
"""Report attempt to confirm age."""
- self._downloader.to_stdout(u'[youtube] Confirming age')
+ self._downloader.to_screen(u'[youtube] Confirming age')
def report_video_webpage_download(self, video_id):
"""Report attempt to download video webpage."""
- self._downloader.to_stdout(u'[youtube] %s: Downloading video webpage' %
video_id)
+ self._downloader.to_screen(u'[youtube] %s: Downloading video webpage' %
video_id)
def report_video_info_webpage_download(self, video_id):
"""Report attempt to download video info webpage."""
- self._downloader.to_stdout(u'[youtube] %s: Downloading video info
webpage' % video_id)
+ self._downloader.to_screen(u'[youtube] %s: Downloading video info
webpage' % video_id)
def report_information_extraction(self, video_id):
"""Report attempt to extract video information."""
- self._downloader.to_stdout(u'[youtube] %s: Extracting video
information' % video_id)
+ self._downloader.to_screen(u'[youtube] %s: Extracting video
information' % video_id)
def report_unavailable_format(self, video_id, format):
"""Report extracted video URL."""
- self._downloader.to_stdout(u'[youtube] %s: Format %s not available' %
(video_id, format))
+ self._downloader.to_screen(u'[youtube] %s: Format %s not available' %
(video_id, format))
def report_rtmp_download(self):
"""Indicate the download will use the RTMP protocol."""
- self._downloader.to_stdout(u'[youtube] RTMP download detected')
+ self._downloader.to_screen(u'[youtube] RTMP download detected')
def _real_initialize(self):
if self._downloader is None:
@@ -817,7 +846,7 @@
# Get video webpage
self.report_video_webpage_download(video_id)
- request =
urllib2.Request('http://www.youtube.com/watch?v=%s&gl=US&hl=en' % video_id,
None, std_headers)
+ request =
urllib2.Request('http://www.youtube.com/watch?v=%s&gl=US&hl=en&has_verified=1' %
video_id, None, std_headers)
try:
video_webpage = urllib2.urlopen(request).read()
except (urllib2.URLError, httplib.HTTPException, socket.error), err:
@@ -825,9 +854,9 @@
return
# Attempt to extract SWF player URL
- mobj = re.search(r'swfConfig.*"(http://.*?watch.*?-.*?\.swf)"',
video_webpage)
+ mobj = re.search(r'swfConfig.*?"(http:\\/\\/.*?watch.*?-.*?\.swf)"',
video_webpage)
if mobj is not None:
- player_url = mobj.group(1)
+ player_url = re.sub(r'\\(.)', r'\1', mobj.group(1))
else:
player_url = None
@@ -847,7 +876,7 @@
return
if 'token' not in video_info:
if 'reason' in video_info:
- self._downloader.trouble(u'ERROR: YouTube said: %s' %
video_info['reason'][0])
+ self._downloader.trouble(u'ERROR: YouTube said: %s' %
video_info['reason'][0].decode('utf-8'))
else:
self._downloader.trouble(u'ERROR: "token" parameter not in video info
for unknown reason')
return
@@ -880,6 +909,23 @@
else: # don't panic if we can't find it
video_thumbnail = urllib.unquote_plus(video_info['thumbnail_url'][0])
+ # upload date
+ upload_date = u'NA'
+ mobj = re.search(r'id="eow-date".*?>(.*?)</span>', video_webpage,
re.DOTALL)
+ if mobj is not None:
+ try:
+ if ',' in mobj.group(1):
+ # Month Day, Year
+ m, d, y = mobj.group(1).replace(',', '').split()
+ else:
+ # Day Month Year, we'll suppose
+ d, m, y = mobj.group(1).split()
+ m = month_name_to_number[m]
+ d = '%02d' % (long(d))
+ upload_date = '%s%s%s' % (y, m, d)
+ except:
+ upload_date = u'NA'
+
# description
video_description = 'No description available.'
if self._downloader.params.get('forcedescription', False):
@@ -934,6 +980,7 @@
'id': video_id.decode('utf-8'),
'url': video_real_url.decode('utf-8'),
'uploader': video_uploader.decode('utf-8'),
+ 'upload_date': upload_date,
'title': video_title,
'stitle': simple_title,
'ext': video_extension.decode('utf-8'),
@@ -964,19 +1011,19 @@
def report_disclaimer(self):
"""Report disclaimer retrieval."""
- self._downloader.to_stdout(u'[metacafe] Retrieving disclaimer')
+ self._downloader.to_screen(u'[metacafe] Retrieving disclaimer')
def report_age_confirmation(self):
"""Report attempt to confirm age."""
- self._downloader.to_stdout(u'[metacafe] Confirming age')
+ self._downloader.to_screen(u'[metacafe] Confirming age')
def report_download_webpage(self, video_id):
"""Report webpage download."""
- self._downloader.to_stdout(u'[metacafe] %s: Downloading webpage' %
video_id)
+ self._downloader.to_screen(u'[metacafe] %s: Downloading webpage' %
video_id)
def report_extraction(self, video_id):
"""Report information extraction."""
- self._downloader.to_stdout(u'[metacafe] %s: Extracting information' %
video_id)
+ self._downloader.to_screen(u'[metacafe] %s: Extracting information' %
video_id)
def _real_initialize(self):
# Retrieve disclaimer
@@ -1020,7 +1067,6 @@
self._downloader.increment_downloads()
simple_title = mobj.group(2).decode('utf-8')
- video_extension = 'flv'
# Retrieve video webpage to extract further information
request = urllib2.Request('http://www.metacafe.com/watch/%s/' % video_id)
@@ -1034,20 +1080,33 @@
# Extract URL, uploader and title from webpage
self.report_extraction(video_id)
mobj = re.search(r'(?m)&mediaURL=([^&]+)', webpage)
- if mobj is None:
- self._downloader.trouble(u'ERROR: unable to extract media URL')
- return
- mediaURL = urllib.unquote(mobj.group(1))
-
- # Extract gdaKey if available
- mobj = re.search(r'(?m)&gdaKey=(.*?)&', webpage)
- if mobj is None:
- video_url = mediaURL
- #self._downloader.trouble(u'ERROR: unable to extract gdaKey')
- #return
+ if mobj is not None:
+ mediaURL = urllib.unquote(mobj.group(1))
+ video_extension = mediaURL[-3:]
+
+ # Extract gdaKey if available
+ mobj = re.search(r'(?m)&gdaKey=(.*?)&', webpage)
+ if mobj is None:
+ video_url = mediaURL
+ else:
+ gdaKey = mobj.group(1)
+ video_url = '%s?__gda__=%s' % (mediaURL, gdaKey)
else:
- gdaKey = mobj.group(1)
- video_url = '%s?__gda__=%s' % (mediaURL, gdaKey)
+ mobj = re.search(r' name="flashvars" value="(.*?)"', webpage)
+ if mobj is None:
+ self._downloader.trouble(u'ERROR: unable to extract media URL')
+ return
+ vardict = parse_qs(mobj.group(1))
+ if 'mediaData' not in vardict:
+ self._downloader.trouble(u'ERROR: unable to extract media URL')
+ return
+ mobj = re.search(r'"mediaURL":"(http.*?)","key":"(.*?)"',
vardict['mediaData'][0])
+ if mobj is None:
+ self._downloader.trouble(u'ERROR: unable to extract media URL')
+ return
+ mediaURL = mobj.group(1).replace('\\/', '/')
+ video_extension = mediaURL[-3:]
+ video_url = '%s?__gda__=%s' % (mediaURL, mobj.group(2))
mobj = re.search(r'(?im)<title>(.*) - Video</title>', webpage)
if mobj is None:
@@ -1068,6 +1127,7 @@
'id': video_id.decode('utf-8'),
'url': video_url.decode('utf-8'),
'uploader': video_uploader.decode('utf-8'),
+ 'upload_date': u'NA',
'title': video_title,
'stitle': simple_title,
'ext': video_extension.decode('utf-8'),
@@ -1092,11 +1152,11 @@
def report_download_webpage(self, video_id):
"""Report webpage download."""
- self._downloader.to_stdout(u'[dailymotion] %s: Downloading webpage' %
video_id)
+ self._downloader.to_screen(u'[dailymotion] %s: Downloading webpage' %
video_id)
def report_extraction(self, video_id):
"""Report information extraction."""
- self._downloader.to_stdout(u'[dailymotion] %s: Extracting information' %
video_id)
+ self._downloader.to_screen(u'[dailymotion] %s: Extracting information' %
video_id)
def _real_initialize(self):
return
@@ -1144,7 +1204,7 @@
video_title = mobj.group(1).decode('utf-8')
video_title = sanitize_title(video_title)
- mobj = re.search(r'(?im)<div class="dmco_html owner">.*?<a class="name"
href="/.+?">(.+?)</a></div>', webpage)
+ mobj = re.search(r'(?im)<div class="dmco_html owner">.*?<a class="name"
href="/.+?">(.+?)</a>', webpage)
if mobj is None:
self._downloader.trouble(u'ERROR: unable to extract uploader nickname')
return
@@ -1156,6 +1216,7 @@
'id': video_id.decode('utf-8'),
'url': video_url.decode('utf-8'),
'uploader': video_uploader.decode('utf-8'),
+ 'upload_date': u'NA',
'title': video_title,
'stitle': simple_title,
'ext': video_extension.decode('utf-8'),
@@ -1179,11 +1240,11 @@
def report_download_webpage(self, video_id):
"""Report webpage download."""
- self._downloader.to_stdout(u'[video.google] %s: Downloading webpage' %
video_id)
+ self._downloader.to_screen(u'[video.google] %s: Downloading webpage' %
video_id)
def report_extraction(self, video_id):
"""Report information extraction."""
- self._downloader.to_stdout(u'[video.google] %s: Extracting
information' % video_id)
+ self._downloader.to_screen(u'[video.google] %s: Extracting
information' % video_id)
def _real_initialize(self):
return
@@ -1265,6 +1326,7 @@
'id': video_id.decode('utf-8'),
'url': video_url.decode('utf-8'),
'uploader': u'NA',
+ 'upload_date': u'NA',
'title': video_title,
'stitle': simple_title,
'ext': video_extension.decode('utf-8'),
@@ -1289,11 +1351,11 @@
def report_download_webpage(self, video_id):
"""Report webpage download."""
- self._downloader.to_stdout(u'[photobucket] %s: Downloading webpage' %
video_id)
+ self._downloader.to_screen(u'[photobucket] %s: Downloading webpage' %
video_id)
def report_extraction(self, video_id):
"""Report information extraction."""
- self._downloader.to_stdout(u'[photobucket] %s: Extracting information' %
video_id)
+ self._downloader.to_screen(u'[photobucket] %s: Extracting information' %
video_id)
def _real_initialize(self):
return
@@ -1346,6 +1408,7 @@
'id': video_id.decode('utf-8'),
'url': video_url.decode('utf-8'),
'uploader': video_uploader,
+ 'upload_date': u'NA',
'title': video_title,
'stitle': simple_title,
'ext': video_extension.decode('utf-8'),
@@ -1373,11 +1436,11 @@
def report_download_webpage(self, video_id):
"""Report webpage download."""
- self._downloader.to_stdout(u'[video.yahoo] %s: Downloading webpage' %
video_id)
+ self._downloader.to_screen(u'[video.yahoo] %s: Downloading webpage' %
video_id)
def report_extraction(self, video_id):
"""Report information extraction."""
- self._downloader.to_stdout(u'[video.yahoo] %s: Extracting information' %
video_id)
+ self._downloader.to_screen(u'[video.yahoo] %s: Extracting information' %
video_id)
def _real_initialize(self):
return
@@ -1500,6 +1563,7 @@
'id': video_id.decode('utf-8'),
'url': video_url,
'uploader': video_uploader,
+ 'upload_date': u'NA',
'title': video_title,
'stitle': simple_title,
'ext': video_extension.decode('utf-8'),
@@ -1525,12 +1589,12 @@
def report_download_webpage(self, video_id):
"""Report webpage download."""
- self._downloader.to_stdout(u'WARNING: Falling back on generic
information extractor.')
- self._downloader.to_stdout(u'[generic] %s: Downloading webpage' %
video_id)
+ self._downloader.to_screen(u'WARNING: Falling back on generic
information extractor.')
+ self._downloader.to_screen(u'[generic] %s: Downloading webpage' %
video_id)
def report_extraction(self, video_id):
"""Report information extraction."""
- self._downloader.to_stdout(u'[generic] %s: Extracting information' %
video_id)
+ self._downloader.to_screen(u'[generic] %s: Extracting information' %
video_id)
def _real_initialize(self):
return
@@ -1602,6 +1666,7 @@
'id': video_id.decode('utf-8'),
'url': video_url.decode('utf-8'),
'uploader': video_uploader,
+ 'upload_date': u'NA',
'title': video_title,
'stitle': simple_title,
'ext': video_extension.decode('utf-8'),
@@ -1632,7 +1697,7 @@
def report_download_page(self, query, pagenum):
"""Report attempt to download playlist page with given number."""
query = query.decode(preferredencoding())
- self._downloader.to_stdout(u'[youtube] query "%s": Downloading
page %s' % (query, pagenum))
+ self._downloader.to_screen(u'[youtube] query "%s": Downloading
page %s' % (query, pagenum))
def _real_initialize(self):
self._youtube_ie.initialize()
@@ -1723,7 +1788,7 @@
def report_download_page(self, query, pagenum):
"""Report attempt to download playlist page with given number."""
query = query.decode(preferredencoding())
- self._downloader.to_stdout(u'[video.google] query "%s": Downloading
page %s' % (query, pagenum))
+ self._downloader.to_screen(u'[video.google] query "%s": Downloading
page %s' % (query, pagenum))
def _real_initialize(self):
self._google_ie.initialize()
@@ -1814,7 +1879,7 @@
def report_download_page(self, query, pagenum):
"""Report attempt to download playlist page with given number."""
query = query.decode(preferredencoding())
- self._downloader.to_stdout(u'[video.yahoo] query "%s": Downloading
page %s' % (query, pagenum))
+ self._downloader.to_screen(u'[video.yahoo] query "%s": Downloading
page %s' % (query, pagenum))
def _real_initialize(self):
self._yahoo_ie.initialize()
@@ -1904,7 +1969,7 @@
def report_download_page(self, playlist_id, pagenum):
"""Report attempt to download playlist page with given number."""
- self._downloader.to_stdout(u'[youtube] PL %s: Downloading page #%s' %
(playlist_id, pagenum))
+ self._downloader.to_screen(u'[youtube] PL %s: Downloading page #%s' %
(playlist_id, pagenum))
def _real_initialize(self):
self._youtube_ie.initialize()
@@ -1941,11 +2006,10 @@
break
pagenum = pagenum + 1
- playliststart = self._downloader.params.get('playliststart', 1)
- playliststart -= 1 #our arrays are zero-based but the playlist is 1-based
- if playliststart > 0:
- video_ids = video_ids[playliststart:]
-
+ playliststart = self._downloader.params.get('playliststart', 1) - 1
+ playlistend = self._downloader.params.get('playlistend', -1)
+ video_ids = video_ids[playliststart:playlistend]
+
for id in video_ids:
self._youtube_ie.extract('http://www.youtube.com/watch?v=%s' % id)
return
@@ -1968,7 +2032,7 @@
def report_download_page(self, username):
"""Report attempt to download user page."""
- self._downloader.to_stdout(u'[youtube] user %s: Downloading page ' %
(username))
+ self._downloader.to_screen(u'[youtube] user %s: Downloading page ' %
(username))
def _real_initialize(self):
self._youtube_ie.initialize()
@@ -2001,10 +2065,9 @@
ids_in_page.append(mobj.group(1))
video_ids.extend(ids_in_page)
- playliststart = self._downloader.params.get('playliststart', 1)
- playliststart = playliststart-1 #our arrays are zero-based but the
playlist is 1-based
- if playliststart > 0:
- video_ids = video_ids[playliststart:]
+ playliststart = self._downloader.params.get('playliststart', 1) - 1
+ playlistend = self._downloader.params.get('playlistend', -1)
+ video_ids = video_ids[playliststart:playlistend]
for id in video_ids:
self._youtube_ie.extract('http://www.youtube.com/watch?v=%s' % id)
@@ -2069,25 +2132,20 @@
if not os.access (filename, os.W_OK):
sys.exit('ERROR: no write permissions on %s' % filename)
- downloader.to_stdout('Updating to latest stable version...')
- latest_url
= 'http://bitbucket.org/rg3/youtube-dl/raw/tip/LATEST_VERSION'
+ downloader.to_screen('Updating to latest stable version...')
+ latest_url
= 'http://github.com/rg3/youtube-dl/raw/master/LATEST_VERSION'
latest_version = urllib.urlopen(latest_url).read().strip()
- prog_url = 'http://bitbucket.org/rg3/youtube-dl/raw/%s/youtube-dl' %
latest_version
+ prog_url = 'http://github.com/rg3/youtube-dl/raw/%s/youtube-dl' %
latest_version
newcontent = urllib.urlopen(prog_url).read()
stream = open(filename, 'w')
stream.write(newcontent)
stream.close()
- downloader.to_stdout('Updated to version %s' % latest_version)
-
- # 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)
+ downloader.to_screen('Updated to version %s' % latest_version)
# Parse command line
parser = optparse.OptionParser(
usage='Usage: %prog [options] url...',
- version='2010.08.04',
+ version='2010.11.19',
conflict_handler='resolve',
)
@@ -2105,6 +2163,8 @@
dest='retries', metavar='RETRIES', help='number of retries (default is
10)', default=10)
parser.add_option('--playlist-start',
dest='playliststart', metavar='NUMBER', help='playlist video to start
at (default is 1)', default=1)
+ parser.add_option('--playlist-end',
+ dest='playlistend', metavar='NUMBER', help='playlist video to end at
(default is last)', default=-1)
authentication = optparse.OptionGroup(parser, 'Authentication Options')
authentication.add_option('-u', '--username',
@@ -2150,6 +2210,8 @@
action='store_true', dest='usetitle', help='use title in file name',
default=False)
filesystem.add_option('-l', '--literal',
action='store_true', dest='useliteral', help='use literal title in
file name', default=False)
+ filesystem.add_option('-A', '--auto-number',
+ action='store_true', dest='autonumber', help='number downloaded files
starting from 00000', default=False)
filesystem.add_option('-o', '--output',
dest='outtmpl', metavar='TEMPLATE', help='output filename template')
filesystem.add_option('-a', '--batch-file',
@@ -2158,10 +2220,29 @@
action='store_true', dest='nooverwrites', help='do not overwrite
files', default=False)
filesystem.add_option('-c', '--continue',
action='store_true', dest='continue_dl', help='resume partially
downloaded files', default=False)
+ filesystem.add_option('--cookies',
+ dest='cookiefile', metavar='FILE', help='file to dump cookie jar to')
parser.add_option_group(filesystem)
(opts, args) = parser.parse_args()
+ # Open appropriate CookieJar
+ if opts.cookiefile is None:
+ jar = cookielib.CookieJar()
+ else:
+ try:
+ jar = cookielib.MozillaCookieJar(opts.cookiefile)
+ if os.path.isfile(opts.cookiefile) and os.access(opts.cookiefile,
os.R_OK):
+ jar.load()
+ except (IOError, OSError), err:
+ sys.exit(u'ERROR: unable to open cookie file')
+
+ # General configuration
+ cookie_processor = urllib2.HTTPCookieProcessor(jar)
+ urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler()))
+ urllib2.install_opener(urllib2.build_opener(cookie_processor))
+ socket.setdefaulttimeout(300) # 5 minutes should be enough (famous last
words)
+
# Batch file verification
batchurls = []
if opts.batchfile is not None:
@@ -2172,7 +2253,7 @@
batchfd = open(opts.batchfile, 'r')
batchurls = batchfd.readlines()
batchurls = [x.strip() for x in batchurls]
- batchurls = [x for x in batchurls if len(x) > 0]
+ batchurls = [x for x in batchurls if len(x) > 0 and not
re.search(r'^[#/;]', x)]
except IOError:
sys.exit(u'ERROR: batch file could not be read')
all_urls = batchurls + args
@@ -2184,8 +2265,8 @@
parser.error(u'using .netrc conflicts with giving username/password')
if opts.password is not None and opts.username is None:
parser.error(u'account username missing')
- if opts.outtmpl is not None and (opts.useliteral or opts.usetitle):
- parser.error(u'using output template conflicts with using title or
literal title')
+ if opts.outtmpl is not None and (opts.useliteral or opts.usetitle or
opts.autonumber):
+ parser.error(u'using output template conflicts with using title,
literal title or auto number')
if opts.usetitle and opts.useliteral:
parser.error(u'using title conflicts with using literal title')
if opts.username is not None and opts.password is None:
@@ -2200,11 +2281,18 @@
opts.retries = long(opts.retries)
except (TypeError, ValueError), err:
parser.error(u'invalid retry count specified')
- if opts.playliststart is not None:
- try:
- opts.playliststart = long(opts.playliststart)
- except (TypeError, ValueError), err:
- parser.error(u'invalid playlist page specified')
+ try:
+ opts.playliststart = long(opts.playliststart)
+ if opts.playliststart <= 0:
+ raise ValueError
+ except (TypeError, ValueError), err:
+ parser.error(u'invalid playlist start number specified')
+ try:
+ opts.playlistend = long(opts.playlistend)
+ if opts.playlistend != -1 and (opts.playlistend <= 0 or
opts.playlistend < opts.playliststart):
+ raise ValueError
+ except (TypeError, ValueError), err:
+ parser.error(u'invalid playlist end number specified')
# Information extractors
youtube_ie = YoutubeIE()
@@ -2237,8 +2325,11 @@
or (opts.format == '-1' and opts.usetitle and
u'%(stitle)s-%(id)s-%(format)s.%(ext)s')
or (opts.format == '-1' and opts.useliteral and
u'%(title)s-%(id)s-%(format)s.%(ext)s')
or (opts.format == '-1' and u'%(id)s-%(format)s.%(ext)s')
+ or (opts.usetitle and opts.autonumber and
u'%(autonumber)s-%(stitle)s-%(id)s.%(ext)s')
+ or (opts.useliteral and opts.autonumber and
u'%(autonumber)s-%(title)s-%(id)s.%(ext)s')
or (opts.usetitle and u'%(stitle)s-%(id)s.%(ext)s')
or (opts.useliteral and u'%(title)s-%(id)s.%(ext)s')
+ or (opts.autonumber and u'%(autonumber)s-%(id)s.%(ext)s')
or u'%(id)s.%(ext)s'),
'ignoreerrors': opts.ignoreerrors,
'ratelimit': opts.ratelimit,
@@ -2247,6 +2338,8 @@
'continuedl': opts.continue_dl,
'noprogress': opts.noprogress,
'playliststart': opts.playliststart,
+ 'playlistend': opts.playlistend,
+ 'logtostderr': opts.outtmpl == '-',
})
fd.add_info_extractor(youtube_search_ie)
fd.add_info_extractor(youtube_pl_ie)
@@ -2275,6 +2368,14 @@
else:
sys.exit()
retcode = fd.download(all_urls)
+
+ # Dump cookie jar if requested
+ if opts.cookiefile is not None:
+ try:
+ jar.save()
+ except (IOError, OSError), err:
+ sys.exit(u'ERROR: unable to save cookie jar')
+
sys.exit(retcode)
except DownloadError: