import subprocess
import sys
import time
-import urllib2
if os.name == 'nt':
import ctypes
if not self.params.get('quiet', False):
terminator = [u'\n', u''][skip_eol]
output = message + terminator
- if 'b' not in self._screen_file.mode or sys.version_info[0] < 3: # Python 2 lies about the mode of sys.stdout/sys.stderr
+ if 'b' in getattr(self._screen_file, 'mode', '') or sys.version_info[0] < 3: # Python 2 lies about the mode of sys.stdout/sys.stderr
output = output.encode(preferredencoding(), 'ignore')
self._screen_file.write(output)
self._screen_file.flush()
def fixed_template(self):
"""Checks if the output template is fixed."""
- return (re.search(ur'(?u)%\(.+?\)s', self.params['outtmpl']) is None)
+ return (re.search(u'(?u)%\\(.+?\\)s', self.params['outtmpl']) is None)
def trouble(self, message=None):
"""Determine action to take when a download problem appears.
if old_filename == new_filename:
return
os.rename(encodeFilename(old_filename), encodeFilename(new_filename))
- except (IOError, OSError), err:
+ except (IOError, OSError) as err:
self.trouble(u'ERROR: unable to rename file')
def try_utime(self, filename, last_modified_hdr):
"""Report file has already been fully downloaded."""
try:
self.to_screen(u'[download] %s has already been downloaded' % file_name)
- except (UnicodeEncodeError), err:
+ except (UnicodeEncodeError) as err:
self.to_screen(u'[download] The file has already been downloaded')
def report_unable_to_resume(self):
"""Generate the output filename."""
try:
template_dict = dict(info_dict)
+
template_dict['epoch'] = int(time.time())
template_dict['autonumber'] = u'%05d' % self._num_downloads
- template_dict = dict((k, sanitize_filename(u(v), self.params.get('restrictfilenames'))) for k,v in template_dict.items())
+ template_dict = dict((key, u'NA' if val is None else val) for key, val in template_dict.items())
+ template_dict = dict((k, sanitize_filename(compat_str(v), self.params.get('restrictfilenames'))) for k,v in template_dict.items())
+
filename = self.params['outtmpl'] % template_dict
return filename
- except (ValueError, KeyError), err:
+ except (ValueError, KeyError) as err:
self.trouble(u'ERROR: invalid system charset or erroneous output template')
return None
# Keep for backwards compatibility
info_dict['stitle'] = info_dict['title']
+ if not 'format' in info_dict:
+ info_dict['format'] = info_dict['ext']
+
reason = self._match_entry(info_dict)
if reason is not None:
self.to_screen(u'[download] ' + reason)
dn = os.path.dirname(encodeFilename(filename))
if dn != '' and not os.path.exists(dn): # dn is already encoded
os.makedirs(dn)
- except (OSError, IOError), err:
- self.trouble(u'ERROR: unable to create directory ' + u(err))
+ except (OSError, IOError) as err:
+ self.trouble(u'ERROR: unable to create directory ' + compat_str(err))
return
if self.params.get('writedescription', False):
else:
try:
success = self._do_download(filename, info_dict)
- except (OSError, IOError), err:
+ except (OSError, IOError) as err:
raise UnavailableVideoError
- except (urllib2.URLError, httplib.HTTPException, socket.error), err:
+ except (compat_urllib_error.URLError, httplib.HTTPException, socket.error) as err:
self.trouble(u'ERROR: unable to download video data: %s' % str(err))
return
- except (ContentTooShortError, ), err:
+ except (ContentTooShortError, ) as err:
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:
+ except (PostProcessingError) as err:
self.trouble(u'ERROR: postprocessing: %s' % str(err))
return
if not ie.suitable(url):
continue
+ # Warn if the _WORKING attribute is False
+ if not ie.working():
+ self.trouble(u'WARNING: the program functionality for this site has been marked as broken, '
+ u'and will probably not work. If you want to go on, use the -i option.')
+
# Suitable InfoExtractor found
suitable_found = True
# Do not include the Accept-Encoding header
headers = {'Youtubedl-no-compression': 'True'}
- basic_request = urllib2.Request(url, None, headers)
- request = urllib2.Request(url, None, headers)
+ basic_request = compat_urllib_request.Request(url, None, headers)
+ request = compat_urllib_request.Request(url, None, headers)
# Establish possible resume length
if os.path.isfile(encodeFilename(tmpfilename)):
try:
if count == 0 and 'urlhandle' in info_dict:
data = info_dict['urlhandle']
- data = urllib2.urlopen(request)
+ data = compat_urllib_request.urlopen(request)
break
- except (urllib2.HTTPError, ), err:
+ except (compat_urllib_error.HTTPError, ) as err:
if (err.code < 500 or err.code >= 600) and err.code != 416:
# Unexpected HTTP error
raise
# Unable to resume (requested range not satisfiable)
try:
# Open the connection again without the range header
- data = urllib2.urlopen(basic_request)
+ data = compat_urllib_request.urlopen(basic_request)
content_length = data.info()['Content-Length']
- except (urllib2.HTTPError, ), err:
+ except (compat_urllib_error.HTTPError, ) as err:
if err.code < 500 or err.code >= 600:
raise
else:
assert stream is not None
filename = self.undo_temp_name(tmpfilename)
self.report_destination(filename)
- except (OSError, IOError), err:
+ except (OSError, IOError) as err:
self.trouble(u'ERROR: unable to open for writing: %s' % str(err))
return False
try:
stream.write(data_block)
- except (IOError, OSError), err:
+ except (IOError, OSError) as err:
self.trouble(u'\nERROR: unable to write data: %s' % str(err))
return False
if not self.params.get('noresizebuffer', False):
projects / youtube-dl / blobdiff