]> git.bitcoin.ninja Git - youtube-dl/blob - youtube_dl/utils.py
release 2018.12.09
[youtube-dl] / 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'^(?:https?:)?//', 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         'hi': 'hin',
2972         'ho': 'hmo',
2973         'hr': 'hrv',
2974         'ht': 'hat',
2975         'hu': 'hun',
2976         'hy': 'hye',
2977         'hz': 'her',
2978         'ia': 'ina',
2979         'id': 'ind',
2980         'ie': 'ile',
2981         'ig': 'ibo',
2982         'ii': 'iii',
2983         'ik': 'ipk',
2984         'io': 'ido',
2985         'is': 'isl',
2986         'it': 'ita',
2987         'iu': 'iku',
2988         'ja': 'jpn',
2989         'jv': 'jav',
2990         'ka': 'kat',
2991         'kg': 'kon',
2992         'ki': 'kik',
2993         'kj': 'kua',
2994         'kk': 'kaz',
2995         'kl': 'kal',
2996         'km': 'khm',
2997         'kn': 'kan',
2998         'ko': 'kor',
2999         'kr': 'kau',
3000         'ks': 'kas',
3001         'ku': 'kur',
3002         'kv': 'kom',
3003         'kw': 'cor',
3004         'ky': 'kir',
3005         'la': 'lat',
3006         'lb': 'ltz',
3007         'lg': 'lug',
3008         'li': 'lim',
3009         'ln': 'lin',
3010         'lo': 'lao',
3011         'lt': 'lit',
3012         'lu': 'lub',
3013         'lv': 'lav',
3014         'mg': 'mlg',
3015         'mh': 'mah',
3016         'mi': 'mri',
3017         'mk': 'mkd',
3018         'ml': 'mal',
3019         'mn': 'mon',
3020         'mr': 'mar',
3021         'ms': 'msa',
3022         'mt': 'mlt',
3023         'my': 'mya',
3024         'na': 'nau',
3025         'nb': 'nob',
3026         'nd': 'nde',
3027         'ne': 'nep',
3028         'ng': 'ndo',
3029         'nl': 'nld',
3030         'nn': 'nno',
3031         'no': 'nor',
3032         'nr': 'nbl',
3033         'nv': 'nav',
3034         'ny': 'nya',
3035         'oc': 'oci',
3036         'oj': 'oji',
3037         'om': 'orm',
3038         'or': 'ori',
3039         'os': 'oss',
3040         'pa': 'pan',
3041         'pi': 'pli',
3042         'pl': 'pol',
3043         'ps': 'pus',
3044         'pt': 'por',
3045         'qu': 'que',
3046         'rm': 'roh',
3047         'rn': 'run',
3048         'ro': 'ron',
3049         'ru': 'rus',
3050         'rw': 'kin',
3051         'sa': 'san',
3052         'sc': 'srd',
3053         'sd': 'snd',
3054         'se': 'sme',
3055         'sg': 'sag',
3056         'si': 'sin',
3057         'sk': 'slk',
3058         'sl': 'slv',
3059         'sm': 'smo',
3060         'sn': 'sna',
3061         'so': 'som',
3062         'sq': 'sqi',
3063         'sr': 'srp',
3064         'ss': 'ssw',
3065         'st': 'sot',
3066         'su': 'sun',
3067         'sv': 'swe',
3068         'sw': 'swa',
3069         'ta': 'tam',
3070         'te': 'tel',
3071         'tg': 'tgk',
3072         'th': 'tha',
3073         'ti': 'tir',
3074         'tk': 'tuk',
3075         'tl': 'tgl',
3076         'tn': 'tsn',
3077         'to': 'ton',
3078         'tr': 'tur',
3079         'ts': 'tso',
3080         'tt': 'tat',
3081         'tw': 'twi',
3082         'ty': 'tah',
3083         'ug': 'uig',
3084         'uk': 'ukr',
3085         'ur': 'urd',
3086         'uz': 'uzb',
3087         've': 'ven',
3088         'vi': 'vie',
3089         'vo': 'vol',
3090         'wa': 'wln',
3091         'wo': 'wol',
3092         'xh': 'xho',
3093         'yi': 'yid',
3094         'yo': 'yor',
3095         'za': 'zha',
3096         'zh': 'zho',
3097         'zu': 'zul',
3098     }
3099
3100     @classmethod
3101     def short2long(cls, code):
3102         """Convert language code from ISO 639-1 to ISO 639-2/T"""
3103         return cls._lang_map.get(code[:2])
3104
3105     @classmethod
3106     def long2short(cls, code):
3107         """Convert language code from ISO 639-2/T to ISO 639-1"""
3108         for short_name, long_name in cls._lang_map.items():
3109             if long_name == code:
3110                 return short_name
3111
3112
3113 class ISO3166Utils(object):
3114     # From http://data.okfn.org/data/core/country-list
3115     _country_map = {
3116         'AF': 'Afghanistan',
3117         'AX': 'Åland Islands',
3118         'AL': 'Albania',
3119         'DZ': 'Algeria',
3120         'AS': 'American Samoa',
3121         'AD': 'Andorra',
3122         'AO': 'Angola',
3123         'AI': 'Anguilla',
3124         'AQ': 'Antarctica',
3125         'AG': 'Antigua and Barbuda',
3126         'AR': 'Argentina',
3127         'AM': 'Armenia',
3128         'AW': 'Aruba',
3129         'AU': 'Australia',
3130         'AT': 'Austria',
3131         'AZ': 'Azerbaijan',
3132         'BS': 'Bahamas',
3133         'BH': 'Bahrain',
3134         'BD': 'Bangladesh',
3135         'BB': 'Barbados',
3136         'BY': 'Belarus',
3137         'BE': 'Belgium',
3138         'BZ': 'Belize',
3139         'BJ': 'Benin',
3140         'BM': 'Bermuda',
3141         'BT': 'Bhutan',
3142         'BO': 'Bolivia, Plurinational State of',
3143         'BQ': 'Bonaire, Sint Eustatius and Saba',
3144         'BA': 'Bosnia and Herzegovina',
3145         'BW': 'Botswana',
3146         'BV': 'Bouvet Island',
3147         'BR': 'Brazil',
3148         'IO': 'British Indian Ocean Territory',
3149         'BN': 'Brunei Darussalam',
3150         'BG': 'Bulgaria',
3151         'BF': 'Burkina Faso',
3152         'BI': 'Burundi',
3153         'KH': 'Cambodia',
3154         'CM': 'Cameroon',
3155         'CA': 'Canada',
3156         'CV': 'Cape Verde',
3157         'KY': 'Cayman Islands',
3158         'CF': 'Central African Republic',
3159         'TD': 'Chad',
3160         'CL': 'Chile',
3161         'CN': 'China',
3162         'CX': 'Christmas Island',
3163         'CC': 'Cocos (Keeling) Islands',
3164         'CO': 'Colombia',
3165         'KM': 'Comoros',
3166         'CG': 'Congo',
3167         'CD': 'Congo, the Democratic Republic of the',
3168         'CK': 'Cook Islands',
3169         'CR': 'Costa Rica',
3170         'CI': 'Côte d\'Ivoire',
3171         'HR': 'Croatia',
3172         'CU': 'Cuba',
3173         'CW': 'Curaçao',
3174         'CY': 'Cyprus',
3175         'CZ': 'Czech Republic',
3176         'DK': 'Denmark',
3177         'DJ': 'Djibouti',
3178         'DM': 'Dominica',
3179         'DO': 'Dominican Republic',
3180         'EC': 'Ecuador',
3181         'EG': 'Egypt',
3182         'SV': 'El Salvador',
3183         'GQ': 'Equatorial Guinea',
3184         'ER': 'Eritrea',
3185         'EE': 'Estonia',
3186         'ET': 'Ethiopia',
3187         'FK': 'Falkland Islands (Malvinas)',
3188         'FO': 'Faroe Islands',
3189         'FJ': 'Fiji',
3190         'FI': 'Finland',
3191         'FR': 'France',
3192         'GF': 'French Guiana',
3193         'PF': 'French Polynesia',
3194         'TF': 'French Southern Territories',
3195         'GA': 'Gabon',
3196         'GM': 'Gambia',
3197         'GE': 'Georgia',
3198         'DE': 'Germany',
3199         'GH': 'Ghana',
3200         'GI': 'Gibraltar',
3201         'GR': 'Greece',
3202         'GL': 'Greenland',
3203         'GD': 'Grenada',
3204         'GP': 'Guadeloupe',
3205         'GU': 'Guam',
3206         'GT': 'Guatemala',
3207         'GG': 'Guernsey',
3208         'GN': 'Guinea',
3209         'GW': 'Guinea-Bissau',
3210         'GY': 'Guyana',
3211         'HT': 'Haiti',
3212         'HM': 'Heard Island and McDonald Islands',
3213         'VA': 'Holy See (Vatican City State)',
3214         'HN': 'Honduras',
3215         'HK': 'Hong Kong',
3216         'HU': 'Hungary',
3217         'IS': 'Iceland',
3218         'IN': 'India',
3219         'ID': 'Indonesia',
3220         'IR': 'Iran, Islamic Republic of',
3221         'IQ': 'Iraq',
3222         'IE': 'Ireland',
3223         'IM': 'Isle of Man',
3224         'IL': 'Israel',
3225         'IT': 'Italy',
3226         'JM': 'Jamaica',
3227         'JP': 'Japan',
3228         'JE': 'Jersey',
3229         'JO': 'Jordan',
3230         'KZ': 'Kazakhstan',
3231         'KE': 'Kenya',
3232         'KI': 'Kiribati',
3233         'KP': 'Korea, Democratic People\'s Republic of',
3234         'KR': 'Korea, Republic of',
3235         'KW': 'Kuwait',
3236         'KG': 'Kyrgyzstan',
3237         'LA': 'Lao People\'s Democratic Republic',
3238         'LV': 'Latvia',
3239         'LB': 'Lebanon',
3240         'LS': 'Lesotho',
3241         'LR': 'Liberia',
3242         'LY': 'Libya',
3243         'LI': 'Liechtenstein',
3244         'LT': 'Lithuania',
3245         'LU': 'Luxembourg',
3246         'MO': 'Macao',
3247         'MK': 'Macedonia, the Former Yugoslav Republic of',
3248         'MG': 'Madagascar',
3249         'MW': 'Malawi',
3250         'MY': 'Malaysia',
3251         'MV': 'Maldives',
3252         'ML': 'Mali',
3253         'MT': 'Malta',
3254         'MH': 'Marshall Islands',
3255         'MQ': 'Martinique',
3256         'MR': 'Mauritania',
3257         'MU': 'Mauritius',
3258         'YT': 'Mayotte',
3259         'MX': 'Mexico',
3260         'FM': 'Micronesia, Federated States of',
3261         'MD': 'Moldova, Republic of',
3262         'MC': 'Monaco',
3263         'MN': 'Mongolia',
3264         'ME': 'Montenegro',
3265         'MS': 'Montserrat',
3266         'MA': 'Morocco',
3267         'MZ': 'Mozambique',
3268         'MM': 'Myanmar',
3269         'NA': 'Namibia',
3270         'NR': 'Nauru',
3271         'NP': 'Nepal',
3272         'NL': 'Netherlands',
3273         'NC': 'New Caledonia',
3274         'NZ': 'New Zealand',
3275         'NI': 'Nicaragua',
3276         'NE': 'Niger',
3277         'NG': 'Nigeria',
3278         'NU': 'Niue',
3279         'NF': 'Norfolk Island',
3280         'MP': 'Northern Mariana Islands',
3281         'NO': 'Norway',
3282         'OM': 'Oman',
3283         'PK': 'Pakistan',
3284         'PW': 'Palau',
3285         'PS': 'Palestine, State of',
3286         'PA': 'Panama',
3287         'PG': 'Papua New Guinea',
3288         'PY': 'Paraguay',
3289         'PE': 'Peru',
3290         'PH': 'Philippines',
3291         'PN': 'Pitcairn',
3292         'PL': 'Poland',
3293         'PT': 'Portugal',
3294         'PR': 'Puerto Rico',
3295         'QA': 'Qatar',
3296         'RE': 'Réunion',
3297         'RO': 'Romania',
3298         'RU': 'Russian Federation',
3299         'RW': 'Rwanda',
3300         'BL': 'Saint Barthélemy',
3301         'SH': 'Saint Helena, Ascension and Tristan da Cunha',
3302         'KN': 'Saint Kitts and Nevis',
3303         'LC': 'Saint Lucia',
3304         'MF': 'Saint Martin (French part)',
3305         'PM': 'Saint Pierre and Miquelon',
3306         'VC': 'Saint Vincent and the Grenadines',
3307         'WS': 'Samoa',
3308         'SM': 'San Marino',
3309         'ST': 'Sao Tome and Principe',
3310         'SA': 'Saudi Arabia',
3311         'SN': 'Senegal',
3312         'RS': 'Serbia',
3313         'SC': 'Seychelles',
3314         'SL': 'Sierra Leone',
3315         'SG': 'Singapore',
3316         'SX': 'Sint Maarten (Dutch part)',
3317         'SK': 'Slovakia',
3318         'SI': 'Slovenia',
3319         'SB': 'Solomon Islands',
3320         'SO': 'Somalia',
3321         'ZA': 'South Africa',
3322         'GS': 'South Georgia and the South Sandwich Islands',
3323         'SS': 'South Sudan',
3324         'ES': 'Spain',
3325         'LK': 'Sri Lanka',
3326         'SD': 'Sudan',
3327         'SR': 'Suriname',
3328         'SJ': 'Svalbard and Jan Mayen',
3329         'SZ': 'Swaziland',
3330         'SE': 'Sweden',
3331         'CH': 'Switzerland',
3332         'SY': 'Syrian Arab Republic',
3333         'TW': 'Taiwan, Province of China',
3334         'TJ': 'Tajikistan',
3335         'TZ': 'Tanzania, United Republic of',
3336         'TH': 'Thailand',
3337         'TL': 'Timor-Leste',
3338         'TG': 'Togo',
3339         'TK': 'Tokelau',
3340         'TO': 'Tonga',
3341         'TT': 'Trinidad and Tobago',
3342         'TN': 'Tunisia',
3343         'TR': 'Turkey',
3344         'TM': 'Turkmenistan',
3345         'TC': 'Turks and Caicos Islands',
3346         'TV': 'Tuvalu',
3347         'UG': 'Uganda',
3348         'UA': 'Ukraine',
3349         'AE': 'United Arab Emirates',
3350         'GB': 'United Kingdom',
3351         'US': 'United States',
3352         'UM': 'United States Minor Outlying Islands',
3353         'UY': 'Uruguay',
3354         'UZ': 'Uzbekistan',
3355         'VU': 'Vanuatu',
3356         'VE': 'Venezuela, Bolivarian Republic of',
3357         'VN': 'Viet Nam',
3358         'VG': 'Virgin Islands, British',
3359         'VI': 'Virgin Islands, U.S.',
3360         'WF': 'Wallis and Futuna',
3361         'EH': 'Western Sahara',
3362         'YE': 'Yemen',
3363         'ZM': 'Zambia',
3364         'ZW': 'Zimbabwe',
3365     }
3366
3367     @classmethod
3368     def short2full(cls, code):
3369         """Convert an ISO 3166-2 country code to the corresponding full name"""
3370         return cls._country_map.get(code.upper())
3371
3372
3373 class GeoUtils(object):
3374     # Major IPv4 address blocks per country
3375     _country_ip_map = {
3376         'AD': '85.94.160.0/19',
3377         'AE': '94.200.0.0/13',
3378         'AF': '149.54.0.0/17',
3379         'AG': '209.59.64.0/18',
3380         'AI': '204.14.248.0/21',
3381         'AL': '46.99.0.0/16',
3382         'AM': '46.70.0.0/15',
3383         'AO': '105.168.0.0/13',
3384         'AP': '159.117.192.0/21',
3385         'AR': '181.0.0.0/12',
3386         'AS': '202.70.112.0/20',
3387         'AT': '84.112.0.0/13',
3388         'AU': '1.128.0.0/11',
3389         'AW': '181.41.0.0/18',
3390         'AZ': '5.191.0.0/16',
3391         'BA': '31.176.128.0/17',
3392         'BB': '65.48.128.0/17',
3393         'BD': '114.130.0.0/16',
3394         'BE': '57.0.0.0/8',
3395         'BF': '129.45.128.0/17',
3396         'BG': '95.42.0.0/15',
3397         'BH': '37.131.0.0/17',
3398         'BI': '154.117.192.0/18',
3399         'BJ': '137.255.0.0/16',
3400         'BL': '192.131.134.0/24',
3401         'BM': '196.12.64.0/18',
3402         'BN': '156.31.0.0/16',
3403         'BO': '161.56.0.0/16',
3404         'BQ': '161.0.80.0/20',
3405         'BR': '152.240.0.0/12',
3406         'BS': '24.51.64.0/18',
3407         'BT': '119.2.96.0/19',
3408         'BW': '168.167.0.0/16',
3409         'BY': '178.120.0.0/13',
3410         'BZ': '179.42.192.0/18',
3411         'CA': '99.224.0.0/11',
3412         'CD': '41.243.0.0/16',
3413         'CF': '196.32.200.0/21',
3414         'CG': '197.214.128.0/17',
3415         'CH': '85.0.0.0/13',
3416         'CI': '154.232.0.0/14',
3417         'CK': '202.65.32.0/19',
3418         'CL': '152.172.0.0/14',
3419         'CM': '165.210.0.0/15',
3420         'CN': '36.128.0.0/10',
3421         'CO': '181.240.0.0/12',
3422         'CR': '201.192.0.0/12',
3423         'CU': '152.206.0.0/15',
3424         'CV': '165.90.96.0/19',
3425         'CW': '190.88.128.0/17',
3426         'CY': '46.198.0.0/15',
3427         'CZ': '88.100.0.0/14',
3428         'DE': '53.0.0.0/8',
3429         'DJ': '197.241.0.0/17',
3430         'DK': '87.48.0.0/12',
3431         'DM': '192.243.48.0/20',
3432         'DO': '152.166.0.0/15',
3433         'DZ': '41.96.0.0/12',
3434         'EC': '186.68.0.0/15',
3435         'EE': '90.190.0.0/15',
3436         'EG': '156.160.0.0/11',
3437         'ER': '196.200.96.0/20',
3438         'ES': '88.0.0.0/11',
3439         'ET': '196.188.0.0/14',
3440         'EU': '2.16.0.0/13',
3441         'FI': '91.152.0.0/13',
3442         'FJ': '144.120.0.0/16',
3443         'FM': '119.252.112.0/20',
3444         'FO': '88.85.32.0/19',
3445         'FR': '90.0.0.0/9',
3446         'GA': '41.158.0.0/15',
3447         'GB': '25.0.0.0/8',
3448         'GD': '74.122.88.0/21',
3449         'GE': '31.146.0.0/16',
3450         'GF': '161.22.64.0/18',
3451         'GG': '62.68.160.0/19',
3452         'GH': '45.208.0.0/14',
3453         'GI': '85.115.128.0/19',
3454         'GL': '88.83.0.0/19',
3455         'GM': '160.182.0.0/15',
3456         'GN': '197.149.192.0/18',
3457         'GP': '104.250.0.0/19',
3458         'GQ': '105.235.224.0/20',
3459         'GR': '94.64.0.0/13',
3460         'GT': '168.234.0.0/16',
3461         'GU': '168.123.0.0/16',
3462         'GW': '197.214.80.0/20',
3463         'GY': '181.41.64.0/18',
3464         'HK': '113.252.0.0/14',
3465         'HN': '181.210.0.0/16',
3466         'HR': '93.136.0.0/13',
3467         'HT': '148.102.128.0/17',
3468         'HU': '84.0.0.0/14',
3469         'ID': '39.192.0.0/10',
3470         'IE': '87.32.0.0/12',
3471         'IL': '79.176.0.0/13',
3472         'IM': '5.62.80.0/20',
3473         'IN': '117.192.0.0/10',
3474         'IO': '203.83.48.0/21',
3475         'IQ': '37.236.0.0/14',
3476         'IR': '2.176.0.0/12',
3477         'IS': '82.221.0.0/16',
3478         'IT': '79.0.0.0/10',
3479         'JE': '87.244.64.0/18',
3480         'JM': '72.27.0.0/17',
3481         'JO': '176.29.0.0/16',
3482         'JP': '126.0.0.0/8',
3483         'KE': '105.48.0.0/12',
3484         'KG': '158.181.128.0/17',
3485         'KH': '36.37.128.0/17',
3486         'KI': '103.25.140.0/22',
3487         'KM': '197.255.224.0/20',
3488         'KN': '198.32.32.0/19',
3489         'KP': '175.45.176.0/22',
3490         'KR': '175.192.0.0/10',
3491         'KW': '37.36.0.0/14',
3492         'KY': '64.96.0.0/15',
3493         'KZ': '2.72.0.0/13',
3494         'LA': '115.84.64.0/18',
3495         'LB': '178.135.0.0/16',
3496         'LC': '192.147.231.0/24',
3497         'LI': '82.117.0.0/19',
3498         'LK': '112.134.0.0/15',
3499         'LR': '41.86.0.0/19',
3500         'LS': '129.232.0.0/17',
3501         'LT': '78.56.0.0/13',
3502         'LU': '188.42.0.0/16',
3503         'LV': '46.109.0.0/16',
3504         'LY': '41.252.0.0/14',
3505         'MA': '105.128.0.0/11',
3506         'MC': '88.209.64.0/18',
3507         'MD': '37.246.0.0/16',
3508         'ME': '178.175.0.0/17',
3509         'MF': '74.112.232.0/21',
3510         'MG': '154.126.0.0/17',
3511         'MH': '117.103.88.0/21',
3512         'MK': '77.28.0.0/15',
3513         'ML': '154.118.128.0/18',
3514         'MM': '37.111.0.0/17',
3515         'MN': '49.0.128.0/17',
3516         'MO': '60.246.0.0/16',
3517         'MP': '202.88.64.0/20',
3518         'MQ': '109.203.224.0/19',
3519         'MR': '41.188.64.0/18',
3520         'MS': '208.90.112.0/22',
3521         'MT': '46.11.0.0/16',
3522         'MU': '105.16.0.0/12',
3523         'MV': '27.114.128.0/18',
3524         'MW': '105.234.0.0/16',
3525         'MX': '187.192.0.0/11',
3526         'MY': '175.136.0.0/13',
3527         'MZ': '197.218.0.0/15',
3528         'NA': '41.182.0.0/16',
3529         'NC': '101.101.0.0/18',
3530         'NE': '197.214.0.0/18',
3531         'NF': '203.17.240.0/22',
3532         'NG': '105.112.0.0/12',
3533         'NI': '186.76.0.0/15',
3534         'NL': '145.96.0.0/11',
3535         'NO': '84.208.0.0/13',
3536         'NP': '36.252.0.0/15',
3537         'NR': '203.98.224.0/19',
3538         'NU': '49.156.48.0/22',
3539         'NZ': '49.224.0.0/14',
3540         'OM': '5.36.0.0/15',
3541         'PA': '186.72.0.0/15',
3542         'PE': '186.160.0.0/14',
3543         'PF': '123.50.64.0/18',
3544         'PG': '124.240.192.0/19',
3545         'PH': '49.144.0.0/13',
3546         'PK': '39.32.0.0/11',
3547         'PL': '83.0.0.0/11',
3548         'PM': '70.36.0.0/20',
3549         'PR': '66.50.0.0/16',
3550         'PS': '188.161.0.0/16',
3551         'PT': '85.240.0.0/13',
3552         'PW': '202.124.224.0/20',
3553         'PY': '181.120.0.0/14',
3554         'QA': '37.210.0.0/15',
3555         'RE': '139.26.0.0/16',
3556         'RO': '79.112.0.0/13',
3557         'RS': '178.220.0.0/14',
3558         'RU': '5.136.0.0/13',
3559         'RW': '105.178.0.0/15',
3560         'SA': '188.48.0.0/13',
3561         'SB': '202.1.160.0/19',
3562         'SC': '154.192.0.0/11',
3563         'SD': '154.96.0.0/13',
3564         'SE': '78.64.0.0/12',
3565         'SG': '152.56.0.0/14',
3566         'SI': '188.196.0.0/14',
3567         'SK': '78.98.0.0/15',
3568         'SL': '197.215.0.0/17',
3569         'SM': '89.186.32.0/19',
3570         'SN': '41.82.0.0/15',
3571         'SO': '197.220.64.0/19',
3572         'SR': '186.179.128.0/17',
3573         'SS': '105.235.208.0/21',
3574         'ST': '197.159.160.0/19',
3575         'SV': '168.243.0.0/16',
3576         'SX': '190.102.0.0/20',
3577         'SY': '5.0.0.0/16',
3578         'SZ': '41.84.224.0/19',
3579         'TC': '65.255.48.0/20',
3580         'TD': '154.68.128.0/19',
3581         'TG': '196.168.0.0/14',
3582         'TH': '171.96.0.0/13',
3583         'TJ': '85.9.128.0/18',
3584         'TK': '27.96.24.0/21',
3585         'TL': '180.189.160.0/20',
3586         'TM': '95.85.96.0/19',
3587         'TN': '197.0.0.0/11',
3588         'TO': '175.176.144.0/21',
3589         'TR': '78.160.0.0/11',
3590         'TT': '186.44.0.0/15',
3591         'TV': '202.2.96.0/19',
3592         'TW': '120.96.0.0/11',
3593         'TZ': '156.156.0.0/14',
3594         'UA': '93.72.0.0/13',
3595         'UG': '154.224.0.0/13',
3596         'US': '3.0.0.0/8',
3597         'UY': '167.56.0.0/13',
3598         'UZ': '82.215.64.0/18',
3599         'VA': '212.77.0.0/19',
3600         'VC': '24.92.144.0/20',
3601         'VE': '186.88.0.0/13',
3602         'VG': '172.103.64.0/18',
3603         'VI': '146.226.0.0/16',
3604         'VN': '14.160.0.0/11',
3605         'VU': '202.80.32.0/20',
3606         'WF': '117.20.32.0/21',
3607         'WS': '202.4.32.0/19',
3608         'YE': '134.35.0.0/16',
3609         'YT': '41.242.116.0/22',
3610         'ZA': '41.0.0.0/11',
3611         'ZM': '165.56.0.0/13',
3612         'ZW': '41.85.192.0/19',
3613     }
3614
3615     @classmethod
3616     def random_ipv4(cls, code_or_block):
3617         if len(code_or_block) == 2:
3618             block = cls._country_ip_map.get(code_or_block.upper())
3619             if not block:
3620                 return None
3621         else:
3622             block = code_or_block
3623         addr, preflen = block.split('/')
3624         addr_min = compat_struct_unpack('!L', socket.inet_aton(addr))[0]
3625         addr_max = addr_min | (0xffffffff >> int(preflen))
3626         return compat_str(socket.inet_ntoa(
3627             compat_struct_pack('!L', random.randint(addr_min, addr_max))))
3628
3629
3630 class PerRequestProxyHandler(compat_urllib_request.ProxyHandler):
3631     def __init__(self, proxies=None):
3632         # Set default handlers
3633         for type in ('http', 'https'):
3634             setattr(self, '%s_open' % type,
3635                     lambda r, proxy='__noproxy__', type=type, meth=self.proxy_open:
3636                         meth(r, proxy, type))
3637         compat_urllib_request.ProxyHandler.__init__(self, proxies)
3638
3639     def proxy_open(self, req, proxy, type):
3640         req_proxy = req.headers.get('Ytdl-request-proxy')
3641         if req_proxy is not None:
3642             proxy = req_proxy
3643             del req.headers['Ytdl-request-proxy']
3644
3645         if proxy == '__noproxy__':
3646             return None  # No Proxy
3647         if compat_urlparse.urlparse(proxy).scheme.lower() in ('socks', 'socks4', 'socks4a', 'socks5'):
3648             req.add_header('Ytdl-socks-proxy', proxy)
3649             # youtube-dl's http/https handlers do wrapping the socket with socks
3650             return None
3651         return compat_urllib_request.ProxyHandler.proxy_open(
3652             self, req, proxy, type)
3653
3654
3655 # Both long_to_bytes and bytes_to_long are adapted from PyCrypto, which is
3656 # released into Public Domain
3657 # https://github.com/dlitz/pycrypto/blob/master/lib/Crypto/Util/number.py#L387
3658
3659 def long_to_bytes(n, blocksize=0):
3660     """long_to_bytes(n:long, blocksize:int) : string
3661     Convert a long integer to a byte string.
3662
3663     If optional blocksize is given and greater than zero, pad the front of the
3664     byte string with binary zeros so that the length is a multiple of
3665     blocksize.
3666     """
3667     # after much testing, this algorithm was deemed to be the fastest
3668     s = b''
3669     n = int(n)
3670     while n > 0:
3671         s = compat_struct_pack('>I', n & 0xffffffff) + s
3672         n = n >> 32
3673     # strip off leading zeros
3674     for i in range(len(s)):
3675         if s[i] != b'\000'[0]:
3676             break
3677     else:
3678         # only happens when n == 0
3679         s = b'\000'
3680         i = 0
3681     s = s[i:]
3682     # add back some pad bytes.  this could be done more efficiently w.r.t. the
3683     # de-padding being done above, but sigh...
3684     if blocksize > 0 and len(s) % blocksize:
3685         s = (blocksize - len(s) % blocksize) * b'\000' + s
3686     return s
3687
3688
3689 def bytes_to_long(s):
3690     """bytes_to_long(string) : long
3691     Convert a byte string to a long integer.
3692
3693     This is (essentially) the inverse of long_to_bytes().
3694     """
3695     acc = 0
3696     length = len(s)
3697     if length % 4:
3698         extra = (4 - length % 4)
3699         s = b'\000' * extra + s
3700         length = length + extra
3701     for i in range(0, length, 4):
3702         acc = (acc << 32) + compat_struct_unpack('>I', s[i:i + 4])[0]
3703     return acc
3704
3705
3706 def ohdave_rsa_encrypt(data, exponent, modulus):
3707     '''
3708     Implement OHDave's RSA algorithm. See http://www.ohdave.com/rsa/
3709
3710     Input:
3711         data: data to encrypt, bytes-like object
3712         exponent, modulus: parameter e and N of RSA algorithm, both integer
3713     Output: hex string of encrypted data
3714
3715     Limitation: supports one block encryption only
3716     '''
3717
3718     payload = int(binascii.hexlify(data[::-1]), 16)
3719     encrypted = pow(payload, exponent, modulus)
3720     return '%x' % encrypted
3721
3722
3723 def pkcs1pad(data, length):
3724     """
3725     Padding input data with PKCS#1 scheme
3726
3727     @param {int[]} data        input data
3728     @param {int}   length      target length
3729     @returns {int[]}           padded data
3730     """
3731     if len(data) > length - 11:
3732         raise ValueError('Input data too long for PKCS#1 padding')
3733
3734     pseudo_random = [random.randint(0, 254) for _ in range(length - len(data) - 3)]
3735     return [0, 2] + pseudo_random + [0] + data
3736
3737
3738 def encode_base_n(num, n, table=None):
3739     FULL_TABLE = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
3740     if not table:
3741         table = FULL_TABLE[:n]
3742
3743     if n > len(table):
3744         raise ValueError('base %d exceeds table length %d' % (n, len(table)))
3745
3746     if num == 0:
3747         return table[0]
3748
3749     ret = ''
3750     while num:
3751         ret = table[num % n] + ret
3752         num = num // n
3753     return ret
3754
3755
3756 def decode_packed_codes(code):
3757     mobj = re.search(PACKED_CODES_RE, code)
3758     obfucasted_code, base, count, symbols = mobj.groups()
3759     base = int(base)
3760     count = int(count)
3761     symbols = symbols.split('|')
3762     symbol_table = {}
3763
3764     while count:
3765         count -= 1
3766         base_n_count = encode_base_n(count, base)
3767         symbol_table[base_n_count] = symbols[count] or base_n_count
3768
3769     return re.sub(
3770         r'\b(\w+)\b', lambda mobj: symbol_table[mobj.group(0)],
3771         obfucasted_code)
3772
3773
3774 def parse_m3u8_attributes(attrib):
3775     info = {}
3776     for (key, val) in re.findall(r'(?P<key>[A-Z0-9-]+)=(?P<val>"[^"]+"|[^",]+)(?:,|$)', attrib):
3777         if val.startswith('"'):
3778             val = val[1:-1]
3779         info[key] = val
3780     return info
3781
3782
3783 def urshift(val, n):
3784     return val >> n if val >= 0 else (val + 0x100000000) >> n
3785
3786
3787 # Based on png2str() written by @gdkchan and improved by @yokrysty
3788 # Originally posted at https://github.com/rg3/youtube-dl/issues/9706
3789 def decode_png(png_data):
3790     # Reference: https://www.w3.org/TR/PNG/
3791     header = png_data[8:]
3792
3793     if png_data[:8] != b'\x89PNG\x0d\x0a\x1a\x0a' or header[4:8] != b'IHDR':
3794         raise IOError('Not a valid PNG file.')
3795
3796     int_map = {1: '>B', 2: '>H', 4: '>I'}
3797     unpack_integer = lambda x: compat_struct_unpack(int_map[len(x)], x)[0]
3798
3799     chunks = []
3800
3801     while header:
3802         length = unpack_integer(header[:4])
3803         header = header[4:]
3804
3805         chunk_type = header[:4]
3806         header = header[4:]
3807
3808         chunk_data = header[:length]
3809         header = header[length:]
3810
3811         header = header[4:]  # Skip CRC
3812
3813         chunks.append({
3814             'type': chunk_type,
3815             'length': length,
3816             'data': chunk_data
3817         })
3818
3819     ihdr = chunks[0]['data']
3820
3821     width = unpack_integer(ihdr[:4])
3822     height = unpack_integer(ihdr[4:8])
3823
3824     idat = b''
3825
3826     for chunk in chunks:
3827         if chunk['type'] == b'IDAT':
3828             idat += chunk['data']
3829
3830     if not idat:
3831         raise IOError('Unable to read PNG data.')
3832
3833     decompressed_data = bytearray(zlib.decompress(idat))
3834
3835     stride = width * 3
3836     pixels = []
3837
3838     def _get_pixel(idx):
3839         x = idx % stride
3840         y = idx // stride
3841         return pixels[y][x]
3842
3843     for y in range(height):
3844         basePos = y * (1 + stride)
3845         filter_type = decompressed_data[basePos]
3846
3847         current_row = []
3848
3849         pixels.append(current_row)
3850
3851         for x in range(stride):
3852             color = decompressed_data[1 + basePos + x]
3853             basex = y * stride + x
3854             left = 0
3855             up = 0
3856
3857             if x > 2:
3858                 left = _get_pixel(basex - 3)
3859             if y > 0:
3860                 up = _get_pixel(basex - stride)
3861
3862             if filter_type == 1:  # Sub
3863                 color = (color + left) & 0xff
3864             elif filter_type == 2:  # Up
3865                 color = (color + up) & 0xff
3866             elif filter_type == 3:  # Average
3867                 color = (color + ((left + up) >> 1)) & 0xff
3868             elif filter_type == 4:  # Paeth
3869                 a = left
3870                 b = up
3871                 c = 0
3872
3873                 if x > 2 and y > 0:
3874                     c = _get_pixel(basex - stride - 3)
3875
3876                 p = a + b - c
3877
3878                 pa = abs(p - a)
3879                 pb = abs(p - b)
3880                 pc = abs(p - c)
3881
3882                 if pa <= pb and pa <= pc:
3883                     color = (color + a) & 0xff
3884                 elif pb <= pc:
3885                     color = (color + b) & 0xff
3886                 else:
3887                     color = (color + c) & 0xff
3888
3889             current_row.append(color)
3890
3891     return width, height, pixels
3892
3893
3894 def write_xattr(path, key, value):
3895     # This mess below finds the best xattr tool for the job
3896     try:
3897         # try the pyxattr module...
3898         import xattr
3899
3900         if hasattr(xattr, 'set'):  # pyxattr
3901             # Unicode arguments are not supported in python-pyxattr until
3902             # version 0.5.0
3903             # See https://github.com/rg3/youtube-dl/issues/5498
3904             pyxattr_required_version = '0.5.0'
3905             if version_tuple(xattr.__version__) < version_tuple(pyxattr_required_version):
3906                 # TODO: fallback to CLI tools
3907                 raise XAttrUnavailableError(
3908                     'python-pyxattr is detected but is too old. '
3909                     'youtube-dl requires %s or above while your version is %s. '
3910                     'Falling back to other xattr implementations' % (
3911                         pyxattr_required_version, xattr.__version__))
3912
3913             setxattr = xattr.set
3914         else:  # xattr
3915             setxattr = xattr.setxattr
3916
3917         try:
3918             setxattr(path, key, value)
3919         except EnvironmentError as e:
3920             raise XAttrMetadataError(e.errno, e.strerror)
3921
3922     except ImportError:
3923         if compat_os_name == 'nt':
3924             # Write xattrs to NTFS Alternate Data Streams:
3925             # http://en.wikipedia.org/wiki/NTFS#Alternate_data_streams_.28ADS.29
3926             assert ':' not in key
3927             assert os.path.exists(path)
3928
3929             ads_fn = path + ':' + key
3930             try:
3931                 with open(ads_fn, 'wb') as f:
3932                     f.write(value)
3933             except EnvironmentError as e:
3934                 raise XAttrMetadataError(e.errno, e.strerror)
3935         else:
3936             user_has_setfattr = check_executable('setfattr', ['--version'])
3937             user_has_xattr = check_executable('xattr', ['-h'])
3938
3939             if user_has_setfattr or user_has_xattr:
3940
3941                 value = value.decode('utf-8')
3942                 if user_has_setfattr:
3943                     executable = 'setfattr'
3944                     opts = ['-n', key, '-v', value]
3945                 elif user_has_xattr:
3946                     executable = 'xattr'
3947                     opts = ['-w', key, value]
3948
3949                 cmd = ([encodeFilename(executable, True)] +
3950                        [encodeArgument(o) for o in opts] +
3951                        [encodeFilename(path, True)])
3952
3953                 try:
3954                     p = subprocess.Popen(
3955                         cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
3956                 except EnvironmentError as e:
3957                     raise XAttrMetadataError(e.errno, e.strerror)
3958                 stdout, stderr = p.communicate()
3959                 stderr = stderr.decode('utf-8', 'replace')
3960                 if p.returncode != 0:
3961                     raise XAttrMetadataError(p.returncode, stderr)
3962
3963             else:
3964                 # On Unix, and can't find pyxattr, setfattr, or xattr.
3965                 if sys.platform.startswith('linux'):
3966                     raise XAttrUnavailableError(
3967                         "Couldn't find a tool to set the xattrs. "
3968                         "Install either the python 'pyxattr' or 'xattr' "
3969                         "modules, or the GNU 'attr' package "
3970                         "(which contains the 'setfattr' tool).")
3971                 else:
3972                     raise XAttrUnavailableError(
3973                         "Couldn't find a tool to set the xattrs. "
3974                         "Install either the python 'xattr' module, "
3975                         "or the 'xattr' binary.")
3976
3977
3978 def random_birthday(year_field, month_field, day_field):
3979     start_date = datetime.date(1950, 1, 1)
3980     end_date = datetime.date(1995, 12, 31)
3981     offset = random.randint(0, (end_date - start_date).days)
3982     random_date = start_date + datetime.timedelta(offset)
3983     return {
3984         year_field: str(random_date.year),
3985         month_field: str(random_date.month),
3986         day_field: str(random_date.day),
3987     }