_ Git - youtube-dl/blob - youtube_dl/utils.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 import gzip
   5 import io
   6 import json
   7 import locale
   8 import os
   9 import re
  10 import sys
  11 import traceback
  12 import zlib
  13 import email.utils
  14 import json
  15
  16 try:
  17     import urllib.request as compat_urllib_request
  18 except ImportError: # Python 2
  19     import urllib2 as compat_urllib_request
  20
  21 try:
  22     import urllib.error as compat_urllib_error
  23 except ImportError: # Python 2
  24     import urllib2 as compat_urllib_error
  25
  26 try:
  27     import urllib.parse as compat_urllib_parse
  28 except ImportError: # Python 2
  29     import urllib as compat_urllib_parse
  30
  31 try:
  32     from urllib.parse import urlparse as compat_urllib_parse_urlparse
  33 except ImportError: # Python 2
  34     from urlparse import urlparse as compat_urllib_parse_urlparse
  35
  36 try:
  37     import http.cookiejar as compat_cookiejar
  38 except ImportError: # Python 2
  39     import cookielib as compat_cookiejar
  40
  41 try:
  42     import html.entities as compat_html_entities
  43 except ImportError: # Python 2
  44     import htmlentitydefs as compat_html_entities
  45
  46 try:
  47     import html.parser as compat_html_parser
  48 except ImportError: # Python 2
  49     import HTMLParser as compat_html_parser
  50
  51 try:
  52     import http.client as compat_http_client
  53 except ImportError: # Python 2
  54     import httplib as compat_http_client
  55
  56 try:
  57     from subprocess import DEVNULL
  58     compat_subprocess_get_DEVNULL = lambda: DEVNULL
  59 except ImportError:
  60     compat_subprocess_get_DEVNULL = lambda: open(os.path.devnull, 'w')
  61
  62 try:
  63     from urllib.parse import parse_qs as compat_parse_qs
  64 except ImportError: # Python 2
  65     # HACK: The following is the correct parse_qs implementation from cpython 3's stdlib.
  66     # Python 2's version is apparently totally broken
  67     def _unquote(string, encoding='utf-8', errors='replace'):
  68         if string == '':
  69             return string
  70         res = string.split('%')
  71         if len(res) == 1:
  72             return string
  73         if encoding is None:
  74             encoding = 'utf-8'
  75         if errors is None:
  76             errors = 'replace'
  77         # pct_sequence: contiguous sequence of percent-encoded bytes, decoded
  78         pct_sequence = b''
  79         string = res[0]
  80         for item in res[1:]:
  81             try:
  82                 if not item:
  83                     raise ValueError
  84                 pct_sequence += item[:2].decode('hex')
  85                 rest = item[2:]
  86                 if not rest:
  87                     # This segment was just a single percent-encoded character.
  88                     # May be part of a sequence of code units, so delay decoding.
  89                     # (Stored in pct_sequence).
  90                     continue
  91             except ValueError:
  92                 rest = '%' + item
  93             # Encountered non-percent-encoded characters. Flush the current
  94             # pct_sequence.
  95             string += pct_sequence.decode(encoding, errors) + rest
  96             pct_sequence = b''
  97         if pct_sequence:
  98             # Flush the final pct_sequence
  99             string += pct_sequence.decode(encoding, errors)
 100         return string
 101
 102     def _parse_qsl(qs, keep_blank_values=False, strict_parsing=False,
 103                 encoding='utf-8', errors='replace'):
 104         qs, _coerce_result = qs, unicode
 105         pairs = [s2 for s1 in qs.split('&') for s2 in s1.split(';')]
 106         r = []
 107         for name_value in pairs:
 108             if not name_value and not strict_parsing:
 109                 continue
 110             nv = name_value.split('=', 1)
 111             if len(nv) != 2:
 112                 if strict_parsing:
 113                     raise ValueError("bad query field: %r" % (name_value,))
 114                 # Handle case of a control-name with no equal sign
 115                 if keep_blank_values:
 116                     nv.append('')
 117                 else:
 118                     continue
 119             if len(nv[1]) or keep_blank_values:
 120                 name = nv[0].replace('+', ' ')
 121                 name = _unquote(name, encoding=encoding, errors=errors)
 122                 name = _coerce_result(name)
 123                 value = nv[1].replace('+', ' ')
 124                 value = _unquote(value, encoding=encoding, errors=errors)
 125                 value = _coerce_result(value)
 126                 r.append((name, value))
 127         return r
 128
 129     def compat_parse_qs(qs, keep_blank_values=False, strict_parsing=False,
 130                 encoding='utf-8', errors='replace'):
 131         parsed_result = {}
 132         pairs = _parse_qsl(qs, keep_blank_values, strict_parsing,
 133                         encoding=encoding, errors=errors)
 134         for name, value in pairs:
 135             if name in parsed_result:
 136                 parsed_result[name].append(value)
 137             else:
 138                 parsed_result[name] = [value]
 139         return parsed_result
 140
 141 try:
 142     compat_str = unicode # Python 2
 143 except NameError:
 144     compat_str = str
 145
 146 try:
 147     compat_chr = unichr # Python 2
 148 except NameError:
 149     compat_chr = chr
 150
 151 std_headers = {
 152     'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:10.0) Gecko/20100101 Firefox/10.0',
 153     'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
 154     'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
 155     'Accept-Encoding': 'gzip, deflate',
 156     'Accept-Language': 'en-us,en;q=0.5',
 157 }
 158
 159 def preferredencoding():
 160     """Get preferred encoding.
 161
 162     Returns the best encoding scheme for the system, based on
 163     locale.getpreferredencoding() and some further tweaks.
 164     """
 165     try:
 166         pref = locale.getpreferredencoding()
 167         u'TEST'.encode(pref)
 168     except:
 169         pref = 'UTF-8'
 170
 171     return pref
 172
 173 if sys.version_info < (3,0):
 174     def compat_print(s):
 175         print(s.encode(preferredencoding(), 'xmlcharrefreplace'))
 176 else:
 177     def compat_print(s):
 178         assert type(s) == type(u'')
 179         print(s)
 180
 181 # In Python 2.x, json.dump expects a bytestream.
 182 # In Python 3.x, it writes to a character stream
 183 if sys.version_info < (3,0):
 184     def write_json_file(obj, fn):
 185         with open(fn, 'wb') as f:
 186             json.dump(obj, f)
 187 else:
 188     def write_json_file(obj, fn):
 189         with open(fn, 'w', encoding='utf-8') as f:
 190             json.dump(obj, f)
 191
 192 def htmlentity_transform(matchobj):
 193     """Transforms an HTML entity to a character.
 194
 195     This function receives a match object and is intended to be used with
 196     the re.sub() function.
 197     """
 198     entity = matchobj.group(1)
 199
 200     # Known non-numeric HTML entity
 201     if entity in compat_html_entities.name2codepoint:
 202         return compat_chr(compat_html_entities.name2codepoint[entity])
 203
 204     mobj = re.match(u'(?u)#(x?\\d+)', entity)
 205     if mobj is not None:
 206         numstr = mobj.group(1)
 207         if numstr.startswith(u'x'):
 208             base = 16
 209             numstr = u'0%s' % numstr
 210         else:
 211             base = 10
 212         return compat_chr(int(numstr, base))
 213
 214     # Unknown entity in name, return its literal representation
 215     return (u'&%s;' % entity)
 216
 217 compat_html_parser.locatestarttagend = re.compile(r"""<[a-zA-Z][-.a-zA-Z0-9:_]*(?:\s+(?:(?<=['"\s])[^\s/>][^\s/=>]*(?:\s*=+\s*(?:'[^']*'|"[^"]*"|(?!['"])[^>\s]*))?\s*)*)?\s*""", re.VERBOSE) # backport bugfix
 218 class AttrParser(compat_html_parser.HTMLParser):
 219     """Modified HTMLParser that isolates a tag with the specified attribute"""
 220     def __init__(self, attribute, value):
 221         self.attribute = attribute
 222         self.value = value
 223         self.result = None
 224         self.started = False
 225         self.depth = {}
 226         self.html = None
 227         self.watch_startpos = False
 228         self.error_count = 0
 229         compat_html_parser.HTMLParser.__init__(self)
 230
 231     def error(self, message):
 232         if self.error_count > 10 or self.started:
 233             raise compat_html_parser.HTMLParseError(message, self.getpos())
 234         self.rawdata = '\n'.join(self.html.split('\n')[self.getpos()[0]:]) # skip one line
 235         self.error_count += 1
 236         self.goahead(1)
 237
 238     def loads(self, html):
 239         self.html = html
 240         self.feed(html)
 241         self.close()
 242
 243     def handle_starttag(self, tag, attrs):
 244         attrs = dict(attrs)
 245         if self.started:
 246             self.find_startpos(None)
 247         if self.attribute in attrs and attrs[self.attribute] == self.value:
 248             self.result = [tag]
 249             self.started = True
 250             self.watch_startpos = True
 251         if self.started:
 252             if not tag in self.depth: self.depth[tag] = 0
 253             self.depth[tag] += 1
 254
 255     def handle_endtag(self, tag):
 256         if self.started:
 257             if tag in self.depth: self.depth[tag] -= 1
 258             if self.depth[self.result[0]] == 0:
 259                 self.started = False
 260                 self.result.append(self.getpos())
 261
 262     def find_startpos(self, x):
 263         """Needed to put the start position of the result (self.result[1])
 264         after the opening tag with the requested id"""
 265         if self.watch_startpos:
 266             self.watch_startpos = False
 267             self.result.append(self.getpos())
 268     handle_entityref = handle_charref = handle_data = handle_comment = \
 269     handle_decl = handle_pi = unknown_decl = find_startpos
 270
 271     def get_result(self):
 272         if self.result is None:
 273             return None
 274         if len(self.result) != 3:
 275             return None
 276         lines = self.html.split('\n')
 277         lines = lines[self.result[1][0]-1:self.result[2][0]]
 278         lines[0] = lines[0][self.result[1][1]:]
 279         if len(lines) == 1:
 280             lines[-1] = lines[-1][:self.result[2][1]-self.result[1][1]]
 281         lines[-1] = lines[-1][:self.result[2][1]]
 282         return '\n'.join(lines).strip()
 283 # Hack for https://github.com/rg3/youtube-dl/issues/662
 284 if sys.version_info < (2, 7, 3):
 285     AttrParser.parse_endtag = (lambda self, i:
 286         i + len("</scr'+'ipt>")
 287         if self.rawdata[i:].startswith("</scr'+'ipt>")
 288         else compat_html_parser.HTMLParser.parse_endtag(self, i))
 289
 290 def get_element_by_id(id, html):
 291     """Return the content of the tag with the specified ID in the passed HTML document"""
 292     return get_element_by_attribute("id", id, html)
 293
 294 def get_element_by_attribute(attribute, value, html):
 295     """Return the content of the tag with the specified attribute in the passed HTML document"""
 296     parser = AttrParser(attribute, value)
 297     try:
 298         parser.loads(html)
 299     except compat_html_parser.HTMLParseError:
 300         pass
 301     return parser.get_result()
 302
 303
 304 def clean_html(html):
 305     """Clean an HTML snippet into a readable string"""
 306     # Newline vs <br />
 307     html = html.replace('\n', ' ')
 308     html = re.sub(r'\s*<\s*br\s*/?\s*>\s*', '\n', html)
 309     html = re.sub(r'<\s*/\s*p\s*>\s*<\s*p[^>]*>', '\n', html)
 310     # Strip html tags
 311     html = re.sub('<.*?>', '', html)
 312     # Replace html entities
 313     html = unescapeHTML(html)
 314     return html.strip()
 315
 316
 317 def sanitize_open(filename, open_mode):
 318     """Try to open the given filename, and slightly tweak it if this fails.
 319
 320     Attempts to open the given filename. If this fails, it tries to change
 321     the filename slightly, step by step, until it's either able to open it
 322     or it fails and raises a final exception, like the standard open()
 323     function.
 324
 325     It returns the tuple (stream, definitive_file_name).
 326     """
 327     try:
 328         if filename == u'-':
 329             if sys.platform == 'win32':
 330                 import msvcrt
 331                 msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
 332             return (sys.stdout.buffer if hasattr(sys.stdout, 'buffer') else sys.stdout, filename)
 333         stream = open(encodeFilename(filename), open_mode)
 334         return (stream, filename)
 335     except (IOError, OSError) as err:
 336         # In case of error, try to remove win32 forbidden chars
 337         filename = re.sub(u'[/<>:"\\|\\\\?\\*]', u'#', filename)
 338
 339         # An exception here should be caught in the caller
 340         stream = open(encodeFilename(filename), open_mode)
 341         return (stream, filename)
 342
 343
 344 def timeconvert(timestr):
 345     """Convert RFC 2822 defined time string into system timestamp"""
 346     timestamp = None
 347     timetuple = email.utils.parsedate_tz(timestr)
 348     if timetuple is not None:
 349         timestamp = email.utils.mktime_tz(timetuple)
 350     return timestamp
 351
 352 def sanitize_filename(s, restricted=False, is_id=False):
 353     """Sanitizes a string so it could be used as part of a filename.
 354     If restricted is set, use a stricter subset of allowed characters.
 355     Set is_id if this is not an arbitrary string, but an ID that should be kept if possible
 356     """
 357     def replace_insane(char):
 358         if char == '?' or ord(char) < 32 or ord(char) == 127:
 359             return ''
 360         elif char == '"':
 361             return '' if restricted else '\''
 362         elif char == ':':
 363             return '_-' if restricted else ' -'
 364         elif char in '\\/|*<>':
 365             return '_'
 366         if restricted and (char in '!&\'()[]{}$;`^,#' or char.isspace()):
 367             return '_'
 368         if restricted and ord(char) > 127:
 369             return '_'
 370         return char
 371
 372     result = u''.join(map(replace_insane, s))
 373     if not is_id:
 374         while '__' in result:
 375             result = result.replace('__', '_')
 376         result = result.strip('_')
 377         # Common case of "Foreign band name - English song title"
 378         if restricted and result.startswith('-_'):
 379             result = result[2:]
 380         if not result:
 381             result = '_'
 382     return result
 383
 384 def orderedSet(iterable):
 385     """ Remove all duplicates from the input iterable """
 386     res = []
 387     for el in iterable:
 388         if el not in res:
 389             res.append(el)
 390     return res
 391
 392 def unescapeHTML(s):
 393     """
 394     @param s a string
 395     """
 396     assert type(s) == type(u'')
 397
 398     result = re.sub(u'(?u)&(.+?);', htmlentity_transform, s)
 399     return result
 400
 401 def encodeFilename(s):
 402     """
 403     @param s The name of the file
 404     """
 405
 406     assert type(s) == type(u'')
 407
 408     # Python 3 has a Unicode API
 409     if sys.version_info >= (3, 0):
 410         return s
 411
 412     if sys.platform == 'win32' and sys.getwindowsversion()[0] >= 5:
 413         # Pass u'' directly to use Unicode APIs on Windows 2000 and up
 414         # (Detecting Windows NT 4 is tricky because 'major >= 4' would
 415         # match Windows 9x series as well. Besides, NT 4 is obsolete.)
 416         return s
 417     else:
 418         encoding = sys.getfilesystemencoding()
 419         if encoding is None:
 420             encoding = 'utf-8'
 421         return s.encode(encoding, 'ignore')
 422
 423 def decodeOption(optval):
 424     if optval is None:
 425         return optval
 426     if isinstance(optval, bytes):
 427         optval = optval.decode(preferredencoding())
 428
 429     assert isinstance(optval, compat_str)
 430     return optval
 431
 432 class ExtractorError(Exception):
 433     """Error during info extraction."""
 434     def __init__(self, msg, tb=None):
 435         """ tb, if given, is the original traceback (so that it can be printed out). """
 436         super(ExtractorError, self).__init__(msg)
 437         self.traceback = tb
 438         self.exc_info = sys.exc_info()  # preserve original exception
 439
 440     def format_traceback(self):
 441         if self.traceback is None:
 442             return None
 443         return u''.join(traceback.format_tb(self.traceback))
 444
 445
 446 class DownloadError(Exception):
 447     """Download Error exception.
 448
 449     This exception may be thrown by FileDownloader objects if they are not
 450     configured to continue on errors. They will contain the appropriate
 451     error message.
 452     """
 453     def __init__(self, msg, exc_info=None):
 454         """ exc_info, if given, is the original exception that caused the trouble (as returned by sys.exc_info()). """
 455         super(DownloadError, self).__init__(msg)
 456         self.exc_info = exc_info
 457
 458
 459 class SameFileError(Exception):
 460     """Same File exception.
 461
 462     This exception will be thrown by FileDownloader objects if they detect
 463     multiple files would have to be downloaded to the same file on disk.
 464     """
 465     pass
 466
 467
 468 class PostProcessingError(Exception):
 469     """Post Processing exception.
 470
 471     This exception may be raised by PostProcessor's .run() method to
 472     indicate an error in the postprocessing task.
 473     """
 474     def __init__(self, msg):
 475         self.msg = msg
 476
 477 class MaxDownloadsReached(Exception):
 478     """ --max-downloads limit has been reached. """
 479     pass
 480
 481
 482 class UnavailableVideoError(Exception):
 483     """Unavailable Format exception.
 484
 485     This exception will be thrown when a video is requested
 486     in a format that is not available for that video.
 487     """
 488     pass
 489
 490
 491 class ContentTooShortError(Exception):
 492     """Content Too Short exception.
 493
 494     This exception may be raised by FileDownloader objects when a file they
 495     download is too small for what the server announced first, indicating
 496     the connection was probably interrupted.
 497     """
 498     # Both in bytes
 499     downloaded = None
 500     expected = None
 501
 502     def __init__(self, downloaded, expected):
 503         self.downloaded = downloaded
 504         self.expected = expected
 505
 506 class YoutubeDLHandler(compat_urllib_request.HTTPHandler):
 507     """Handler for HTTP requests and responses.
 508
 509     This class, when installed with an OpenerDirector, automatically adds
 510     the standard headers to every HTTP request and handles gzipped and
 511     deflated responses from web servers. If compression is to be avoided in
 512     a particular request, the original request in the program code only has
 513     to include the HTTP header "Youtubedl-No-Compression", which will be
 514     removed before making the real request.
 515
 516     Part of this code was copied from:
 517
 518     http://techknack.net/python-urllib2-handlers/
 519
 520     Andrew Rowls, the author of that code, agreed to release it to the
 521     public domain.
 522     """
 523
 524     @staticmethod
 525     def deflate(data):
 526         try:
 527             return zlib.decompress(data, -zlib.MAX_WBITS)
 528         except zlib.error:
 529             return zlib.decompress(data)
 530
 531     @staticmethod
 532     def addinfourl_wrapper(stream, headers, url, code):
 533         if hasattr(compat_urllib_request.addinfourl, 'getcode'):
 534             return compat_urllib_request.addinfourl(stream, headers, url, code)
 535         ret = compat_urllib_request.addinfourl(stream, headers, url)
 536         ret.code = code
 537         return ret
 538
 539     def http_request(self, req):
 540         for h,v in std_headers.items():
 541             if h in req.headers:
 542                 del req.headers[h]
 543             req.add_header(h, v)
 544         if 'Youtubedl-no-compression' in req.headers:
 545             if 'Accept-encoding' in req.headers:
 546                 del req.headers['Accept-encoding']
 547             del req.headers['Youtubedl-no-compression']
 548         if 'Youtubedl-user-agent' in req.headers:
 549             if 'User-agent' in req.headers:
 550                 del req.headers['User-agent']
 551             req.headers['User-agent'] = req.headers['Youtubedl-user-agent']
 552             del req.headers['Youtubedl-user-agent']
 553         return req
 554
 555     def http_response(self, req, resp):
 556         old_resp = resp
 557         # gzip
 558         if resp.headers.get('Content-encoding', '') == 'gzip':
 559             gz = gzip.GzipFile(fileobj=io.BytesIO(resp.read()), mode='r')
 560             resp = self.addinfourl_wrapper(gz, old_resp.headers, old_resp.url, old_resp.code)
 561             resp.msg = old_resp.msg
 562         # deflate
 563         if resp.headers.get('Content-encoding', '') == 'deflate':
 564             gz = io.BytesIO(self.deflate(resp.read()))
 565             resp = self.addinfourl_wrapper(gz, old_resp.headers, old_resp.url, old_resp.code)
 566             resp.msg = old_resp.msg
 567         return resp
 568
 569     https_request = http_request
 570     https_response = http_response