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