add python3.6 modules

lib/python3.4/site-packages/pip/utils/__init__.py

@@ -42,7 +42,7 @@ __all__ = ['rmtree', 'display_path', 'backup_dir',
            'normalize_path',
            'renames', 'get_terminal_size', 'get_prog',
            'unzip_file', 'untar_file', 'unpack_file', 'call_subprocess',
-           'captured_stdout', 'remove_tracebacks', 'ensure_dir',
+           'captured_stdout', 'ensure_dir',
            'ARCHIVE_EXTENSIONS', 'SUPPORTED_EXTENSIONS',
            'get_installed_version']
 
@@ -639,20 +639,9 @@ def unpack_file(filename, location, content_type, link):
         )
 
 
-def remove_tracebacks(output):
-    pattern = (r'(?:\W+File "(?:.*)", line (?:.*)\W+(?:.*)\W+\^\W+)?'
-               r'Syntax(?:Error|Warning): (?:.*)')
-    output = re.sub(pattern, '', output)
-    if PY2:
-        return output
-    # compileall.compile_dir() prints different messages to stdout
-    # in Python 3
-    return re.sub(r"\*\*\* Error compiling (?:.*)", '', output)
-
-
 def call_subprocess(cmd, show_stdout=True, cwd=None,
                     on_returncode='raise',
-                    command_level=std_logging.DEBUG, command_desc=None,
+                    command_desc=None,
                     extra_environ=None, spinner=None):
     # This function's handling of subprocess output is confusing and I
     # previously broke it terribly, so as penance I will write a long comment
@@ -686,7 +675,7 @@ def call_subprocess(cmd, show_stdout=True, cwd=None,
                 part = '"%s"' % part.replace('"', '\\"')
             cmd_parts.append(part)
         command_desc = ' '.join(cmd_parts)
-    logger.log(command_level, "Running command %s", command_desc)
+    logger.debug("Running command %s", command_desc)
     env = os.environ.copy()
     if extra_environ:
         env.update(extra_environ)
@@ -745,7 +734,7 @@ def call_subprocess(cmd, show_stdout=True, cwd=None,
             raise ValueError('Invalid value: on_returncode=%s' %
                              repr(on_returncode))
     if not show_stdout:
-        return remove_tracebacks(''.join(all_output))
+        return ''.join(all_output)
 
 
 def read_text_file(filename):
@@ -856,14 +845,17 @@ class cached_property(object):
         return value
 
 
-def get_installed_version(dist_name):
+def get_installed_version(dist_name, lookup_dirs=None):
     """Get the installed version of dist_name avoiding pkg_resources cache"""
     # Create a requirement that we'll look for inside of setuptools.
     req = pkg_resources.Requirement.parse(dist_name)
 
     # We want to avoid having this cached, so we need to construct a new
     # working set each time.
-    working_set = pkg_resources.WorkingSet()
+    if lookup_dirs is None:
+        working_set = pkg_resources.WorkingSet()
+    else:
+        working_set = pkg_resources.WorkingSet(lookup_dirs)
 
     # Get the installed distribution from our working set
     dist = working_set.find(req)

lib/python3.4/site-packages/pip/utils/appdirs.py

@@ -8,6 +8,7 @@ import os
 import sys
 
 from pip.compat import WINDOWS, expanduser
+from pip._vendor.six import PY2, text_type
 
 
 def user_cache_dir(appname):
@@ -17,9 +18,9 @@ def user_cache_dir(appname):
         "appname" is the name of application.
 
     Typical user cache directories are:
-        Mac OS X:   ~/Library/Caches/<AppName>
+        macOS:      ~/Library/Caches/<AppName>
         Unix:       ~/.cache/<AppName> (XDG default)
-        Windows:      C:\Users\<username>\AppData\Local\<AppName>\Cache
+        Windows:    C:\Users\<username>\AppData\Local\<AppName>\Cache
 
     On Windows the only suggestion in the MSDN docs is that local settings go
     in the `CSIDL_LOCAL_APPDATA` directory. This is identical to the
@@ -35,6 +36,11 @@ def user_cache_dir(appname):
         # Get the base path
         path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
 
+        # When using Python 2, return paths as bytes on Windows like we do on
+        # other operating systems. See helper function docs for more details.
+        if PY2 and isinstance(path, text_type):
+            path = _win_path_to_bytes(path)
+
         # Add our app name and Cache directory to it
         path = os.path.join(path, appname, "Cache")
     elif sys.platform == "darwin":
@@ -67,7 +73,7 @@ def user_data_dir(appname, roaming=False):
             for a discussion of issues.
 
     Typical user data directories are:
-        Mac OS X:               ~/Library/Application Support/<AppName>
+        macOS:                  ~/Library/Application Support/<AppName>
         Unix:                   ~/.local/share/<AppName>    # or in
                                 $XDG_DATA_HOME, if defined
         Win XP (not roaming):   C:\Documents and Settings\<username>\ ...
@@ -110,12 +116,12 @@ def user_config_dir(appname, roaming=True):
             for a discussion of issues.
 
     Typical user data directories are:
-        Mac OS X:               same as user_data_dir
+        macOS:                  same as user_data_dir
         Unix:                   ~/.config/<AppName>
         Win *:                  same as user_data_dir
 
     For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME.
-    That means, by deafult "~/.config/<AppName>".
+    That means, by default "~/.config/<AppName>".
     """
     if WINDOWS:
         path = user_data_dir(appname, roaming=roaming)
@@ -136,7 +142,7 @@ def site_config_dirs(appname):
         "appname" is the name of application.
 
     Typical user config directories are:
-        Mac OS X:   /Library/Application Support/<AppName>/
+        macOS:      /Library/Application Support/<AppName>/
         Unix:       /etc or $XDG_CONFIG_DIRS[i]/<AppName>/ for each value in
                     $XDG_CONFIG_DIRS
         Win XP:     C:\Documents and Settings\All Users\Application ...
@@ -222,3 +228,21 @@ if WINDOWS:
         _get_win_folder = _get_win_folder_with_ctypes
     except ImportError:
         _get_win_folder = _get_win_folder_from_registry
+
+
+def _win_path_to_bytes(path):
+    """Encode Windows paths to bytes. Only used on Python 2.
+
+    Motivation is to be consistent with other operating systems where paths
+    are also returned as bytes. This avoids problems mixing bytes and Unicode
+    elsewhere in the codebase. For more details and discussion see
+    <https://github.com/pypa/pip/issues/3463>.
+
+    If encoding using ASCII and MBCS fails, return the original Unicode path.
+    """
+    for encoding in ('ASCII', 'MBCS'):
+        try:
+            return path.encode(encoding)
+        except (UnicodeEncodeError, LookupError):
+            pass
+    return path

lib/python3.4/site-packages/pip/utils/deprecation.py

@@ -1,5 +1,5 @@
 """
-A module that implments tooling to enable easy warnings about deprecations.
+A module that implements tooling to enable easy warnings about deprecations.
 """
 from __future__ import absolute_import
 
@@ -15,15 +15,15 @@ class Pending(object):
     pass
 
 
-class RemovedInPip9Warning(PipDeprecationWarning):
+class RemovedInPip10Warning(PipDeprecationWarning):
     pass
 
 
-class RemovedInPip10Warning(PipDeprecationWarning, Pending):
+class RemovedInPip11Warning(PipDeprecationWarning, Pending):
     pass
 
 
-class Python26DeprecationWarning(PipDeprecationWarning, Pending):
+class Python26DeprecationWarning(PipDeprecationWarning):
     pass
 
 

lib/python3.4/site-packages/pip/utils/glibc.py

@@ -0,0 +1,81 @@
+from __future__ import absolute_import
+
+import re
+import ctypes
+import platform
+import warnings
+
+
+def glibc_version_string():
+    "Returns glibc version string, or None if not using glibc."
+
+    # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen
+    # manpage says, "If filename is NULL, then the returned handle is for the
+    # main program". This way we can let the linker do the work to figure out
+    # which libc our process is actually using.
+    process_namespace = ctypes.CDLL(None)
+    try:
+        gnu_get_libc_version = process_namespace.gnu_get_libc_version
+    except AttributeError:
+        # Symbol doesn't exist -> therefore, we are not linked to
+        # glibc.
+        return None
+
+    # Call gnu_get_libc_version, which returns a string like "2.5"
+    gnu_get_libc_version.restype = ctypes.c_char_p
+    version_str = gnu_get_libc_version()
+    # py2 / py3 compatibility:
+    if not isinstance(version_str, str):
+        version_str = version_str.decode("ascii")
+
+    return version_str
+
+
+# Separated out from have_compatible_glibc for easier unit testing
+def check_glibc_version(version_str, required_major, minimum_minor):
+    # Parse string and check against requested version.
+    #
+    # We use a regexp instead of str.split because we want to discard any
+    # random junk that might come after the minor version -- this might happen
+    # in patched/forked versions of glibc (e.g. Linaro's version of glibc
+    # uses version strings like "2.20-2014.11"). See gh-3588.
+    m = re.match(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str)
+    if not m:
+        warnings.warn("Expected glibc version with 2 components major.minor,"
+                      " got: %s" % version_str, RuntimeWarning)
+        return False
+    return (int(m.group("major")) == required_major and
+            int(m.group("minor")) >= minimum_minor)
+
+
+def have_compatible_glibc(required_major, minimum_minor):
+    version_str = glibc_version_string()
+    if version_str is None:
+        return False
+    return check_glibc_version(version_str, required_major, minimum_minor)
+
+
+# platform.libc_ver regularly returns completely nonsensical glibc
+# versions. E.g. on my computer, platform says:
+#
+#   ~$ python2.7 -c 'import platform; print(platform.libc_ver())'
+#   ('glibc', '2.7')
+#   ~$ python3.5 -c 'import platform; print(platform.libc_ver())'
+#   ('glibc', '2.9')
+#
+# But the truth is:
+#
+#   ~$ ldd --version
+#   ldd (Debian GLIBC 2.22-11) 2.22
+#
+# This is unfortunate, because it means that the linehaul data on libc
+# versions that was generated by pip 8.1.2 and earlier is useless and
+# misleading. Solution: instead of using platform, use our code that actually
+# works.
+def libc_ver():
+    glibc_version = glibc_version_string()
+    if glibc_version is None:
+        # For non-glibc platforms, fall back on platform.libc_ver
+        return platform.libc_ver()
+    else:
+        return ("glibc", glibc_version)

lib/python3.4/site-packages/pip/utils/packaging.py

@@ -0,0 +1,63 @@
+from __future__ import absolute_import
+
+from email.parser import FeedParser
+
+import logging
+import sys
+
+from pip._vendor.packaging import specifiers
+from pip._vendor.packaging import version
+from pip._vendor import pkg_resources
+
+from pip import exceptions
+
+logger = logging.getLogger(__name__)
+
+
+def check_requires_python(requires_python):
+    """
+    Check if the python version in use match the `requires_python` specifier.
+
+    Returns `True` if the version of python in use matches the requirement.
+    Returns `False` if the version of python in use does not matches the
+    requirement.
+
+    Raises an InvalidSpecifier if `requires_python` have an invalid format.
+    """
+    if requires_python is None:
+        # The package provides no information
+        return True
+    requires_python_specifier = specifiers.SpecifierSet(requires_python)
+
+    # We only use major.minor.micro
+    python_version = version.parse('.'.join(map(str, sys.version_info[:3])))
+    return python_version in requires_python_specifier
+
+
+def get_metadata(dist):
+    if (isinstance(dist, pkg_resources.DistInfoDistribution) and
+            dist.has_metadata('METADATA')):
+        return dist.get_metadata('METADATA')
+    elif dist.has_metadata('PKG-INFO'):
+        return dist.get_metadata('PKG-INFO')
+
+
+def check_dist_requires_python(dist):
+    metadata = get_metadata(dist)
+    feed_parser = FeedParser()
+    feed_parser.feed(metadata)
+    pkg_info_dict = feed_parser.close()
+    requires_python = pkg_info_dict.get('Requires-Python')
+    try:
+        if not check_requires_python(requires_python):
+            raise exceptions.UnsupportedPythonVersion(
+                "%s requires Python '%s' but the running Python is %s" % (
+                    dist.project_name,
+                    requires_python,
+                    '.'.join(map(str, sys.version_info[:3])),)
+            )
+    except specifiers.InvalidSpecifier as e:
+        logger.warning(
+            "Package %s has an invalid Requires-Python entry %s - %s" % (
+                dist.project_name, requires_python, e))
+        return

lib/python3.4/site-packages/pip/utils/setuptools_build.py

@@ -1,6 +1,8 @@
 # Shim to wrap setup.py invocation with setuptools
 SETUPTOOLS_SHIM = (
     "import setuptools, tokenize;__file__=%r;"
-    "exec(compile(getattr(tokenize, 'open', open)(__file__).read()"
-    ".replace('\\r\\n', '\\n'), __file__, 'exec'))"
+    "f=getattr(tokenize, 'open', open)(__file__);"
+    "code=f.read().replace('\\r\\n', '\\n');"
+    "f.close();"
+    "exec(compile(code, __file__, 'exec'))"
 )