#!/usr/bin/env python
# -*- coding: utf-8 -*-
-# Author: Ricardo Garcia Gonzalez
-# Author: Danny Colligan
-# Author: Benjamin Johnson
-# Author: Vasyl' Vavrychuk
-# Author: Witold Baryluk
-# Author: Paweł Paprota
-# License: Public domain code
+
+__author__ = (
+ 'Ricardo Garcia Gonzalez',
+ 'Danny Colligan',
+ 'Benjamin Johnson',
+ 'Vasyl\' Vavrychuk',
+ 'Witold Baryluk',
+ 'Paweł Paprota',
+ 'Gergely Imreh',
+ )
+
+__license__ = 'Public Domain'
+__version__ = '2011.08.24-phihag'
+
import cookielib
-import ctypes
import datetime
-import email.utils
import gzip
import htmlentitydefs
import httplib
import re
import socket
import string
-import StringIO
import subprocess
import sys
import time
import urllib
import urllib2
+import warnings
import zlib
+if os.name == 'nt':
+ import ctypes
+
+try:
+ import email.utils
+except ImportError: # Python 2.4
+ import email.Utils
+try:
+ import cStringIO as StringIO
+except ImportError:
+ import StringIO
+
# parse_qs was moved from the cgi module to the urlparse module recently.
try:
from urlparse import parse_qs
except ImportError:
from cgi import parse_qs
+try:
+ import lxml.etree
+except ImportError:
+ pass # Handled below
+
std_headers = {
- 'User-Agent': 'Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.12) Gecko/20101028 Firefox/3.6.12',
+ 'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:5.0.1) Gecko/20100101 Firefox/5.0.1',
'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-Encoding': 'gzip, deflate',
simple_title_chars = string.ascii_letters.decode('ascii') + string.digits.decode('ascii')
+try:
+ import json
+except ImportError: # Python <2.6, use trivialjson (https://github.com/phihag/trivialjson):
+ import re
+ class json(object):
+ @staticmethod
+ def loads(s):
+ s = s.decode('UTF-8')
+ def raiseError(msg, i):
+ raise ValueError(msg + ' at position ' + str(i) + ' of ' + repr(s) + ': ' + repr(s[i:]))
+ def skipSpace(i, expectMore=True):
+ while i < len(s) and s[i] in ' \t\r\n':
+ i += 1
+ if expectMore:
+ if i >= len(s):
+ raiseError('Premature end', i)
+ return i
+ def decodeEscape(match):
+ esc = match.group(1)
+ _STATIC = {
+ '"': '"',
+ '\\': '\\',
+ '/': '/',
+ 'b': unichr(0x8),
+ 'f': unichr(0xc),
+ 'n': '\n',
+ 'r': '\r',
+ 't': '\t',
+ }
+ if esc in _STATIC:
+ return _STATIC[esc]
+ if esc[0] == 'u':
+ if len(esc) == 1+4:
+ return unichr(int(esc[1:5], 16))
+ if len(esc) == 5+6 and esc[5:7] == '\\u':
+ hi = int(esc[1:5], 16)
+ low = int(esc[7:11], 16)
+ return unichr((hi - 0xd800) * 0x400 + low - 0xdc00 + 0x10000)
+ raise ValueError('Unknown escape ' + str(esc))
+ def parseString(i):
+ i += 1
+ e = i
+ while True:
+ e = s.index('"', e)
+ bslashes = 0
+ while s[e-bslashes-1] == '\\':
+ bslashes += 1
+ if bslashes % 2 == 1:
+ e += 1
+ continue
+ break
+ rexp = re.compile(r'\\(u[dD][89aAbB][0-9a-fA-F]{2}\\u[0-9a-fA-F]{4}|u[0-9a-fA-F]{4}|.|$)')
+ stri = rexp.sub(decodeEscape, s[i:e])
+ return (e+1,stri)
+ def parseObj(i):
+ i += 1
+ res = {}
+ i = skipSpace(i)
+ if s[i] == '}': # Empty dictionary
+ return (i+1,res)
+ while True:
+ if s[i] != '"':
+ raiseError('Expected a string object key', i)
+ i,key = parseString(i)
+ i = skipSpace(i)
+ if i >= len(s) or s[i] != ':':
+ raiseError('Expected a colon', i)
+ i,val = parse(i+1)
+ res[key] = val
+ i = skipSpace(i)
+ if s[i] == '}':
+ return (i+1, res)
+ if s[i] != ',':
+ raiseError('Expected comma or closing curly brace', i)
+ i = skipSpace(i+1)
+ def parseArray(i):
+ res = []
+ i = skipSpace(i+1)
+ if s[i] == ']': # Empty array
+ return (i+1,res)
+ while True:
+ i,val = parse(i)
+ res.append(val)
+ i = skipSpace(i) # Raise exception if premature end
+ if s[i] == ']':
+ return (i+1, res)
+ if s[i] != ',':
+ raiseError('Expected a comma or closing bracket', i)
+ i = skipSpace(i+1)
+ def parseDiscrete(i):
+ for k,v in {'true': True, 'false': False, 'null': None}.items():
+ if s.startswith(k, i):
+ return (i+len(k), v)
+ raiseError('Not a boolean (or null)', i)
+ def parseNumber(i):
+ mobj = re.match('^(-?(0|[1-9][0-9]*)(\.[0-9]*)?([eE][+-]?[0-9]+)?)', s[i:])
+ if mobj is None:
+ raiseError('Not a number', i)
+ nums = mobj.group(1)
+ if '.' in nums or 'e' in nums or 'E' in nums:
+ return (i+len(nums), float(nums))
+ return (i+len(nums), int(nums))
+ CHARMAP = {'{': parseObj, '[': parseArray, '"': parseString, 't': parseDiscrete, 'f': parseDiscrete, 'n': parseDiscrete}
+ def parse(i):
+ i = skipSpace(i)
+ i,res = CHARMAP.get(s[i], parseNumber)(i)
+ i = skipSpace(i, False)
+ return (i,res)
+ i,res = parse(0)
+ if i < len(s):
+ raise ValueError('Extra data at end of input (index ' + str(i) + ' of ' + repr(s) + ': ' + repr(s[i:]) + ')')
+ return res
+
def preferredencoding():
"""Get preferred encoding.
consoletitle: Display progress in console window's titlebar.
nopart: Do not use temporary .part files.
updatetime: Use the Last-modified header to set output file timestamps.
+ writedescription: Write the video description to a .description file
+ writeinfojson: Write the video description to a .info.json file
"""
params = None
except:
pass
+ def report_writedescription(self, descfn):
+ """ Report that the description file is being written """
+ self.to_screen(u'[info] Writing video description to: %s' % descfn, ignore_encoding_errors=True)
+
+ def report_writeinfojson(self, infofn):
+ """ Report that the metadata file has been written """
+ self.to_screen(u'[info] Video description metadata as JSON to: %s' % infofn, ignore_encoding_errors=True)
+
def report_destination(self, filename):
"""Report destination filename."""
self.to_screen(u'[download] Destination: %s' % filename, ignore_encoding_errors=True)
self.trouble(u'ERROR: unable to create directories: %s' % str(err))
return
+ if self.params.get('writedescription', False):
+ try:
+ descfn = filename + '.description'
+ self.report_writedescription(descfn)
+ descfile = open(descfn, 'wb')
+ try:
+ descfile.write(info_dict['description'].encode('utf-8'))
+ finally:
+ descfile.close()
+ except (OSError, IOError):
+ self.trouble(u'ERROR: Cannot write description file: %s' % str(descfn))
+ return
+
+ if self.params.get('writeinfojson', False):
+ infofn = filename + '.info.json'
+ self.report_writeinfojson(infofn)
+ try:
+ json.dump
+ except (NameError,AttributeError):
+ self.trouble(u'ERROR: No JSON encoder found. Update to Python 2.6+, setup a json module, or leave out --write-info-json.')
+ return
+ try:
+ infof = open(infofn, 'wb')
+ try:
+ json.dump(info_dict, infof)
+ finally:
+ infof.close()
+ except (OSError, IOError):
+ self.trouble(u'ERROR: Cannot write metadata to JSON file: %s' % str(infofn))
+ return
+
try:
success = self._do_download(filename, info_dict['url'].encode('utf-8'), info_dict.get('player_url', None))
except (OSError, IOError), err:
else:
# Examine the reported length
if (content_length is not None and
- (resume_len - 100 < long(content_length) < resume_len + 100)):
+ (resume_len - 100 < long(content_length) < resume_len + 100)):
# The file had already been fully downloaded.
# Explanation to the above condition: in issue #175 it was revealed that
# YouTube sometimes adds or removes a few bytes from the end of the file,
class YoutubeIE(InfoExtractor):
"""Information extractor for youtube.com."""
- _VALID_URL = r'^((?:https?://)?(?:youtu\.be/|(?:\w+\.)?youtube(?:-nocookie)?\.com/)(?:(?:(?:v|embed)/)|(?:(?:watch(?:_popup)?(?:\.php)?)?(?:\?|#!?)(?:.+&)?v=)))?([0-9A-Za-z_-]+)(?(1).+)?$'
+ _VALID_URL = r'^((?:https?://)?(?:youtu\.be/|(?:\w+\.)?youtube(?:-nocookie)?\.com/)(?:(?:(?:v|embed|e)/)|(?:(?: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 = 'https://www.youtube.com/signup?next=/&gl=US&hl=en'
_AGE_URL = 'http://www.youtube.com/verify_age?next_url=/&gl=US&hl=en'
# upload date
upload_date = u'NA'
- mobj = re.search(r'id="eow-date".*?>(.*?)</span>', video_webpage, re.DOTALL)
+ mobj = re.search(r'id="eow-date.*?>(.*?)</span>', video_webpage, re.DOTALL)
if mobj is not None:
upload_date = ' '.join(re.sub(r'[/,-]', r' ', mobj.group(1)).split())
- format_expressions = ['%d %B %Y', '%B %d %Y']
+ format_expressions = ['%d %B %Y', '%B %d %Y', '%b %d %Y']
for expression in format_expressions:
try:
upload_date = datetime.datetime.strptime(upload_date, expression).strftime('%Y%m%d')
pass
# description
- video_description = 'No description available.'
- if self._downloader.params.get('forcedescription', False):
- mobj = re.search(r'<meta name="description" content="(.*)"(?:\s*/)?>', video_webpage)
- if mobj is not None:
- video_description = mobj.group(1)
+ try:
+ lxml.etree
+ except NameError:
+ video_description = u'No description available.'
+ if self._downloader.params.get('forcedescription', False) or self._downloader.params.get('writedescription', False):
+ mobj = re.search(r'<meta name="description" content="(.*)"(?:\s*/)?>', video_webpage)
+ if mobj is not None:
+ video_description = mobj.group(1).decode('utf-8')
+ else:
+ html_parser = lxml.etree.HTMLParser(encoding='utf-8')
+ vwebpage_doc = lxml.etree.parse(StringIO.StringIO(video_webpage), html_parser)
+ video_description = u''.join(vwebpage_doc.xpath('id("eow-description")//text()'))
+ # TODO use another parser
# token
video_token = urllib.unquote_plus(video_info['token'][0])
# Decide which formats to download
req_format = self._downloader.params.get('format', None)
- if 'fmt_url_map' in video_info:
- url_map = dict(tuple(pair.split('|')) for pair in video_info['fmt_url_map'][0].split(','))
+ if 'conn' in video_info and video_info['conn'][0].startswith('rtmp'):
+ self.report_rtmp_download()
+ video_url_list = [(None, video_info['conn'][0])]
+ elif 'url_encoded_fmt_stream_map' in video_info and len(video_info['url_encoded_fmt_stream_map']) >= 1:
+ url_data_strs = video_info['url_encoded_fmt_stream_map'][0].split(',')
+ url_data = [parse_qs(uds) for uds in url_data_strs]
+ url_data = filter(lambda ud: 'itag' in ud and 'url' in ud, url_data)
+ url_map = dict((ud['itag'][0], ud['url'][0]) for ud in url_data)
+
format_limit = self._downloader.params.get('format_limit', None)
if format_limit is not None and format_limit in self._available_formats:
format_list = self._available_formats[self._available_formats.index(format_limit):]
self._downloader.trouble(u'ERROR: requested format not available')
return
video_url_list = [(req_format, url_map[req_format])] # Specific format
-
- elif 'conn' in video_info and video_info['conn'][0].startswith('rtmp'):
- self.report_rtmp_download()
- video_url_list = [(None, video_info['conn'][0])]
-
else:
- self._downloader.trouble(u'ERROR: no fmt_url_map or conn information found in video info')
+ self._downloader.trouble(u'ERROR: no conn or url_encoded_fmt_stream_map information found in video info')
return
for format_param, video_real_url in video_url_list:
# Extension
video_extension = self._video_extensions.get(format_param, 'flv')
- # Find the video URL in fmt_url_map or conn paramters
try:
# Process video information
self._downloader.process_info({
'ext': video_extension.decode('utf-8'),
'format': (format_param is None and u'NA' or format_param.decode('utf-8')),
'thumbnail': video_thumbnail.decode('utf-8'),
- 'description': video_description.decode('utf-8'),
+ 'description': video_description,
'player_url': player_url,
})
except UnavailableVideoError, err:
yv_lg = 'R0xx6idZnW2zlrKP8xxAIR' # not sure what this represents
yv_bitrate = '700' # according to Wikipedia this is hard-coded
request = urllib2.Request('http://cosmos.bcst.yahoo.com/up/yep/process/getPlaylistFOP.php?node_id=' + video_id +
- '&tech=flash&mode=playlist&lg=' + yv_lg + '&bitrate=' + yv_bitrate + '&vidH=' + yv_video_height +
- '&vidW=' + yv_video_width + '&swf=as3&rd=video.yahoo.com&tk=null&adsupported=v1,v2,&eventid=1301797')
+ '&tech=flash&mode=playlist&lg=' + yv_lg + '&bitrate=' + yv_bitrate + '&vidH=' + yv_video_height +
+ '&vidW=' + yv_video_width + '&swf=as3&rd=video.yahoo.com&tk=null&adsupported=v1,v2,&eventid=1301797')
try:
self.report_download_webpage(video_id)
webpage = urllib2.urlopen(request).read()
class YoutubePlaylistIE(InfoExtractor):
"""Information Extractor for YouTube playlists."""
- _VALID_URL = r'(?:http://)?(?:\w+\.)?youtube.com/(?:(?:view_play_list|my_playlists)\?.*?p=|user/.*?/user/|p/)([^&]+).*'
- _TEMPLATE_URL = 'http://www.youtube.com/view_play_list?p=%s&page=%s&gl=US&hl=en'
+ _VALID_URL = r'(?:http://)?(?:\w+\.)?youtube.com/(?:(?:view_play_list|my_playlists|artist)\?.*?(p|a)=|user/.*?/user/|p/|user/.*?#[pg]/c/)([0-9A-Za-z]+)(?:/.*?/([0-9A-Za-z_-]+))?.*'
+ _TEMPLATE_URL = 'http://www.youtube.com/%s?%s=%s&page=%s&gl=US&hl=en'
_VIDEO_INDICATOR = r'/watch\?v=(.+?)&'
_MORE_PAGES_INDICATOR = r'(?m)>\s*Next\s*</a>'
_youtube_ie = None
self._downloader.trouble(u'ERROR: invalid url: %s' % url)
return
+ # Single video case
+ if mobj.group(3) is not None:
+ self._youtube_ie.extract(mobj.group(3))
+ return
+
# Download playlist pages
- playlist_id = mobj.group(1)
+ # prefix is 'p' as default for playlists but there are other types that need extra care
+ playlist_prefix = mobj.group(1)
+ if playlist_prefix == 'a':
+ playlist_access = 'artist'
+ else:
+ playlist_prefix = 'p'
+ playlist_access = 'view_play_list'
+ playlist_id = mobj.group(2)
video_ids = []
pagenum = 1
while True:
self.report_download_page(playlist_id, pagenum)
- request = urllib2.Request(self._TEMPLATE_URL % (playlist_id, pagenum))
+ request = urllib2.Request(self._TEMPLATE_URL % (playlist_access, playlist_prefix, playlist_id, pagenum))
try:
page = urllib2.urlopen(request).read()
except (urllib2.URLError, httplib.HTTPException, socket.error), err:
video_ids = video_ids[playliststart:]
else:
video_ids = video_ids[playliststart:playlistend]
-
+
self._downloader.to_screen("[youtube] user %s: Collected %d video ids (downloading %d of them)" %
- (username, all_ids_count, len(video_ids)))
+ (username, all_ids_count, len(video_ids)))
for video_id in video_ids:
self._youtube_ie.extract('http://www.youtube.com/watch?v=%s' % video_id)
except UnavailableVideoError, err:
self._downloader.trouble(u'ERROR: unable to download file')
+class FacebookIE(InfoExtractor):
+ """Information Extractor for Facebook"""
+
+ _VALID_URL = r'^(?:https?://)?(?:\w+\.)?facebook.com/video/video.php\?(?:.*?)v=(?P<ID>\d+)(?:.*)'
+ _LOGIN_URL = 'https://login.facebook.com/login.php?m&next=http%3A%2F%2Fm.facebook.com%2Fhome.php&'
+ _NETRC_MACHINE = 'facebook'
+ _available_formats = ['highqual', 'lowqual']
+ _video_extensions = {
+ 'highqual': 'mp4',
+ 'lowqual': 'mp4',
+ }
+
+ def __init__(self, downloader=None):
+ InfoExtractor.__init__(self, downloader)
+
+ @staticmethod
+ def suitable(url):
+ return (re.match(FacebookIE._VALID_URL, url) is not None)
+
+ def _reporter(self, message):
+ """Add header and report message."""
+ self._downloader.to_screen(u'[facebook] %s' % message)
+
+ def report_login(self):
+ """Report attempt to log in."""
+ self._reporter(u'Logging in')
+
+ def report_video_webpage_download(self, video_id):
+ """Report attempt to download video webpage."""
+ self._reporter(u'%s: Downloading video webpage' % video_id)
+
+ def report_information_extraction(self, video_id):
+ """Report attempt to extract video information."""
+ self._reporter(u'%s: Extracting video information' % video_id)
+
+ def _parse_page(self, video_webpage):
+ """Extract video information from page"""
+ # General data
+ data = {'title': r'class="video_title datawrap">(.*?)</',
+ 'description': r'<div class="datawrap">(.*?)</div>',
+ 'owner': r'\("video_owner_name", "(.*?)"\)',
+ 'upload_date': r'data-date="(.*?)"',
+ 'thumbnail': r'\("thumb_url", "(?P<THUMB>.*?)"\)',
+ }
+ video_info = {}
+ for piece in data.keys():
+ mobj = re.search(data[piece], video_webpage)
+ if mobj is not None:
+ video_info[piece] = urllib.unquote_plus(mobj.group(1).decode("unicode_escape"))
+
+ # Video urls
+ video_urls = {}
+ for fmt in self._available_formats:
+ mobj = re.search(r'\("%s_src\", "(.+?)"\)' % fmt, video_webpage)
+ if mobj is not None:
+ # URL is in a Javascript segment inside an escaped Unicode format within
+ # the generally utf-8 page
+ video_urls[fmt] = urllib.unquote_plus(mobj.group(1).decode("unicode_escape"))
+ video_info['video_urls'] = video_urls
+
+ return video_info
+
+ def _real_initialize(self):
+ if self._downloader is None:
+ return
+
+ useremail = None
+ password = None
+ downloader_params = self._downloader.params
+
+ # Attempt to use provided username and password or .netrc data
+ if downloader_params.get('username', None) is not None:
+ useremail = downloader_params['username']
+ password = downloader_params['password']
+ elif downloader_params.get('usenetrc', False):
+ try:
+ info = netrc.netrc().authenticators(self._NETRC_MACHINE)
+ if info is not None:
+ useremail = info[0]
+ password = info[2]
+ else:
+ raise netrc.NetrcParseError('No authenticators for %s' % self._NETRC_MACHINE)
+ except (IOError, netrc.NetrcParseError), err:
+ self._downloader.to_stderr(u'WARNING: parsing .netrc: %s' % str(err))
+ return
+
+ if useremail is None:
+ return
+
+ # Log in
+ login_form = {
+ 'email': useremail,
+ 'pass': password,
+ 'login': 'Log+In'
+ }
+ request = urllib2.Request(self._LOGIN_URL, urllib.urlencode(login_form))
+ try:
+ self.report_login()
+ login_results = urllib2.urlopen(request).read()
+ if re.search(r'<form(.*)name="login"(.*)</form>', login_results) is not None:
+ self._downloader.to_stderr(u'WARNING: unable to log in: bad username/password, or exceded login rate limit (~3/min). Check credentials or wait.')
+ return
+ except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+ self._downloader.to_stderr(u'WARNING: unable to log in: %s' % str(err))
+ return
+
+ 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)
+ return
+ video_id = mobj.group('ID')
+
+ # Get video webpage
+ self.report_video_webpage_download(video_id)
+ request = urllib2.Request('https://www.facebook.com/video/video.php?v=%s' % video_id)
+ try:
+ page = urllib2.urlopen(request)
+ video_webpage = page.read()
+ except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+ self._downloader.trouble(u'ERROR: unable to download video webpage: %s' % str(err))
+ return
+
+ # Start extracting information
+ self.report_information_extraction(video_id)
+
+ # Extract information
+ video_info = self._parse_page(video_webpage)
+
+ # uploader
+ if 'owner' not in video_info:
+ self._downloader.trouble(u'ERROR: unable to extract uploader nickname')
+ return
+ video_uploader = video_info['owner']
+
+ # title
+ if 'title' not in video_info:
+ self._downloader.trouble(u'ERROR: unable to extract video title')
+ return
+ video_title = video_info['title']
+ video_title = video_title.decode('utf-8')
+ video_title = sanitize_title(video_title)
+
+ # simplified title
+ simple_title = re.sub(ur'(?u)([^%s]+)' % simple_title_chars, ur'_', video_title)
+ simple_title = simple_title.strip(ur'_')
+
+ # thumbnail image
+ if 'thumbnail' not in video_info:
+ self._downloader.trouble(u'WARNING: unable to extract video thumbnail')
+ video_thumbnail = ''
+ else:
+ video_thumbnail = video_info['thumbnail']
+
+ # upload date
+ upload_date = u'NA'
+ if 'upload_date' in video_info:
+ upload_time = video_info['upload_date']
+ timetuple = email.utils.parsedate_tz(upload_time)
+ if timetuple is not None:
+ try:
+ upload_date = time.strftime('%Y%m%d', timetuple[0:9])
+ except:
+ pass
+
+ # description
+ video_description = video_info.get('description', 'No description available.')
+
+ url_map = video_info['video_urls']
+ if len(url_map.keys()) > 0:
+ # Decide which formats to download
+ req_format = self._downloader.params.get('format', None)
+ format_limit = self._downloader.params.get('format_limit', None)
+
+ if format_limit is not None and format_limit in self._available_formats:
+ format_list = self._available_formats[self._available_formats.index(format_limit):]
+ else:
+ format_list = self._available_formats
+ existing_formats = [x for x in format_list if x in url_map]
+ if len(existing_formats) == 0:
+ self._downloader.trouble(u'ERROR: no known formats available for video')
+ return
+ if req_format is None:
+ video_url_list = [(existing_formats[0], url_map[existing_formats[0]])] # Best quality
+ elif req_format == '-1':
+ video_url_list = [(f, url_map[f]) for f in existing_formats] # All formats
+ else:
+ # Specific format
+ if req_format not in url_map:
+ self._downloader.trouble(u'ERROR: requested format not available')
+ return
+ video_url_list = [(req_format, url_map[req_format])] # Specific format
+
+ for format_param, video_real_url in video_url_list:
+
+ # At this point we have a new video
+ self._downloader.increment_downloads()
+
+ # Extension
+ video_extension = self._video_extensions.get(format_param, 'mp4')
+
+ try:
+ # Process video information
+ self._downloader.process_info({
+ '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'),
+ 'format': (format_param is None and u'NA' or format_param.decode('utf-8')),
+ 'thumbnail': video_thumbnail.decode('utf-8'),
+ 'description': video_description.decode('utf-8'),
+ 'player_url': None,
+ })
+ except UnavailableVideoError, err:
+ self._downloader.trouble(u'\nERROR: unable to download video')
+
+class BlipTVIE(InfoExtractor):
+ """Information extractor for blip.tv"""
+
+ _VALID_URL = r'^(?:https?://)?(?:\w+\.)?blip\.tv(/.+)$'
+ _URL_EXT = r'^.*\.([a-z0-9]+)$'
+
+ @staticmethod
+ def suitable(url):
+ return (re.match(BlipTVIE._VALID_URL, url) is not None)
+
+ def report_extraction(self, file_id):
+ """Report information extraction."""
+ self._downloader.to_screen(u'[blip.tv] %s: Extracting information' % file_id)
+
+ def _simplify_title(self, title):
+ res = re.sub(ur'(?u)([^%s]+)' % simple_title_chars, ur'_', title)
+ res = res.strip(ur'_')
+ return res
+
+ 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)
+ return
+
+ if '?' in url:
+ cchar = '&'
+ else:
+ cchar = '?'
+ json_url = url + cchar + 'skin=json&version=2&no_wrap=1'
+ request = urllib2.Request(json_url)
+ self.report_extraction(mobj.group(1))
+ try:
+ json_code = urllib2.urlopen(request).read()
+ except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+ self._downloader.trouble(u'ERROR: unable to download video info webpage: %s' % str(err))
+ return
+ try:
+ json_data = json.loads(json_code)
+ if 'Post' in json_data:
+ data = json_data['Post']
+ else:
+ data = json_data
+
+ upload_date = datetime.datetime.strptime(data['datestamp'], '%m-%d-%y %H:%M%p').strftime('%Y%m%d')
+ video_url = data['media']['url']
+ umobj = re.match(self._URL_EXT, video_url)
+ if umobj is None:
+ raise ValueError('Can not determine filename extension')
+ ext = umobj.group(1)
+
+ self._downloader.increment_downloads()
+
+ info = {
+ 'id': data['item_id'],
+ 'url': video_url,
+ 'uploader': data['display_name'],
+ 'upload_date': upload_date,
+ 'title': data['title'],
+ 'stitle': self._simplify_title(data['title']),
+ 'ext': ext,
+ 'format': data['media']['mimeType'],
+ 'thumbnail': data['thumbnailUrl'],
+ 'description': data['description'],
+ 'player_url': data['embedUrl']
+ }
+ except (ValueError,KeyError), err:
+ self._downloader.trouble(u'ERROR: unable to parse video information: %s' % repr(err))
+ return
+
+ try:
+ self._downloader.process_info(info)
+ except UnavailableVideoError, err:
+ self._downloader.trouble(u'\nERROR: unable to download video')
+
+
class PostProcessor(object):
"""Post Processor class.
"""
return information # by default, do nothing
-### MAIN PROGRAM ###
-if __name__ == '__main__':
- try:
- # Modules needed only when running the main program
- import getpass
- import optparse
+class FFmpegExtractAudioPP(PostProcessor):
- # Function to update the program file with the latest version from the repository.
- def update_self(downloader, filename):
- # Note: downloader only used for options
- if not os.access(filename, os.W_OK):
- sys.exit('ERROR: no write permissions on %s' % filename)
+ def __init__(self, downloader=None, preferredcodec=None):
+ PostProcessor.__init__(self, downloader)
+ if preferredcodec is None:
+ preferredcodec = 'best'
+ self._preferredcodec = preferredcodec
- downloader.to_screen('Updating to latest stable version...')
- try:
- latest_url = 'http://github.com/rg3/youtube-dl/raw/master/LATEST_VERSION'
- latest_version = urllib.urlopen(latest_url).read().strip()
- prog_url = 'http://github.com/rg3/youtube-dl/raw/%s/youtube-dl' % latest_version
- newcontent = urllib.urlopen(prog_url).read()
- except (IOError, OSError), err:
- sys.exit('ERROR: unable to download latest version')
- try:
- stream = open(filename, 'w')
- stream.write(newcontent)
- stream.close()
- except (IOError, OSError), err:
- sys.exit('ERROR: unable to overwrite current version')
- downloader.to_screen('Updated to version %s' % latest_version)
-
- # Parse command line
- parser = optparse.OptionParser(
- usage='Usage: %prog [options] url...',
- version='2010.12.09',
- 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', '--update',
- action='store_true', dest='update_self', help='update this program to latest stable version')
- parser.add_option('-i', '--ignore-errors',
- action='store_true', dest='ignoreerrors', help='continue on download errors', default=False)
- parser.add_option('-r', '--rate-limit',
- dest='ratelimit', metavar='LIMIT', help='download rate limit (e.g. 50k or 44.6m)')
- parser.add_option('-R', '--retries',
- 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)
- parser.add_option('--dump-user-agent',
- action='store_true', dest='dump_user_agent',
- help='display the current browser identification', default=False)
-
- authentication = optparse.OptionGroup(parser, 'Authentication Options')
- authentication.add_option('-u', '--username',
- dest='username', metavar='USERNAME', help='account username')
- authentication.add_option('-p', '--password',
- dest='password', metavar='PASSWORD', help='account password')
- authentication.add_option('-n', '--netrc',
- action='store_true', dest='usenetrc', help='use .netrc authentication data', default=False)
- parser.add_option_group(authentication)
-
- video_format = optparse.OptionGroup(parser, 'Video Format Options')
- video_format.add_option('-f', '--format',
- action='store', dest='format', metavar='FORMAT', help='video format code')
- video_format.add_option('--all-formats',
- action='store_const', dest='format', help='download all available video formats', const='-1')
- video_format.add_option('--max-quality',
- action='store', dest='format_limit', metavar='FORMAT', help='highest quality format to download')
- parser.add_option_group(video_format)
-
- verbosity = optparse.OptionGroup(parser, 'Verbosity / Simulation Options')
- verbosity.add_option('-q', '--quiet',
- action='store_true', dest='quiet', help='activates quiet mode', default=False)
- verbosity.add_option('-s', '--simulate',
- action='store_true', dest='simulate', help='do not download video', default=False)
- verbosity.add_option('-g', '--get-url',
- action='store_true', dest='geturl', help='simulate, quiet but print URL', default=False)
- verbosity.add_option('-e', '--get-title',
- action='store_true', dest='gettitle', help='simulate, quiet but print title', default=False)
- verbosity.add_option('--get-thumbnail',
- action='store_true', dest='getthumbnail',
- help='simulate, quiet but print thumbnail URL', default=False)
- verbosity.add_option('--get-description',
- action='store_true', dest='getdescription',
- help='simulate, quiet but print video description', default=False)
- verbosity.add_option('--get-filename',
- action='store_true', dest='getfilename',
- help='simulate, quiet but print output filename', default=False)
- verbosity.add_option('--no-progress',
- action='store_true', dest='noprogress', help='do not print progress bar', default=False)
- verbosity.add_option('--console-title',
- action='store_true', dest='consoletitle',
- help='display progress in console titlebar', default=False)
- parser.add_option_group(verbosity)
-
- filesystem = optparse.OptionGroup(parser, 'Filesystem Options')
- filesystem.add_option('-t', '--title',
- 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',
- dest='batchfile', metavar='FILE', help='file containing URLs to download (\'-\' for stdin)')
- filesystem.add_option('-w', '--no-overwrites',
- 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')
- filesystem.add_option('--no-part',
- action='store_true', dest='nopart', help='do not use .part files', default=False)
- filesystem.add_option('--no-mtime',
- action='store_false', dest='updatetime',
- help='do not use the Last-modified header to set the file modification time', default=True)
- parser.add_option_group(filesystem)
-
- (opts, args) = parser.parse_args()
-
- # Open appropriate CookieJar
- if opts.cookiefile is None:
- jar = cookielib.CookieJar()
+ @staticmethod
+ def get_audio_codec(path):
+ try:
+ cmd = ['ffprobe', '-show_streams', '--', path]
+ handle = subprocess.Popen(cmd, stderr=file(os.path.devnull, 'w'), stdout=subprocess.PIPE)
+ output = handle.communicate()[0]
+ if handle.wait() != 0:
+ return None
+ except (IOError, OSError):
+ return None
+ audio_codec = None
+ for line in output.split('\n'):
+ if line.startswith('codec_name='):
+ audio_codec = line.split('=')[1].strip()
+ elif line.strip() == 'codec_type=audio' and audio_codec is not None:
+ return audio_codec
+ return None
+
+ @staticmethod
+ def run_ffmpeg(path, out_path, codec, more_opts):
+ try:
+ cmd = ['ffmpeg', '-y', '-i', path, '-vn', '-acodec', codec] + more_opts + ['--', out_path]
+ ret = subprocess.call(cmd, stdout=file(os.path.devnull, 'w'), stderr=subprocess.STDOUT)
+ return (ret == 0)
+ except (IOError, OSError):
+ return False
+
+ def run(self, information):
+ path = information['filepath']
+
+ filecodec = self.get_audio_codec(path)
+ if filecodec is None:
+ self._downloader.to_stderr(u'WARNING: unable to obtain file audio codec with ffprobe')
+ return None
+
+ more_opts = []
+ if self._preferredcodec == 'best' or self._preferredcodec == filecodec:
+ if filecodec == 'aac' or filecodec == 'mp3':
+ # Lossless if possible
+ acodec = 'copy'
+ extension = filecodec
+ if filecodec == 'aac':
+ more_opts = ['-f', 'adts']
+ else:
+ # MP3 otherwise.
+ acodec = 'libmp3lame'
+ extension = 'mp3'
+ more_opts = ['-ab', '128k']
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')
+ # We convert the audio (lossy)
+ acodec = {'mp3': 'libmp3lame', 'aac': 'aac'}[self._preferredcodec]
+ extension = self._preferredcodec
+ more_opts = ['-ab', '128k']
+ if self._preferredcodec == 'aac':
+ more_opts += ['-f', 'adts']
+
+ (prefix, ext) = os.path.splitext(path)
+ new_path = prefix + '.' + extension
+ self._downloader.to_screen(u'[ffmpeg] Destination: %s' % new_path)
+ status = self.run_ffmpeg(path, new_path, acodec, more_opts)
+
+ if not status:
+ self._downloader.to_stderr(u'WARNING: error running ffmpeg')
+ return None
- # Dump user agent
- if opts.dump_user_agent:
- print std_headers['User-Agent']
- sys.exit(0)
+ try:
+ os.remove(path)
+ except (IOError, OSError):
+ self._downloader.to_stderr(u'WARNING: Unable to remove downloaded video file')
+ return None
- # General configuration
- cookie_processor = urllib2.HTTPCookieProcessor(jar)
- urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler(), cookie_processor, YoutubeDLHandler()))
- socket.setdefaulttimeout(300) # 5 minutes should be enough (famous last words)
+ information['filepath'] = new_path
+ return information
- # Batch file verification
- batchurls = []
- if opts.batchfile is not None:
- try:
- if opts.batchfile == '-':
- batchfd = sys.stdin
- else:
- 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 and not re.search(r'^[#/;]', x)]
- except IOError:
- sys.exit(u'ERROR: batch file could not be read')
- all_urls = batchurls + args
-
- # Conflicting, missing and erroneous options
- if opts.usenetrc and (opts.username is not None or opts.password is not None):
- 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 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:
- opts.password = getpass.getpass(u'Type account password and press return:')
- if opts.ratelimit is not None:
- numeric_limit = FileDownloader.parse_bytes(opts.ratelimit)
- if numeric_limit is None:
- parser.error(u'invalid rate limit specified')
- opts.ratelimit = numeric_limit
- if opts.retries is not None:
- try:
- opts.retries = long(opts.retries)
- except (TypeError, ValueError), err:
- parser.error(u'invalid retry count specified')
+
+def updateSelf(downloader, filename):
+ ''' Update the program file with the latest version from the repository '''
+ # Note: downloader only used for options
+ if not os.access(filename, os.W_OK):
+ sys.exit('ERROR: no write permissions on %s' % filename)
+
+ downloader.to_screen('Updating to latest stable version...')
+
+ try:
+ latest_url = 'http://github.com/rg3/youtube-dl/raw/master/LATEST_VERSION'
+ latest_version = urllib.urlopen(latest_url).read().strip()
+ prog_url = 'http://github.com/rg3/youtube-dl/raw/%s/youtube-dl' % latest_version
+ newcontent = urllib.urlopen(prog_url).read()
+ except (IOError, OSError), err:
+ sys.exit('ERROR: unable to download latest version')
+
+ try:
+ stream = open(filename, 'w')
+ stream.write(newcontent)
+ stream.close()
+ except (IOError, OSError), err:
+ sys.exit('ERROR: unable to overwrite current version')
+
+ downloader.to_screen('Updated to version %s' % latest_version)
+
+def parseOpts():
+ # Deferred imports
+ import getpass
+ import optparse
+
+ def _format_option_string(option):
+ ''' ('-o', '--option') -> -o, --format METAVAR'''
+
+ opts = []
+
+ if option._short_opts: opts.append(option._short_opts[0])
+ if option._long_opts: opts.append(option._long_opts[0])
+ if len(opts) > 1: opts.insert(1, ', ')
+
+ if option.takes_value(): opts.append(' %s' % option.metavar)
+
+ return "".join(opts)
+
+ def _find_term_columns():
+ columns = os.environ.get('COLUMNS', None)
+ if columns:
+ return int(columns)
+
+ # TODO: Breaks on phihag's system
+ #if sys.platform.startswith('linux'):
+ # try:
+ # return os.popen('stty size', 'r').read().split()[1]
+ # except: pass
+ return None
+
+ max_width = 80
+ max_help_position = 80
+
+ # No need to wrap help messages if we're on a wide console
+ columns = _find_term_columns()
+ if columns: max_width = columns
+
+ fmt = optparse.IndentedHelpFormatter(width=max_width, max_help_position=max_help_position)
+ fmt.format_option_strings = _format_option_string
+
+ kw = {
+ 'version' : __version__,
+ 'formatter' : fmt,
+ 'usage' : '%prog [options] url...',
+ 'conflict_handler' : 'resolve',
+ }
+
+ parser = optparse.OptionParser(**kw)
+
+ # option groups
+ general = optparse.OptionGroup(parser, 'General Options')
+ authentication = optparse.OptionGroup(parser, 'Authentication Options')
+ video_format = optparse.OptionGroup(parser, 'Video Format Options')
+ postproc = optparse.OptionGroup(parser, 'Post-processing Options')
+ filesystem = optparse.OptionGroup(parser, 'Filesystem Options')
+ verbosity = optparse.OptionGroup(parser, 'Verbosity / Simulation Options')
+
+ general.add_option('-h', '--help',
+ action='help', help='print this help text and exit')
+ general.add_option('-v', '--version',
+ action='version', help='print program version and exit')
+ general.add_option('-U', '--update',
+ action='store_true', dest='update_self', help='update this program to latest stable version')
+ general.add_option('-i', '--ignore-errors',
+ action='store_true', dest='ignoreerrors', help='continue on download errors', default=False)
+ general.add_option('-r', '--rate-limit',
+ dest='ratelimit', metavar='LIMIT', help='download rate limit (e.g. 50k or 44.6m)')
+ general.add_option('-R', '--retries',
+ dest='retries', metavar='RETRIES', help='number of retries (default is 10)', default=10)
+ general.add_option('--playlist-start',
+ dest='playliststart', metavar='NUMBER', help='playlist video to start at (default is 1)', default=1)
+ general.add_option('--playlist-end',
+ dest='playlistend', metavar='NUMBER', help='playlist video to end at (default is last)', default=-1)
+ general.add_option('--dump-user-agent',
+ action='store_true', dest='dump_user_agent',
+ help='display the current browser identification', default=False)
+
+ authentication.add_option('-u', '--username',
+ dest='username', metavar='USERNAME', help='account username')
+ authentication.add_option('-p', '--password',
+ dest='password', metavar='PASSWORD', help='account password')
+ authentication.add_option('-n', '--netrc',
+ action='store_true', dest='usenetrc', help='use .netrc authentication data', default=False)
+
+
+ video_format.add_option('-f', '--format',
+ action='store', dest='format', metavar='FORMAT', help='video format code')
+ video_format.add_option('--all-formats',
+ action='store_const', dest='format', help='download all available video formats', const='-1')
+ video_format.add_option('--max-quality',
+ action='store', dest='format_limit', metavar='FORMAT', help='highest quality format to download')
+
+
+ verbosity.add_option('-q', '--quiet',
+ action='store_true', dest='quiet', help='activates quiet mode', default=False)
+ verbosity.add_option('-s', '--simulate',
+ action='store_true', dest='simulate', help='do not download video', default=False)
+ verbosity.add_option('-g', '--get-url',
+ action='store_true', dest='geturl', help='simulate, quiet but print URL', default=False)
+ verbosity.add_option('-e', '--get-title',
+ action='store_true', dest='gettitle', help='simulate, quiet but print title', default=False)
+ verbosity.add_option('--get-thumbnail',
+ action='store_true', dest='getthumbnail',
+ help='simulate, quiet but print thumbnail URL', default=False)
+ verbosity.add_option('--get-description',
+ action='store_true', dest='getdescription',
+ help='simulate, quiet but print video description', default=False)
+ verbosity.add_option('--get-filename',
+ action='store_true', dest='getfilename',
+ help='simulate, quiet but print output filename', default=False)
+ verbosity.add_option('--no-progress',
+ action='store_true', dest='noprogress', help='do not print progress bar', default=False)
+ verbosity.add_option('--console-title',
+ action='store_true', dest='consoletitle',
+ help='display progress in console titlebar', default=False)
+
+
+ filesystem.add_option('-t', '--title',
+ 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',
+ dest='batchfile', metavar='FILE', help='file containing URLs to download (\'-\' for stdin)')
+ filesystem.add_option('-w', '--no-overwrites',
+ 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')
+ filesystem.add_option('--no-part',
+ action='store_true', dest='nopart', help='do not use .part files', default=False)
+ filesystem.add_option('--no-mtime',
+ action='store_false', dest='updatetime',
+ help='do not use the Last-modified header to set the file modification time', default=True)
+ filesystem.add_option('--write-description',
+ action='store_true', dest='writedescription',
+ help='write video description to a .description file', default=False)
+ filesystem.add_option('--write-info-json',
+ action='store_true', dest='writeinfojson',
+ help='write video metadata to a .info.json file', default=False)
+
+
+ postproc.add_option('--extract-audio', action='store_true', dest='extractaudio', default=False,
+ help='convert video files to audio-only files (requires ffmpeg and ffprobe)')
+ postproc.add_option('--audio-format', metavar='FORMAT', dest='audioformat', default='best',
+ help='"best", "aac" or "mp3"; best by default')
+
+
+ parser.add_option_group(general)
+ parser.add_option_group(filesystem)
+ parser.add_option_group(verbosity)
+ parser.add_option_group(video_format)
+ parser.add_option_group(authentication)
+ parser.add_option_group(postproc)
+
+ opts, args = parser.parse_args()
+
+ return parser, opts, args
+
+def main():
+ parser, opts, args = parseOpts()
+
+ # Open appropriate CookieJar
+ if opts.cookiefile is None:
+ jar = cookielib.CookieJar()
+ else:
try:
- opts.playliststart = long(opts.playliststart)
- if opts.playliststart <= 0:
- raise ValueError
- except (TypeError, ValueError), err:
- parser.error(u'invalid playlist start number specified')
+ 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')
+
+ # Dump user agent
+ if opts.dump_user_agent:
+ print std_headers['User-Agent']
+ sys.exit(0)
+
+ # General configuration
+ cookie_processor = urllib2.HTTPCookieProcessor(jar)
+ urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler(), cookie_processor, YoutubeDLHandler()))
+ socket.setdefaulttimeout(300) # 5 minutes should be enough (famous last words)
+
+ # Batch file verification
+ batchurls = []
+ if opts.batchfile is not None:
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()
- metacafe_ie = MetacafeIE(youtube_ie)
- dailymotion_ie = DailymotionIE()
- youtube_pl_ie = YoutubePlaylistIE(youtube_ie)
- youtube_user_ie = YoutubeUserIE(youtube_ie)
- youtube_search_ie = YoutubeSearchIE(youtube_ie)
- google_ie = GoogleIE()
- google_search_ie = GoogleSearchIE(google_ie)
- photobucket_ie = PhotobucketIE()
- yahoo_ie = YahooIE()
- yahoo_search_ie = YahooSearchIE(yahoo_ie)
- deposit_files_ie = DepositFilesIE()
- generic_ie = GenericIE()
-
- # File downloader
- fd = FileDownloader({
- 'usenetrc': opts.usenetrc,
- 'username': opts.username,
- 'password': opts.password,
- 'quiet': (opts.quiet or opts.geturl or opts.gettitle or opts.getthumbnail or opts.getdescription or opts.getfilename),
- 'forceurl': opts.geturl,
- 'forcetitle': opts.gettitle,
- 'forcethumbnail': opts.getthumbnail,
- 'forcedescription': opts.getdescription,
- 'forcefilename': opts.getfilename,
- 'simulate': (opts.simulate or opts.geturl or opts.gettitle or opts.getthumbnail or opts.getdescription or opts.getfilename),
- 'format': opts.format,
- 'format_limit': opts.format_limit,
- 'outtmpl': ((opts.outtmpl is not None and opts.outtmpl.decode(preferredencoding()))
- 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,
- 'nooverwrites': opts.nooverwrites,
- 'retries': opts.retries,
- 'continuedl': opts.continue_dl,
- 'noprogress': opts.noprogress,
- 'playliststart': opts.playliststart,
- 'playlistend': opts.playlistend,
- 'logtostderr': opts.outtmpl == '-',
- 'consoletitle': opts.consoletitle,
- 'nopart': opts.nopart,
- 'updatetime': opts.updatetime,
- })
- fd.add_info_extractor(youtube_search_ie)
- fd.add_info_extractor(youtube_pl_ie)
- fd.add_info_extractor(youtube_user_ie)
- fd.add_info_extractor(metacafe_ie)
- fd.add_info_extractor(dailymotion_ie)
- fd.add_info_extractor(youtube_ie)
- fd.add_info_extractor(google_ie)
- fd.add_info_extractor(google_search_ie)
- fd.add_info_extractor(photobucket_ie)
- fd.add_info_extractor(yahoo_ie)
- fd.add_info_extractor(yahoo_search_ie)
- fd.add_info_extractor(deposit_files_ie)
-
- # This must come last since it's the
- # fallback if none of the others work
- fd.add_info_extractor(generic_ie)
-
- # Update version
- if opts.update_self:
- update_self(fd, sys.argv[0])
-
- # Maybe do nothing
- if len(all_urls) < 1:
- if not opts.update_self:
- parser.error(u'you must provide at least one URL')
+ if opts.batchfile == '-':
+ batchfd = sys.stdin
else:
- sys.exit()
- retcode = fd.download(all_urls)
+ 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 and not re.search(r'^[#/;]', x)]
+ except IOError:
+ sys.exit(u'ERROR: batch file could not be read')
+ all_urls = batchurls + args
+
+ # Conflicting, missing and erroneous options
+ if opts.usenetrc and (opts.username is not None or opts.password is not None):
+ 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 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:
+ opts.password = getpass.getpass(u'Type account password and press return:')
+ if opts.ratelimit is not None:
+ numeric_limit = FileDownloader.parse_bytes(opts.ratelimit)
+ if numeric_limit is None:
+ parser.error(u'invalid rate limit specified')
+ opts.ratelimit = numeric_limit
+ if opts.retries is not None:
+ try:
+ opts.retries = long(opts.retries)
+ except (TypeError, ValueError), err:
+ parser.error(u'invalid retry count specified')
+ try:
+ opts.playliststart = int(opts.playliststart)
+ if opts.playliststart <= 0:
+ raise ValueError(u'Playlist start must be positive')
+ except (TypeError, ValueError), err:
+ parser.error(u'invalid playlist start number specified')
+ try:
+ opts.playlistend = int(opts.playlistend)
+ if opts.playlistend != -1 and (opts.playlistend <= 0 or opts.playlistend < opts.playliststart):
+ raise ValueError(u'Playlist end must be greater than playlist start')
+ except (TypeError, ValueError), err:
+ parser.error(u'invalid playlist end number specified')
+ if opts.extractaudio:
+ if opts.audioformat not in ['best', 'aac', 'mp3']:
+ parser.error(u'invalid audio format specified')
+
+ # Information extractors
+ youtube_ie = YoutubeIE()
+ metacafe_ie = MetacafeIE(youtube_ie)
+ dailymotion_ie = DailymotionIE()
+ youtube_pl_ie = YoutubePlaylistIE(youtube_ie)
+ youtube_user_ie = YoutubeUserIE(youtube_ie)
+ youtube_search_ie = YoutubeSearchIE(youtube_ie)
+ google_ie = GoogleIE()
+ google_search_ie = GoogleSearchIE(google_ie)
+ photobucket_ie = PhotobucketIE()
+ yahoo_ie = YahooIE()
+ yahoo_search_ie = YahooSearchIE(yahoo_ie)
+ deposit_files_ie = DepositFilesIE()
+ facebook_ie = FacebookIE()
+ bliptv_ie = BlipTVIE()
+ generic_ie = GenericIE()
+
+ # File downloader
+ fd = FileDownloader({
+ 'usenetrc': opts.usenetrc,
+ 'username': opts.username,
+ 'password': opts.password,
+ 'quiet': (opts.quiet or opts.geturl or opts.gettitle or opts.getthumbnail or opts.getdescription or opts.getfilename),
+ 'forceurl': opts.geturl,
+ 'forcetitle': opts.gettitle,
+ 'forcethumbnail': opts.getthumbnail,
+ 'forcedescription': opts.getdescription,
+ 'forcefilename': opts.getfilename,
+ 'simulate': (opts.simulate or opts.geturl or opts.gettitle or opts.getthumbnail or opts.getdescription or opts.getfilename),
+ 'format': opts.format,
+ 'format_limit': opts.format_limit,
+ 'outtmpl': ((opts.outtmpl is not None and opts.outtmpl.decode(preferredencoding()))
+ 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,
+ 'nooverwrites': opts.nooverwrites,
+ 'retries': opts.retries,
+ 'continuedl': opts.continue_dl,
+ 'noprogress': opts.noprogress,
+ 'playliststart': opts.playliststart,
+ 'playlistend': opts.playlistend,
+ 'logtostderr': opts.outtmpl == '-',
+ 'consoletitle': opts.consoletitle,
+ 'nopart': opts.nopart,
+ 'updatetime': opts.updatetime,
+ 'writedescription': opts.writedescription,
+ 'writeinfojson': opts.writeinfojson,
+ })
+ fd.add_info_extractor(youtube_search_ie)
+ fd.add_info_extractor(youtube_pl_ie)
+ fd.add_info_extractor(youtube_user_ie)
+ fd.add_info_extractor(metacafe_ie)
+ fd.add_info_extractor(dailymotion_ie)
+ fd.add_info_extractor(youtube_ie)
+ fd.add_info_extractor(google_ie)
+ fd.add_info_extractor(google_search_ie)
+ fd.add_info_extractor(photobucket_ie)
+ fd.add_info_extractor(yahoo_ie)
+ fd.add_info_extractor(yahoo_search_ie)
+ fd.add_info_extractor(deposit_files_ie)
+ fd.add_info_extractor(facebook_ie)
+ fd.add_info_extractor(bliptv_ie)
+
+ # This must come last since it's the
+ # fallback if none of the others work
+ fd.add_info_extractor(generic_ie)
+
+ # PostProcessors
+ if opts.extractaudio:
+ fd.add_post_processor(FFmpegExtractAudioPP(preferredcodec=opts.audioformat))
+
+ # Update version
+ if opts.update_self:
+ updateSelf(fd, sys.argv[0])
+
+ # Maybe do nothing
+ if len(all_urls) < 1:
+ if not opts.update_self:
+ parser.error(u'you must provide at least one URL')
+ 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')
+ # 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)
+ sys.exit(retcode)
+
+if __name__ == '__main__':
+ try:
+ main()
except DownloadError:
sys.exit(1)
except SameFileError:
sys.exit(u'ERROR: fixed output name but more than one file to download')
except KeyboardInterrupt:
sys.exit(u'\nERROR: Interrupted by user')
+
+# vim: set ts=4 sw=4 sts=4 noet ai si filetype=python: