]> gitweb @ CieloNegro.org - youtube-dl.git/blob - youtube_dl/utils.py
release 2014.02.06.2
[youtube-dl.git] / youtube_dl / utils.py
1 #!/usr/bin/env python
2 # -*- coding: utf-8 -*-
3
4 import ctypes
5 import datetime
6 import email.utils
7 import errno
8 import gzip
9 import itertools
10 import io
11 import json
12 import locale
13 import math
14 import os
15 import pipes
16 import platform
17 import re
18 import ssl
19 import socket
20 import subprocess
21 import sys
22 import traceback
23 import zlib
24
25 try:
26     import urllib.request as compat_urllib_request
27 except ImportError: # Python 2
28     import urllib2 as compat_urllib_request
29
30 try:
31     import urllib.error as compat_urllib_error
32 except ImportError: # Python 2
33     import urllib2 as compat_urllib_error
34
35 try:
36     import urllib.parse as compat_urllib_parse
37 except ImportError: # Python 2
38     import urllib as compat_urllib_parse
39
40 try:
41     from urllib.parse import urlparse as compat_urllib_parse_urlparse
42 except ImportError: # Python 2
43     from urlparse import urlparse as compat_urllib_parse_urlparse
44
45 try:
46     import urllib.parse as compat_urlparse
47 except ImportError: # Python 2
48     import urlparse as compat_urlparse
49
50 try:
51     import http.cookiejar as compat_cookiejar
52 except ImportError: # Python 2
53     import cookielib as compat_cookiejar
54
55 try:
56     import html.entities as compat_html_entities
57 except ImportError: # Python 2
58     import htmlentitydefs as compat_html_entities
59
60 try:
61     import html.parser as compat_html_parser
62 except ImportError: # Python 2
63     import HTMLParser as compat_html_parser
64
65 try:
66     import http.client as compat_http_client
67 except ImportError: # Python 2
68     import httplib as compat_http_client
69
70 try:
71     from urllib.error import HTTPError as compat_HTTPError
72 except ImportError:  # Python 2
73     from urllib2 import HTTPError as compat_HTTPError
74
75 try:
76     from urllib.request import urlretrieve as compat_urlretrieve
77 except ImportError:  # Python 2
78     from urllib import urlretrieve as compat_urlretrieve
79
80
81 try:
82     from subprocess import DEVNULL
83     compat_subprocess_get_DEVNULL = lambda: DEVNULL
84 except ImportError:
85     compat_subprocess_get_DEVNULL = lambda: open(os.path.devnull, 'w')
86
87 try:
88     from urllib.parse import parse_qs as compat_parse_qs
89 except ImportError: # Python 2
90     # HACK: The following is the correct parse_qs implementation from cpython 3's stdlib.
91     # Python 2's version is apparently totally broken
92     def _unquote(string, encoding='utf-8', errors='replace'):
93         if string == '':
94             return string
95         res = string.split('%')
96         if len(res) == 1:
97             return string
98         if encoding is None:
99             encoding = 'utf-8'
100         if errors is None:
101             errors = 'replace'
102         # pct_sequence: contiguous sequence of percent-encoded bytes, decoded
103         pct_sequence = b''
104         string = res[0]
105         for item in res[1:]:
106             try:
107                 if not item:
108                     raise ValueError
109                 pct_sequence += item[:2].decode('hex')
110                 rest = item[2:]
111                 if not rest:
112                     # This segment was just a single percent-encoded character.
113                     # May be part of a sequence of code units, so delay decoding.
114                     # (Stored in pct_sequence).
115                     continue
116             except ValueError:
117                 rest = '%' + item
118             # Encountered non-percent-encoded characters. Flush the current
119             # pct_sequence.
120             string += pct_sequence.decode(encoding, errors) + rest
121             pct_sequence = b''
122         if pct_sequence:
123             # Flush the final pct_sequence
124             string += pct_sequence.decode(encoding, errors)
125         return string
126
127     def _parse_qsl(qs, keep_blank_values=False, strict_parsing=False,
128                 encoding='utf-8', errors='replace'):
129         qs, _coerce_result = qs, unicode
130         pairs = [s2 for s1 in qs.split('&') for s2 in s1.split(';')]
131         r = []
132         for name_value in pairs:
133             if not name_value and not strict_parsing:
134                 continue
135             nv = name_value.split('=', 1)
136             if len(nv) != 2:
137                 if strict_parsing:
138                     raise ValueError("bad query field: %r" % (name_value,))
139                 # Handle case of a control-name with no equal sign
140                 if keep_blank_values:
141                     nv.append('')
142                 else:
143                     continue
144             if len(nv[1]) or keep_blank_values:
145                 name = nv[0].replace('+', ' ')
146                 name = _unquote(name, encoding=encoding, errors=errors)
147                 name = _coerce_result(name)
148                 value = nv[1].replace('+', ' ')
149                 value = _unquote(value, encoding=encoding, errors=errors)
150                 value = _coerce_result(value)
151                 r.append((name, value))
152         return r
153
154     def compat_parse_qs(qs, keep_blank_values=False, strict_parsing=False,
155                 encoding='utf-8', errors='replace'):
156         parsed_result = {}
157         pairs = _parse_qsl(qs, keep_blank_values, strict_parsing,
158                         encoding=encoding, errors=errors)
159         for name, value in pairs:
160             if name in parsed_result:
161                 parsed_result[name].append(value)
162             else:
163                 parsed_result[name] = [value]
164         return parsed_result
165
166 try:
167     compat_str = unicode # Python 2
168 except NameError:
169     compat_str = str
170
171 try:
172     compat_chr = unichr # Python 2
173 except NameError:
174     compat_chr = chr
175
176 def compat_ord(c):
177     if type(c) is int: return c
178     else: return ord(c)
179
180 # This is not clearly defined otherwise
181 compiled_regex_type = type(re.compile(''))
182
183 std_headers = {
184     'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:10.0) Gecko/20100101 Firefox/10.0 (Chrome)',
185     'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
186     'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
187     'Accept-Encoding': 'gzip, deflate',
188     'Accept-Language': 'en-us,en;q=0.5',
189 }
190
191 def preferredencoding():
192     """Get preferred encoding.
193
194     Returns the best encoding scheme for the system, based on
195     locale.getpreferredencoding() and some further tweaks.
196     """
197     try:
198         pref = locale.getpreferredencoding()
199         u'TEST'.encode(pref)
200     except:
201         pref = 'UTF-8'
202
203     return pref
204
205 if sys.version_info < (3,0):
206     def compat_print(s):
207         print(s.encode(preferredencoding(), 'xmlcharrefreplace'))
208 else:
209     def compat_print(s):
210         assert type(s) == type(u'')
211         print(s)
212
213 # In Python 2.x, json.dump expects a bytestream.
214 # In Python 3.x, it writes to a character stream
215 if sys.version_info < (3,0):
216     def write_json_file(obj, fn):
217         with open(fn, 'wb') as f:
218             json.dump(obj, f)
219 else:
220     def write_json_file(obj, fn):
221         with open(fn, 'w', encoding='utf-8') as f:
222             json.dump(obj, f)
223
224 if sys.version_info >= (2,7):
225     def find_xpath_attr(node, xpath, key, val):
226         """ Find the xpath xpath[@key=val] """
227         assert re.match(r'^[a-zA-Z]+$', key)
228         assert re.match(r'^[a-zA-Z0-9@\s:._]*$', val)
229         expr = xpath + u"[@%s='%s']" % (key, val)
230         return node.find(expr)
231 else:
232     def find_xpath_attr(node, xpath, key, val):
233         for f in node.findall(xpath):
234             if f.attrib.get(key) == val:
235                 return f
236         return None
237
238 # On python2.6 the xml.etree.ElementTree.Element methods don't support
239 # the namespace parameter
240 def xpath_with_ns(path, ns_map):
241     components = [c.split(':') for c in path.split('/')]
242     replaced = []
243     for c in components:
244         if len(c) == 1:
245             replaced.append(c[0])
246         else:
247             ns, tag = c
248             replaced.append('{%s}%s' % (ns_map[ns], tag))
249     return '/'.join(replaced)
250
251 def htmlentity_transform(matchobj):
252     """Transforms an HTML entity to a character.
253
254     This function receives a match object and is intended to be used with
255     the re.sub() function.
256     """
257     entity = matchobj.group(1)
258
259     # Known non-numeric HTML entity
260     if entity in compat_html_entities.name2codepoint:
261         return compat_chr(compat_html_entities.name2codepoint[entity])
262
263     mobj = re.match(u'(?u)#(x?\\d+)', entity)
264     if mobj is not None:
265         numstr = mobj.group(1)
266         if numstr.startswith(u'x'):
267             base = 16
268             numstr = u'0%s' % numstr
269         else:
270             base = 10
271         return compat_chr(int(numstr, base))
272
273     # Unknown entity in name, return its literal representation
274     return (u'&%s;' % entity)
275
276 compat_html_parser.locatestarttagend = re.compile(r"""<[a-zA-Z][-.a-zA-Z0-9:_]*(?:\s+(?:(?<=['"\s])[^\s/>][^\s/=>]*(?:\s*=+\s*(?:'[^']*'|"[^"]*"|(?!['"])[^>\s]*))?\s*)*)?\s*""", re.VERBOSE) # backport bugfix
277 class BaseHTMLParser(compat_html_parser.HTMLParser):
278     def __init(self):
279         compat_html_parser.HTMLParser.__init__(self)
280         self.html = None
281
282     def loads(self, html):
283         self.html = html
284         self.feed(html)
285         self.close()
286
287 class AttrParser(BaseHTMLParser):
288     """Modified HTMLParser that isolates a tag with the specified attribute"""
289     def __init__(self, attribute, value):
290         self.attribute = attribute
291         self.value = value
292         self.result = None
293         self.started = False
294         self.depth = {}
295         self.watch_startpos = False
296         self.error_count = 0
297         BaseHTMLParser.__init__(self)
298
299     def error(self, message):
300         if self.error_count > 10 or self.started:
301             raise compat_html_parser.HTMLParseError(message, self.getpos())
302         self.rawdata = '\n'.join(self.html.split('\n')[self.getpos()[0]:]) # skip one line
303         self.error_count += 1
304         self.goahead(1)
305
306     def handle_starttag(self, tag, attrs):
307         attrs = dict(attrs)
308         if self.started:
309             self.find_startpos(None)
310         if self.attribute in attrs and attrs[self.attribute] == self.value:
311             self.result = [tag]
312             self.started = True
313             self.watch_startpos = True
314         if self.started:
315             if not tag in self.depth: self.depth[tag] = 0
316             self.depth[tag] += 1
317
318     def handle_endtag(self, tag):
319         if self.started:
320             if tag in self.depth: self.depth[tag] -= 1
321             if self.depth[self.result[0]] == 0:
322                 self.started = False
323                 self.result.append(self.getpos())
324
325     def find_startpos(self, x):
326         """Needed to put the start position of the result (self.result[1])
327         after the opening tag with the requested id"""
328         if self.watch_startpos:
329             self.watch_startpos = False
330             self.result.append(self.getpos())
331     handle_entityref = handle_charref = handle_data = handle_comment = \
332     handle_decl = handle_pi = unknown_decl = find_startpos
333
334     def get_result(self):
335         if self.result is None:
336             return None
337         if len(self.result) != 3:
338             return None
339         lines = self.html.split('\n')
340         lines = lines[self.result[1][0]-1:self.result[2][0]]
341         lines[0] = lines[0][self.result[1][1]:]
342         if len(lines) == 1:
343             lines[-1] = lines[-1][:self.result[2][1]-self.result[1][1]]
344         lines[-1] = lines[-1][:self.result[2][1]]
345         return '\n'.join(lines).strip()
346 # Hack for https://github.com/rg3/youtube-dl/issues/662
347 if sys.version_info < (2, 7, 3):
348     AttrParser.parse_endtag = (lambda self, i:
349         i + len("</scr'+'ipt>")
350         if self.rawdata[i:].startswith("</scr'+'ipt>")
351         else compat_html_parser.HTMLParser.parse_endtag(self, i))
352
353 def get_element_by_id(id, html):
354     """Return the content of the tag with the specified ID in the passed HTML document"""
355     return get_element_by_attribute("id", id, html)
356
357 def get_element_by_attribute(attribute, value, html):
358     """Return the content of the tag with the specified attribute in the passed HTML document"""
359     parser = AttrParser(attribute, value)
360     try:
361         parser.loads(html)
362     except compat_html_parser.HTMLParseError:
363         pass
364     return parser.get_result()
365
366 class MetaParser(BaseHTMLParser):
367     """
368     Modified HTMLParser that isolates a meta tag with the specified name 
369     attribute.
370     """
371     def __init__(self, name):
372         BaseHTMLParser.__init__(self)
373         self.name = name
374         self.content = None
375         self.result = None
376
377     def handle_starttag(self, tag, attrs):
378         if tag != 'meta':
379             return
380         attrs = dict(attrs)
381         if attrs.get('name') == self.name:
382             self.result = attrs.get('content')
383
384     def get_result(self):
385         return self.result
386
387 def get_meta_content(name, html):
388     """
389     Return the content attribute from the meta tag with the given name attribute.
390     """
391     parser = MetaParser(name)
392     try:
393         parser.loads(html)
394     except compat_html_parser.HTMLParseError:
395         pass
396     return parser.get_result()
397
398
399 def clean_html(html):
400     """Clean an HTML snippet into a readable string"""
401     # Newline vs <br />
402     html = html.replace('\n', ' ')
403     html = re.sub(r'\s*<\s*br\s*/?\s*>\s*', '\n', html)
404     html = re.sub(r'<\s*/\s*p\s*>\s*<\s*p[^>]*>', '\n', html)
405     # Strip html tags
406     html = re.sub('<.*?>', '', html)
407     # Replace html entities
408     html = unescapeHTML(html)
409     return html.strip()
410
411
412 def sanitize_open(filename, open_mode):
413     """Try to open the given filename, and slightly tweak it if this fails.
414
415     Attempts to open the given filename. If this fails, it tries to change
416     the filename slightly, step by step, until it's either able to open it
417     or it fails and raises a final exception, like the standard open()
418     function.
419
420     It returns the tuple (stream, definitive_file_name).
421     """
422     try:
423         if filename == u'-':
424             if sys.platform == 'win32':
425                 import msvcrt
426                 msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
427             return (sys.stdout.buffer if hasattr(sys.stdout, 'buffer') else sys.stdout, filename)
428         stream = open(encodeFilename(filename), open_mode)
429         return (stream, filename)
430     except (IOError, OSError) as err:
431         if err.errno in (errno.EACCES,):
432             raise
433
434         # In case of error, try to remove win32 forbidden chars
435         alt_filename = os.path.join(
436                         re.sub(u'[/<>:"\\|\\\\?\\*]', u'#', path_part)
437                         for path_part in os.path.split(filename)
438                        )
439         if alt_filename == filename:
440             raise
441         else:
442             # An exception here should be caught in the caller
443             stream = open(encodeFilename(filename), open_mode)
444             return (stream, alt_filename)
445
446
447 def timeconvert(timestr):
448     """Convert RFC 2822 defined time string into system timestamp"""
449     timestamp = None
450     timetuple = email.utils.parsedate_tz(timestr)
451     if timetuple is not None:
452         timestamp = email.utils.mktime_tz(timetuple)
453     return timestamp
454
455 def sanitize_filename(s, restricted=False, is_id=False):
456     """Sanitizes a string so it could be used as part of a filename.
457     If restricted is set, use a stricter subset of allowed characters.
458     Set is_id if this is not an arbitrary string, but an ID that should be kept if possible
459     """
460     def replace_insane(char):
461         if char == '?' or ord(char) < 32 or ord(char) == 127:
462             return ''
463         elif char == '"':
464             return '' if restricted else '\''
465         elif char == ':':
466             return '_-' if restricted else ' -'
467         elif char in '\\/|*<>':
468             return '_'
469         if restricted and (char in '!&\'()[]{}$;`^,#' or char.isspace()):
470             return '_'
471         if restricted and ord(char) > 127:
472             return '_'
473         return char
474
475     result = u''.join(map(replace_insane, s))
476     if not is_id:
477         while '__' in result:
478             result = result.replace('__', '_')
479         result = result.strip('_')
480         # Common case of "Foreign band name - English song title"
481         if restricted and result.startswith('-_'):
482             result = result[2:]
483         if not result:
484             result = '_'
485     return result
486
487 def orderedSet(iterable):
488     """ Remove all duplicates from the input iterable """
489     res = []
490     for el in iterable:
491         if el not in res:
492             res.append(el)
493     return res
494
495 def unescapeHTML(s):
496     """
497     @param s a string
498     """
499     assert type(s) == type(u'')
500
501     result = re.sub(u'(?u)&(.+?);', htmlentity_transform, s)
502     return result
503
504
505 def encodeFilename(s, for_subprocess=False):
506     """
507     @param s The name of the file
508     """
509
510     assert type(s) == compat_str
511
512     # Python 3 has a Unicode API
513     if sys.version_info >= (3, 0):
514         return s
515
516     if sys.platform == 'win32' and sys.getwindowsversion()[0] >= 5:
517         # Pass u'' directly to use Unicode APIs on Windows 2000 and up
518         # (Detecting Windows NT 4 is tricky because 'major >= 4' would
519         # match Windows 9x series as well. Besides, NT 4 is obsolete.)
520         if not for_subprocess:
521             return s
522         else:
523             # For subprocess calls, encode with locale encoding
524             # Refer to http://stackoverflow.com/a/9951851/35070
525             encoding = preferredencoding()
526     else:
527         encoding = sys.getfilesystemencoding()
528     if encoding is None:
529         encoding = 'utf-8'
530     return s.encode(encoding, 'ignore')
531
532
533 def decodeOption(optval):
534     if optval is None:
535         return optval
536     if isinstance(optval, bytes):
537         optval = optval.decode(preferredencoding())
538
539     assert isinstance(optval, compat_str)
540     return optval
541
542 def formatSeconds(secs):
543     if secs > 3600:
544         return '%d:%02d:%02d' % (secs // 3600, (secs % 3600) // 60, secs % 60)
545     elif secs > 60:
546         return '%d:%02d' % (secs // 60, secs % 60)
547     else:
548         return '%d' % secs
549
550
551 def make_HTTPS_handler(opts_no_check_certificate, **kwargs):
552     if sys.version_info < (3, 2):
553         import httplib
554
555         class HTTPSConnectionV3(httplib.HTTPSConnection):
556             def __init__(self, *args, **kwargs):
557                 httplib.HTTPSConnection.__init__(self, *args, **kwargs)
558
559             def connect(self):
560                 sock = socket.create_connection((self.host, self.port), self.timeout)
561                 if getattr(self, '_tunnel_host', False):
562                     self.sock = sock
563                     self._tunnel()
564                 try:
565                     self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file, ssl_version=ssl.PROTOCOL_SSLv3)
566                 except ssl.SSLError:
567                     self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file, ssl_version=ssl.PROTOCOL_SSLv23)
568
569         class HTTPSHandlerV3(compat_urllib_request.HTTPSHandler):
570             def https_open(self, req):
571                 return self.do_open(HTTPSConnectionV3, req)
572         return HTTPSHandlerV3(**kwargs)
573     else:
574         context = ssl.SSLContext(ssl.PROTOCOL_SSLv3)
575         context.verify_mode = (ssl.CERT_NONE
576                                if opts_no_check_certificate
577                                else ssl.CERT_REQUIRED)
578         context.set_default_verify_paths()
579         try:
580             context.load_default_certs()
581         except AttributeError:
582             pass  # Python < 3.4
583         return compat_urllib_request.HTTPSHandler(context=context, **kwargs)
584
585 class ExtractorError(Exception):
586     """Error during info extraction."""
587     def __init__(self, msg, tb=None, expected=False, cause=None):
588         """ tb, if given, is the original traceback (so that it can be printed out).
589         If expected is set, this is a normal error message and most likely not a bug in youtube-dl.
590         """
591
592         if sys.exc_info()[0] in (compat_urllib_error.URLError, socket.timeout, UnavailableVideoError):
593             expected = True
594         if not expected:
595             msg = msg + u'; please report this issue on https://yt-dl.org/bug . Be sure to call youtube-dl with the --verbose flag and include its complete output. Make sure you are using the latest version; type  youtube-dl -U  to update.'
596         super(ExtractorError, self).__init__(msg)
597
598         self.traceback = tb
599         self.exc_info = sys.exc_info()  # preserve original exception
600         self.cause = cause
601
602     def format_traceback(self):
603         if self.traceback is None:
604             return None
605         return u''.join(traceback.format_tb(self.traceback))
606
607
608 class RegexNotFoundError(ExtractorError):
609     """Error when a regex didn't match"""
610     pass
611
612
613 class DownloadError(Exception):
614     """Download Error exception.
615
616     This exception may be thrown by FileDownloader objects if they are not
617     configured to continue on errors. They will contain the appropriate
618     error message.
619     """
620     def __init__(self, msg, exc_info=None):
621         """ exc_info, if given, is the original exception that caused the trouble (as returned by sys.exc_info()). """
622         super(DownloadError, self).__init__(msg)
623         self.exc_info = exc_info
624
625
626 class SameFileError(Exception):
627     """Same File exception.
628
629     This exception will be thrown by FileDownloader objects if they detect
630     multiple files would have to be downloaded to the same file on disk.
631     """
632     pass
633
634
635 class PostProcessingError(Exception):
636     """Post Processing exception.
637
638     This exception may be raised by PostProcessor's .run() method to
639     indicate an error in the postprocessing task.
640     """
641     def __init__(self, msg):
642         self.msg = msg
643
644 class MaxDownloadsReached(Exception):
645     """ --max-downloads limit has been reached. """
646     pass
647
648
649 class UnavailableVideoError(Exception):
650     """Unavailable Format exception.
651
652     This exception will be thrown when a video is requested
653     in a format that is not available for that video.
654     """
655     pass
656
657
658 class ContentTooShortError(Exception):
659     """Content Too Short exception.
660
661     This exception may be raised by FileDownloader objects when a file they
662     download is too small for what the server announced first, indicating
663     the connection was probably interrupted.
664     """
665     # Both in bytes
666     downloaded = None
667     expected = None
668
669     def __init__(self, downloaded, expected):
670         self.downloaded = downloaded
671         self.expected = expected
672
673 class YoutubeDLHandler(compat_urllib_request.HTTPHandler):
674     """Handler for HTTP requests and responses.
675
676     This class, when installed with an OpenerDirector, automatically adds
677     the standard headers to every HTTP request and handles gzipped and
678     deflated responses from web servers. If compression is to be avoided in
679     a particular request, the original request in the program code only has
680     to include the HTTP header "Youtubedl-No-Compression", which will be
681     removed before making the real request.
682
683     Part of this code was copied from:
684
685     http://techknack.net/python-urllib2-handlers/
686
687     Andrew Rowls, the author of that code, agreed to release it to the
688     public domain.
689     """
690
691     @staticmethod
692     def deflate(data):
693         try:
694             return zlib.decompress(data, -zlib.MAX_WBITS)
695         except zlib.error:
696             return zlib.decompress(data)
697
698     @staticmethod
699     def addinfourl_wrapper(stream, headers, url, code):
700         if hasattr(compat_urllib_request.addinfourl, 'getcode'):
701             return compat_urllib_request.addinfourl(stream, headers, url, code)
702         ret = compat_urllib_request.addinfourl(stream, headers, url)
703         ret.code = code
704         return ret
705
706     def http_request(self, req):
707         for h,v in std_headers.items():
708             if h in req.headers:
709                 del req.headers[h]
710             req.add_header(h, v)
711         if 'Youtubedl-no-compression' in req.headers:
712             if 'Accept-encoding' in req.headers:
713                 del req.headers['Accept-encoding']
714             del req.headers['Youtubedl-no-compression']
715         if 'Youtubedl-user-agent' in req.headers:
716             if 'User-agent' in req.headers:
717                 del req.headers['User-agent']
718             req.headers['User-agent'] = req.headers['Youtubedl-user-agent']
719             del req.headers['Youtubedl-user-agent']
720         return req
721
722     def http_response(self, req, resp):
723         old_resp = resp
724         # gzip
725         if resp.headers.get('Content-encoding', '') == 'gzip':
726             content = resp.read()
727             gz = gzip.GzipFile(fileobj=io.BytesIO(content), mode='rb')
728             try:
729                 uncompressed = io.BytesIO(gz.read())
730             except IOError as original_ioerror:
731                 # There may be junk add the end of the file
732                 # See http://stackoverflow.com/q/4928560/35070 for details
733                 for i in range(1, 1024):
734                     try:
735                         gz = gzip.GzipFile(fileobj=io.BytesIO(content[:-i]), mode='rb')
736                         uncompressed = io.BytesIO(gz.read())
737                     except IOError:
738                         continue
739                     break
740                 else:
741                     raise original_ioerror
742             resp = self.addinfourl_wrapper(uncompressed, old_resp.headers, old_resp.url, old_resp.code)
743             resp.msg = old_resp.msg
744         # deflate
745         if resp.headers.get('Content-encoding', '') == 'deflate':
746             gz = io.BytesIO(self.deflate(resp.read()))
747             resp = self.addinfourl_wrapper(gz, old_resp.headers, old_resp.url, old_resp.code)
748             resp.msg = old_resp.msg
749         return resp
750
751     https_request = http_request
752     https_response = http_response
753
754
755 def unified_strdate(date_str):
756     """Return a string with the date in the format YYYYMMDD"""
757     upload_date = None
758     #Replace commas
759     date_str = date_str.replace(',',' ')
760     # %z (UTC offset) is only supported in python>=3.2
761     date_str = re.sub(r' ?(\+|-)[0-9:]*$', '', date_str)
762     format_expressions = [
763         '%d %B %Y',
764         '%B %d %Y',
765         '%b %d %Y',
766         '%Y-%m-%d',
767         '%d/%m/%Y',
768         '%Y/%m/%d %H:%M:%S',
769         '%Y-%m-%d %H:%M:%S',
770         '%d.%m.%Y %H:%M',
771         '%Y-%m-%dT%H:%M:%SZ',
772         '%Y-%m-%dT%H:%M:%S.%fZ',
773         '%Y-%m-%dT%H:%M:%S.%f0Z',
774         '%Y-%m-%dT%H:%M:%S',
775         '%Y-%m-%dT%H:%M',
776     ]
777     for expression in format_expressions:
778         try:
779             upload_date = datetime.datetime.strptime(date_str, expression).strftime('%Y%m%d')
780         except ValueError:
781             pass
782     if upload_date is None:
783         timetuple = email.utils.parsedate_tz(date_str)
784         if timetuple:
785             upload_date = datetime.datetime(*timetuple[:6]).strftime('%Y%m%d')
786     return upload_date
787
788 def determine_ext(url, default_ext=u'unknown_video'):
789     guess = url.partition(u'?')[0].rpartition(u'.')[2]
790     if re.match(r'^[A-Za-z0-9]+$', guess):
791         return guess
792     else:
793         return default_ext
794
795 def subtitles_filename(filename, sub_lang, sub_format):
796     return filename.rsplit('.', 1)[0] + u'.' + sub_lang + u'.' + sub_format
797
798 def date_from_str(date_str):
799     """
800     Return a datetime object from a string in the format YYYYMMDD or
801     (now|today)[+-][0-9](day|week|month|year)(s)?"""
802     today = datetime.date.today()
803     if date_str == 'now'or date_str == 'today':
804         return today
805     match = re.match('(now|today)(?P<sign>[+-])(?P<time>\d+)(?P<unit>day|week|month|year)(s)?', date_str)
806     if match is not None:
807         sign = match.group('sign')
808         time = int(match.group('time'))
809         if sign == '-':
810             time = -time
811         unit = match.group('unit')
812         #A bad aproximation?
813         if unit == 'month':
814             unit = 'day'
815             time *= 30
816         elif unit == 'year':
817             unit = 'day'
818             time *= 365
819         unit += 's'
820         delta = datetime.timedelta(**{unit: time})
821         return today + delta
822     return datetime.datetime.strptime(date_str, "%Y%m%d").date()
823     
824 def hyphenate_date(date_str):
825     """
826     Convert a date in 'YYYYMMDD' format to 'YYYY-MM-DD' format"""
827     match = re.match(r'^(\d\d\d\d)(\d\d)(\d\d)$', date_str)
828     if match is not None:
829         return '-'.join(match.groups())
830     else:
831         return date_str
832
833 class DateRange(object):
834     """Represents a time interval between two dates"""
835     def __init__(self, start=None, end=None):
836         """start and end must be strings in the format accepted by date"""
837         if start is not None:
838             self.start = date_from_str(start)
839         else:
840             self.start = datetime.datetime.min.date()
841         if end is not None:
842             self.end = date_from_str(end)
843         else:
844             self.end = datetime.datetime.max.date()
845         if self.start > self.end:
846             raise ValueError('Date range: "%s" , the start date must be before the end date' % self)
847     @classmethod
848     def day(cls, day):
849         """Returns a range that only contains the given day"""
850         return cls(day,day)
851     def __contains__(self, date):
852         """Check if the date is in the range"""
853         if not isinstance(date, datetime.date):
854             date = date_from_str(date)
855         return self.start <= date <= self.end
856     def __str__(self):
857         return '%s - %s' % ( self.start.isoformat(), self.end.isoformat())
858
859
860 def platform_name():
861     """ Returns the platform name as a compat_str """
862     res = platform.platform()
863     if isinstance(res, bytes):
864         res = res.decode(preferredencoding())
865
866     assert isinstance(res, compat_str)
867     return res
868
869
870 def write_string(s, out=None):
871     if out is None:
872         out = sys.stderr
873     assert type(s) == compat_str
874
875     if ('b' in getattr(out, 'mode', '') or
876             sys.version_info[0] < 3):  # Python 2 lies about mode of sys.stderr
877         s = s.encode(preferredencoding(), 'ignore')
878     try:
879         out.write(s)
880     except UnicodeEncodeError:
881         # In Windows shells, this can fail even when the codec is just charmap!?
882         # See https://wiki.python.org/moin/PrintFails#Issue
883         if sys.platform == 'win32' and hasattr(out, 'encoding'):
884             s = s.encode(out.encoding, 'ignore').decode(out.encoding)
885             out.write(s)
886         else:
887             raise
888
889     out.flush()
890
891
892 def bytes_to_intlist(bs):
893     if not bs:
894         return []
895     if isinstance(bs[0], int):  # Python 3
896         return list(bs)
897     else:
898         return [ord(c) for c in bs]
899
900
901 def intlist_to_bytes(xs):
902     if not xs:
903         return b''
904     if isinstance(chr(0), bytes):  # Python 2
905         return ''.join([chr(x) for x in xs])
906     else:
907         return bytes(xs)
908
909
910 def get_cachedir(params={}):
911     cache_root = os.environ.get('XDG_CACHE_HOME',
912                                 os.path.expanduser('~/.cache'))
913     return params.get('cachedir', os.path.join(cache_root, 'youtube-dl'))
914
915
916 # Cross-platform file locking
917 if sys.platform == 'win32':
918     import ctypes.wintypes
919     import msvcrt
920
921     class OVERLAPPED(ctypes.Structure):
922         _fields_ = [
923             ('Internal', ctypes.wintypes.LPVOID),
924             ('InternalHigh', ctypes.wintypes.LPVOID),
925             ('Offset', ctypes.wintypes.DWORD),
926             ('OffsetHigh', ctypes.wintypes.DWORD),
927             ('hEvent', ctypes.wintypes.HANDLE),
928         ]
929
930     kernel32 = ctypes.windll.kernel32
931     LockFileEx = kernel32.LockFileEx
932     LockFileEx.argtypes = [
933         ctypes.wintypes.HANDLE,     # hFile
934         ctypes.wintypes.DWORD,      # dwFlags
935         ctypes.wintypes.DWORD,      # dwReserved
936         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockLow
937         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockHigh
938         ctypes.POINTER(OVERLAPPED)  # Overlapped
939     ]
940     LockFileEx.restype = ctypes.wintypes.BOOL
941     UnlockFileEx = kernel32.UnlockFileEx
942     UnlockFileEx.argtypes = [
943         ctypes.wintypes.HANDLE,     # hFile
944         ctypes.wintypes.DWORD,      # dwReserved
945         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockLow
946         ctypes.wintypes.DWORD,      # nNumberOfBytesToLockHigh
947         ctypes.POINTER(OVERLAPPED)  # Overlapped
948     ]
949     UnlockFileEx.restype = ctypes.wintypes.BOOL
950     whole_low = 0xffffffff
951     whole_high = 0x7fffffff
952
953     def _lock_file(f, exclusive):
954         overlapped = OVERLAPPED()
955         overlapped.Offset = 0
956         overlapped.OffsetHigh = 0
957         overlapped.hEvent = 0
958         f._lock_file_overlapped_p = ctypes.pointer(overlapped)
959         handle = msvcrt.get_osfhandle(f.fileno())
960         if not LockFileEx(handle, 0x2 if exclusive else 0x0, 0,
961                           whole_low, whole_high, f._lock_file_overlapped_p):
962             raise OSError('Locking file failed: %r' % ctypes.FormatError())
963
964     def _unlock_file(f):
965         assert f._lock_file_overlapped_p
966         handle = msvcrt.get_osfhandle(f.fileno())
967         if not UnlockFileEx(handle, 0,
968                             whole_low, whole_high, f._lock_file_overlapped_p):
969             raise OSError('Unlocking file failed: %r' % ctypes.FormatError())
970
971 else:
972     import fcntl
973
974     def _lock_file(f, exclusive):
975         fcntl.lockf(f, fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH)
976
977     def _unlock_file(f):
978         fcntl.lockf(f, fcntl.LOCK_UN)
979
980
981 class locked_file(object):
982     def __init__(self, filename, mode, encoding=None):
983         assert mode in ['r', 'a', 'w']
984         self.f = io.open(filename, mode, encoding=encoding)
985         self.mode = mode
986
987     def __enter__(self):
988         exclusive = self.mode != 'r'
989         try:
990             _lock_file(self.f, exclusive)
991         except IOError:
992             self.f.close()
993             raise
994         return self
995
996     def __exit__(self, etype, value, traceback):
997         try:
998             _unlock_file(self.f)
999         finally:
1000             self.f.close()
1001
1002     def __iter__(self):
1003         return iter(self.f)
1004
1005     def write(self, *args):
1006         return self.f.write(*args)
1007
1008     def read(self, *args):
1009         return self.f.read(*args)
1010
1011
1012 def shell_quote(args):
1013     quoted_args = []
1014     encoding = sys.getfilesystemencoding()
1015     if encoding is None:
1016         encoding = 'utf-8'
1017     for a in args:
1018         if isinstance(a, bytes):
1019             # We may get a filename encoded with 'encodeFilename'
1020             a = a.decode(encoding)
1021         quoted_args.append(pipes.quote(a))
1022     return u' '.join(quoted_args)
1023
1024
1025 def takewhile_inclusive(pred, seq):
1026     """ Like itertools.takewhile, but include the latest evaluated element
1027         (the first element so that Not pred(e)) """
1028     for e in seq:
1029         yield e
1030         if not pred(e):
1031             return
1032
1033
1034 def smuggle_url(url, data):
1035     """ Pass additional data in a URL for internal use. """
1036
1037     sdata = compat_urllib_parse.urlencode(
1038         {u'__youtubedl_smuggle': json.dumps(data)})
1039     return url + u'#' + sdata
1040
1041
1042 def unsmuggle_url(smug_url, default=None):
1043     if not '#__youtubedl_smuggle' in smug_url:
1044         return smug_url, default
1045     url, _, sdata = smug_url.rpartition(u'#')
1046     jsond = compat_parse_qs(sdata)[u'__youtubedl_smuggle'][0]
1047     data = json.loads(jsond)
1048     return url, data
1049
1050
1051 def format_bytes(bytes):
1052     if bytes is None:
1053         return u'N/A'
1054     if type(bytes) is str:
1055         bytes = float(bytes)
1056     if bytes == 0.0:
1057         exponent = 0
1058     else:
1059         exponent = int(math.log(bytes, 1024.0))
1060     suffix = [u'B', u'KiB', u'MiB', u'GiB', u'TiB', u'PiB', u'EiB', u'ZiB', u'YiB'][exponent]
1061     converted = float(bytes) / float(1024 ** exponent)
1062     return u'%.2f%s' % (converted, suffix)
1063
1064
1065 def str_to_int(int_str):
1066     int_str = re.sub(r'[,\.]', u'', int_str)
1067     return int(int_str)
1068
1069
1070 def get_term_width():
1071     columns = os.environ.get('COLUMNS', None)
1072     if columns:
1073         return int(columns)
1074
1075     try:
1076         sp = subprocess.Popen(
1077             ['stty', 'size'],
1078             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
1079         out, err = sp.communicate()
1080         return int(out.split()[1])
1081     except:
1082         pass
1083     return None
1084
1085
1086 def month_by_name(name):
1087     """ Return the number of a month by (locale-independently) English name """
1088
1089     ENGLISH_NAMES = [
1090         u'January', u'February', u'March', u'April', u'May', u'June',
1091         u'July', u'August', u'September', u'October', u'November', u'December']
1092     try:
1093         return ENGLISH_NAMES.index(name) + 1
1094     except ValueError:
1095         return None
1096
1097
1098 def fix_xml_ampersands(xml_str):
1099     """Replace all the '&' by '&amp;' in XML"""
1100     return re.sub(
1101         r'&(?!amp;|lt;|gt;|apos;|quot;|#x[0-9a-fA-F]{,4};|#[0-9]{,4};)',
1102         u'&amp;',
1103         xml_str)
1104
1105
1106 def setproctitle(title):
1107     assert isinstance(title, compat_str)
1108     try:
1109         libc = ctypes.cdll.LoadLibrary("libc.so.6")
1110     except OSError:
1111         return
1112     title = title
1113     buf = ctypes.create_string_buffer(len(title) + 1)
1114     buf.value = title.encode('utf-8')
1115     try:
1116         libc.prctl(15, ctypes.byref(buf), 0, 0, 0)
1117     except AttributeError:
1118         return  # Strange libc, just skip this
1119
1120
1121 def remove_start(s, start):
1122     if s.startswith(start):
1123         return s[len(start):]
1124     return s
1125
1126
1127 def url_basename(url):
1128     path = compat_urlparse.urlparse(url).path
1129     return path.strip(u'/').split(u'/')[-1]
1130
1131
1132 class HEADRequest(compat_urllib_request.Request):
1133     def get_method(self):
1134         return "HEAD"
1135
1136
1137 def int_or_none(v, scale=1):
1138     return v if v is None else (int(v) // scale)
1139
1140
1141 def parse_duration(s):
1142     if s is None:
1143         return None
1144
1145     m = re.match(
1146         r'(?:(?:(?P<hours>[0-9]+):)?(?P<mins>[0-9]+):)?(?P<secs>[0-9]+)$', s)
1147     if not m:
1148         return None
1149     res = int(m.group('secs'))
1150     if m.group('mins'):
1151         res += int(m.group('mins')) * 60
1152         if m.group('hours'):
1153             res += int(m.group('hours')) * 60 * 60
1154     return res
1155
1156
1157 def prepend_extension(filename, ext):
1158     name, real_ext = os.path.splitext(filename) 
1159     return u'{0}.{1}{2}'.format(name, ext, real_ext)
1160
1161
1162 def check_executable(exe, args=[]):
1163     """ Checks if the given binary is installed somewhere in PATH, and returns its name.
1164     args can be a list of arguments for a short output (like -version) """
1165     try:
1166         subprocess.Popen([exe] + args, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
1167     except OSError:
1168         return False
1169     return exe
1170
1171
1172 class PagedList(object):
1173     def __init__(self, pagefunc, pagesize):
1174         self._pagefunc = pagefunc
1175         self._pagesize = pagesize
1176
1177     def __len__(self):
1178         # This is only useful for tests
1179         return len(self.getslice())
1180
1181     def getslice(self, start=0, end=None):
1182         res = []
1183         for pagenum in itertools.count(start // self._pagesize):
1184             firstid = pagenum * self._pagesize
1185             nextfirstid = pagenum * self._pagesize + self._pagesize
1186             if start >= nextfirstid:
1187                 continue
1188
1189             page_results = list(self._pagefunc(pagenum))
1190
1191             startv = (
1192                 start % self._pagesize
1193                 if firstid <= start < nextfirstid
1194                 else 0)
1195
1196             endv = (
1197                 ((end - 1) % self._pagesize) + 1
1198                 if (end is not None and firstid <= end <= nextfirstid)
1199                 else None)
1200
1201             if startv != 0 or endv is not None:
1202                 page_results = page_results[startv:endv]
1203             res.extend(page_results)
1204
1205             # A little optimization - if current page is not "full", ie. does
1206             # not contain page_size videos then we can assume that this page
1207             # is the last one - there are no more ids on further pages -
1208             # i.e. no need to query again.
1209             if len(page_results) + startv < self._pagesize:
1210                 break
1211
1212             # If we got the whole page, but the next page is not interesting,
1213             # break out early as well
1214             if end == nextfirstid:
1215                 break
1216         return res