Update vendored six to 1.16.0

src/urllib3/packages/six.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2010-2019 Benjamin Peterson
+# Copyright (c) 2010-2020 Benjamin Peterson
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -29,7 +29,7 @@
 import types
 
 __author__ = "Benjamin Peterson <[email protected]>"
-__version__ = "1.12.0"
+__version__ = "1.16.0"
 
 
 # Useful for very coarse version differentiation.
@@ -71,6 +71,11 @@ def __len__(self):
  MAXSIZE = int((1 << 63) - 1)
  del X
 
+if PY34:
+ from importlib.util import spec_from_loader
+else:
+ spec_from_loader = None
+
 
 def _add_doc(func, doc):
  """Add documentation to a function."""
@@ -182,6 +187,11 @@ def find_module(self, fullname, path=None):
  return self
  return None
 
+ def find_spec(self, fullname, path, target=None):
+ if fullname in self.known_modules:
+ return spec_from_loader(fullname, self)
+ return None
+
  def __get_module(self, fullname):
  try:
  return self.known_modules[fullname]
@@ -220,6 +230,12 @@ def get_code(self, fullname):
 
  get_source = get_code # same as get_code
 
+ def create_module(self, spec):
+ return self.load_module(spec.name)
+
+ def exec_module(self, module):
+ pass
+
 
 _importer = _SixMetaPathImporter(__name__)
 
@@ -260,9 +276,19 @@ class _MovedItems(_LazyModule):
  ),
  MovedModule("builtins", "__builtin__"),
  MovedModule("configparser", "ConfigParser"),
+ MovedModule(
+ "collections_abc",
+ "collections",
+ "collections.abc" if sys.version_info >= (3, 3) else "collections",
+ ),
  MovedModule("copyreg", "copy_reg"),
  MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
- MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
+ MovedModule("dbm_ndbm", "dbm", "dbm.ndbm"),
+ MovedModule(
+ "_dummy_thread",
+ "dummy_thread",
+ "_dummy_thread" if sys.version_info < (3, 9) else "_thread",
+ ),
  MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
  MovedModule("http_cookies", "Cookie", "http.cookies"),
  MovedModule("html_entities", "htmlentitydefs", "html.entities"),
@@ -307,7 +333,9 @@ class _MovedItems(_LazyModule):
 ]
 # Add windows specific modules.
 if sys.platform == "win32":
- _moved_attributes += [MovedModule("winreg", "_winreg")]
+ _moved_attributes += [
+ MovedModule("winreg", "_winreg"),
+ ]
 
 for attr in _moved_attributes:
  setattr(_MovedItems, attr.name, attr)
@@ -476,7 +504,7 @@ class Module_six_moves_urllib_robotparser(_LazyModule):
 
 
 _urllib_robotparser_moved_attributes = [
- MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser")
+ MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
 ]
 for attr in _urllib_robotparser_moved_attributes:
  setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
@@ -678,9 +706,11 @@ def u(s):
  if sys.version_info[1] <= 1:
  _assertRaisesRegex = "assertRaisesRegexp"
  _assertRegex = "assertRegexpMatches"
+ _assertNotRegex = "assertNotRegexpMatches"
  else:
  _assertRaisesRegex = "assertRaisesRegex"
  _assertRegex = "assertRegex"
+ _assertNotRegex = "assertNotRegex"
 else:
 
  def b(s):
@@ -707,6 +737,7 @@ def indexbytes(buf, i):
  _assertCountEqual = "assertItemsEqual"
  _assertRaisesRegex = "assertRaisesRegexp"
  _assertRegex = "assertRegexpMatches"
+ _assertNotRegex = "assertNotRegexpMatches"
 _add_doc(b, """Byte literal""")
 _add_doc(u, """Text literal""")
 
@@ -723,6 +754,10 @@ def assertRegex(self, *args, **kwargs):
  return getattr(self, _assertRegex)(*args, **kwargs)
 
 
+def assertNotRegex(self, *args, **kwargs):
+ return getattr(self, _assertNotRegex)(*args, **kwargs)
+
+
 if PY3:
  exec_ = getattr(moves.builtins, "exec")
 
@@ -762,18 +797,7 @@ def exec_(_code_, _globs_=None, _locs_=None):
  )
 
 
