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

   1 #!/usr/bin/env python
   2 # coding: utf-8
   3
   4 from __future__ import unicode_literals
   5
   6 import base64
   7 import binascii
   8 import calendar
   9 import codecs
  10 import contextlib
  11 import ctypes
  12 import datetime
  13 import email.utils
  14 import email.header
  15 import errno
  16 import functools
  17 import gzip
  18 import io
  19 import itertools
  20 import json
  21 import locale
  22 import math
  23 import operator
  24 import os
  25 import platform
  26 import random
  27 import re
  28 import socket
  29 import ssl
  30 import subprocess
  31 import sys
  32 import tempfile
  33 import traceback
  34 import xml.etree.ElementTree
  35 import zlib
  36
  37 from .compat import (
  38     compat_HTMLParseError,
  39     compat_HTMLParser,
  40     compat_basestring,
  41     compat_chr,
  42     compat_cookiejar,
  43     compat_ctypes_WINFUNCTYPE,
  44     compat_etree_fromstring,
  45     compat_expanduser,
  46     compat_html_entities,
  47     compat_html_entities_html5,
  48     compat_http_client,
  49     compat_kwargs,
  50     compat_os_name,
  51     compat_parse_qs,
  52     compat_shlex_quote,
  53     compat_str,
  54     compat_struct_pack,
  55     compat_struct_unpack,
  56     compat_urllib_error,
  57     compat_urllib_parse,
  58     compat_urllib_parse_urlencode,
  59     compat_urllib_parse_urlparse,
  60     compat_urllib_parse_unquote_plus,
  61     compat_urllib_request,
  62     compat_urlparse,
  63     compat_xpath,
  64 )
  65
  66 from .socks import (
  67     ProxyType,
  68     sockssocket,
  69 )
  70
  71
  72 def register_socks_protocols():
  73     # "Register" SOCKS protocols
  74     # In Python < 2.6.5, urlsplit() suffers from bug https://bugs.python.org/issue7904
  75     # URLs with protocols not in urlparse.uses_netloc are not handled correctly
  76     for scheme in ('socks', 'socks4', 'socks4a', 'socks5'):
  77         if scheme not in compat_urlparse.uses_netloc:
  78             compat_urlparse.uses_netloc.append(scheme)
  79
  80
  81 # This is not clearly defined otherwise
  82 compiled_regex_type = type(re.compile(''))
  83
  84 std_headers = {
  85     'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:59.0) Gecko/20100101 Firefox/59.0',
  86     'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
  87     'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
  88     'Accept-Encoding': 'gzip, deflate',
  89     'Accept-Language': 'en-us,en;q=0.5',
  90 }
  91
  92
  93 USER_AGENTS = {
  94     'Safari': 'Mozilla/5.0 (X11; Linux x86_64; rv:10.0) AppleWebKit/533.20.25 (KHTML, like Gecko) Version/5.0.4 Safari/533.20.27',
  95 }
  96
  97
  98 NO_DEFAULT = object()
  99
 100 ENGLISH_MONTH_NAMES = [
 101     'January', 'February', 'March', 'April', 'May', 'June',
 102     'July', 'August', 'September', 'October', 'November', 'December']
 103
 104 MONTH_NAMES = {
 105     'en': ENGLISH_MONTH_NAMES,
 106     'fr': [
 107         'janvier', 'février', 'mars', 'avril', 'mai', 'juin',
 108         'juillet', 'août', 'septembre', 'octobre', 'novembre', 'décembre'],
 109 }
 110
 111 KNOWN_EXTENSIONS = (
 112     'mp4', 'm4a', 'm4p', 'm4b', 'm4r', 'm4v', 'aac',
 113     'flv', 'f4v', 'f4a', 'f4b',
 114     'webm', 'ogg', 'ogv', 'oga', 'ogx', 'spx', 'opus',
 115     'mkv', 'mka', 'mk3d',
 116     'avi', 'divx',
 117     'mov',
 118     'asf', 'wmv', 'wma',
 119     '3gp', '3g2',
 120     'mp3',
 121     'flac',
 122     'ape',
 123     'wav',
 124     'f4f', 'f4m', 'm3u8', 'smil')
 125
 126 # needed for sanitizing filenames in restricted mode
 127 ACCENT_CHARS = dict(zip('ÂÃÄÀÁÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖŐØŒÙÚÛÜŰÝÞßàáâãäåæçèéêëìíîïðñòóôõöőøœùúûüűýþÿ',
 128                         itertools.chain('AAAAAA', ['AE'], 'CEEEEIIIIDNOOOOOOO', ['OE'], 'UUUUUYP', ['ss'],
 129                                         'aaaaaa', ['ae'], 'ceeeeiiiionooooooo', ['oe'], 'uuuuuypy')))
 130
 131 DATE_FORMATS = (
 132     '%d %B %Y',
 133     '%d %b %Y',
 134     '%B %d %Y',
 135     '%B %dst %Y',
 136     '%B %dnd %Y',
 137     '%B %dth %Y',
 138     '%b %d %Y',
 139     '%b %dst %Y',
 140     '%b %dnd %Y',
 141     '%b %dth %Y',
 142     '%b %dst %Y %I:%M',
 143     '%b %dnd %Y %I:%M',
 144     '%b %dth %Y %I:%M',
 145     '%Y %m %d',
 146     '%Y-%m-%d',
 147     '%Y/%m/%d',
 148     '%Y/%m/%d %H:%M',
 149     '%Y/%m/%d %H:%M:%S',
 150     '%Y-%m-%d %H:%M',
 151     '%Y-%m-%d %H:%M:%S',
 152     '%Y-%m-%d %H:%M:%S.%f',
 153     '%d.%m.%Y %H:%M',
 154     '%d.%m.%Y %H.%M',
 155     '%Y-%m-%dT%H:%M:%SZ',
 156     '%Y-%m-%dT%H:%M:%S.%fZ',
 157     '%Y-%m-%dT%H:%M:%S.%f0Z',
 158     '%Y-%m-%dT%H:%M:%S',
 159     '%Y-%m-%dT%H:%M:%S.%f',
 160     '%Y-%m-%dT%H:%M',
 161     '%b %d %Y at %H:%M',
 162     '%b %d %Y at %H:%M:%S',
 163     '%B %d %Y at %H:%M',
 164     '%B %d %Y at %H:%M:%S',
 165 )
 166
 167 DATE_FORMATS_DAY_FIRST = list(DATE_FORMATS)
 168 DATE_FORMATS_DAY_FIRST.extend([
 169     '%d-%m-%Y',
 170     '%d.%m.%Y',
 171     '%d.%m.%y',
 172     '%d/%m/%Y',
 173     '%d/%m/%y',
 174     '%d/%m/%Y %H:%M:%S',
 175 ])
 176
 177 DATE_FORMATS_MONTH_FIRST = list(DATE_FORMATS)
 178 DATE_FORMATS_MONTH_FIRST.extend([
 179     '%m-%d-%Y',
 180     '%m.%d.%Y',
 181     '%m/%d/%Y',
 182     '%m/%d/%y',
 183     '%m/%d/%Y %H:%M:%S',
 184 ])
 185
 186 PACKED_CODES_RE = r"}\('(.+)',(\d+),(\d+),'([^']+)'\.split\('\|'\)"
 187 JSON_LD_RE = r'(?is)<script[^>]+type=(["\']?)application/ld\+json\1[^>]*>(?P<json_ld>.+?)</script>'
 188
 189
 190 def preferredencoding():
 191     """Get preferred encoding.
 192
 193     Returns the best encoding scheme for the system, based on
 194     locale.getpreferredencoding() and some further tweaks.
 195     """
 196     try:
 197         pref = locale.getpreferredencoding()
 198         'TEST'.encode(pref)
 199     except Exception:
 200         pref = 'UTF-8'
 201
 202     return pref
 203
 204
 205 def write_json_file(obj, fn):
 206     """ Encode obj as JSON and write it to fn, atomically if possible """
 207
 208     fn = encodeFilename(fn)
 209     if sys.version_info < (3, 0) and sys.platform != 'win32':
 210         encoding = get_filesystem_encoding()
 211         # os.path.basename returns a bytes object, but NamedTemporaryFile
 212         # will fail if the filename contains non ascii characters unless we
 213         # use a unicode object
 214         path_basename = lambda f: os.path.basename(fn).decode(encoding)
 215         # the same for os.path.dirname
 216         path_dirname = lambda f: os.path.dirname(fn).decode(encoding)
 217     else:
 218         path_basename = os.path.basename
 219         path_dirname = os.path.dirname
 220
 221     args = {
 222         'suffix': '.tmp',
 223         'prefix': path_basename(fn) + '.',
 224         'dir': path_dirname(fn),
 225         'delete': False,
 226     }
 227
 228     # In Python 2.x, json.dump expects a bytestream.
 229     # In Python 3.x, it writes to a character stream
 230     if sys.version_info < (3, 0):
 231         args['mode'] = 'wb'
 232     else:
 233         args.update({
 234             'mode': 'w',
 235             'encoding': 'utf-8',
 236         })
 237
 238     tf = tempfile.NamedTemporaryFile(**compat_kwargs(args))
 239
 240     try:
 241         with tf:
 242             json.dump(obj, tf)
 243         if sys.platform == 'win32':
 244             # Need to remove existing file on Windows, else os.rename raises
 245             # WindowsError or FileExistsError.
 246             try:
 247                 os.unlink(fn)
 248             except OSError:
 249                 pass
 250         os.rename(tf.name, fn)
 251     except Exception:
 252         try:
 253             os.remove(tf.name)
 254         except OSError:
 255             pass
 256         raise
 257
 258
 259 if sys.version_info >= (2, 7):
 260     def find_xpath_attr(node, xpath, key, val=None):
 261         """ Find the xpath xpath[@key=val] """
 262         assert re.match(r'^[a-zA-Z_-]+$', key)
 263         expr = xpath + ('[@%s]' % key if val is None else "[@%s='%s']" % (key, val))
 264         return node.find(expr)
 265 else:
 266     def find_xpath_attr(node, xpath, key, val=None):
 267         for f in node.findall(compat_xpath(xpath)):
 268             if key not in f.attrib:
 269                 continue
 270             if val is None or f.attrib.get(key) == val:
 271                 return f
 272         return None
 273
 274 # On python2.6 the xml.etree.ElementTree.Element methods don't support
 275 # the namespace parameter
 276
 277
 278 def xpath_with_ns(path, ns_map):
 279     components = [c.split(':') for c in path.split('/')]
 280     replaced = []
 281     for c in components:
 282         if len(c) == 1:
 283             replaced.append(c[0])
 284         else:
 285             ns, tag = c
 286             replaced.append('{%s}%s' % (ns_map[ns], tag))
 287     return '/'.join(replaced)
 288
 289
 290 def xpath_element(node, xpath, name=None, fatal=False, default=NO_DEFAULT):
 291     def _find_xpath(xpath):
 292         return node.find(compat_xpath(xpath))
 293
 294     if isinstance(xpath, (str, compat_str)):
 295         n = _find_xpath(xpath)
 296     else:
 297         for xp in xpath:
 298             n = _find_xpath(xp)
 299             if n is not None:
 300                 break
 301
 302     if n is None:
 303         if default is not NO_DEFAULT:
 304             return default
 305         elif fatal:
 306             name = xpath if name is None else name
 307             raise ExtractorError('Could not find XML element %s' % name)
 308         else:
 309             return None
 310     return n
 311
 312
 313 def xpath_text(node, xpath, name=None, fatal=False, default=NO_DEFAULT):
 314     n = xpath_element(node, xpath, name, fatal=fatal, default=default)
 315     if n is None or n == default:
 316         return n
 317     if n.text is None:
 318         if default is not NO_DEFAULT:
 319             return default
 320         elif fatal:
 321             name = xpath if name is None else name
 322             raise ExtractorError('Could not find XML element\'s text %s' % name)
 323         else:
 324             return None
 325     return n.text
 326
 327
 328 def xpath_attr(node, xpath, key, name=None, fatal=False, default=NO_DEFAULT):
 329     n = find_xpath_attr(node, xpath, key)
 330     if n is None:
 331         if default is not NO_DEFAULT:
 332             return default
 333         elif fatal:
 334             name = '%s[@%s]' % (xpath, key) if name is None else name
 335             raise ExtractorError('Could not find XML attribute %s' % name)
 336         else:
 337             return None
 338     return n.attrib[key]
 339
 340
 341 def get_element_by_id(id, html):
 342     """Return the content of the tag with the specified ID in the passed HTML document"""
 343     return get_element_by_attribute('id', id, html)
 344
 345
 346 def get_element_by_class(class_name, html):
 347     """Return the content of the first tag with the specified class in the passed HTML document"""
 348     retval = get_elements_by_class(class_name, html)
 349     return retval[0] if retval else None
 350
 351
 352 def get_element_by_attribute(attribute, value, html, escape_value=True):
 353     retval = get_elements_by_attribute(attribute, value, html, escape_value)
 354     return retval[0] if retval else None
 355
 356
 357 def get_elements_by_class(class_name, html):
 358     """Return the content of all tags with the specified class in the passed HTML document as a list"""
 359     return get_elements_by_attribute(
 360         'class', r'[^\'"]*\b%s\b[^\'"]*' % re.escape(class_name),
 361         html, escape_value=False)
 362
 363
 364 def get_elements_by_attribute(attribute, value, html, escape_value=True):
 365     """Return the content of the tag with the specified attribute in the passed HTML document"""
 366
 367     value = re.escape(value) if escape_value else value
 368
 369     retlist = []
 370     for m in re.finditer(r'''(?xs)
 371         <([a-zA-Z0-9:._-]+)
 372          (?:\s+[a-zA-Z0-9:._-]+(?:=[a-zA-Z0-9:._-]*|="[^"]*"|='[^']*'|))*?
 373          \s+%s=['"]?%s['"]?
 374          (?:\s+[a-zA-Z0-9:._-]+(?:=[a-zA-Z0-9:._-]*|="[^"]*"|='[^']*'|))*?
 375         \s*>
 376         (?P<content>.*?)
 377         </\1>
 378     ''' % (re.escape(attribute), value), html):
 379         res = m.group('content')
 380
 381         if res.startswith('"') or res.startswith("'"):
 382             res = res[1:-1]
 383
 384         retlist.append(unescapeHTML(res))
 385
 386     return retlist
 387
 388
 389 class HTMLAttributeParser(compat_HTMLParser):
 390     """Trivial HTML parser to gather the attributes for a single element"""
 391     def __init__(self):
 392         self.attrs = {}
 393         compat_HTMLParser.__init__(self)
 394
 395     def handle_starttag(self, tag, attrs):
 396         self.attrs = dict(attrs)
 397
 398
 399 def extract_attributes(html_element):
 400     """Given a string for an HTML element such as
 401     <el
 402          a="foo" B="bar" c="&98;az" d=boz
 403          empty= noval entity="&amp;"
 404          sq='"' dq="'"
 405     >
 406     Decode and return a dictionary of attributes.
 407     {
 408         'a': 'foo', 'b': 'bar', c: 'baz', d: 'boz',
 409         'empty': '', 'noval': None, 'entity': '&',
 410         'sq': '"', 'dq': '\''
 411     }.
 412     NB HTMLParser is stricter in Python 2.6 & 3.2 than in later versions,
 413     but the cases in the unit test will work for all of 2.6, 2.7, 3.2-3.5.
 414     """
 415     parser = HTMLAttributeParser()
 416     try:
 417         parser.feed(html_element)
 418         parser.close()
 419     # Older Python may throw HTMLParseError in case of malformed HTML
 420     except compat_HTMLParseError:
 421         pass
 422     return parser.attrs
 423
 424
 425 def clean_html(html):
 426     """Clean an HTML snippet into a readable string"""
 427
 428     if html is None:  # Convenience for sanitizing descriptions etc.
 429         return html
 430
 431     # Newline vs <br />
 432     html = html.replace('\n', ' ')
 433     html = re.sub(r'(?u)\s*<\s*br\s*/?\s*>\s*', '\n', html)
 434     html = re.sub(r'(?u)<\s*/\s*p\s*>\s*<\s*p[^>]*>', '\n', html)
 435     # Strip html tags
 436     html = re.sub('<.*?>', '', html)
 437     # Replace html entities
 438     html = unescapeHTML(html)
 439     return html.strip()
 440
 441
 442 def sanitize_open(filename, open_mode):
 443     """Try to open the given filename, and slightly tweak it if this fails.
 444
 445     Attempts to open the given filename. If this fails, it tries to change
 446     the filename slightly, step by step, until it's either able to open it
 447     or it fails and raises a final exception, like the standard open()
 448     function.
 449
 450     It returns the tuple (stream, definitive_file_name).
 451     """
 452     try:
 453         if filename == '-':
 454             if sys.platform == 'win32':
 455                 import msvcrt
 456                 msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
 457             return (sys.stdout.buffer if hasattr(sys.stdout, 'buffer') else sys.stdout, filename)
 458         stream = open(encodeFilename(filename), open_mode)
 459         return (stream, filename)
 460     except (IOError, OSError) as err:
 461         if err.errno in (errno.EACCES,):
 462             raise
 463
 464         # In case of error, try to remove win32 forbidden chars
 465         alt_filename = sanitize_path(filename)
 466         if alt_filename == filename:
 467             raise
 468         else:
 469             # An exception here should be caught in the caller
 470             stream = open(encodeFilename(alt_filename), open_mode)
 471             return (stream, alt_filename)
 472
 473
 474 def timeconvert(timestr):
 475     """Convert RFC 2822 defined time string into system timestamp"""
 476     timestamp = None
 477     timetuple = email.utils.parsedate_tz(timestr)
 478     if timetuple is not None:
 479         timestamp = email.utils.mktime_tz(timetuple)
 480     return timestamp
 481
 482
 483 def sanitize_filename(s, restricted=False, is_id=False):
 484     """Sanitizes a string so it could be used as part of a filename.
 485     If restricted is set, use a stricter subset of allowed characters.
 486     Set is_id if this is not an arbitrary string, but an ID that should be kept
 487     if possible.
 488     """
 489     def replace_insane(char):
 490         if restricted and char in ACCENT_CHARS:
 491             return ACCENT_CHARS[char]
 492         if char == '?' or ord(char) < 32 or ord(char) == 127:
 493             return ''
 494         elif char == '"':
 495             return '' if restricted else '\''
 496         elif char == ':':
 497             return '_-' if restricted else ' -'
 498         elif char in '\\/|*<>':
 499             return '_'
 500         if restricted and (char in '!&\'()[]{}$;`^,#' or char.isspace()):
 501             return '_'
 502         if restricted and ord(char) > 127:
 503             return '_'
 504         return char
 505
 506     # Handle timestamps
 507     s = re.sub(r'[0-9]+(?::[0-9]+)+', lambda m: m.group(0).replace(':', '_'), s)
 508     result = ''.join(map(replace_insane, s))
 509     if not is_id:
 510         while '__' in result:
 511             result = result.replace('__', '_')
 512         result = result.strip('_')
 513         # Common case of "Foreign band name - English song title"
 514         if restricted and result.startswith('-_'):
 515             result = result[2:]
 516         if result.startswith('-'):
 517             result = '_' + result[len('-'):]
 518         result = result.lstrip('.')
 519         if not result:
 520             result = '_'
 521     return result
 522
 523
 524 def sanitize_path(s):
 525     """Sanitizes and normalizes path on Windows"""
 526     if sys.platform != 'win32':
 527         return s
 528     drive_or_unc, _ = os.path.splitdrive(s)
 529     if sys.version_info < (2, 7) and not drive_or_unc:
 530         drive_or_unc, _ = os.path.splitunc(s)
 531     norm_path = os.path.normpath(remove_start(s, drive_or_unc)).split(os.path.sep)
 532     if drive_or_unc:
 533         norm_path.pop(0)
 534     sanitized_path = [
 535         path_part if path_part in ['.', '..'] else re.sub(r'(?:[/<>:"\|\\?\*]|[\s.]$)', '#', path_part)
 536         for path_part in norm_path]
 537     if drive_or_unc:
 538         sanitized_path.insert(0, drive_or_unc + os.path.sep)
 539     return os.path.join(*sanitized_path)
 540
 541
 542 def sanitize_url(url):
 543     # Prepend protocol-less URLs with `http:` scheme in order to mitigate
 544     # the number of unwanted failures due to missing protocol
 545     if url.startswith('//'):
 546         return 'http:%s' % url
 547     # Fix some common typos seen so far
 548     COMMON_TYPOS = (
 549         # https://github.com/rg3/youtube-dl/issues/15649
 550         (r'^httpss://', r'https://'),
 551         # https://bx1.be/lives/direct-tv/
 552         (r'^rmtp([es]?)://', r'rtmp\1://'),
 553     )
 554     for mistake, fixup in COMMON_TYPOS:
 555         if re.match(mistake, url):
 556             return re.sub(mistake, fixup, url)
 557     return url
 558
 559
 560 def sanitized_Request(url, *args, **kwargs):
 561     return compat_urllib_request.Request(sanitize_url(url), *args, **kwargs)
 562
 563
 564 def expand_path(s):
 565     """Expand shell variables and ~"""
 566     return os.path.expandvars(compat_expanduser(s))
 567
 568
 569 def orderedSet(iterable):
 570     """ Remove all duplicates from the input iterable """
 571     res = []
 572     for el in iterable:
 573         if el not in res:
 574             res.append(el)
 575     return res
 576
 577
 578 def _htmlentity_transform(entity_with_semicolon):
 579     """Transforms an HTML entity to a character."""
 580     entity = entity_with_semicolon[:-1]
 581
 582     # Known non-numeric HTML entity
 583     if entity in compat_html_entities.name2codepoint:
 584         return compat_chr(compat_html_entities.name2codepoint[entity])
 585
 586     # TODO: HTML5 allows entities without a semicolon. For example,
 587     # '&Eacuteric' should be decoded as 'Éric'.
 588     if entity_with_semicolon in compat_html_entities_html5:
 589         return compat_html_entities_html5[entity_with_semicolon]
 590
 591     mobj = re.match(r'#(x[0-9a-fA-F]+|[0-9]+)', entity)
 592     if mobj is not None:
 593         numstr = mobj.group(1)
 594         if numstr.startswith('x'):
 595             base = 16
 596             numstr = '0%s' % numstr
 597         else:
 598             base = 10
 599         # See https://github.com/rg3/youtube-dl/issues/7518
 600         try:
 601             return compat_chr(int(numstr, base))
 602         except ValueError:
 603             pass
 604
 605     # Unknown entity in name, return its literal representation
 606     return '&%s;' % entity
 607
 608
 609 def unescapeHTML(s):
 610     if s is None:
 611         return None
 612     assert type(s) == compat_str
 613
 614     return re.sub(
 615         r'&([^&;]+;)', lambda m: _htmlentity_transform(m.group(1)), s)
 616
 617
 618 def get_subprocess_encoding():
 619     if sys.platform == 'win32' and sys.getwindowsversion()[0] >= 5:
 620         # For subprocess calls, encode with locale encoding
 621         # Refer to http://stackoverflow.com/a/9951851/35070
 622         encoding = preferredencoding()
 623     else:
 624         encoding = sys.getfilesystemencoding()
 625     if encoding is None:
 626         encoding = 'utf-8'
 627     return encoding
 628
 629
 630 def encodeFilename(s, for_subprocess=False):
 631     """
 632     @param s The name of the file
 633     """
 634
 635     assert type(s) == compat_str
 636
 637     # Python 3 has a Unicode API
 638     if sys.version_info >= (3, 0):
 639         return s
 640
 641     # Pass '' directly to use Unicode APIs on Windows 2000 and up
 642     # (Detecting Windows NT 4 is tricky because 'major >= 4' would
 643     # match Windows 9x series as well. Besides, NT 4 is obsolete.)
 644     if not for_subprocess and sys.platform == 'win32' and sys.getwindowsversion()[0] >= 5:
 645         return s
 646
 647     # Jython assumes filenames are Unicode strings though reported as Python 2.x compatible
 648     if sys.platform.startswith('java'):
 649         return s
 650
 651     return s.encode(get_subprocess_encoding(), 'ignore')
 652
 653
 654 def decodeFilename(b, for_subprocess=False):
 655
 656     if sys.version_info >= (3, 0):
 657         return b
 658
 659     if not isinstance(b, bytes):
 660         return b
 661
 662     return b.decode(get_subprocess_encoding(), 'ignore')
 663
 664
 665 def encodeArgument(s):
 666     if not isinstance(s, compat_str):
 667         # Legacy code that uses byte strings
 668         # Uncomment the following line after fixing all post processors
 669         # assert False, 'Internal error: %r should be of type %r, is %r' % (s, compat_str, type(s))
 670         s = s.decode('ascii')
 671     return encodeFilename(s, True)
 672
 673
 674 def decodeArgument(b):
 675     return decodeFilename(b, True)
 676
 677
 678 def decodeOption(optval):
 679     if optval is None:
 680         return optval
 681     if isinstance(optval, bytes):
 682         optval = optval.decode(preferredencoding())
 683
 684     assert isinstance(optval, compat_str)
 685     return optval
 686
 687
 688 def formatSeconds(secs):
 689     if secs > 3600:
 690         return '%d:%02d:%02d' % (secs // 3600, (secs % 3600) // 60, secs % 60)
 691     elif secs > 60:
 692         return '%d:%02d' % (secs // 60, secs % 60)
 693     else:
 694         return '%d' % secs
 695
 696
 697 def make_HTTPS_handler(params, **kwargs):
 698     opts_no_check_certificate = params.get('nocheckcertificate', False)
 699     if hasattr(ssl, 'create_default_context'):  # Python >= 3.4 or 2.7.9
 700         context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
 701         if opts_no_check_certificate:
 702             context.check_hostname = False
 703             context.verify_mode = ssl.CERT_NONE
 704         try:
 705             return YoutubeDLHTTPSHandler(params, context=context, **kwargs)
 706         except TypeError:
 707             # Python 2.7.8
 708             # (create_default_context present but HTTPSHandler has no context=)
 709             pass
 710
 711     if sys.version_info < (3, 2):
 712         return YoutubeDLHTTPSHandler(params, **kwargs)
 713     else:  # Python < 3.4
 714         context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
 715         context.verify_mode = (ssl.CERT_NONE
 716                                if opts_no_check_certificate
 717                                else ssl.CERT_REQUIRED)
 718         context.set_default_verify_paths()
 719         return YoutubeDLHTTPSHandler(params, context=context, **kwargs)
 720
 721
 722 def bug_reports_message():
 723     if ytdl_is_updateable():
 724         update_cmd = 'type  youtube-dl -U  to update'
 725     else:
 726         update_cmd = 'see  https://yt-dl.org/update  on how to update'
 727     msg = '; please report this issue on https://yt-dl.org/bug .'
 728     msg += ' Make sure you are using the latest version; %s.' % update_cmd
 729     msg += ' Be sure to call youtube-dl with the --verbose flag and include its complete output.'
 730     return msg
 731
 732
 733 class YoutubeDLError(Exception):
 734     """Base exception for YoutubeDL errors."""
 735     pass
 736
 737
 738 class ExtractorError(YoutubeDLError):
 739     """Error during info extraction."""
 740
 741     def __init__(self, msg, tb=None, expected=False, cause=None, video_id=None):
 742         """ tb, if given, is the original traceback (so that it can be printed out).
 743         If expected is set, this is a normal error message and most likely not a bug in youtube-dl.
 744         """
 745
 746         if sys.exc_info()[0] in (compat_urllib_error.URLError, socket.timeout, UnavailableVideoError):
 747             expected = True
 748         if video_id is not None:
 749             msg = video_id + ': ' + msg
 750         if cause:
 751             msg += ' (caused by %r)' % cause
 752         if not expected:
 753             msg += bug_reports_message()
 754         super(ExtractorError, self).__init__(msg)
 755
 756         self.traceback = tb
 757         self.exc_info = sys.exc_info()  # preserve original exception
 758         self.cause = cause
 759         self.video_id = video_id
 760
 761     def format_traceback(self):
 762         if self.traceback is None:
 763             return None
 764         return ''.join(traceback.format_tb(self.traceback))
 765
 766
 767 class UnsupportedError(ExtractorError):
 768     def __init__(self, url):
 769         super(UnsupportedError, self).__init__(
 770             'Unsupported URL: %s' % url, expected=True)
 771         self.url = url
 772
 773
 774 class RegexNotFoundError(ExtractorError):
 775     """Error when a regex didn't match"""
 776     pass
 777
 778
 779 class GeoRestrictedError(ExtractorError):
 780     """Geographic restriction Error exception.
 781
 782     This exception may be thrown when a video is not available from your
 783     geographic location due to geographic restrictions imposed by a website.
 784     """
 785     def __init__(self, msg, countries=None):
 786         super(GeoRestrictedError, self).__init__(msg, expected=True)
 787         self.msg = msg
 788         self.countries = countries
 789
 790
 791 class DownloadError(YoutubeDLError):
 792     """Download Error exception.
 793
 794     This exception may be thrown by FileDownloader objects if they are not
 795     configured to continue on errors. They will contain the appropriate
 796     error message.
 797     """
 798
 799     def __init__(self, msg, exc_info=None):
 800         """ exc_info, if given, is the original exception that caused the trouble (as returned by sys.exc_info()). """
 801         super(DownloadError, self).__init__(msg)
 802         self.exc_info = exc_info
 803
 804
 805 class SameFileError(YoutubeDLError):
 806     """Same File exception.
 807
 808     This exception will be thrown by FileDownloader objects if they detect
 809     multiple files would have to be downloaded to the same file on disk.
 810     """
 811     pass
 812
 813
 814 class PostProcessingError(YoutubeDLError):
 815     """Post Processing exception.
 816
 817     This exception may be raised by PostProcessor's .run() method to
 818     indicate an error in the postprocessing task.
 819     """
 820
 821     def __init__(self, msg):
 822         super(PostProcessingError, self).__init__(msg)
 823         self.msg = msg
 824
 825
 826 class MaxDownloadsReached(YoutubeDLError):
 827     """ --max-downloads limit has been reached. """
 828     pass
 829
 830
 831 class UnavailableVideoError(YoutubeDLError):
 832     """Unavailable Format exception.
 833
 834     This exception will be thrown when a video is requested
 835     in a format that is not available for that video.
 836     """
 837     pass
 838
 839
 840 class ContentTooShortError(YoutubeDLError):
 841     """Content Too Short exception.
 842
 843     This exception may be raised by FileDownloader objects when a file they
 844     download is too small for what the server announced first, indicating
 845     the connection was probably interrupted.
 846     """
 847
 848     def __init__(self, downloaded, expected):
 849         super(ContentTooShortError, self).__init__(
 850             'Downloaded {0} bytes, expected {1} bytes'.format(downloaded, expected)
 851         )
 852         # Both in bytes
 853         self.downloaded = downloaded
 854         self.expected = expected
 855
 856
 857 class XAttrMetadataError(YoutubeDLError):
 858     def __init__(self, code=None, msg='Unknown error'):
 859         super(XAttrMetadataError, self).__init__(msg)
 860         self.code = code
 861         self.msg = msg
 862
 863         # Parsing code and msg
 864         if (self.code in (errno.ENOSPC, errno.EDQUOT) or
 865                 'No space left' in self.msg or 'Disk quota excedded' in self.msg):
 866             self.reason = 'NO_SPACE'
 867         elif self.code == errno.E2BIG or 'Argument list too long' in self.msg:
 868             self.reason = 'VALUE_TOO_LONG'
 869         else:
 870             self.reason = 'NOT_SUPPORTED'
 871
 872
 873 class XAttrUnavailableError(YoutubeDLError):
 874     pass
 875
 876
 877 def _create_http_connection(ydl_handler, http_class, is_https, *args, **kwargs):
 878     # Working around python 2 bug (see http://bugs.python.org/issue17849) by limiting
 879     # expected HTTP responses to meet HTTP/1.0 or later (see also
 880     # https://github.com/rg3/youtube-dl/issues/6727)
 881     if sys.version_info < (3, 0):
 882         kwargs['strict'] = True
 883     hc = http_class(*args, **compat_kwargs(kwargs))
 884     source_address = ydl_handler._params.get('source_address')
 885
 886     if source_address is not None:
 887         # This is to workaround _create_connection() from socket where it will try all
 888         # address data from getaddrinfo() including IPv6. This filters the result from
 889         # getaddrinfo() based on the source_address value.
 890         # This is based on the cpython socket.create_connection() function.
 891         # https://github.com/python/cpython/blob/master/Lib/socket.py#L691
 892         def _create_connection(address, timeout=socket._GLOBAL_DEFAULT_TIMEOUT, source_address=None):
 893             host, port = address
 894             err = None
 895             addrs = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM)
 896             af = socket.AF_INET if '.' in source_address[0] else socket.AF_INET6
 897             ip_addrs = [addr for addr in addrs if addr[0] == af]
 898             if addrs and not ip_addrs:
 899                 ip_version = 'v4' if af == socket.AF_INET else 'v6'
 900                 raise socket.error(
 901                     "No remote IP%s addresses available for connect, can't use '%s' as source address"
 902                     % (ip_version, source_address[0]))
 903             for res in ip_addrs:
 904                 af, socktype, proto, canonname, sa = res
 905                 sock = None
 906                 try:
 907                     sock = socket.socket(af, socktype, proto)
 908                     if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT:
 909                         sock.settimeout(timeout)
 910                     sock.bind(source_address)
 911                     sock.connect(sa)
 912                     err = None  # Explicitly break reference cycle
 913                     return sock
 914                 except socket.error as _:
 915                     err = _
 916                     if sock is not None:
 917                         sock.close()
 918             if err is not None:
 919                 raise err
 920             else:
 921                 raise socket.error('getaddrinfo returns an empty list')
 922         if hasattr(hc, '_create_connection'):
 923             hc._create_connection = _create_connection
 924         sa = (source_address, 0)
 925         if hasattr(hc, 'source_address'):  # Python 2.7+
 926             hc.source_address = sa
 927         else:  # Python 2.6
 928             def _hc_connect(self, *args, **kwargs):
 929                 sock = _create_connection(
 930                     (self.host, self.port), self.timeout, sa)
 931                 if is_https:
 932                     self.sock = ssl.wrap_socket(
 933                         sock, self.key_file, self.cert_file,
 934                         ssl_version=ssl.PROTOCOL_TLSv1)
 935                 else:
 936                     self.sock = sock
 937             hc.connect = functools.partial(_hc_connect, hc)
 938
 939     return hc
 940
 941
 942 def handle_youtubedl_headers(headers):
 943     filtered_headers = headers
 944
 945     if 'Youtubedl-no-compression' in filtered_headers:
 946         filtered_headers = dict((k, v) for k, v in filtered_headers.items() if k.lower() != 'accept-encoding')
 947         del filtered_headers['Youtubedl-no-compression']
 948
 949     return filtered_headers
 950
 951
 952 class YoutubeDLHandler(compat_urllib_request.HTTPHandler):
 953     """Handler for HTTP requests and responses.
 954
 955     This class, when installed with an OpenerDirector, automatically adds
 956     the standard headers to every HTTP request and handles gzipped and
 957     deflated responses from web servers. If compression is to be avoided in
 958     a particular request, the original request in the program code only has
 959     to include the HTTP header "Youtubedl-no-compression", which will be
 960     removed before making the real request.
 961
 962     Part of this code was copied from:
 963
 964     http://techknack.net/python-urllib2-handlers/
 965
 966     Andrew Rowls, the author of that code, agreed to release it to the
 967     public domain.
 968     """
 969
 970     def __init__(self, params, *args, **kwargs):
 971         compat_urllib_request.HTTPHandler.__init__(self, *args, **kwargs)
 972         self._params = params
 973
 974     def http_open(self, req):
 975         conn_class = compat_http_client.HTTPConnection
 976
 977         socks_proxy = req.headers.get('Ytdl-socks-proxy')
 978         if socks_proxy:
 979             conn_class = make_socks_conn_class(conn_class, socks_proxy)
 980             del req.headers['Ytdl-socks-proxy']
 981
 982         return self.do_open(functools.partial(
 983             _create_http_connection, self, conn_class, False),
 984             req)
 985
 986     @staticmethod
 987     def deflate(data):
 988         try:
 989             return zlib.decompress(data, -zlib.MAX_WBITS)
 990         except zlib.error:
 991             return zlib.decompress(data)
 992
 993     def http_request(self, req):
 994         # According to RFC 3986, URLs can not contain non-ASCII characters, however this is not
 995         # always respected by websites, some tend to give out URLs with non percent-encoded
 996         # non-ASCII characters (see telemb.py, ard.py [#3412])
 997         # urllib chokes on URLs with non-ASCII characters (see http://bugs.python.org/issue3991)
 998         # To work around aforementioned issue we will replace request's original URL with
 999         # percent-encoded one
1000         # Since redirects are also affected (e.g. http://www.southpark.de/alle-episoden/s18e09)
1001         # the code of this workaround has been moved here from YoutubeDL.urlopen()
1002         url = req.get_full_url()
1003         url_escaped = escape_url(url)
1004
1005         # Substitute URL if any change after escaping
1006         if url != url_escaped:
1007             req = update_Request(req, url=url_escaped)
1008
1009         for h, v in std_headers.items():
1010             # Capitalize is needed because of Python bug 2275: http://bugs.python.org/issue2275
1011             # The dict keys are capitalized because of this bug by urllib
1012             if h.capitalize() not in req.headers:
1013                 req.add_header(h, v)
1014
1015         req.headers = handle_youtubedl_headers(req.headers)
1016
1017         if sys.version_info < (2, 7) and '#' in req.get_full_url():
1018             # Python 2.6 is brain-dead when it comes to fragments
1019             req._Request__original = req._Request__original.partition('#')[0]
1020             req._Request__r_type = req._Request__r_type.partition('#')[0]
1021
1022         return req
1023
1024     def http_response(self, req, resp):
1025         old_resp = resp
1026         # gzip
1027         if resp.headers.get('Content-encoding', '') == 'gzip':
1028             content = resp.read()
1029             gz = gzip.GzipFile(fileobj=io.BytesIO(content), mode='rb')
1030             try:
1031                 uncompressed = io.BytesIO(gz.read())
1032             except IOError as original_ioerror:
1033                 # There may be junk add the end of the file
1034                 # See http://stackoverflow.com/q/4928560/35070 for details
1035                 for i in range(1, 1024):
1036                     try:
1037                         gz = gzip.GzipFile(fileobj=io.BytesIO(content[:-i]), mode='rb')
1038                         uncompressed = io.BytesIO(gz.read())
1039                     except IOError:
1040                         continue
1041                     break
1042                 else:
1043                     raise original_ioerror
1044             resp = compat_urllib_request.addinfourl(uncompressed, old_resp.headers, old_resp.url, old_resp.code)
1045             resp.msg = old_resp.msg
1046             del resp.headers['Content-encoding']
1047         # deflate
1048         if resp.headers.get('Content-encoding', '') == 'deflate':
1049             gz = io.BytesIO(self.deflate(resp.read()))
1050             resp = compat_urllib_request.addinfourl(gz, old_resp.headers, old_resp.url, old_resp.code)
1051             resp.msg = old_resp.msg
1052             del resp.headers['Content-encoding']
1053         # Percent-encode redirect URL of Location HTTP header to satisfy RFC 3986 (see
1054         # https://github.com/rg3/youtube-dl/issues/6457).
1055         if 300 <= resp.code < 400:
1056             location = resp.headers.get('Location')
1057             if location:
1058                 # As of RFC 2616 default charset is iso-8859-1 that is respected by python 3
1059                 if sys.version_info >= (3, 0):
1060                     location = location.encode('iso-8859-1').decode('utf-8')
1061                 else:
1062                     location = location.decode('utf-8')
1063                 location_escaped = escape_url(location)
1064                 if location != location_escaped:
1065                     del resp.headers['Location']
1066                     if sys.version_info < (3, 0):
1067                         location_escaped = location_escaped.encode('utf-8')
1068                     resp.headers['Location'] = location_escaped
1069         return resp
1070
1071     https_request = http_request
1072     https_response = http_response
1073
1074
1075 def make_socks_conn_class(base_class, socks_proxy):
1076     assert issubclass(base_class, (
1077         compat_http_client.HTTPConnection, compat_http_client.HTTPSConnection))
1078
1079     url_components = compat_urlparse.urlparse(socks_proxy)
1080     if url_components.scheme.lower() == 'socks5':
1081         socks_type = ProxyType.SOCKS5
1082     elif url_components.scheme.lower() in ('socks', 'socks4'):
1083         socks_type = ProxyType.SOCKS4
1084     elif url_components.scheme.lower() == 'socks4a':
1085         socks_type = ProxyType.SOCKS4A
1086
1087     def unquote_if_non_empty(s):
1088         if not s:
1089             return s
1090         return compat_urllib_parse_unquote_plus(s)
1091
1092     proxy_args = (
1093         socks_type,
1094         url_components.hostname, url_components.port or 1080,
1095         True,  # Remote DNS
1096         unquote_if_non_empty(url_components.username),
1097         unquote_if_non_empty(url_components.password),
1098     )
1099
1100     class SocksConnection(base_class):
1101         def connect(self):
1102             self.sock = sockssocket()
1103             self.sock.setproxy(*proxy_args)
1104             if type(self.timeout) in (int, float):
1105                 self.sock.settimeout(self.timeout)
1106             self.sock.connect((self.host, self.port))
1107
1108             if isinstance(self, compat_http_client.HTTPSConnection):
1109                 if hasattr(self, '_context'):  # Python > 2.6
1110                     self.sock = self._context.wrap_socket(
1111                         self.sock, server_hostname=self.host)
1112                 else:
1113                     self.sock = ssl.wrap_socket(self.sock)
1114
1115     return SocksConnection
1116
1117
1118 class YoutubeDLHTTPSHandler(compat_urllib_request.HTTPSHandler):
1119     def __init__(self, params, https_conn_class=None, *args, **kwargs):
1120         compat_urllib_request.HTTPSHandler.__init__(self, *args, **kwargs)
1121         self._https_conn_class = https_conn_class or compat_http_client.HTTPSConnection
1122         self._params = params
1123
1124     def https_open(self, req):
1125         kwargs = {}
1126         conn_class = self._https_conn_class
1127
1128         if hasattr(self, '_context'):  # python > 2.6
1129             kwargs['context'] = self._context
1130         if hasattr(self, '_check_hostname'):  # python 3.x
1131             kwargs['check_hostname'] = self._check_hostname
1132
1133         socks_proxy = req.headers.get('Ytdl-socks-proxy')
1134         if socks_proxy:
1135             conn_class = make_socks_conn_class(conn_class, socks_proxy)
1136             del req.headers['Ytdl-socks-proxy']
1137
1138         return self.do_open(functools.partial(
1139             _create_http_connection, self, conn_class, True),
1140             req, **kwargs)
1141
1142
1143 class YoutubeDLCookieJar(compat_cookiejar.MozillaCookieJar):
1144     def save(self, filename=None, ignore_discard=False, ignore_expires=False):
1145         # Store session cookies with `expires` set to 0 instead of an empty
1146         # string
1147         for cookie in self:
1148             if cookie.expires is None:
1149                 cookie.expires = 0
1150         compat_cookiejar.MozillaCookieJar.save(self, filename, ignore_discard, ignore_expires)
1151
1152     def load(self, filename=None, ignore_discard=False, ignore_expires=False):
1153         compat_cookiejar.MozillaCookieJar.load(self, filename, ignore_discard, ignore_expires)
1154         # Session cookies are denoted by either `expires` field set to
1155         # an empty string or 0. MozillaCookieJar only recognizes the former
1156         # (see [1]). So we need force the latter to be recognized as session
1157         # cookies on our own.
1158         # Session cookies may be important for cookies-based authentication,
1159         # e.g. usually, when user does not check 'Remember me' check box while
1160         # logging in on a site, some important cookies are stored as session
1161         # cookies so that not recognizing them will result in failed login.
1162         # 1. https://bugs.python.org/issue17164
1163         for cookie in self:
1164             # Treat `expires=0` cookies as session cookies
1165             if cookie.expires == 0:
1166                 cookie.expires = None
1167                 cookie.discard = True
1168
1169
1170 class YoutubeDLCookieProcessor(compat_urllib_request.HTTPCookieProcessor):
1171     def __init__(self, cookiejar=None):
1172         compat_urllib_request.HTTPCookieProcessor.__init__(self, cookiejar)
1173
1174     def http_response(self, request, response):
1175         # Python 2 will choke on next HTTP request in row if there are non-ASCII
1176         # characters in Set-Cookie HTTP header of last response (see
1177         # https://github.com/rg3/youtube-dl/issues/6769).
1178         # In order to at least prevent crashing we will percent encode Set-Cookie
1179         # header before HTTPCookieProcessor starts processing it.
1180         # if sys.version_info < (3, 0) and response.headers:
1181         #     for set_cookie_header in ('Set-Cookie', 'Set-Cookie2'):
1182         #         set_cookie = response.headers.get(set_cookie_header)
1183         #         if set_cookie:
1184         #             set_cookie_escaped = compat_urllib_parse.quote(set_cookie, b"%/;:@&=+$,!~*'()?#[] ")
1185         #             if set_cookie != set_cookie_escaped:
1186         #                 del response.headers[set_cookie_header]
1187         #                 response.headers[set_cookie_header] = set_cookie_escaped
1188         return compat_urllib_request.HTTPCookieProcessor.http_response(self, request, response)
1189
1190     https_request = compat_urllib_request.HTTPCookieProcessor.http_request
1191     https_response = http_response
1192
1193
1194 def extract_timezone(date_str):
1195     m = re.search(
1196         r'^.{8,}?(?P<tz>Z$| ?(?P<sign>\+|-)(?P<hours>[0-9]{2}):?(?P<minutes>[0-9]{2})$)',
1197         date_str)
1198     if not m:
1199         timezone = datetime.timedelta()
1200     else:
1201         date_str = date_str[:-len(m.group('tz'))]
1202         if not m.group('sign'):
1203             timezone = datetime.timedelta()
1204         else:
1205             sign = 1 if m.group('sign') == '+' else -1
1206             timezone = datetime.timedelta(
1207                 hours=sign * int(m.group('hours')),
1208                 minutes=sign * int(m.group('minutes')))
1209     return timezone, date_str
1210
1211
1212 def parse_iso8601(date_str, delimiter='T', timezone=None):
1213     """ Return a UNIX timestamp from the given date """
1214
1215     if date_str is None:
1216         return None
1217
1218     date_str = re.sub(r'\.[0-9]+', '', date_str)
1219
1220     if timezone is None:
1221         timezone, date_str = extract_timezone(date_str)
1222
1223     try:
1224         date_format = '%Y-%m-%d{0}%H:%M:%S'.format(delimiter)
1225         dt = datetime.datetime.strptime(date_str, date_format) - timezone
1226         return calendar.timegm(dt.timetuple())
1227     except ValueError:
1228         pass
1229
1230
1231 def date_formats(day_first=True):
1232     return DATE_FORMATS_DAY_FIRST if day_first else DATE_FORMATS_MONTH_FIRST
1233
1234
1235 def unified_strdate(date_str, day_first=True):
1236     """Return a string with the date in the format YYYYMMDD"""
1237
1238     if date_str is None:
1239         return None
1240     upload_date = None
1241     # Replace commas
1242     date_str = date_str.replace(',', ' ')
1243     # Remove AM/PM + timezone
1244     date_str = re.sub(r'(?i)\s*(?:AM|PM)(?:\s+[A-Z]+)?', '', date_str)
1245     _, date_str = extract_timezone(date_str)
1246
1247     for expression in date_formats(day_first):
1248         try:
1249             upload_date = datetime.datetime.strptime(date_str, expression).strftime('%Y%m%d')
1250         except ValueError:
1251             pass
1252     if upload_date is None:
1253         timetuple = email.utils.parsedate_tz(date_str)
1254         if timetuple:
1255             try:
1256                 upload_date = datetime.datetime(*timetuple[:6]).strftime('%Y%m%d')
1257             except ValueError:
1258                 pass
1259     if upload_date is not None:
1260         return compat_str(upload_date)
1261
1262
1263 def unified_timestamp(date_str, day_first=True):
1264     if date_str is None:
1265         return None
1266
1267     date_str = re.sub(r'[,|]', '', date_str)
1268
1269     pm_delta = 12 if re.search(r'(?i)PM', date_str) else 0
1270     timezone, date_str = extract_timezone(date_str)
1271
1272     # Remove AM/PM + timezone
1273     date_str = re.sub(r'(?i)\s*(?:AM|PM)(?:\s+[A-Z]+)?', '', date_str)
1274
1275     # Remove unrecognized timezones from ISO 8601 alike timestamps
1276     m = re.search(r'\d{1,2}:\d{1,2}(?:\.\d+)?(?P<tz>\s*[A-Z]+)$', date_str)
1277     if m:
1278         date_str = date_str[:-len(m.group('tz'))]
1279
1280     # Python only supports microseconds, so remove nanoseconds
1281     m = re.search(r'^([0-9]{4,}-[0-9]{1,2}-[0-9]{1,2}T[0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2}\.[0-9]{6})[0-9]+$', date_str)
1282     if m:
1283         date_str = m.group(1)
1284
1285     for expression in date_formats(day_first):
1286         try:
1287             dt = datetime.datetime.strptime(date_str, expression) - timezone + datetime.timedelta(hours=pm_delta)
1288             return calendar.timegm(dt.timetuple())
1289         except ValueError:
1290             pass
1291     timetuple = email.utils.parsedate_tz(date_str)
1292     if timetuple:
1293         return calendar.timegm(timetuple) + pm_delta * 3600
1294
1295
1296 def determine_ext(url, default_ext='unknown_video'):
1297     if url is None or '.' not in url:
1298         return default_ext
1299     guess = url.partition('?')[0].rpartition('.')[2]
1300     if re.match(r'^[A-Za-z0-9]+$', guess):
1301         return guess
1302     # Try extract ext from URLs like http://example.com/foo/bar.mp4/?download
1303     elif guess.rstrip('/') in KNOWN_EXTENSIONS:
1304         return guess.rstrip('/')
1305     else:
1306         return default_ext
1307
1308
1309 def subtitles_filename(filename, sub_lang, sub_format):
1310     return filename.rsplit('.', 1)[0] + '.' + sub_lang + '.' + sub_format
1311
1312
1313 def date_from_str(date_str):
1314     """
1315     Return a datetime object from a string in the format YYYYMMDD or
1316     (now|today)[+-][0-9](day|week|month|year)(s)?"""
1317     today = datetime.date.today()
1318     if date_str in ('now', 'today'):
1319         return today
1320     if date_str == 'yesterday':
1321         return today - datetime.timedelta(days=1)
1322     match = re.match(r'(now|today)(?P<sign>[+-])(?P<time>\d+)(?P<unit>day|week|month|year)(s)?', date_str)
1323     if match is not None:
1324         sign = match.group('sign')
1325         time = int(match.group('time'))
1326         if sign == '-':
1327             time = -time
1328         unit = match.group('unit')
1329         # A bad approximation?
1330         if unit == 'month':
1331             unit = 'day'
1332             time *= 30
1333         elif unit == 'year':
1334             unit = 'day'
1335             time *= 365
1336         unit += 's'
1337         delta = datetime.timedelta(**{unit: time})
1338         return today + delta
1339     return datetime.datetime.strptime(date_str, '%Y%m%d').date()
1340
1341
1342 def hyphenate_date(date_str):
1343     """
1344     Convert a date in 'YYYYMMDD' format to 'YYYY-MM-DD' format"""
1345     match = re.match(r'^(\d\d\d\d)(\d\d)(\d\d)$', date_str)
1346     if match is not None:
1347         return '-'.join(match.groups())
1348     else:
1349         return date_str
1350
1351
1352 class DateRange(object):
1353     """Represents a time interval between two dates"""
1354
1355     def __init__(self, start=None, end=None):
1356         """start and end must be strings in the format accepted by date"""
1357         if start is not None:
1358             self.start = date_from_str(start)
1359         else:
1360             self.start = datetime.datetime.min.date()
1361         if end is not None:
1362             self.end = date_from_str(end)
1363         else:
1364             self.end = datetime.datetime.max.date()
1365         if self.start > self.end:
1366             raise ValueError('Date range: "%s" , the start date must be before the end date' % self)
1367
1368     @classmethod
1369     def day(cls, day):
1370         """Returns a range that only contains the given day"""
1371         return cls(day, day)
1372
1373     def __contains__(self, date):
1374         """Check if the date is in the range"""
1375         if not isinstance(date, datetime.date):
1376             date = date_from_str(date)
1377         return self.start <= date <= self.end
1378
1379     def __str__(self):
1380         return '%s - %s' % (self.start.isoformat(), self.end.isoformat())
1381
1382
1383 def platform_name():
1384     """ Returns the platform name as a compat_str """
1385     res = platform.platform()
1386     if isinstance(res, bytes):
1387         res = res.decode(preferredencoding())
1388
1389     assert isinstance(res, compat_str)
1390     return res
1391
1392
1393 def _windows_write_string(s, out):
1394     """ Returns True if the string was written using special methods,
1395     False if it has yet to be written out."""
1396     # Adapted from http://stackoverflow.com/a/3259271/35070
1397
1398     import ctypes
1399     import ctypes.wintypes
1400
1401     WIN_OUTPUT_IDS = {
1402         1: -11,
1403         2: -12,
1404     }
1405
1406     try:
1407         fileno = out.fileno()
1408     except AttributeError:
1409         # If the output stream doesn't have a fileno, it's virtual
1410         return False
1411     except io.UnsupportedOperation:
1412         # Some strange Windows pseudo files?
1413         return False
1414     if fileno not in WIN_OUTPUT_IDS:
1415         return False
1416
1417     GetStdHandle = compat_ctypes_WINFUNCTYPE(
1418         ctypes.wintypes.HANDLE, ctypes.wintypes.DWORD)(
1419         ('GetStdHandle', ctypes.windll.kernel32))
1420     h = GetStdHandle(WIN_OUTPUT_IDS[fileno])
1421
1422     WriteConsoleW = compat_ctypes_WINFUNCTYPE(
1423         ctypes.wintypes.BOOL, ctypes.wintypes.HANDLE, ctypes.wintypes.LPWSTR,
1424         ctypes.wintypes.DWORD, ctypes.POINTER(ctypes.wintypes.DWORD),
1425         ctypes.wintypes.LPVOID)(('WriteConsoleW', ctypes.windll.kernel32))
1426     written = ctypes.wintypes.DWORD(0)
1427
1428     GetFileType = compat_ctypes_WINFUNCTYPE(ctypes.wintypes.DWORD, ctypes.wintypes.DWORD)(('GetFileType', ctypes.windll.kernel32))
1429     FILE_TYPE_CHAR = 0x0002
1430     FILE_TYPE_REMOTE = 0x8000
1431     GetConsoleMode = compat_ctypes_WINFUNCTYPE(
1432         ctypes.wintypes.BOOL, ctypes.wintypes.HANDLE,
1433         ctypes.POINTER(ctypes.wintypes.DWORD))(
1434         ('GetConsoleMode', ctypes.windll.kernel32))
1435     INVALID_HANDLE_VALUE = ctypes.wintypes.DWORD(-1).value
1436
1437     def not_a_console(handle):
1438         if handle == INVALID_HANDLE_VALUE or handle is None:
1439             return True
1440         return ((GetFileType(handle) & ~FILE_TYPE_REMOTE) != FILE_TYPE_CHAR or
1441                 GetConsoleMode(handle, ctypes.byref(ctypes.wintypes.DWORD())) == 0)
1442
1443     if not_a_console(h):
1444         return False
1445
1446     def next_nonbmp_pos(s):
1447         try:
1448             return next(i for i, c in enumerate(s) if ord(c) > 0xffff)
1449         except StopIteration:
1450             return len(s)
1451
1452     while s:
1453         count = min(next_nonbmp_pos(s), 1024)
1454
1455         ret = WriteConsoleW(
1456             h, s, count if count else 2, ctypes.byref(written), None)
1457         if ret == 0:
1458             raise OSError('Failed to write string')
1459         if not count:  # We just wrote a non-BMP character
1460             assert written.value == 2
1461             s = s[1:]
1462         else:
1463             assert written.value > 0
1464             s = s[written.value:]
1465     return True
1466
1467
1468 def write_string(s, out=None, encoding=None):
1469     if out is None:
1470         out = sys.stderr
1471     assert type(s) == compat_str
1472
1473     if sys.platform == 'win32' and encoding is None and hasattr(out, 'fileno'):
1474         if _windows_write_string(s, out):
1475             return
1476
1477     if ('b' in getattr(out, 'mode', '') or
1478             sys.version_info[0] < 3):  # Python 2 lies about mode of sys.stderr
1479         byt = s.encode(encoding or preferredencoding(), 'ignore')
1480         out.write(byt)
1481     elif hasattr(out, 'buffer'):
1482         enc = encoding or getattr(out, 'encoding', None) or preferredencoding()
1483         byt = s.encode(enc, 'ignore')
1484         out.buffer.write(byt)
1485     else:
1486         out.write(s)
1487     out.flush()
1488
1489
1490 def bytes_to_intlist(bs):
1491     if not bs:
1492         return []
1493     if isinstance(bs[0], int):  # Python 3
1494         return list(bs)
1495     else:
1496         return [ord(c) for c in bs]
1497
1498
1499 def intlist_to_bytes(xs):
1500     if not xs:
1501         return b''
1502     return compat_struct_pack('%dB' % len(xs), *xs)
1503
1504
1505 # Cross-platform file locking
1506 if sys.platform == 'win32':
1507     import ctypes.wintypes
1508     import msvcrt
1509
1510     class OVERLAPPED(ctypes.Structure):
1511         _fields_ = [
1512             ('Internal', ctypes.wintypes.LPVOID),
1513             ('InternalHigh', ctypes.wintypes.LPVOID),
1514             ('Offset', ctypes.wintypes.DWORD),
1515             ('OffsetHigh', ctypes.wintypes.DWORD),
1516             ('hEvent', ctypes.wintypes.HANDLE),
1517         ]
1518
1519     kernel32 = ctypes.windll.kernel32
1520     LockFileEx = kernel32.LockFileEx
1521     LockFileEx.argtypes = [
1522         ctypes.wintypes.HANDLE,     # hFile
1523         ctypes.wintypes.DWORD,      # dwFlags
1524         ctypes.wintypes.DWORD,      # dwReserved
1525         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockLow
1526         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockHigh
1527         ctypes.POINTER(OVERLAPPED)  # Overlapped
1528     ]
1529     LockFileEx.restype = ctypes.wintypes.BOOL
1530     UnlockFileEx = kernel32.UnlockFileEx
1531     UnlockFileEx.argtypes = [
1532         ctypes.wintypes.HANDLE,     # hFile
1533         ctypes.wintypes.DWORD,      # dwReserved
1534         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockLow
1535         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockHigh
1536         ctypes.POINTER(OVERLAPPED)  # Overlapped
1537     ]
1538     UnlockFileEx.restype = ctypes.wintypes.BOOL
1539     whole_low = 0xffffffff
1540     whole_high = 0x7fffffff
1541
1542     def _lock_file(f, exclusive):
1543         overlapped = OVERLAPPED()
1544         overlapped.Offset = 0
1545         overlapped.OffsetHigh = 0
1546         overlapped.hEvent = 0
1547         f._lock_file_overlapped_p = ctypes.pointer(overlapped)
1548         handle = msvcrt.get_osfhandle(f.fileno())
1549         if not LockFileEx(handle, 0x2 if exclusive else 0x0, 0,
1550                           whole_low, whole_high, f._lock_file_overlapped_p):
1551             raise OSError('Locking file failed: %r' % ctypes.FormatError())
1552
1553     def _unlock_file(f):
1554         assert f._lock_file_overlapped_p
1555         handle = msvcrt.get_osfhandle(f.fileno())
1556         if not UnlockFileEx(handle, 0,
1557                             whole_low, whole_high, f._lock_file_overlapped_p):
1558             raise OSError('Unlocking file failed: %r' % ctypes.FormatError())
1559
1560 else:
1561     # Some platforms, such as Jython, is missing fcntl
1562     try:
1563         import fcntl
1564
1565         def _lock_file(f, exclusive):
1566             fcntl.flock(f, fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH)
1567
1568         def _unlock_file(f):
1569             fcntl.flock(f, fcntl.LOCK_UN)
1570     except ImportError:
1571         UNSUPPORTED_MSG = 'file locking is not supported on this platform'
1572
1573         def _lock_file(f, exclusive):
1574             raise IOError(UNSUPPORTED_MSG)
1575
1576         def _unlock_file(f):
1577             raise IOError(UNSUPPORTED_MSG)
1578
1579
1580 class locked_file(object):
1581     def __init__(self, filename, mode, encoding=None):
1582         assert mode in ['r', 'a', 'w']
1583         self.f = io.open(filename, mode, encoding=encoding)
1584         self.mode = mode
1585
1586     def __enter__(self):
1587         exclusive = self.mode != 'r'
1588         try:
1589             _lock_file(self.f, exclusive)
1590         except IOError:
1591             self.f.close()
1592             raise
1593         return self
1594
1595     def __exit__(self, etype, value, traceback):
1596         try:
1597             _unlock_file(self.f)
1598         finally:
1599             self.f.close()
1600
1601     def __iter__(self):
1602         return iter(self.f)
1603
1604     def write(self, *args):
1605         return self.f.write(*args)
1606
1607     def read(self, *args):
1608         return self.f.read(*args)
1609
1610
1611 def get_filesystem_encoding():
1612     encoding = sys.getfilesystemencoding()
1613     return encoding if encoding is not None else 'utf-8'
1614
1615
1616 def shell_quote(args):
1617     quoted_args = []
1618     encoding = get_filesystem_encoding()
1619     for a in args:
1620         if isinstance(a, bytes):
1621             # We may get a filename encoded with 'encodeFilename'
1622             a = a.decode(encoding)
1623         quoted_args.append(compat_shlex_quote(a))
1624     return ' '.join(quoted_args)
1625
1626
1627 def smuggle_url(url, data):
1628     """ Pass additional data in a URL for internal use. """
1629
1630     url, idata = unsmuggle_url(url, {})
1631     data.update(idata)
1632     sdata = compat_urllib_parse_urlencode(
1633         {'__youtubedl_smuggle': json.dumps(data)})
1634     return url + '#' + sdata
1635
1636
1637 def unsmuggle_url(smug_url, default=None):
1638     if '#__youtubedl_smuggle' not in smug_url:
1639         return smug_url, default
1640     url, _, sdata = smug_url.rpartition('#')
1641     jsond = compat_parse_qs(sdata)['__youtubedl_smuggle'][0]
1642     data = json.loads(jsond)
1643     return url, data
1644
1645
1646 def format_bytes(bytes):
1647     if bytes is None:
1648         return 'N/A'
1649     if type(bytes) is str:
1650         bytes = float(bytes)
1651     if bytes == 0.0:
1652         exponent = 0
1653     else:
1654         exponent = int(math.log(bytes, 1024.0))
1655     suffix = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'][exponent]
1656     converted = float(bytes) / float(1024 ** exponent)
1657     return '%.2f%s' % (converted, suffix)
1658
1659
1660 def lookup_unit_table(unit_table, s):
1661     units_re = '|'.join(re.escape(u) for u in unit_table)
1662     m = re.match(
1663         r'(?P<num>[0-9]+(?:[,.][0-9]*)?)\s*(?P<unit>%s)\b' % units_re, s)
1664     if not m:
1665         return None
1666     num_str = m.group('num').replace(',', '.')
1667     mult = unit_table[m.group('unit')]
1668     return int(float(num_str) * mult)
1669
1670
1671 def parse_filesize(s):
1672     if s is None:
1673         return None
1674
1675     # The lower-case forms are of course incorrect and unofficial,
1676     # but we support those too
1677     _UNIT_TABLE = {
1678         'B': 1,
1679         'b': 1,
1680         'bytes': 1,
1681         'KiB': 1024,
1682         'KB': 1000,
1683         'kB': 1024,
1684         'Kb': 1000,
1685         'kb': 1000,
1686         'kilobytes': 1000,
1687         'kibibytes': 1024,
1688         'MiB': 1024 ** 2,
1689         'MB': 1000 ** 2,
1690         'mB': 1024 ** 2,
1691         'Mb': 1000 ** 2,
1692         'mb': 1000 ** 2,
1693         'megabytes': 1000 ** 2,
1694         'mebibytes': 1024 ** 2,
1695         'GiB': 1024 ** 3,
1696         'GB': 1000 ** 3,
1697         'gB': 1024 ** 3,
1698         'Gb': 1000 ** 3,
1699         'gb': 1000 ** 3,
1700         'gigabytes': 1000 ** 3,
1701         'gibibytes': 1024 ** 3,
1702         'TiB': 1024 ** 4,
1703         'TB': 1000 ** 4,
1704         'tB': 1024 ** 4,
1705         'Tb': 1000 ** 4,
1706         'tb': 1000 ** 4,
1707         'terabytes': 1000 ** 4,
1708         'tebibytes': 1024 ** 4,
1709         'PiB': 1024 ** 5,
1710         'PB': 1000 ** 5,
1711         'pB': 1024 ** 5,
1712         'Pb': 1000 ** 5,
1713         'pb': 1000 ** 5,
1714         'petabytes': 1000 ** 5,
1715         'pebibytes': 1024 ** 5,
1716         'EiB': 1024 ** 6,
1717         'EB': 1000 ** 6,
1718         'eB': 1024 ** 6,
1719         'Eb': 1000 ** 6,
1720         'eb': 1000 ** 6,
1721         'exabytes': 1000 ** 6,
1722         'exbibytes': 1024 ** 6,
1723         'ZiB': 1024 ** 7,
1724         'ZB': 1000 ** 7,
1725         'zB': 1024 ** 7,
1726         'Zb': 1000 ** 7,
1727         'zb': 1000 ** 7,
1728         'zettabytes': 1000 ** 7,
1729         'zebibytes': 1024 ** 7,
1730         'YiB': 1024 ** 8,
1731         'YB': 1000 ** 8,
1732         'yB': 1024 ** 8,
1733         'Yb': 1000 ** 8,
1734         'yb': 1000 ** 8,
1735         'yottabytes': 1000 ** 8,
1736         'yobibytes': 1024 ** 8,
1737     }
1738
1739     return lookup_unit_table(_UNIT_TABLE, s)
1740
1741
1742 def parse_count(s):
1743     if s is None:
1744         return None
1745
1746     s = s.strip()
1747
1748     if re.match(r'^[\d,.]+$', s):
1749         return str_to_int(s)
1750
1751     _UNIT_TABLE = {
1752         'k': 1000,
1753         'K': 1000,
1754         'm': 1000 ** 2,
1755         'M': 1000 ** 2,
1756         'kk': 1000 ** 2,
1757         'KK': 1000 ** 2,
1758     }
1759
1760     return lookup_unit_table(_UNIT_TABLE, s)
1761
1762
1763 def parse_resolution(s):
1764     if s is None:
1765         return {}
1766
1767     mobj = re.search(r'\b(?P<w>\d+)\s*[xX×]\s*(?P<h>\d+)\b', s)
1768     if mobj:
1769         return {
1770             'width': int(mobj.group('w')),
1771             'height': int(mobj.group('h')),
1772         }
1773
1774     mobj = re.search(r'\b(\d+)[pPiI]\b', s)
1775     if mobj:
1776         return {'height': int(mobj.group(1))}
1777
1778     mobj = re.search(r'\b([48])[kK]\b', s)
1779     if mobj:
1780         return {'height': int(mobj.group(1)) * 540}
1781
1782     return {}
1783
1784
1785 def month_by_name(name, lang='en'):
1786     """ Return the number of a month by (locale-independently) English name """
1787
1788     month_names = MONTH_NAMES.get(lang, MONTH_NAMES['en'])
1789
1790     try:
1791         return month_names.index(name) + 1
1792     except ValueError:
1793         return None
1794
1795
1796 def month_by_abbreviation(abbrev):
1797     """ Return the number of a month by (locale-independently) English
1798         abbreviations """
1799
1800     try:
1801         return [s[:3] for s in ENGLISH_MONTH_NAMES].index(abbrev) + 1
1802     except ValueError:
1803         return None
1804
1805
1806 def fix_xml_ampersands(xml_str):
1807     """Replace all the '&' by '&amp;' in XML"""
1808     return re.sub(
1809         r'&(?!amp;|lt;|gt;|apos;|quot;|#x[0-9a-fA-F]{,4};|#[0-9]{,4};)',
1810         '&amp;',
1811         xml_str)
1812
1813
1814 def setproctitle(title):
1815     assert isinstance(title, compat_str)
1816
1817     # ctypes in Jython is not complete
1818     # http://bugs.jython.org/issue2148
1819     if sys.platform.startswith('java'):
1820         return
1821
1822     try:
1823         libc = ctypes.cdll.LoadLibrary('libc.so.6')
1824     except OSError:
1825         return
1826     except TypeError:
1827         # LoadLibrary in Windows Python 2.7.13 only expects
1828         # a bytestring, but since unicode_literals turns
1829         # every string into a unicode string, it fails.
1830         return
1831     title_bytes = title.encode('utf-8')
1832     buf = ctypes.create_string_buffer(len(title_bytes))
1833     buf.value = title_bytes
1834     try:
1835         libc.prctl(15, buf, 0, 0, 0)
1836     except AttributeError:
1837         return  # Strange libc, just skip this
1838
1839
1840 def remove_start(s, start):
1841     return s[len(start):] if s is not None and s.startswith(start) else s
1842
1843
1844 def remove_end(s, end):
1845     return s[:-len(end)] if s is not None and s.endswith(end) else s
1846
1847
1848 def remove_quotes(s):
1849     if s is None or len(s) < 2:
1850         return s
1851     for quote in ('"', "'", ):
1852         if s[0] == quote and s[-1] == quote:
1853             return s[1:-1]
1854     return s
1855
1856
1857 def url_basename(url):
1858     path = compat_urlparse.urlparse(url).path
1859     return path.strip('/').split('/')[-1]
1860
1861
1862 def base_url(url):
1863     return re.match(r'https?://[^?#&]+/', url).group()
1864
1865
1866 def urljoin(base, path):
1867     if isinstance(path, bytes):
1868         path = path.decode('utf-8')
1869     if not isinstance(path, compat_str) or not path:
1870         return None
1871     if re.match(r'^(?:[a-zA-Z][a-zA-Z0-9+-.]*:)?//', path):
1872         return path
1873     if isinstance(base, bytes):
1874         base = base.decode('utf-8')
1875     if not isinstance(base, compat_str) or not re.match(
1876             r'^(?:https?:)?//', base):
1877         return None
1878     return compat_urlparse.urljoin(base, path)
1879
1880
1881 class HEADRequest(compat_urllib_request.Request):
1882     def get_method(self):
1883         return 'HEAD'
1884
1885
1886 class PUTRequest(compat_urllib_request.Request):
1887     def get_method(self):
1888         return 'PUT'
1889
1890
1891 def int_or_none(v, scale=1, default=None, get_attr=None, invscale=1):
1892     if get_attr:
1893         if v is not None:
1894             v = getattr(v, get_attr, None)
1895     if v == '':
1896         v = None
1897     if v is None:
1898         return default
1899     try:
1900         return int(v) * invscale // scale
1901     except ValueError:
1902         return default
1903
1904
1905 def str_or_none(v, default=None):
1906     return default if v is None else compat_str(v)
1907
1908
1909 def str_to_int(int_str):
1910     """ A more relaxed version of int_or_none """
1911     if int_str is None:
1912         return None
1913     int_str = re.sub(r'[,\.\+]', '', int_str)
1914     return int(int_str)
1915
1916
1917 def float_or_none(v, scale=1, invscale=1, default=None):
1918     if v is None:
1919         return default
1920     try:
1921         return float(v) * invscale / scale
1922     except ValueError:
1923         return default
1924
1925
1926 def bool_or_none(v, default=None):
1927     return v if isinstance(v, bool) else default
1928
1929
1930 def strip_or_none(v):
1931     return None if v is None else v.strip()
1932
1933
1934 def url_or_none(url):
1935     if not url or not isinstance(url, compat_str):
1936         return None
1937     url = url.strip()
1938     return url if re.match(r'^(?:[a-zA-Z][\da-zA-Z.+-]*:)?//', url) else None
1939
1940
1941 def parse_duration(s):
1942     if not isinstance(s, compat_basestring):
1943         return None
1944
1945     s = s.strip()
1946
1947     days, hours, mins, secs, ms = [None] * 5
1948     m = re.match(r'(?:(?:(?:(?P<days>[0-9]+):)?(?P<hours>[0-9]+):)?(?P<mins>[0-9]+):)?(?P<secs>[0-9]+)(?P<ms>\.[0-9]+)?Z?$', s)
1949     if m:
1950         days, hours, mins, secs, ms = m.groups()
1951     else:
1952         m = re.match(
1953             r'''(?ix)(?:P?
1954                 (?:
1955                     [0-9]+\s*y(?:ears?)?\s*
1956                 )?
1957                 (?:
1958                     [0-9]+\s*m(?:onths?)?\s*
1959                 )?
1960                 (?:
1961                     [0-9]+\s*w(?:eeks?)?\s*
1962                 )?
1963                 (?:
1964                     (?P<days>[0-9]+)\s*d(?:ays?)?\s*
1965                 )?
1966                 T)?
1967                 (?:
1968                     (?P<hours>[0-9]+)\s*h(?:ours?)?\s*
1969                 )?
1970                 (?:
1971                     (?P<mins>[0-9]+)\s*m(?:in(?:ute)?s?)?\s*
1972                 )?
1973                 (?:
1974                     (?P<secs>[0-9]+)(?P<ms>\.[0-9]+)?\s*s(?:ec(?:ond)?s?)?\s*
1975                 )?Z?$''', s)
1976         if m:
1977             days, hours, mins, secs, ms = m.groups()
1978         else:
1979             m = re.match(r'(?i)(?:(?P<hours>[0-9.]+)\s*(?:hours?)|(?P<mins>[0-9.]+)\s*(?:mins?\.?|minutes?)\s*)Z?$', s)
1980             if m:
1981                 hours, mins = m.groups()
1982             else:
1983                 return None
1984
1985     duration = 0
1986     if secs:
1987         duration += float(secs)
1988     if mins:
1989         duration += float(mins) * 60
1990     if hours:
1991         duration += float(hours) * 60 * 60
1992     if days:
1993         duration += float(days) * 24 * 60 * 60
1994     if ms:
1995         duration += float(ms)
1996     return duration
1997
1998
1999 def prepend_extension(filename, ext, expected_real_ext=None):
2000     name, real_ext = os.path.splitext(filename)
2001     return (
2002         '{0}.{1}{2}'.format(name, ext, real_ext)
2003         if not expected_real_ext or real_ext[1:] == expected_real_ext
2004         else '{0}.{1}'.format(filename, ext))
2005
2006
2007 def replace_extension(filename, ext, expected_real_ext=None):
2008     name, real_ext = os.path.splitext(filename)
2009     return '{0}.{1}'.format(
2010         name if not expected_real_ext or real_ext[1:] == expected_real_ext else filename,
2011         ext)
2012
2013
2014 def check_executable(exe, args=[]):
2015     """ Checks if the given binary is installed somewhere in PATH, and returns its name.
2016     args can be a list of arguments for a short output (like -version) """
2017     try:
2018         subprocess.Popen([exe] + args, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
2019     except OSError:
2020         return False
2021     return exe
2022
2023
2024 def get_exe_version(exe, args=['--version'],
2025                     version_re=None, unrecognized='present'):
2026     """ Returns the version of the specified executable,
2027     or False if the executable is not present """
2028     try:
2029         # STDIN should be redirected too. On UNIX-like systems, ffmpeg triggers
2030         # SIGTTOU if youtube-dl is run in the background.
2031         # See https://github.com/rg3/youtube-dl/issues/955#issuecomment-209789656
2032         out, _ = subprocess.Popen(
2033             [encodeArgument(exe)] + args,
2034             stdin=subprocess.PIPE,
2035             stdout=subprocess.PIPE, stderr=subprocess.STDOUT).communicate()
2036     except OSError:
2037         return False
2038     if isinstance(out, bytes):  # Python 2.x
2039         out = out.decode('ascii', 'ignore')
2040     return detect_exe_version(out, version_re, unrecognized)
2041
2042
2043 def detect_exe_version(output, version_re=None, unrecognized='present'):
2044     assert isinstance(output, compat_str)
2045     if version_re is None:
2046         version_re = r'version\s+([-0-9._a-zA-Z]+)'
2047     m = re.search(version_re, output)
2048     if m:
2049         return m.group(1)
2050     else:
2051         return unrecognized
2052
2053
2054 class PagedList(object):
2055     def __len__(self):
2056         # This is only useful for tests
2057         return len(self.getslice())
2058
2059
2060 class OnDemandPagedList(PagedList):
2061     def __init__(self, pagefunc, pagesize, use_cache=True):
2062         self._pagefunc = pagefunc
2063         self._pagesize = pagesize
2064         self._use_cache = use_cache
2065         if use_cache:
2066             self._cache = {}
2067
2068     def getslice(self, start=0, end=None):
2069         res = []
2070         for pagenum in itertools.count(start // self._pagesize):
2071             firstid = pagenum * self._pagesize
2072             nextfirstid = pagenum * self._pagesize + self._pagesize
2073             if start >= nextfirstid:
2074                 continue
2075
2076             page_results = None
2077             if self._use_cache:
2078                 page_results = self._cache.get(pagenum)
2079             if page_results is None:
2080                 page_results = list(self._pagefunc(pagenum))
2081             if self._use_cache:
2082                 self._cache[pagenum] = page_results
2083
2084             startv = (
2085                 start % self._pagesize
2086                 if firstid <= start < nextfirstid
2087                 else 0)
2088
2089             endv = (
2090                 ((end - 1) % self._pagesize) + 1
2091                 if (end is not None and firstid <= end <= nextfirstid)
2092                 else None)
2093
2094             if startv != 0 or endv is not None:
2095                 page_results = page_results[startv:endv]
2096             res.extend(page_results)
2097
2098             # A little optimization - if current page is not "full", ie. does
2099             # not contain page_size videos then we can assume that this page
2100             # is the last one - there are no more ids on further pages -
2101             # i.e. no need to query again.
2102             if len(page_results) + startv < self._pagesize:
2103                 break
2104
2105             # If we got the whole page, but the next page is not interesting,
2106             # break out early as well
2107             if end == nextfirstid:
2108                 break
2109         return res
2110
2111
2112 class InAdvancePagedList(PagedList):
2113     def __init__(self, pagefunc, pagecount, pagesize):
2114         self._pagefunc = pagefunc
2115         self._pagecount = pagecount
2116         self._pagesize = pagesize
2117
2118     def getslice(self, start=0, end=None):
2119         res = []
2120         start_page = start // self._pagesize
2121         end_page = (
2122             self._pagecount if end is None else (end // self._pagesize + 1))
2123         skip_elems = start - start_page * self._pagesize
2124         only_more = None if end is None else end - start
2125         for pagenum in range(start_page, end_page):
2126             page = list(self._pagefunc(pagenum))
2127             if skip_elems:
2128                 page = page[skip_elems:]
2129                 skip_elems = None
2130             if only_more is not None:
2131                 if len(page) < only_more:
2132                     only_more -= len(page)
2133                 else:
2134                     page = page[:only_more]
2135                     res.extend(page)
2136                     break
2137             res.extend(page)
2138         return res
2139
2140
2141 def uppercase_escape(s):
2142     unicode_escape = codecs.getdecoder('unicode_escape')
2143     return re.sub(
2144         r'\\U[0-9a-fA-F]{8}',
2145         lambda m: unicode_escape(m.group(0))[0],
2146         s)
2147
2148
2149 def lowercase_escape(s):
2150     unicode_escape = codecs.getdecoder('unicode_escape')
2151     return re.sub(
2152         r'\\u[0-9a-fA-F]{4}',
2153         lambda m: unicode_escape(m.group(0))[0],
2154         s)
2155
2156
2157 def escape_rfc3986(s):
2158     """Escape non-ASCII characters as suggested by RFC 3986"""
2159     if sys.version_info < (3, 0) and isinstance(s, compat_str):
2160         s = s.encode('utf-8')
2161     return compat_urllib_parse.quote(s, b"%/;:@&=+$,!~*'()?#[]")
2162
2163
2164 def escape_url(url):
2165     """Escape URL as suggested by RFC 3986"""
2166     url_parsed = compat_urllib_parse_urlparse(url)
2167     return url_parsed._replace(
2168         netloc=url_parsed.netloc.encode('idna').decode('ascii'),
2169         path=escape_rfc3986(url_parsed.path),
2170         params=escape_rfc3986(url_parsed.params),
2171         query=escape_rfc3986(url_parsed.query),
2172         fragment=escape_rfc3986(url_parsed.fragment)
2173     ).geturl()
2174
2175
2176 def read_batch_urls(batch_fd):
2177     def fixup(url):
2178         if not isinstance(url, compat_str):
2179             url = url.decode('utf-8', 'replace')
2180         BOM_UTF8 = '\xef\xbb\xbf'
2181         if url.startswith(BOM_UTF8):
2182             url = url[len(BOM_UTF8):]
2183         url = url.strip()
2184         if url.startswith(('#', ';', ']')):
2185             return False
2186         return url
2187
2188     with contextlib.closing(batch_fd) as fd:
2189         return [url for url in map(fixup, fd) if url]
2190
2191
2192 def urlencode_postdata(*args, **kargs):
2193     return compat_urllib_parse_urlencode(*args, **kargs).encode('ascii')
2194
2195
2196 def update_url_query(url, query):
2197     if not query:
2198         return url
2199     parsed_url = compat_urlparse.urlparse(url)
2200     qs = compat_parse_qs(parsed_url.query)
2201     qs.update(query)
2202     return compat_urlparse.urlunparse(parsed_url._replace(
2203         query=compat_urllib_parse_urlencode(qs, True)))
2204
2205
2206 def update_Request(req, url=None, data=None, headers={}, query={}):
2207     req_headers = req.headers.copy()
2208     req_headers.update(headers)
2209     req_data = data or req.data
2210     req_url = update_url_query(url or req.get_full_url(), query)
2211     req_get_method = req.get_method()
2212     if req_get_method == 'HEAD':
2213         req_type = HEADRequest
2214     elif req_get_method == 'PUT':
2215         req_type = PUTRequest
2216     else:
2217         req_type = compat_urllib_request.Request
2218     new_req = req_type(
2219         req_url, data=req_data, headers=req_headers,
2220         origin_req_host=req.origin_req_host, unverifiable=req.unverifiable)
2221     if hasattr(req, 'timeout'):
2222         new_req.timeout = req.timeout
2223     return new_req
2224
2225
2226 def _multipart_encode_impl(data, boundary):
2227     content_type = 'multipart/form-data; boundary=%s' % boundary
2228
2229     out = b''
2230     for k, v in data.items():
2231         out += b'--' + boundary.encode('ascii') + b'\r\n'
2232         if isinstance(k, compat_str):
2233             k = k.encode('utf-8')
2234         if isinstance(v, compat_str):
2235             v = v.encode('utf-8')
2236         # RFC 2047 requires non-ASCII field names to be encoded, while RFC 7578
2237         # suggests sending UTF-8 directly. Firefox sends UTF-8, too
2238         content = b'Content-Disposition: form-data; name="' + k + b'"\r\n\r\n' + v + b'\r\n'
2239         if boundary.encode('ascii') in content:
2240             raise ValueError('Boundary overlaps with data')
2241         out += content
2242
2243     out += b'--' + boundary.encode('ascii') + b'--\r\n'
2244
2245     return out, content_type
2246
2247
2248 def multipart_encode(data, boundary=None):
2249     '''
2250     Encode a dict to RFC 7578-compliant form-data
2251
2252     data:
2253         A dict where keys and values can be either Unicode or bytes-like
2254         objects.
2255     boundary:
2256         If specified a Unicode object, it's used as the boundary. Otherwise
2257         a random boundary is generated.
2258
2259     Reference: https://tools.ietf.org/html/rfc7578
2260     '''
2261     has_specified_boundary = boundary is not None
2262
2263     while True:
2264         if boundary is None:
2265             boundary = '---------------' + str(random.randrange(0x0fffffff, 0xffffffff))
2266
2267         try:
2268             out, content_type = _multipart_encode_impl(data, boundary)
2269             break
2270         except ValueError:
2271             if has_specified_boundary:
2272                 raise
2273             boundary = None
2274
2275     return out, content_type
2276
2277
2278 def dict_get(d, key_or_keys, default=None, skip_false_values=True):
2279     if isinstance(key_or_keys, (list, tuple)):
2280         for key in key_or_keys:
2281             if key not in d or d[key] is None or skip_false_values and not d[key]:
2282                 continue
2283             return d[key]
2284         return default
2285     return d.get(key_or_keys, default)
2286
2287
2288 def try_get(src, getter, expected_type=None):
2289     if not isinstance(getter, (list, tuple)):
2290         getter = [getter]
2291     for get in getter:
2292         try:
2293             v = get(src)
2294         except (AttributeError, KeyError, TypeError, IndexError):
2295             pass
2296         else:
2297             if expected_type is None or isinstance(v, expected_type):
2298                 return v
2299
2300
2301 def merge_dicts(*dicts):
2302     merged = {}
2303     for a_dict in dicts:
2304         for k, v in a_dict.items():
2305             if v is None:
2306                 continue
2307             if (k not in merged or
2308                     (isinstance(v, compat_str) and v and
2309                         isinstance(merged[k], compat_str) and
2310                         not merged[k])):
2311                 merged[k] = v
2312     return merged
2313
2314
2315 def encode_compat_str(string, encoding=preferredencoding(), errors='strict'):
2316     return string if isinstance(string, compat_str) else compat_str(string, encoding, errors)
2317
2318
2319 US_RATINGS = {
2320     'G': 0,
2321     'PG': 10,
2322     'PG-13': 13,
2323     'R': 16,
2324     'NC': 18,
2325 }
2326
2327
2328 TV_PARENTAL_GUIDELINES = {
2329     'TV-Y': 0,
2330     'TV-Y7': 7,
2331     'TV-G': 0,
2332     'TV-PG': 0,
2333     'TV-14': 14,
2334     'TV-MA': 17,
2335 }
2336
2337
2338 def parse_age_limit(s):
2339     if type(s) == int:
2340         return s if 0 <= s <= 21 else None
2341     if not isinstance(s, compat_basestring):
2342         return None
2343     m = re.match(r'^(?P<age>\d{1,2})\+?$', s)
2344     if m:
2345         return int(m.group('age'))
2346     if s in US_RATINGS:
2347         return US_RATINGS[s]
2348     m = re.match(r'^TV[_-]?(%s)$' % '|'.join(k[3:] for k in TV_PARENTAL_GUIDELINES), s)
2349     if m:
2350         return TV_PARENTAL_GUIDELINES['TV-' + m.group(1)]
2351     return None
2352
2353
2354 def strip_jsonp(code):
2355     return re.sub(
2356         r'''(?sx)^
2357             (?:window\.)?(?P<func_name>[a-zA-Z0-9_.$]*)
2358             (?:\s*&&\s*(?P=func_name))?
2359             \s*\(\s*(?P<callback_data>.*)\);?
2360             \s*?(?://[^\n]*)*$''',
2361         r'\g<callback_data>', code)
2362
2363
2364 def js_to_json(code):
2365     COMMENT_RE = r'/\*(?:(?!\*/).)*?\*/|//[^\n]*'
2366     SKIP_RE = r'\s*(?:{comment})?\s*'.format(comment=COMMENT_RE)
2367     INTEGER_TABLE = (
2368         (r'(?s)^(0[xX][0-9a-fA-F]+){skip}:?$'.format(skip=SKIP_RE), 16),
2369         (r'(?s)^(0+[0-7]+){skip}:?$'.format(skip=SKIP_RE), 8),
2370     )
2371
2372     def fix_kv(m):
2373         v = m.group(0)
2374         if v in ('true', 'false', 'null'):
2375             return v
2376         elif v.startswith('/*') or v.startswith('//') or v == ',':
2377             return ""
2378
2379         if v[0] in ("'", '"'):
2380             v = re.sub(r'(?s)\\.|"', lambda m: {
2381                 '"': '\\"',
2382                 "\\'": "'",
2383                 '\\\n': '',
2384                 '\\x': '\\u00',
2385             }.get(m.group(0), m.group(0)), v[1:-1])
2386
2387         for regex, base in INTEGER_TABLE:
2388             im = re.match(regex, v)
2389             if im:
2390                 i = int(im.group(1), base)
2391                 return '"%d":' % i if v.endswith(':') else '%d' % i
2392
2393         return '"%s"' % v
2394
2395     return re.sub(r'''(?sx)
2396         "(?:[^"\\]*(?:\\\\|\\['"nurtbfx/\n]))*[^"\\]*"|
2397         '(?:[^'\\]*(?:\\\\|\\['"nurtbfx/\n]))*[^'\\]*'|
2398         {comment}|,(?={skip}[\]}}])|
2399         (?:(?<![0-9])[eE]|[a-df-zA-DF-Z_])[.a-zA-Z_0-9]*|
2400         \b(?:0[xX][0-9a-fA-F]+|0+[0-7]+)(?:{skip}:)?|
2401         [0-9]+(?={skip}:)
2402         '''.format(comment=COMMENT_RE, skip=SKIP_RE), fix_kv, code)
2403
2404
2405 def qualities(quality_ids):
2406     """ Get a numeric quality value out of a list of possible values """
2407     def q(qid):
2408         try:
2409             return quality_ids.index(qid)
2410         except ValueError:
2411             return -1
2412     return q
2413
2414
2415 DEFAULT_OUTTMPL = '%(title)s-%(id)s.%(ext)s'
2416
2417
2418 def limit_length(s, length):
2419     """ Add ellipses to overly long strings """
2420     if s is None:
2421         return None
2422     ELLIPSES = '...'
2423     if len(s) > length:
2424         return s[:length - len(ELLIPSES)] + ELLIPSES
2425     return s
2426
2427
2428 def version_tuple(v):
2429     return tuple(int(e) for e in re.split(r'[-.]', v))
2430
2431
2432 def is_outdated_version(version, limit, assume_new=True):
2433     if not version:
2434         return not assume_new
2435     try:
2436         return version_tuple(version) < version_tuple(limit)
2437     except ValueError:
2438         return not assume_new
2439
2440
2441 def ytdl_is_updateable():
2442     """ Returns if youtube-dl can be updated with -U """
2443     from zipimport import zipimporter
2444
2445     return isinstance(globals().get('__loader__'), zipimporter) or hasattr(sys, 'frozen')
2446
2447
2448 def args_to_str(args):
2449     # Get a short string representation for a subprocess command
2450     return ' '.join(compat_shlex_quote(a) for a in args)
2451
2452
2453 def error_to_compat_str(err):
2454     err_str = str(err)
2455     # On python 2 error byte string must be decoded with proper
2456     # encoding rather than ascii
2457     if sys.version_info[0] < 3:
2458         err_str = err_str.decode(preferredencoding())
2459     return err_str
2460
2461
2462 def mimetype2ext(mt):
2463     if mt is None:
2464         return None
2465
2466     ext = {
2467         'audio/mp4': 'm4a',
2468         # Per RFC 3003, audio/mpeg can be .mp1, .mp2 or .mp3. Here use .mp3 as
2469         # it's the most popular one
2470         'audio/mpeg': 'mp3',
2471     }.get(mt)
2472     if ext is not None:
2473         return ext
2474
2475     _, _, res = mt.rpartition('/')
2476     res = res.split(';')[0].strip().lower()
2477
2478     return {
2479         '3gpp': '3gp',
2480         'smptett+xml': 'tt',
2481         'ttaf+xml': 'dfxp',
2482         'ttml+xml': 'ttml',
2483         'x-flv': 'flv',
2484         'x-mp4-fragmented': 'mp4',
2485         'x-ms-sami': 'sami',
2486         'x-ms-wmv': 'wmv',
2487         'mpegurl': 'm3u8',
2488         'x-mpegurl': 'm3u8',
2489         'vnd.apple.mpegurl': 'm3u8',
2490         'dash+xml': 'mpd',
2491         'f4m+xml': 'f4m',
2492         'hds+xml': 'f4m',
2493         'vnd.ms-sstr+xml': 'ism',
2494         'quicktime': 'mov',
2495         'mp2t': 'ts',
2496     }.get(res, res)
2497
2498
2499 def parse_codecs(codecs_str):
2500     # http://tools.ietf.org/html/rfc6381
2501     if not codecs_str:
2502         return {}
2503     splited_codecs = list(filter(None, map(
2504         lambda str: str.strip(), codecs_str.strip().strip(',').split(','))))
2505     vcodec, acodec = None, None
2506     for full_codec in splited_codecs:
2507         codec = full_codec.split('.')[0]
2508         if codec in ('avc1', 'avc2', 'avc3', 'avc4', 'vp9', 'vp8', 'hev1', 'hev2', 'h263', 'h264', 'mp4v', 'hvc1', 'av01'):
2509             if not vcodec:
2510                 vcodec = full_codec
2511         elif codec in ('mp4a', 'opus', 'vorbis', 'mp3', 'aac', 'ac-3', 'ec-3', 'eac3', 'dtsc', 'dtse', 'dtsh', 'dtsl'):
2512             if not acodec:
2513                 acodec = full_codec
2514         else:
2515             write_string('WARNING: Unknown codec %s\n' % full_codec, sys.stderr)
2516     if not vcodec and not acodec:
2517         if len(splited_codecs) == 2:
2518             return {
2519                 'vcodec': vcodec,
2520                 'acodec': acodec,
2521             }
2522         elif len(splited_codecs) == 1:
2523             return {
2524                 'vcodec': 'none',
2525                 'acodec': vcodec,
2526             }
2527     else:
2528         return {
2529             'vcodec': vcodec or 'none',
2530             'acodec': acodec or 'none',
2531         }
2532     return {}
2533
2534
2535 def urlhandle_detect_ext(url_handle):
2536     getheader = url_handle.headers.get
2537
2538     cd = getheader('Content-Disposition')
2539     if cd:
2540         m = re.match(r'attachment;\s*filename="(?P<filename>[^"]+)"', cd)
2541         if m:
2542             e = determine_ext(m.group('filename'), default_ext=None)
2543             if e:
2544                 return e
2545
2546     return mimetype2ext(getheader('Content-Type'))
2547
2548
2549 def encode_data_uri(data, mime_type):
2550     return 'data:%s;base64,%s' % (mime_type, base64.b64encode(data).decode('ascii'))
2551
2552
2553 def age_restricted(content_limit, age_limit):
2554     """ Returns True iff the content should be blocked """
2555
2556     if age_limit is None:  # No limit set
2557         return False
2558     if content_limit is None:
2559         return False  # Content available for everyone
2560     return age_limit < content_limit
2561
2562
2563 def is_html(first_bytes):
2564     """ Detect whether a file contains HTML by examining its first bytes. """
2565
2566     BOMS = [
2567         (b'\xef\xbb\xbf', 'utf-8'),
2568         (b'\x00\x00\xfe\xff', 'utf-32-be'),
2569         (b'\xff\xfe\x00\x00', 'utf-32-le'),
2570         (b'\xff\xfe', 'utf-16-le'),
2571         (b'\xfe\xff', 'utf-16-be'),
2572     ]
2573     for bom, enc in BOMS:
2574         if first_bytes.startswith(bom):
2575             s = first_bytes[len(bom):].decode(enc, 'replace')
2576             break
2577     else:
2578         s = first_bytes.decode('utf-8', 'replace')
2579
2580     return re.match(r'^\s*<', s)
2581
2582
2583 def determine_protocol(info_dict):
2584     protocol = info_dict.get('protocol')
2585     if protocol is not None:
2586         return protocol
2587
2588     url = info_dict['url']
2589     if url.startswith('rtmp'):
2590         return 'rtmp'
2591     elif url.startswith('mms'):
2592         return 'mms'
2593     elif url.startswith('rtsp'):
2594         return 'rtsp'
2595
2596     ext = determine_ext(url)
2597     if ext == 'm3u8':
2598         return 'm3u8'
2599     elif ext == 'f4m':
2600         return 'f4m'
2601
2602     return compat_urllib_parse_urlparse(url).scheme
2603
2604
2605 def render_table(header_row, data):
2606     """ Render a list of rows, each as a list of values """
2607     table = [header_row] + data
2608     max_lens = [max(len(compat_str(v)) for v in col) for col in zip(*table)]
2609     format_str = ' '.join('%-' + compat_str(ml + 1) + 's' for ml in max_lens[:-1]) + '%s'
2610     return '\n'.join(format_str % tuple(row) for row in table)
2611
2612
2613 def _match_one(filter_part, dct):
2614     COMPARISON_OPERATORS = {
2615         '<': operator.lt,
2616         '<=': operator.le,
2617         '>': operator.gt,
2618         '>=': operator.ge,
2619         '=': operator.eq,
2620         '!=': operator.ne,
2621     }
2622     operator_rex = re.compile(r'''(?x)\s*
2623         (?P<key>[a-z_]+)
2624         \s*(?P<op>%s)(?P<none_inclusive>\s*\?)?\s*
2625         (?:
2626             (?P<intval>[0-9.]+(?:[kKmMgGtTpPeEzZyY]i?[Bb]?)?)|
2627             (?P<quote>["\'])(?P<quotedstrval>(?:\\.|(?!(?P=quote)|\\).)+?)(?P=quote)|
2628             (?P<strval>(?![0-9.])[a-z0-9A-Z]*)
2629         )
2630         \s*$
2631         ''' % '|'.join(map(re.escape, COMPARISON_OPERATORS.keys())))
2632     m = operator_rex.search(filter_part)
2633     if m:
2634         op = COMPARISON_OPERATORS[m.group('op')]
2635         actual_value = dct.get(m.group('key'))
2636         if (m.group('quotedstrval') is not None or
2637             m.group('strval') is not None or
2638             # If the original field is a string and matching comparisonvalue is
2639             # a number we should respect the origin of the original field
2640             # and process comparison value as a string (see
2641             # https://github.com/rg3/youtube-dl/issues/11082).
2642             actual_value is not None and m.group('intval') is not None and
2643                 isinstance(actual_value, compat_str)):
2644             if m.group('op') not in ('=', '!='):
2645                 raise ValueError(
2646                     'Operator %s does not support string values!' % m.group('op'))
2647             comparison_value = m.group('quotedstrval') or m.group('strval') or m.group('intval')
2648             quote = m.group('quote')
2649             if quote is not None:
2650                 comparison_value = comparison_value.replace(r'\%s' % quote, quote)
2651         else:
2652             try:
2653                 comparison_value = int(m.group('intval'))
2654             except ValueError:
2655                 comparison_value = parse_filesize(m.group('intval'))
2656                 if comparison_value is None:
2657                     comparison_value = parse_filesize(m.group('intval') + 'B')
2658                 if comparison_value is None:
2659                     raise ValueError(
2660                         'Invalid integer value %r in filter part %r' % (
2661                             m.group('intval'), filter_part))
2662         if actual_value is None:
2663             return m.group('none_inclusive')
2664         return op(actual_value, comparison_value)
2665
2666     UNARY_OPERATORS = {
2667         '': lambda v: (v is True) if isinstance(v, bool) else (v is not None),
2668         '!': lambda v: (v is False) if isinstance(v, bool) else (v is None),
2669     }
2670     operator_rex = re.compile(r'''(?x)\s*
2671         (?P<op>%s)\s*(?P<key>[a-z_]+)
2672         \s*$
2673         ''' % '|'.join(map(re.escape, UNARY_OPERATORS.keys())))
2674     m = operator_rex.search(filter_part)
2675     if m:
2676         op = UNARY_OPERATORS[m.group('op')]
2677         actual_value = dct.get(m.group('key'))
2678         return op(actual_value)
2679
2680     raise ValueError('Invalid filter part %r' % filter_part)
2681
2682
2683 def match_str(filter_str, dct):
2684     """ Filter a dictionary with a simple string syntax. Returns True (=passes filter) or false """
2685
2686     return all(
2687         _match_one(filter_part, dct) for filter_part in filter_str.split('&'))
2688
2689
2690 def match_filter_func(filter_str):
2691     def _match_func(info_dict):
2692         if match_str(filter_str, info_dict):
2693             return None
2694         else:
2695             video_title = info_dict.get('title', info_dict.get('id', 'video'))
2696             return '%s does not pass filter %s, skipping ..' % (video_title, filter_str)
2697     return _match_func
2698
2699
2700 def parse_dfxp_time_expr(time_expr):
2701     if not time_expr:
2702         return
2703
2704     mobj = re.match(r'^(?P<time_offset>\d+(?:\.\d+)?)s?$', time_expr)
2705     if mobj:
2706         return float(mobj.group('time_offset'))
2707
2708     mobj = re.match(r'^(\d+):(\d\d):(\d\d(?:(?:\.|:)\d+)?)$', time_expr)
2709     if mobj:
2710         return 3600 * int(mobj.group(1)) + 60 * int(mobj.group(2)) + float(mobj.group(3).replace(':', '.'))
2711
2712
2713 def srt_subtitles_timecode(seconds):
2714     return '%02d:%02d:%02d,%03d' % (seconds / 3600, (seconds % 3600) / 60, seconds % 60, (seconds % 1) * 1000)
2715
2716
2717 def dfxp2srt(dfxp_data):
2718     '''
2719     @param dfxp_data A bytes-like object containing DFXP data
2720     @returns A unicode object containing converted SRT data
2721     '''
2722     LEGACY_NAMESPACES = (
2723         (b'http://www.w3.org/ns/ttml', [
2724             b'http://www.w3.org/2004/11/ttaf1',
2725             b'http://www.w3.org/2006/04/ttaf1',
2726             b'http://www.w3.org/2006/10/ttaf1',
2727         ]),
2728         (b'http://www.w3.org/ns/ttml#styling', [
2729             b'http://www.w3.org/ns/ttml#style',
2730         ]),
2731     )
2732
2733     SUPPORTED_STYLING = [
2734         'color',
2735         'fontFamily',
2736         'fontSize',
2737         'fontStyle',
2738         'fontWeight',
2739         'textDecoration'
2740     ]
2741
2742     _x = functools.partial(xpath_with_ns, ns_map={
2743         'xml': 'http://www.w3.org/XML/1998/namespace',
2744         'ttml': 'http://www.w3.org/ns/ttml',
2745         'tts': 'http://www.w3.org/ns/ttml#styling',
2746     })
2747
2748     styles = {}
2749     default_style = {}
2750
2751     class TTMLPElementParser(object):
2752         _out = ''
2753         _unclosed_elements = []
2754         _applied_styles = []
2755
2756         def start(self, tag, attrib):
2757             if tag in (_x('ttml:br'), 'br'):
2758                 self._out += '\n'
2759             else:
2760                 unclosed_elements = []
2761                 style = {}
2762                 element_style_id = attrib.get('style')
2763                 if default_style:
2764                     style.update(default_style)
2765                 if element_style_id:
2766                     style.update(styles.get(element_style_id, {}))
2767                 for prop in SUPPORTED_STYLING:
2768                     prop_val = attrib.get(_x('tts:' + prop))
2769                     if prop_val:
2770                         style[prop] = prop_val
2771                 if style:
2772                     font = ''
2773                     for k, v in sorted(style.items()):
2774                         if self._applied_styles and self._applied_styles[-1].get(k) == v:
2775                             continue
2776                         if k == 'color':
2777                             font += ' color="%s"' % v
2778                         elif k == 'fontSize':
2779                             font += ' size="%s"' % v
2780                         elif k == 'fontFamily':
2781                             font += ' face="%s"' % v
2782                         elif k == 'fontWeight' and v == 'bold':
2783                             self._out += '<b>'
2784                             unclosed_elements.append('b')
2785                         elif k == 'fontStyle' and v == 'italic':
2786                             self._out += '<i>'
2787                             unclosed_elements.append('i')
2788                         elif k == 'textDecoration' and v == 'underline':
2789                             self._out += '<u>'
2790                             unclosed_elements.append('u')
2791                     if font:
2792                         self._out += '<font' + font + '>'
2793                         unclosed_elements.append('font')
2794                     applied_style = {}
2795                     if self._applied_styles:
2796                         applied_style.update(self._applied_styles[-1])
2797                     applied_style.update(style)
2798                     self._applied_styles.append(applied_style)
2799                 self._unclosed_elements.append(unclosed_elements)
2800
2801         def end(self, tag):
2802             if tag not in (_x('ttml:br'), 'br'):
2803                 unclosed_elements = self._unclosed_elements.pop()
2804                 for element in reversed(unclosed_elements):
2805                     self._out += '</%s>' % element
2806                 if unclosed_elements and self._applied_styles:
2807                     self._applied_styles.pop()
2808
2809         def data(self, data):
2810             self._out += data
2811
2812         def close(self):
2813             return self._out.strip()
2814
2815     def parse_node(node):
2816         target = TTMLPElementParser()
2817         parser = xml.etree.ElementTree.XMLParser(target=target)
2818         parser.feed(xml.etree.ElementTree.tostring(node))
2819         return parser.close()
2820
2821     for k, v in LEGACY_NAMESPACES:
2822         for ns in v:
2823             dfxp_data = dfxp_data.replace(ns, k)
2824
2825     dfxp = compat_etree_fromstring(dfxp_data)
2826     out = []
2827     paras = dfxp.findall(_x('.//ttml:p')) or dfxp.findall('.//p')
2828
2829     if not paras:
2830         raise ValueError('Invalid dfxp/TTML subtitle')
2831
2832     repeat = False
2833     while True:
2834         for style in dfxp.findall(_x('.//ttml:style')):
2835             style_id = style.get('id') or style.get(_x('xml:id'))
2836             if not style_id:
2837                 continue
2838             parent_style_id = style.get('style')
2839             if parent_style_id:
2840                 if parent_style_id not in styles:
2841                     repeat = True
2842                     continue
2843                 styles[style_id] = styles[parent_style_id].copy()
2844             for prop in SUPPORTED_STYLING:
2845                 prop_val = style.get(_x('tts:' + prop))
2846                 if prop_val:
2847                     styles.setdefault(style_id, {})[prop] = prop_val
2848         if repeat:
2849             repeat = False
2850         else:
2851             break
2852
2853     for p in ('body', 'div'):
2854         ele = xpath_element(dfxp, [_x('.//ttml:' + p), './/' + p])
2855         if ele is None:
2856             continue
2857         style = styles.get(ele.get('style'))
2858         if not style:
2859             continue
2860         default_style.update(style)
2861
2862     for para, index in zip(paras, itertools.count(1)):
2863         begin_time = parse_dfxp_time_expr(para.attrib.get('begin'))
2864         end_time = parse_dfxp_time_expr(para.attrib.get('end'))
2865         dur = parse_dfxp_time_expr(para.attrib.get('dur'))
2866         if begin_time is None:
2867             continue
2868         if not end_time:
2869             if not dur:
2870                 continue
2871             end_time = begin_time + dur
2872         out.append('%d\n%s --> %s\n%s\n\n' % (
2873             index,
2874             srt_subtitles_timecode(begin_time),
2875             srt_subtitles_timecode(end_time),
2876             parse_node(para)))
2877
2878     return ''.join(out)
2879
2880
2881 def cli_option(params, command_option, param):
2882     param = params.get(param)
2883     if param:
2884         param = compat_str(param)
2885     return [command_option, param] if param is not None else []
2886
2887
2888 def cli_bool_option(params, command_option, param, true_value='true', false_value='false', separator=None):
2889     param = params.get(param)
2890     if param is None:
2891         return []
2892     assert isinstance(param, bool)
2893     if separator:
2894         return [command_option + separator + (true_value if param else false_value)]
2895     return [command_option, true_value if param else false_value]
2896
2897
2898 def cli_valueless_option(params, command_option, param, expected_value=True):
2899     param = params.get(param)
2900     return [command_option] if param == expected_value else []
2901
2902
2903 def cli_configuration_args(params, param, default=[]):
2904     ex_args = params.get(param)
2905     if ex_args is None:
2906         return default
2907     assert isinstance(ex_args, list)
2908     return ex_args
2909
2910
2911 class ISO639Utils(object):
2912     # See http://www.loc.gov/standards/iso639-2/ISO-639-2_utf-8.txt
2913     _lang_map = {
2914         'aa': 'aar',
2915         'ab': 'abk',
2916         'ae': 'ave',
2917         'af': 'afr',
2918         'ak': 'aka',
2919         'am': 'amh',
2920         'an': 'arg',
2921         'ar': 'ara',
2922         'as': 'asm',
2923         'av': 'ava',
2924         'ay': 'aym',
2925         'az': 'aze',
2926         'ba': 'bak',
2927         'be': 'bel',
2928         'bg': 'bul',
2929         'bh': 'bih',
2930         'bi': 'bis',
2931         'bm': 'bam',
2932         'bn': 'ben',
2933         'bo': 'bod',
2934         'br': 'bre',
2935         'bs': 'bos',
2936         'ca': 'cat',
2937         'ce': 'che',
2938         'ch': 'cha',
2939         'co': 'cos',
2940         'cr': 'cre',
2941         'cs': 'ces',
2942         'cu': 'chu',
2943         'cv': 'chv',
2944         'cy': 'cym',
2945         'da': 'dan',
2946         'de': 'deu',
2947         'dv': 'div',
2948         'dz': 'dzo',
2949         'ee': 'ewe',
2950         'el': 'ell',
2951         'en': 'eng',
2952         'eo': 'epo',
2953         'es': 'spa',
2954         'et': 'est',
2955         'eu': 'eus',
2956         'fa': 'fas',
2957         'ff': 'ful',
2958         'fi': 'fin',
2959         'fj': 'fij',
2960         'fo': 'fao',
2961         'fr': 'fra',
2962         'fy': 'fry',
2963         'ga': 'gle',
2964         'gd': 'gla',
2965         'gl': 'glg',
2966         'gn': 'grn',
2967         'gu': 'guj',
2968         'gv': 'glv',
2969         'ha': 'hau',
2970         'he': 'heb',
2971         'iw': 'heb',  # Replaced by he in 1989 revision
2972         'hi': 'hin',
2973         'ho': 'hmo',
2974         'hr': 'hrv',
2975         'ht': 'hat',
2976         'hu': 'hun',
2977         'hy': 'hye',
2978         'hz': 'her',
2979         'ia': 'ina',
2980         'id': 'ind',
2981         'in': 'ind',  # Replaced by id in 1989 revision
2982         'ie': 'ile',
2983         'ig': 'ibo',
2984         'ii': 'iii',
2985         'ik': 'ipk',
2986         'io': 'ido',
2987         'is': 'isl',
2988         'it': 'ita',
2989         'iu': 'iku',
2990         'ja': 'jpn',
2991         'jv': 'jav',
2992         'ka': 'kat',
2993         'kg': 'kon',
2994         'ki': 'kik',
2995         'kj': 'kua',
2996         'kk': 'kaz',
2997         'kl': 'kal',
2998         'km': 'khm',
2999         'kn': 'kan',
3000         'ko': 'kor',
3001         'kr': 'kau',
3002         'ks': 'kas',
3003         'ku': 'kur',
3004         'kv': 'kom',
3005         'kw': 'cor',
3006         'ky': 'kir',
3007         'la': 'lat',
3008         'lb': 'ltz',
3009         'lg': 'lug',
3010         'li': 'lim',
3011         'ln': 'lin',
3012         'lo': 'lao',
3013         'lt': 'lit',
3014         'lu': 'lub',
3015         'lv': 'lav',
3016         'mg': 'mlg',
3017         'mh': 'mah',
3018         'mi': 'mri',
3019         'mk': 'mkd',
3020         'ml': 'mal',
3021         'mn': 'mon',
3022         'mr': 'mar',
3023         'ms': 'msa',
3024         'mt': 'mlt',
3025         'my': 'mya',
3026         'na': 'nau',
3027         'nb': 'nob',
3028         'nd': 'nde',
3029         'ne': 'nep',
3030         'ng': 'ndo',
3031         'nl': 'nld',
3032         'nn': 'nno',
3033         'no': 'nor',
3034         'nr': 'nbl',
3035         'nv': 'nav',
3036         'ny': 'nya',
3037         'oc': 'oci',
3038         'oj': 'oji',
3039         'om': 'orm',
3040         'or': 'ori',
3041         'os': 'oss',
3042         'pa': 'pan',
3043         'pi': 'pli',
3044         'pl': 'pol',
3045         'ps': 'pus',
3046         'pt': 'por',
3047         'qu': 'que',
3048         'rm': 'roh',
3049         'rn': 'run',
3050         'ro': 'ron',
3051         'ru': 'rus',
3052         'rw': 'kin',
3053         'sa': 'san',
3054         'sc': 'srd',
3055         'sd': 'snd',
3056         'se': 'sme',
3057         'sg': 'sag',
3058         'si': 'sin',
3059         'sk': 'slk',
3060         'sl': 'slv',
3061         'sm': 'smo',
3062         'sn': 'sna',
3063         'so': 'som',
3064         'sq': 'sqi',
3065         'sr': 'srp',
3066         'ss': 'ssw',
3067         'st': 'sot',
3068         'su': 'sun',
3069         'sv': 'swe',
3070         'sw': 'swa',
3071         'ta': 'tam',
3072         'te': 'tel',
3073         'tg': 'tgk',
3074         'th': 'tha',
3075         'ti': 'tir',
3076         'tk': 'tuk',
3077         'tl': 'tgl',
3078         'tn': 'tsn',
3079         'to': 'ton',
3080         'tr': 'tur',
3081         'ts': 'tso',
3082         'tt': 'tat',
3083         'tw': 'twi',
3084         'ty': 'tah',
3085         'ug': 'uig',
3086         'uk': 'ukr',
3087         'ur': 'urd',
3088         'uz': 'uzb',
3089         've': 'ven',
3090         'vi': 'vie',
3091         'vo': 'vol',
3092         'wa': 'wln',
3093         'wo': 'wol',
3094         'xh': 'xho',
3095         'yi': 'yid',
3096         'ji': 'yid',  # Replaced by yi in 1989 revision
3097         'yo': 'yor',
3098         'za': 'zha',
3099         'zh': 'zho',
3100         'zu': 'zul',
3101     }
3102
3103     @classmethod
3104     def short2long(cls, code):
3105         """Convert language code from ISO 639-1 to ISO 639-2/T"""
3106         return cls._lang_map.get(code[:2])
3107
3108     @classmethod
3109     def long2short(cls, code):
3110         """Convert language code from ISO 639-2/T to ISO 639-1"""
3111         for short_name, long_name in cls._lang_map.items():
3112             if long_name == code:
3113                 return short_name
3114
3115
3116 class ISO3166Utils(object):
3117     # From http://data.okfn.org/data/core/country-list
3118     _country_map = {
3119         'AF': 'Afghanistan',
3120         'AX': 'Åland Islands',
3121         'AL': 'Albania',
3122         'DZ': 'Algeria',
3123         'AS': 'American Samoa',
3124         'AD': 'Andorra',
3125         'AO': 'Angola',
3126         'AI': 'Anguilla',
3127         'AQ': 'Antarctica',
3128         'AG': 'Antigua and Barbuda',
3129         'AR': 'Argentina',
3130         'AM': 'Armenia',
3131         'AW': 'Aruba',
3132         'AU': 'Australia',
3133         'AT': 'Austria',
3134         'AZ': 'Azerbaijan',
3135         'BS': 'Bahamas',
3136         'BH': 'Bahrain',
3137         'BD': 'Bangladesh',
3138         'BB': 'Barbados',
3139         'BY': 'Belarus',
3140         'BE': 'Belgium',
3141         'BZ': 'Belize',
3142         'BJ': 'Benin',
3143         'BM': 'Bermuda',
3144         'BT': 'Bhutan',
3145         'BO': 'Bolivia, Plurinational State of',
3146         'BQ': 'Bonaire, Sint Eustatius and Saba',
3147         'BA': 'Bosnia and Herzegovina',
3148         'BW': 'Botswana',
3149         'BV': 'Bouvet Island',
3150         'BR': 'Brazil',
3151         'IO': 'British Indian Ocean Territory',
3152         'BN': 'Brunei Darussalam',
3153         'BG': 'Bulgaria',
3154         'BF': 'Burkina Faso',
3155         'BI': 'Burundi',
3156         'KH': 'Cambodia',
3157         'CM': 'Cameroon',
3158         'CA': 'Canada',
3159         'CV': 'Cape Verde',
3160         'KY': 'Cayman Islands',
3161         'CF': 'Central African Republic',
3162         'TD': 'Chad',
3163         'CL': 'Chile',
3164         'CN': 'China',
3165         'CX': 'Christmas Island',
3166         'CC': 'Cocos (Keeling) Islands',
3167         'CO': 'Colombia',
3168         'KM': 'Comoros',
3169         'CG': 'Congo',
3170         'CD': 'Congo, the Democratic Republic of the',
3171         'CK': 'Cook Islands',
3172         'CR': 'Costa Rica',
3173         'CI': 'Côte d\'Ivoire',
3174         'HR': 'Croatia',
3175         'CU': 'Cuba',
3176         'CW': 'Curaçao',
3177         'CY': 'Cyprus',
3178         'CZ': 'Czech Republic',
3179         'DK': 'Denmark',
3180         'DJ': 'Djibouti',
3181         'DM': 'Dominica',
3182         'DO': 'Dominican Republic',
3183         'EC': 'Ecuador',
3184         'EG': 'Egypt',
3185         'SV': 'El Salvador',
3186         'GQ': 'Equatorial Guinea',
3187         'ER': 'Eritrea',
3188         'EE': 'Estonia',
3189         'ET': 'Ethiopia',
3190         'FK': 'Falkland Islands (Malvinas)',
3191         'FO': 'Faroe Islands',
3192         'FJ': 'Fiji',
3193         'FI': 'Finland',
3194         'FR': 'France',
3195         'GF': 'French Guiana',
3196         'PF': 'French Polynesia',
3197         'TF': 'French Southern Territories',
3198         'GA': 'Gabon',
3199         'GM': 'Gambia',
3200         'GE': 'Georgia',
3201         'DE': 'Germany',
3202         'GH': 'Ghana',
3203         'GI': 'Gibraltar',
3204         'GR': 'Greece',
3205         'GL': 'Greenland',
3206         'GD': 'Grenada',
3207         'GP': 'Guadeloupe',
3208         'GU': 'Guam',
3209         'GT': 'Guatemala',
3210         'GG': 'Guernsey',
3211         'GN': 'Guinea',
3212         'GW': 'Guinea-Bissau',
3213         'GY': 'Guyana',
3214         'HT': 'Haiti',
3215         'HM': 'Heard Island and McDonald Islands',
3216         'VA': 'Holy See (Vatican City State)',
3217         'HN': 'Honduras',
3218         'HK': 'Hong Kong',
3219         'HU': 'Hungary',
3220         'IS': 'Iceland',
3221         'IN': 'India',
3222         'ID': 'Indonesia',
3223         'IR': 'Iran, Islamic Republic of',
3224         'IQ': 'Iraq',
3225         'IE': 'Ireland',
3226         'IM': 'Isle of Man',
3227         'IL': 'Israel',
3228         'IT': 'Italy',
3229         'JM': 'Jamaica',
3230         'JP': 'Japan',
3231         'JE': 'Jersey',
3232         'JO': 'Jordan',
3233         'KZ': 'Kazakhstan',
3234         'KE': 'Kenya',
3235         'KI': 'Kiribati',
3236         'KP': 'Korea, Democratic People\'s Republic of',
3237         'KR': 'Korea, Republic of',
3238         'KW': 'Kuwait',
3239         'KG': 'Kyrgyzstan',
3240         'LA': 'Lao People\'s Democratic Republic',
3241         'LV': 'Latvia',
3242         'LB': 'Lebanon',
3243         'LS': 'Lesotho',
3244         'LR': 'Liberia',
3245         'LY': 'Libya',
3246         'LI': 'Liechtenstein',
3247         'LT': 'Lithuania',
3248         'LU': 'Luxembourg',
3249         'MO': 'Macao',
3250         'MK': 'Macedonia, the Former Yugoslav Republic of',
3251         'MG': 'Madagascar',
3252         'MW': 'Malawi',
3253         'MY': 'Malaysia',
3254         'MV': 'Maldives',
3255         'ML': 'Mali',
3256         'MT': 'Malta',
3257         'MH': 'Marshall Islands',
3258         'MQ': 'Martinique',
3259         'MR': 'Mauritania',
3260         'MU': 'Mauritius',
3261         'YT': 'Mayotte',
3262         'MX': 'Mexico',
3263         'FM': 'Micronesia, Federated States of',
3264         'MD': 'Moldova, Republic of',
3265         'MC': 'Monaco',
3266         'MN': 'Mongolia',
3267         'ME': 'Montenegro',
3268         'MS': 'Montserrat',
3269         'MA': 'Morocco',
3270         'MZ': 'Mozambique',
3271         'MM': 'Myanmar',
3272         'NA': 'Namibia',
3273         'NR': 'Nauru',
3274         'NP': 'Nepal',
3275         'NL': 'Netherlands',
3276         'NC': 'New Caledonia',
3277         'NZ': 'New Zealand',
3278         'NI': 'Nicaragua',
3279         'NE': 'Niger',
3280         'NG': 'Nigeria',
3281         'NU': 'Niue',
3282         'NF': 'Norfolk Island',
3283         'MP': 'Northern Mariana Islands',
3284         'NO': 'Norway',
3285         'OM': 'Oman',
3286         'PK': 'Pakistan',
3287         'PW': 'Palau',
3288         'PS': 'Palestine, State of',
3289         'PA': 'Panama',
3290         'PG': 'Papua New Guinea',
3291         'PY': 'Paraguay',
3292         'PE': 'Peru',
3293         'PH': 'Philippines',
3294         'PN': 'Pitcairn',
3295         'PL': 'Poland',
3296         'PT': 'Portugal',
3297         'PR': 'Puerto Rico',
3298         'QA': 'Qatar',
3299         'RE': 'Réunion',
3300         'RO': 'Romania',
3301         'RU': 'Russian Federation',
3302         'RW': 'Rwanda',
3303         'BL': 'Saint Barthélemy',
3304         'SH': 'Saint Helena, Ascension and Tristan da Cunha',
3305         'KN': 'Saint Kitts and Nevis',
3306         'LC': 'Saint Lucia',
3307         'MF': 'Saint Martin (French part)',
3308         'PM': 'Saint Pierre and Miquelon',
3309         'VC': 'Saint Vincent and the Grenadines',
3310         'WS': 'Samoa',
3311         'SM': 'San Marino',
3312         'ST': 'Sao Tome and Principe',
3313         'SA': 'Saudi Arabia',
3314         'SN': 'Senegal',
3315         'RS': 'Serbia',
3316         'SC': 'Seychelles',
3317         'SL': 'Sierra Leone',
3318         'SG': 'Singapore',
3319         'SX': 'Sint Maarten (Dutch part)',
3320         'SK': 'Slovakia',
3321         'SI': 'Slovenia',
3322         'SB': 'Solomon Islands',
3323         'SO': 'Somalia',
3324         'ZA': 'South Africa',
3325         'GS': 'South Georgia and the South Sandwich Islands',
3326         'SS': 'South Sudan',
3327         'ES': 'Spain',
3328         'LK': 'Sri Lanka',
3329         'SD': 'Sudan',
3330         'SR': 'Suriname',
3331         'SJ': 'Svalbard and Jan Mayen',
3332         'SZ': 'Swaziland',
3333         'SE': 'Sweden',
3334         'CH': 'Switzerland',
3335         'SY': 'Syrian Arab Republic',
3336         'TW': 'Taiwan, Province of China',
3337         'TJ': 'Tajikistan',
3338         'TZ': 'Tanzania, United Republic of',
3339         'TH': 'Thailand',
3340         'TL': 'Timor-Leste',
3341         'TG': 'Togo',
3342         'TK': 'Tokelau',
3343         'TO': 'Tonga',
3344         'TT': 'Trinidad and Tobago',
3345         'TN': 'Tunisia',
3346         'TR': 'Turkey',
3347         'TM': 'Turkmenistan',
3348         'TC': 'Turks and Caicos Islands',
3349         'TV': 'Tuvalu',
3350         'UG': 'Uganda',
3351         'UA': 'Ukraine',
3352         'AE': 'United Arab Emirates',
3353         'GB': 'United Kingdom',
3354         'US': 'United States',
3355         'UM': 'United States Minor Outlying Islands',
3356         'UY': 'Uruguay',
3357         'UZ': 'Uzbekistan',
3358         'VU': 'Vanuatu',
3359         'VE': 'Venezuela, Bolivarian Republic of',
3360         'VN': 'Viet Nam',
3361         'VG': 'Virgin Islands, British',
3362         'VI': 'Virgin Islands, U.S.',
3363         'WF': 'Wallis and Futuna',
3364         'EH': 'Western Sahara',
3365         'YE': 'Yemen',
3366         'ZM': 'Zambia',
3367         'ZW': 'Zimbabwe',
3368     }
3369
3370     @classmethod
3371     def short2full(cls, code):
3372         """Convert an ISO 3166-2 country code to the corresponding full name"""
3373         return cls._country_map.get(code.upper())
3374
3375
3376 class GeoUtils(object):
3377     # Major IPv4 address blocks per country
3378     _country_ip_map = {
3379         'AD': '85.94.160.0/19',
3380         'AE': '94.200.0.0/13',
3381         'AF': '149.54.0.0/17',
3382         'AG': '209.59.64.0/18',
3383         'AI': '204.14.248.0/21',
3384         'AL': '46.99.0.0/16',
3385         'AM': '46.70.0.0/15',
3386         'AO': '105.168.0.0/13',
3387         'AP': '159.117.192.0/21',
3388         'AR': '181.0.0.0/12',
3389         'AS': '202.70.112.0/20',
3390         'AT': '84.112.0.0/13',
3391         'AU': '1.128.0.0/11',
3392         'AW': '181.41.0.0/18',
3393         'AZ': '5.191.0.0/16',
3394         'BA': '31.176.128.0/17',
3395         'BB': '65.48.128.0/17',
3396         'BD': '114.130.0.0/16',
3397         'BE': '57.0.0.0/8',
3398         'BF': '129.45.128.0/17',
3399         'BG': '95.42.0.0/15',
3400         'BH': '37.131.0.0/17',
3401         'BI': '154.117.192.0/18',
3402         'BJ': '137.255.0.0/16',
3403         'BL': '192.131.134.0/24',
3404         'BM': '196.12.64.0/18',
3405         'BN': '156.31.0.0/16',
3406         'BO': '161.56.0.0/16',
3407         'BQ': '161.0.80.0/20',
3408         'BR': '152.240.0.0/12',
3409         'BS': '24.51.64.0/18',
3410         'BT': '119.2.96.0/19',
3411         'BW': '168.167.0.0/16',
3412         'BY': '178.120.0.0/13',
3413         'BZ': '179.42.192.0/18',
3414         'CA': '99.224.0.0/11',
3415         'CD': '41.243.0.0/16',
3416         'CF': '196.32.200.0/21',
3417         'CG': '197.214.128.0/17',
3418         'CH': '85.0.0.0/13',
3419         'CI': '154.232.0.0/14',
3420         'CK': '202.65.32.0/19',
3421         'CL': '152.172.0.0/14',
3422         'CM': '165.210.0.0/15',
3423         'CN': '36.128.0.0/10',
3424         'CO': '181.240.0.0/12',
3425         'CR': '201.192.0.0/12',
3426         'CU': '152.206.0.0/15',
3427         'CV': '165.90.96.0/19',
3428         'CW': '190.88.128.0/17',
3429         'CY': '46.198.0.0/15',
3430         'CZ': '88.100.0.0/14',
3431         'DE': '53.0.0.0/8',
3432         'DJ': '197.241.0.0/17',
3433         'DK': '87.48.0.0/12',
3434         'DM': '192.243.48.0/20',
3435         'DO': '152.166.0.0/15',
3436         'DZ': '41.96.0.0/12',
3437         'EC': '186.68.0.0/15',
3438         'EE': '90.190.0.0/15',
3439         'EG': '156.160.0.0/11',
3440         'ER': '196.200.96.0/20',
3441         'ES': '88.0.0.0/11',
3442         'ET': '196.188.0.0/14',
3443         'EU': '2.16.0.0/13',
3444         'FI': '91.152.0.0/13',
3445         'FJ': '144.120.0.0/16',
3446         'FM': '119.252.112.0/20',
3447         'FO': '88.85.32.0/19',
3448         'FR': '90.0.0.0/9',
3449         'GA': '41.158.0.0/15',
3450         'GB': '25.0.0.0/8',
3451         'GD': '74.122.88.0/21',
3452         'GE': '31.146.0.0/16',
3453         'GF': '161.22.64.0/18',
3454         'GG': '62.68.160.0/19',
3455         'GH': '45.208.0.0/14',
3456         'GI': '85.115.128.0/19',
3457         'GL': '88.83.0.0/19',
3458         'GM': '160.182.0.0/15',
3459         'GN': '197.149.192.0/18',
3460         'GP': '104.250.0.0/19',
3461         'GQ': '105.235.224.0/20',
3462         'GR': '94.64.0.0/13',
3463         'GT': '168.234.0.0/16',
3464         'GU': '168.123.0.0/16',
3465         'GW': '197.214.80.0/20',
3466         'GY': '181.41.64.0/18',
3467         'HK': '113.252.0.0/14',
3468         'HN': '181.210.0.0/16',
3469         'HR': '93.136.0.0/13',
3470         'HT': '148.102.128.0/17',
3471         'HU': '84.0.0.0/14',
3472         'ID': '39.192.0.0/10',
3473         'IE': '87.32.0.0/12',
3474         'IL': '79.176.0.0/13',
3475         'IM': '5.62.80.0/20',
3476         'IN': '117.192.0.0/10',
3477         'IO': '203.83.48.0/21',
3478         'IQ': '37.236.0.0/14',
3479         'IR': '2.176.0.0/12',
3480         'IS': '82.221.0.0/16',
3481         'IT': '79.0.0.0/10',
3482         'JE': '87.244.64.0/18',
3483         'JM': '72.27.0.0/17',
3484         'JO': '176.29.0.0/16',
3485         'JP': '126.0.0.0/8',
3486         'KE': '105.48.0.0/12',
3487         'KG': '158.181.128.0/17',
3488         'KH': '36.37.128.0/17',
3489         'KI': '103.25.140.0/22',
3490         'KM': '197.255.224.0/20',
3491         'KN': '198.32.32.0/19',
3492         'KP': '175.45.176.0/22',
3493         'KR': '175.192.0.0/10',
3494         'KW': '37.36.0.0/14',
3495         'KY': '64.96.0.0/15',
3496         'KZ': '2.72.0.0/13',
3497         'LA': '115.84.64.0/18',
3498         'LB': '178.135.0.0/16',
3499         'LC': '192.147.231.0/24',
3500         'LI': '82.117.0.0/19',
3501         'LK': '112.134.0.0/15',
3502         'LR': '41.86.0.0/19',
3503         'LS': '129.232.0.0/17',
3504         'LT': '78.56.0.0/13',
3505         'LU': '188.42.0.0/16',
3506         'LV': '46.109.0.0/16',
3507         'LY': '41.252.0.0/14',
3508         'MA': '105.128.0.0/11',
3509         'MC': '88.209.64.0/18',
3510         'MD': '37.246.0.0/16',
3511         'ME': '178.175.0.0/17',
3512         'MF': '74.112.232.0/21',
3513         'MG': '154.126.0.0/17',
3514         'MH': '117.103.88.0/21',
3515         'MK': '77.28.0.0/15',
3516         'ML': '154.118.128.0/18',
3517         'MM': '37.111.0.0/17',
3518         'MN': '49.0.128.0/17',
3519         'MO': '60.246.0.0/16',
3520         'MP': '202.88.64.0/20',
3521         'MQ': '109.203.224.0/19',
3522         'MR': '41.188.64.0/18',
3523         'MS': '208.90.112.0/22',
3524         'MT': '46.11.0.0/16',
3525         'MU': '105.16.0.0/12',
3526         'MV': '27.114.128.0/18',
3527         'MW': '105.234.0.0/16',
3528         'MX': '187.192.0.0/11',
3529         'MY': '175.136.0.0/13',
3530         'MZ': '197.218.0.0/15',
3531         'NA': '41.182.0.0/16',
3532         'NC': '101.101.0.0/18',
3533         'NE': '197.214.0.0/18',
3534         'NF': '203.17.240.0/22',
3535         'NG': '105.112.0.0/12',
3536         'NI': '186.76.0.0/15',
3537         'NL': '145.96.0.0/11',
3538         'NO': '84.208.0.0/13',
3539         'NP': '36.252.0.0/15',
3540         'NR': '203.98.224.0/19',
3541         'NU': '49.156.48.0/22',
3542         'NZ': '49.224.0.0/14',
3543         'OM': '5.36.0.0/15',
3544         'PA': '186.72.0.0/15',
3545         'PE': '186.160.0.0/14',
3546         'PF': '123.50.64.0/18',
3547         'PG': '124.240.192.0/19',
3548         'PH': '49.144.0.0/13',
3549         'PK': '39.32.0.0/11',
3550         'PL': '83.0.0.0/11',
3551         'PM': '70.36.0.0/20',
3552         'PR': '66.50.0.0/16',
3553         'PS': '188.161.0.0/16',
3554         'PT': '85.240.0.0/13',
3555         'PW': '202.124.224.0/20',
3556         'PY': '181.120.0.0/14',
3557         'QA': '37.210.0.0/15',
3558         'RE': '139.26.0.0/16',
3559         'RO': '79.112.0.0/13',
3560         'RS': '178.220.0.0/14',
3561         'RU': '5.136.0.0/13',
3562         'RW': '105.178.0.0/15',
3563         'SA': '188.48.0.0/13',
3564         'SB': '202.1.160.0/19',
3565         'SC': '154.192.0.0/11',
3566         'SD': '154.96.0.0/13',
3567         'SE': '78.64.0.0/12',
3568         'SG': '152.56.0.0/14',
3569         'SI': '188.196.0.0/14',
3570         'SK': '78.98.0.0/15',
3571         'SL': '197.215.0.0/17',
3572         'SM': '89.186.32.0/19',
3573         'SN': '41.82.0.0/15',
3574         'SO': '197.220.64.0/19',
3575         'SR': '186.179.128.0/17',
3576         'SS': '105.235.208.0/21',
3577         'ST': '197.159.160.0/19',
3578         'SV': '168.243.0.0/16',
3579         'SX': '190.102.0.0/20',
3580         'SY': '5.0.0.0/16',
3581         'SZ': '41.84.224.0/19',
3582         'TC': '65.255.48.0/20',
3583         'TD': '154.68.128.0/19',
3584         'TG': '196.168.0.0/14',
3585         'TH': '171.96.0.0/13',
3586         'TJ': '85.9.128.0/18',
3587         'TK': '27.96.24.0/21',
3588         'TL': '180.189.160.0/20',
3589         'TM': '95.85.96.0/19',
3590         'TN': '197.0.0.0/11',
3591         'TO': '175.176.144.0/21',
3592         'TR': '78.160.0.0/11',
3593         'TT': '186.44.0.0/15',
3594         'TV': '202.2.96.0/19',
3595         'TW': '120.96.0.0/11',
3596         'TZ': '156.156.0.0/14',
3597         'UA': '93.72.0.0/13',
3598         'UG': '154.224.0.0/13',
3599         'US': '3.0.0.0/8',
3600         'UY': '167.56.0.0/13',
3601         'UZ': '82.215.64.0/18',
3602         'VA': '212.77.0.0/19',
3603         'VC': '24.92.144.0/20',
3604         'VE': '186.88.0.0/13',
3605         'VG': '172.103.64.0/18',
3606         'VI': '146.226.0.0/16',
3607         'VN': '14.160.0.0/11',
3608         'VU': '202.80.32.0/20',
3609         'WF': '117.20.32.0/21',
3610         'WS': '202.4.32.0/19',
3611         'YE': '134.35.0.0/16',
3612         'YT': '41.242.116.0/22',
3613         'ZA': '41.0.0.0/11',
3614         'ZM': '165.56.0.0/13',
3615         'ZW': '41.85.192.0/19',
3616     }
3617
3618     @classmethod
3619     def random_ipv4(cls, code_or_block):
3620         if len(code_or_block) == 2:
3621             block = cls._country_ip_map.get(code_or_block.upper())
3622             if not block:
3623                 return None
3624         else:
3625             block = code_or_block
3626         addr, preflen = block.split('/')
3627         addr_min = compat_struct_unpack('!L', socket.inet_aton(addr))[0]
3628         addr_max = addr_min | (0xffffffff >> int(preflen))
3629         return compat_str(socket.inet_ntoa(
3630             compat_struct_pack('!L', random.randint(addr_min, addr_max))))
3631
3632
3633 class PerRequestProxyHandler(compat_urllib_request.ProxyHandler):
3634     def __init__(self, proxies=None):
3635         # Set default handlers
3636         for type in ('http', 'https'):
3637             setattr(self, '%s_open' % type,
3638                     lambda r, proxy='__noproxy__', type=type, meth=self.proxy_open:
3639                         meth(r, proxy, type))
3640         compat_urllib_request.ProxyHandler.__init__(self, proxies)
3641
3642     def proxy_open(self, req, proxy, type):
3643         req_proxy = req.headers.get('Ytdl-request-proxy')
3644         if req_proxy is not None:
3645             proxy = req_proxy
3646             del req.headers['Ytdl-request-proxy']
3647
3648         if proxy == '__noproxy__':
3649             return None  # No Proxy
3650         if compat_urlparse.urlparse(proxy).scheme.lower() in ('socks', 'socks4', 'socks4a', 'socks5'):
3651             req.add_header('Ytdl-socks-proxy', proxy)
3652             # youtube-dl's http/https handlers do wrapping the socket with socks
3653             return None
3654         return compat_urllib_request.ProxyHandler.proxy_open(
3655             self, req, proxy, type)
3656
3657
3658 # Both long_to_bytes and bytes_to_long are adapted from PyCrypto, which is
3659 # released into Public Domain
3660 # https://github.com/dlitz/pycrypto/blob/master/lib/Crypto/Util/number.py#L387
3661
3662 def long_to_bytes(n, blocksize=0):
3663     """long_to_bytes(n:long, blocksize:int) : string
3664     Convert a long integer to a byte string.
3665
3666     If optional blocksize is given and greater than zero, pad the front of the
3667     byte string with binary zeros so that the length is a multiple of
3668     blocksize.
3669     """
3670     # after much testing, this algorithm was deemed to be the fastest
3671     s = b''
3672     n = int(n)
3673     while n > 0:
3674         s = compat_struct_pack('>I', n & 0xffffffff) + s
3675         n = n >> 32
3676     # strip off leading zeros
3677     for i in range(len(s)):
3678         if s[i] != b'\000'[0]:
3679             break
3680     else:
3681         # only happens when n == 0
3682         s = b'\000'
3683         i = 0
3684     s = s[i:]
3685     # add back some pad bytes.  this could be done more efficiently w.r.t. the
3686     # de-padding being done above, but sigh...
3687     if blocksize > 0 and len(s) % blocksize:
3688         s = (blocksize - len(s) % blocksize) * b'\000' + s
3689     return s
3690
3691
3692 def bytes_to_long(s):
3693     """bytes_to_long(string) : long
3694     Convert a byte string to a long integer.
3695
3696     This is (essentially) the inverse of long_to_bytes().
3697     """
3698     acc = 0
3699     length = len(s)
3700     if length % 4:
3701         extra = (4 - length % 4)
3702         s = b'\000' * extra + s
3703         length = length + extra
3704     for i in range(0, length, 4):
3705         acc = (acc << 32) + compat_struct_unpack('>I', s[i:i + 4])[0]
3706     return acc
3707
3708
3709 def ohdave_rsa_encrypt(data, exponent, modulus):
3710     '''
3711     Implement OHDave's RSA algorithm. See http://www.ohdave.com/rsa/
3712
3713     Input:
3714         data: data to encrypt, bytes-like object
3715         exponent, modulus: parameter e and N of RSA algorithm, both integer
3716     Output: hex string of encrypted data
3717
3718     Limitation: supports one block encryption only
3719     '''
3720
3721     payload = int(binascii.hexlify(data[::-1]), 16)
3722     encrypted = pow(payload, exponent, modulus)
3723     return '%x' % encrypted
3724
3725
3726 def pkcs1pad(data, length):
3727     """
3728     Padding input data with PKCS#1 scheme
3729
3730     @param {int[]} data        input data
3731     @param {int}   length      target length
3732     @returns {int[]}           padded data
3733     """
3734     if len(data) > length - 11:
3735         raise ValueError('Input data too long for PKCS#1 padding')
3736
3737     pseudo_random = [random.randint(0, 254) for _ in range(length - len(data) - 3)]
3738     return [0, 2] + pseudo_random + [0] + data
3739
3740
3741 def encode_base_n(num, n, table=None):
3742     FULL_TABLE = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
3743     if not table:
3744         table = FULL_TABLE[:n]
3745
3746     if n > len(table):
3747         raise ValueError('base %d exceeds table length %d' % (n, len(table)))
3748
3749     if num == 0:
3750         return table[0]
3751
3752     ret = ''
3753     while num:
3754         ret = table[num % n] + ret
3755         num = num // n
3756     return ret
3757
3758
3759 def decode_packed_codes(code):
3760     mobj = re.search(PACKED_CODES_RE, code)
3761     obfucasted_code, base, count, symbols = mobj.groups()
3762     base = int(base)
3763     count = int(count)
3764     symbols = symbols.split('|')
3765     symbol_table = {}
3766
3767     while count:
3768         count -= 1
3769         base_n_count = encode_base_n(count, base)
3770         symbol_table[base_n_count] = symbols[count] or base_n_count
3771
3772     return re.sub(
3773         r'\b(\w+)\b', lambda mobj: symbol_table[mobj.group(0)],
3774         obfucasted_code)
3775
3776
3777 def parse_m3u8_attributes(attrib):
3778     info = {}
3779     for (key, val) in re.findall(r'(?P<key>[A-Z0-9-]+)=(?P<val>"[^"]+"|[^",]+)(?:,|$)', attrib):
3780         if val.startswith('"'):
3781             val = val[1:-1]
3782         info[key] = val
3783     return info
3784
3785
3786 def urshift(val, n):
3787     return val >> n if val >= 0 else (val + 0x100000000) >> n
3788
3789
3790 # Based on png2str() written by @gdkchan and improved by @yokrysty
3791 # Originally posted at https://github.com/rg3/youtube-dl/issues/9706
3792 def decode_png(png_data):
3793     # Reference: https://www.w3.org/TR/PNG/
3794     header = png_data[8:]
3795
3796     if png_data[:8] != b'\x89PNG\x0d\x0a\x1a\x0a' or header[4:8] != b'IHDR':
3797         raise IOError('Not a valid PNG file.')
3798
3799     int_map = {1: '>B', 2: '>H', 4: '>I'}
3800     unpack_integer = lambda x: compat_struct_unpack(int_map[len(x)], x)[0]
3801
3802     chunks = []
3803
3804     while header:
3805         length = unpack_integer(header[:4])
3806         header = header[4:]
3807
3808         chunk_type = header[:4]
3809         header = header[4:]
3810
3811         chunk_data = header[:length]
3812         header = header[length:]
3813
3814         header = header[4:]  # Skip CRC
3815
3816         chunks.append({
3817             'type': chunk_type,
3818             'length': length,
3819             'data': chunk_data
3820         })
3821
3822     ihdr = chunks[0]['data']
3823
3824     width = unpack_integer(ihdr[:4])
3825     height = unpack_integer(ihdr[4:8])
3826
3827     idat = b''
3828
3829     for chunk in chunks:
3830         if chunk['type'] == b'IDAT':
3831             idat += chunk['data']
3832
3833     if not idat:
3834         raise IOError('Unable to read PNG data.')
3835
3836     decompressed_data = bytearray(zlib.decompress(idat))
3837
3838     stride = width * 3
3839     pixels = []
3840
3841     def _get_pixel(idx):
3842         x = idx % stride
3843         y = idx // stride
3844         return pixels[y][x]
3845
3846     for y in range(height):
3847         basePos = y * (1 + stride)
3848         filter_type = decompressed_data[basePos]
3849
3850         current_row = []
3851
3852         pixels.append(current_row)
3853
3854         for x in range(stride):
3855             color = decompressed_data[1 + basePos + x]
3856             basex = y * stride + x
3857             left = 0
3858             up = 0
3859
3860             if x > 2:
3861                 left = _get_pixel(basex - 3)
3862             if y > 0:
3863                 up = _get_pixel(basex - stride)
3864
3865             if filter_type == 1:  # Sub
3866                 color = (color + left) & 0xff
3867             elif filter_type == 2:  # Up
3868                 color = (color + up) & 0xff
3869             elif filter_type == 3:  # Average
3870                 color = (color + ((left + up) >> 1)) & 0xff
3871             elif filter_type == 4:  # Paeth
3872                 a = left
3873                 b = up
3874                 c = 0
3875
3876                 if x > 2 and y > 0:
3877                     c = _get_pixel(basex - stride - 3)
3878
3879                 p = a + b - c
3880
3881                 pa = abs(p - a)
3882                 pb = abs(p - b)
3883                 pc = abs(p - c)
3884
3885                 if pa <= pb and pa <= pc:
3886                     color = (color + a) & 0xff
3887                 elif pb <= pc:
3888                     color = (color + b) & 0xff
3889                 else:
3890                     color = (color + c) & 0xff
3891
3892             current_row.append(color)
3893
3894     return width, height, pixels
3895
3896
3897 def write_xattr(path, key, value):
3898     # This mess below finds the best xattr tool for the job
3899     try:
3900         # try the pyxattr module...
3901         import xattr
3902
3903         if hasattr(xattr, 'set'):  # pyxattr
3904             # Unicode arguments are not supported in python-pyxattr until
3905             # version 0.5.0
3906             # See https://github.com/rg3/youtube-dl/issues/5498
3907             pyxattr_required_version = '0.5.0'
3908             if version_tuple(xattr.__version__) < version_tuple(pyxattr_required_version):
3909                 # TODO: fallback to CLI tools
3910                 raise XAttrUnavailableError(
3911                     'python-pyxattr is detected but is too old. '
3912                     'youtube-dl requires %s or above while your version is %s. '
3913                     'Falling back to other xattr implementations' % (
3914                         pyxattr_required_version, xattr.__version__))
3915
3916             setxattr = xattr.set
3917         else:  # xattr
3918             setxattr = xattr.setxattr
3919
3920         try:
3921             setxattr(path, key, value)
3922         except EnvironmentError as e:
3923             raise XAttrMetadataError(e.errno, e.strerror)
3924
3925     except ImportError:
3926         if compat_os_name == 'nt':
3927             # Write xattrs to NTFS Alternate Data Streams:
3928             # http://en.wikipedia.org/wiki/NTFS#Alternate_data_streams_.28ADS.29
3929             assert ':' not in key
3930             assert os.path.exists(path)
3931
3932             ads_fn = path + ':' + key
3933             try:
3934                 with open(ads_fn, 'wb') as f:
3935                     f.write(value)
3936             except EnvironmentError as e:
3937                 raise XAttrMetadataError(e.errno, e.strerror)
3938         else:
3939             user_has_setfattr = check_executable('setfattr', ['--version'])
3940             user_has_xattr = check_executable('xattr', ['-h'])
3941
3942             if user_has_setfattr or user_has_xattr:
3943
3944                 value = value.decode('utf-8')
3945                 if user_has_setfattr:
3946                     executable = 'setfattr'
3947                     opts = ['-n', key, '-v', value]
3948                 elif user_has_xattr:
3949                     executable = 'xattr'
3950                     opts = ['-w', key, value]
3951
3952                 cmd = ([encodeFilename(executable, True)] +
3953                        [encodeArgument(o) for o in opts] +
3954                        [encodeFilename(path, True)])
3955
3956                 try:
3957                     p = subprocess.Popen(
3958                         cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
3959                 except EnvironmentError as e:
3960                     raise XAttrMetadataError(e.errno, e.strerror)
3961                 stdout, stderr = p.communicate()
3962                 stderr = stderr.decode('utf-8', 'replace')
3963                 if p.returncode != 0:
3964                     raise XAttrMetadataError(p.returncode, stderr)
3965
3966             else:
3967                 # On Unix, and can't find pyxattr, setfattr, or xattr.
3968                 if sys.platform.startswith('linux'):
3969                     raise XAttrUnavailableError(
3970                         "Couldn't find a tool to set the xattrs. "
3971                         "Install either the python 'pyxattr' or 'xattr' "
3972                         "modules, or the GNU 'attr' package "
3973                         "(which contains the 'setfattr' tool).")
3974                 else:
3975                     raise XAttrUnavailableError(
3976                         "Couldn't find a tool to set the xattrs. "
3977                         "Install either the python 'xattr' module, "
3978                         "or the 'xattr' binary.")
3979
3980
3981 def random_birthday(year_field, month_field, day_field):
3982     start_date = datetime.date(1950, 1, 1)
3983     end_date = datetime.date(1995, 12, 31)
3984     offset = random.randint(0, (end_date - start_date).days)
3985     random_date = start_date + datetime.timedelta(offset)
3986     return {
3987         year_field: str(random_date.year),
3988         month_field: str(random_date.month),
3989         day_field: str(random_date.day),
3990     }