logo

youtube-dl

[mirror] Download/Watch videos from video hostersgit clone https://hacktivis.me/git/mirror/youtube-dl.git

helper.py (11415B)

    

  1. from __future__ import unicode_literals
  3. import errno
  4. import hashlib
  5. import json
  6. import os.path
  7. import re
  8. import types
  9. import ssl
  10. import sys
  11. import unittest
  13. import youtube_dl.extractor
  14. from youtube_dl import YoutubeDL
  15. from youtube_dl.compat import (
  16.     compat_open as open,
  17.     compat_os_name,
  18.     compat_str,
  19. )
  20. from youtube_dl.utils import (
  21.     IDENTITY,
  22.     preferredencoding,
  23.     write_string,
  24. )
  27. def get_params(override=None):
  28.     PARAMETERS_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)),
  29.                                    "parameters.json")
  30.     LOCAL_PARAMETERS_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)),
  31.                                          "local_parameters.json")
  32.     with open(PARAMETERS_FILE, encoding='utf-8') as pf:
  33.         parameters = json.load(pf)
  34.     if os.path.exists(LOCAL_PARAMETERS_FILE):
  35.         with open(LOCAL_PARAMETERS_FILE, encoding='utf-8') as pf:
  36.             parameters.update(json.load(pf))
  37.     if override:
  38.         parameters.update(override)
  39.     return parameters
  42. def try_rm(filename):
  43.     """ Remove a file if it exists """
  44.     try:
  45.         os.remove(filename)
  46.     except OSError as ose:
  47.         if ose.errno != errno.ENOENT:
  48.             raise
  51. def report_warning(message):
  52.     '''
  53.     Print the message to stderr, it will be prefixed with 'WARNING:'
  54.     If stderr is a tty file the 'WARNING:' will be colored
  55.     '''
  56.     if sys.stderr.isatty() and compat_os_name != 'nt':
  57.         _msg_header = '\033[0;33mWARNING:\033[0m'
  58.     else:
  59.         _msg_header = 'WARNING:'
  60.     output = '%s %s\n' % (_msg_header, message)
  61.     if 'b' in getattr(sys.stderr, 'mode', '') or sys.version_info[0] < 3:
  62.         output = output.encode(preferredencoding())
  63.     sys.stderr.write(output)
  66. class FakeYDL(YoutubeDL):
  67.     def __init__(self, override=None):
  68.         # Different instances of the downloader can't share the same dictionary
  69.         # some test set the "sublang" parameter, which would break the md5 checks.
  70.         params = get_params(override=override)
  71.         super(FakeYDL, self).__init__(params, auto_init=False)
  72.         self.result = []
  74.     def to_screen(self, s, skip_eol=None):
  75.         print(s)
  77.     def trouble(self, *args, **kwargs):
  78.         s = args[0] if len(args) > 0 else kwargs.get('message', 'Missing message')
  79.         raise Exception(s)
  81.     def download(self, x):
  82.         self.result.append(x)
  84.     def expect_warning(self, regex):
  85.         # Silence an expected warning matching a regex
  86.         old_report_warning = self.report_warning
  88.         def report_warning(self, message):
  89.             if re.match(regex, message):
  90.                 return
  91.             old_report_warning(message)
  92.         self.report_warning = types.MethodType(report_warning, self)
  95. class FakeLogger(object):
  96.     def debug(self, msg):
  97.         pass
  99.     def warning(self, msg):
  100.         pass
  102.     def error(self, msg):
  103.         pass
  106. def gettestcases(include_onlymatching=False):
  107.     for ie in youtube_dl.extractor.gen_extractors():
  108.         for tc in ie.get_testcases(include_onlymatching):
  109.             yield tc
  112. md5 = lambda s: hashlib.md5(s.encode('utf-8')).hexdigest()
  115. def expect_value(self, got, expected, field):
  116.     if isinstance(expected, compat_str) and expected.startswith('re:'):
  117.         match_str = expected[len('re:'):]
  118.         match_rex = re.compile(match_str)
  120.         self.assertTrue(
  121.             isinstance(got, compat_str),
  122.             'Expected a %s object, but got %s for field %s' % (
  123.                 compat_str.__name__, type(got).__name__, field))
  124.         self.assertTrue(
  125.             match_rex.match(got),
  126.             'field %s (value: %r) should match %r' % (field, got, match_str))
  127.     elif isinstance(expected, compat_str) and expected.startswith('startswith:'):
  128.         start_str = expected[len('startswith:'):]
  129.         self.assertTrue(
  130.             isinstance(got, compat_str),
  131.             'Expected a %s object, but got %s for field %s' % (
  132.                 compat_str.__name__, type(got).__name__, field))
  133.         self.assertTrue(
  134.             got.startswith(start_str),
  135.             'field %s (value: %r) should start with %r' % (field, got, start_str))
  136.     elif isinstance(expected, compat_str) and expected.startswith('contains:'):
  137.         contains_str = expected[len('contains:'):]
  138.         self.assertTrue(
  139.             isinstance(got, compat_str),
  140.             'Expected a %s object, but got %s for field %s' % (
  141.                 compat_str.__name__, type(got).__name__, field))
  142.         self.assertTrue(
  143.             contains_str in got,
  144.             'field %s (value: %r) should contain %r' % (field, got, contains_str))
  145.     elif isinstance(expected, compat_str) and re.match(r'lambda \w+:', expected):
  146.         fn = eval(expected)
  147.         suite = expected.split(':', 1)[1].strip()
  148.         self.assertTrue(
  149.             fn(got),
  150.             'Expected field %s to meet condition %s, but value %r failed ' % (field, suite, got))
  151.     elif isinstance(expected, type):
  152.         self.assertTrue(
  153.             isinstance(got, expected),
  154.             'Expected type %r for field %s, but got value %r of type %r' % (expected, field, got, type(got)))
  155.     elif isinstance(expected, dict) and isinstance(got, dict):
  156.         expect_dict(self, got, expected)
  157.     elif isinstance(expected, list) and isinstance(got, list):
  158.         self.assertEqual(
  159.             len(expected), len(got),
  160.             'Expected a list of length %d, but got a list of length %d for field %s' % (
  161.                 len(expected), len(got), field))
  162.         for index, (item_got, item_expected) in enumerate(zip(got, expected)):
  163.             type_got = type(item_got)
  164.             type_expected = type(item_expected)
  165.             self.assertEqual(
  166.                 type_expected, type_got,
  167.                 'Type mismatch for list item at index %d for field %s, expected %r, got %r' % (
  168.                     index, field, type_expected, type_got))
  169.             expect_value(self, item_got, item_expected, field)
  170.     else:
  171.         if isinstance(expected, compat_str) and expected.startswith('md5:'):
  172.             self.assertTrue(
  173.                 isinstance(got, compat_str),
  174.                 'Expected field %s to be a unicode object, but got value %r of type %r' % (field, got, type(got)))
  175.             got = 'md5:' + md5(got)
  176.         elif isinstance(expected, compat_str) and re.match(r'^(?:min|max)?count:\d+', expected):
  177.             self.assertTrue(
  178.                 isinstance(got, (list, dict)),
  179.                 'Expected field %s to be a list or a dict, but it is of type %s' % (
  180.                     field, type(got).__name__))
  181.             op, _, expected_num = expected.partition(':')
  182.             expected_num = int(expected_num)
  183.             if op == 'mincount':
  184.                 assert_func = assertGreaterEqual
  185.                 msg_tmpl = 'Expected %d items in field %s, but only got %d'
  186.             elif op == 'maxcount':
  187.                 assert_func = assertLessEqual
  188.                 msg_tmpl = 'Expected maximum %d items in field %s, but got %d'
  189.             elif op == 'count':
  190.                 assert_func = assertEqual
  191.                 msg_tmpl = 'Expected exactly %d items in field %s, but got %d'
  192.             else:
  193.                 assert False
  194.             assert_func(
  195.                 self, len(got), expected_num,
  196.                 msg_tmpl % (expected_num, field, len(got)))
  197.             return
  198.         self.assertEqual(
  199.             expected, got,
  200.             'Invalid value for field %s, expected %r, got %r' % (field, expected, got))
  203. def expect_dict(self, got_dict, expected_dict):
  204.     for info_field, expected in expected_dict.items():
  205.         got = got_dict.get(info_field)
  206.         expect_value(self, got, expected, info_field)
  209. def expect_info_dict(self, got_dict, expected_dict):
  210.     expect_dict(self, got_dict, expected_dict)
  211.     # Check for the presence of mandatory fields
  212.     if got_dict.get('_type') not in ('playlist', 'multi_video'):
  213.         for key in ('id', 'url', 'title', 'ext'):
  214.             self.assertTrue(got_dict.get(key), 'Missing mandatory field %s' % key)
  215.     # Check for mandatory fields that are automatically set by YoutubeDL
  216.     for key in ['webpage_url', 'extractor', 'extractor_key']:
  217.         self.assertTrue(got_dict.get(key), 'Missing field: %s' % key)
  219.     # Are checkable fields missing from the test case definition?
  220.     test_info_dict = dict((key, value if not isinstance(value, compat_str) or len(value) < 250 else 'md5:' + md5(value))
  221.                           for key, value in got_dict.items()
  222.                           if value and key in ('id', 'title', 'description', 'uploader', 'upload_date', 'timestamp', 'uploader_id', 'location', 'age_limit'))
  223.     missing_keys = set(test_info_dict.keys()) - set(expected_dict.keys())
  224.     if missing_keys:
  225.         def _repr(v):
  226.             if isinstance(v, compat_str):
  227.                 return "'%s'" % v.replace('\\', '\\\\').replace("'", "\\'").replace('\n', '\\n')
  228.             else:
  229.                 return repr(v)
  230.         info_dict_str = ''
  231.         if len(missing_keys) != len(expected_dict):
  232.             info_dict_str += ''.join(
  233.                 '    %s: %s,\n' % (_repr(k), _repr(v))
  234.                 for k, v in test_info_dict.items() if k not in missing_keys)
  236.             if info_dict_str:
  237.                 info_dict_str += '\n'
  238.         info_dict_str += ''.join(
  239.             '    %s: %s,\n' % (_repr(k), _repr(test_info_dict[k]))
  240.             for k in missing_keys)
  241.         write_string(
  242.             '\n\'info_dict\': {\n' + info_dict_str + '},\n', out=sys.stderr)
  243.         self.assertFalse(
  244.             missing_keys,
  245.             'Missing keys in test definition: %s' % (
  246.                 ', '.join(sorted(missing_keys))))
  249. def assertRegexpMatches(self, text, regexp, msg=None):
  250.     if hasattr(self, 'assertRegexp'):
  251.         return self.assertRegexp(text, regexp, msg)
  252.     else:
  253.         m = re.match(regexp, text)
  254.         if not m:
  255.             note = 'Regexp didn\'t match: %r not found' % (regexp)
  256.             if len(text) < 1000:
  257.                 note += ' in %r' % text
  258.             if msg is None:
  259.                 msg = note
  260.             else:
  261.                 msg = note + ', ' + msg
  262.             self.assertTrue(m, msg)
  265. def assertGreaterEqual(self, got, expected, msg=None):
  266.     if not (got >= expected):
  267.         if msg is None:
  268.             msg = '%r not greater than or equal to %r' % (got, expected)
  269.         self.assertTrue(got >= expected, msg)
  272. def assertLessEqual(self, got, expected, msg=None):
  273.     if not (got <= expected):
  274.         if msg is None:
  275.             msg = '%r not less than or equal to %r' % (got, expected)
  276.         self.assertTrue(got <= expected, msg)
  279. def assertEqual(self, got, expected, msg=None):
  280.     if not (got == expected):
  281.         if msg is None:
  282.             msg = '%r not equal to %r' % (got, expected)
  283.         self.assertTrue(got == expected, msg)
  286. def expect_warnings(ydl, warnings_re):
  287.     real_warning = ydl.report_warning
  289.     def _report_warning(w):
  290.         if not any(re.search(w_re, w) for w_re in warnings_re):
  291.             real_warning(w)
  293.     ydl.report_warning = _report_warning
  296. def http_server_port(httpd):
  297.     if os.name == 'java' and isinstance(httpd.socket, ssl.SSLSocket):
  298.         # In Jython SSLSocket is not a subclass of socket.socket
  299.         sock = httpd.socket.sock
  300.     else:
  301.         sock = httpd.socket
  302.     return sock.getsockname()[1]
  305. def expectedFailureIf(cond):
  306.     return unittest.expectedFailure if cond else IDENTITY