-if sys.version_info[:2] == (3, 2):
- exec_(
- """def raise_from(value, from_value):
- try:
- if from_value is None:
- raise value
- raise value from from_value
- finally:
- value = None
-"""
- )
-elif sys.version_info[:2] > (3, 2):
+if sys.version_info[:2] > (3,):
  exec_(
  """def raise_from(value, from_value):
  try:
@@ -863,19 +887,41 @@ def print_(*args, **kwargs):
 _add_doc(reraise, """Reraise an exception.""")
 
 if sys.version_info[0:2] < (3, 4):
+ # This does exactly the same what the :func:`py3:functools.update_wrapper`
+ # function does on Python versions after 3.2. It sets the ``__wrapped__``
+ # attribute on ``wrapper`` object and it doesn't raise an error if any of
+ # the attributes mentioned in ``assigned`` and ``updated`` are missing on
+ # ``wrapped`` object.
+ def _update_wrapper(
+ wrapper,
+ wrapped,
+ assigned=functools.WRAPPER_ASSIGNMENTS,
+ updated=functools.WRAPPER_UPDATES,
+ ):
+ for attr in assigned:
+ try:
+ value = getattr(wrapped, attr)
+ except AttributeError:
+ continue
+ else:
+ setattr(wrapper, attr, value)
+ for attr in updated:
+ getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
+ wrapper.__wrapped__ = wrapped
+ return wrapper
+
+ _update_wrapper.__doc__ = functools.update_wrapper.__doc__
 
  def wraps(
  wrapped,
  assigned=functools.WRAPPER_ASSIGNMENTS,
  updated=functools.WRAPPER_UPDATES,
  ):
- def wrapper(f):
- f = functools.wraps(wrapped, assigned, updated)(f)
- f.__wrapped__ = wrapped
- return f
-
- return wrapper
+ return functools.partial(
+ _update_wrapper, wrapped=wrapped, assigned=assigned, updated=updated
+ )
 
+ wraps.__doc__ = functools.wraps.__doc__
 
 else:
  wraps = functools.wraps
@@ -888,7 +934,15 @@ def with_metaclass(meta, *bases):
  # the actual metaclass.
  class metaclass(type):
  def __new__(cls, name, this_bases, d):
- return meta(name, bases, d)
+ if sys.version_info[:2] >= (3, 7):
+ # This version introduced PEP 560 that requires a bit
+ # of extra care (we mimic what is done by __build_class__).
+ resolved_bases = types.resolve_bases(bases)
+ if resolved_bases is not bases:
+ d["__orig_bases__"] = bases
+ else:
+ resolved_bases = bases
+ return meta(name, resolved_bases, d)
 
  @classmethod
  def __prepare__(cls, name, this_bases):
@@ -928,12 +982,11 @@ def ensure_binary(s, encoding="utf-8", errors="strict"):
  - `str` -> encoded to `bytes`
  - `bytes` -> `bytes`
  """
+ if isinstance(s, binary_type):
+ return s
  if isinstance(s, text_type):
  return s.encode(encoding, errors)
- elif isinstance(s, binary_type):
- return s
- else:
- raise TypeError("not expecting type '%s'" % type(s))
+ raise TypeError("not expecting type '%s'" % type(s))
 
 
 def ensure_str(s, encoding="utf-8", errors="strict"):
@@ -947,12 +1000,15 @@ def ensure_str(s, encoding="utf-8", errors="strict"):
  - `str` -> `str`
  - `bytes` -> decoded to `str`
  """
- if not isinstance(s, (text_type, binary_type)):
- raise TypeError("not expecting type '%s'" % type(s))
+ # Optimization: Fast return for the common case.
+ if type(s) is str:
+ return s
  if PY2 and isinstance(s, text_type):
- s = s.encode(encoding, errors)
+ return s.encode(encoding, errors)
  elif PY3 and isinstance(s, binary_type):
- s = s.decode(encoding, errors)
+ return s.decode(encoding, errors)
+ elif not isinstance(s, (text_type, binary_type)):
+ raise TypeError("not expecting type '%s'" % type(s))
  return s
 
 
@@ -977,7 +1033,7 @@ def ensure_text(s, encoding="utf-8", errors="strict"):
 
 def python_2_unicode_compatible(klass):
  """
- A decorator that defines __unicode__ and __str__ methods under Python 2.
+ A class decorator that defines __unicode__ and __str__ methods under Python 2.
  Under Python 3 it does nothing.
 
  To support Python 2 and 3 with a single code base, define a __str__ method