Unify querying of executable versions.

anntzer · anntzer · commit 2a3edfeda9c5 · 2017-10-30T22:54:43.000-07:00
diff --git a/lib/matplotlib/__init__.py b/lib/matplotlib/__init__.py
@@ -103,11 +103,12 @@
                         unicode_literals)
 
 import six
+from six.moves.urllib.request import urlopen
+from six.moves import reload_module as reload
 
-from collections import MutableMapping
+from collections import MutableMapping, namedtuple
 import contextlib
-import distutils.version
-import distutils.sysconfig
+from distutils.version import LooseVersion
 import functools
 import io
 import inspect
@@ -119,6 +120,11 @@
 import tempfile
 import warnings
 
+try:
+    from functools import lru_cache
+except ImportError:
+    from backports.functools_lru_cache import lru_cache
+
 # cbook must import matplotlib only within function
 # definitions, so it is safe to import from it here.
 from . import cbook
@@ -128,8 +134,6 @@
 from matplotlib.rcsetup import defaultParams, validate_backend, cycler
 
 import numpy
-from six.moves.urllib.request import urlopen
-from six.moves import reload_module as reload
 
 # Get the version from the _version.py versioneer file. For a git checkout,
 # this is computed based on the number of commits since the last tag.
@@ -169,9 +173,7 @@ def compare_versions(a, b):
                 a = a.decode('ascii')
             if isinstance(b, bytes):
                 b = b.decode('ascii')
-        a = distutils.version.LooseVersion(a)
-        b = distutils.version.LooseVersion(b)
-        return a >= b
+        return LooseVersion(a) >= LooseVersion(b)
     else:
         return False
 
@@ -314,89 +316,125 @@ def ge(self, level):
 verbose = Verbose()
 
 
+_ExecInfo = namedtuple("_ExecInfo", "executable version")
+
+
+@lru_cache()
+def get_executable_info(name):
+    """Get the version of some executables that Matplotlib depends on.
+
+    .. warning:
+       The list of executables that this function supports is set according to
+       Matplotlib's internal needs, and may change without notice.
+
+    Parameters
+    ----------
+    name : str
+        The executable to query.  The following values are currently supported:
+        "dvipng", "gs", "inkscape", "pdftops", "tex".  This list is subject to
+        change without notice.
+
+    Returns
+    -------
+    If the executable is found, a namedtuple with fields ``executable`` (`str`)
+    and ``version`` (`distutils.version.LooseVersion`, or ``None`` if the
+    version cannot be determined); ``None`` if the executable is not found.
+    """
+
+    def impl(args, regex, min_ver=None):
+        # Execute the subprocess specified by args; capture stdout and stderr.
+        # Search for a regex match in the output; if the match succeeds, use
+        # the *first group* of the match as the version.
+        # If min_ver is not None, emit a warning if the version is less than
+        # min_ver.
+        try:
+            proc = subprocess.Popen(
+                [str(arg) for arg in args],  # str(): Py2 compat.
+                stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                universal_newlines=True)
+            proc.wait()
+        except OSError:
+            return None
+        match = re.search(regex, proc.stdout.read())
+        if match:
+            version = LooseVersion(match.group(1))
+            if min_ver is not None and version < str(min_ver):
+                warnings.warn("You have {} version {} but the minimum version "
+                              "supported by Matplotlib is {}."
+                              .format(args[0], version, min_ver))
+                return None
+            return _ExecInfo(str(args[0]), version)  # str(): Py2 compat.
+        else:
+            return None
+
+    if name == "dvipng":
+        info = impl(["dvipng", "-version"], "(?m)^dvipng .* (.+)", "1.6")
+    elif name == "gs":
+        execs = (["gswin32c", "gswin64c", "mgs", "gs"]  # "mgs" for miktex.
+                 if sys.platform == "win32" else
+                 ["gs"])
+        info = next(filter(None, (impl([e, "--version"], "(.*)", "8.60")
+                                  for e in execs)),
+                    None)
+    elif name == "inkscape":
+        info = impl(["inkscape", "-V"], "^Inkscape ([^ ]*)")
+    elif name == "pdftops":
+        info = impl(["pdftops", "-v"], "^pdftops version (.*)")
+        if info and not (str("3.0") <= info.version
+                         # poppler version numbers.
+                         or str("0.9") <= info.version <= str("1.0")):
+            warnings.warn(
+                "You have pdftops version {} but the minimum version "
+                "supported by Matplotlib is 3.0.".format(info.version))
+            return None
+    elif name == "tex":
+        info = (_ExecInfo(str("tex"), None)  # str(): Py2 compat.
+                if _backports.which("tex") is not None
+                else None)
+    else:
+        raise ValueError("Unknown executable: {!r}".format(name))
+    return info
+
+
+def get_all_executable_infos():
+    """Query all executables that Matplotlib may need.
+
+    .. warning:
+       The list of executables that this function queries is set according to
+       Matplotlib's internal needs, and may change without notice.
+
+    Returns
+    -------
+    A mapping of the required executable to its corresponding information,
+    as returned by `get_executable_info`.  The keys in the mapping are subject
+    to change without notice.
+    """
+    return {name: get_executable_info(name)
+            for name in ["dvipng", "gs", "inkscape", "pdftops", "tex"]}
+
+
+@cbook.deprecated("2.2")
 def checkdep_dvipng():
-    try:
-        s = subprocess.Popen([str('dvipng'), '-version'],
-                             stdout=subprocess.PIPE,
-                             stderr=subprocess.PIPE)
-        stdout, stderr = s.communicate()
-        line = stdout.decode('ascii').split('\n')[1]
-        v = line.split()[-1]
-        return v
-    except (IndexError, ValueError, OSError):
-        return None
+    return str(get_executable_info("dvipng").version)
 
 
 def checkdep_ghostscript():
-    if checkdep_ghostscript.executable is None:
-        if sys.platform == 'win32':
-            # mgs is the name in miktex
-            gs_execs = ['gswin32c', 'gswin64c', 'mgs', 'gs']
-        else:
-            gs_execs = ['gs']
-        for gs_exec in gs_execs:
-            try:
-                s = subprocess.Popen(
-                    [str(gs_exec), '--version'], stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE)
-                stdout, stderr = s.communicate()
-                if s.returncode == 0:
-                    v = stdout[:-1].decode('ascii')
-                    checkdep_ghostscript.executable = gs_exec
-                    checkdep_ghostscript.version = v
-            except (IndexError, ValueError, OSError):
-                pass
+    info = get_executable_info("gs")
+    checkdep_ghostscript.executable = info.executable
+    checkdep_ghostscript.version = str(info.version)
     return checkdep_ghostscript.executable, checkdep_ghostscript.version
 checkdep_ghostscript.executable = None
 checkdep_ghostscript.version = None
 
 
-# Deprecated, as it is unneeded and some distributions (e.g. MiKTeX 2.9.6350)
-# do not actually report the TeX version.
-@cbook.deprecated("2.1")
-def checkdep_tex():
-    try:
-        s = subprocess.Popen([str('tex'), '-version'], stdout=subprocess.PIPE,
-                             stderr=subprocess.PIPE)
-        stdout, stderr = s.communicate()
-        line = stdout.decode('ascii').split('\n')[0]
-        pattern = r'3\.1\d+'
-        match = re.search(pattern, line)
-        v = match.group(0)
-        return v
-    except (IndexError, ValueError, AttributeError, OSError):
-        return None
-
-
+@cbook.deprecated("2.2")
 def checkdep_pdftops():
-    try:
-        s = subprocess.Popen([str('pdftops'), '-v'], stdout=subprocess.PIPE,
-                             stderr=subprocess.PIPE)
-        stdout, stderr = s.communicate()
-        lines = stderr.decode('ascii').split('\n')
-        for line in lines:
-            if 'version' in line:
-                v = line.split()[-1]
-        return v
-    except (IndexError, ValueError, UnboundLocalError, OSError):
-        return None
+    return str(get_executable_info("pdftops").version)
 
 
+@cbook.deprecated("2.2")
 def checkdep_inkscape():
-    if checkdep_inkscape.version is None:
-        try:
-            s = subprocess.Popen([str('inkscape'), '-V'],
-                                 stdout=subprocess.PIPE,
-                                 stderr=subprocess.PIPE)
-            stdout, stderr = s.communicate()
-            lines = stdout.decode('ascii').split('\n')
-            for line in lines:
-                if 'Inkscape' in line:
-                    v = line.split()[1]
-                    break
-            checkdep_inkscape.version = v
-        except (IndexError, ValueError, UnboundLocalError, OSError):
-            pass
+    checkdep_inkscape.version = str(get_executable_info("inkscape").version)
     return checkdep_inkscape.version
 checkdep_inkscape.version = None
 
@@ -421,65 +459,31 @@ def checkdep_xmllint():
 def checkdep_ps_distiller(s):
     if not s:
         return False
-
-    flag = True
-    gs_req = '8.60'
-    gs_exec, gs_v = checkdep_ghostscript()
-    if not compare_versions(gs_v, gs_req):
-        flag = False
-        warnings.warn(('matplotlibrc ps.usedistiller option can not be used '
-                       'unless ghostscript-%s or later is installed on your '
-                       'system') % gs_req)
-
-    if s == 'xpdf':
-        pdftops_req = '3.0'
-        pdftops_req_alt = '0.9'  # poppler version numbers, ugh
-        pdftops_v = checkdep_pdftops()
-        if compare_versions(pdftops_v, pdftops_req):
-            pass
-        elif (compare_versions(pdftops_v, pdftops_req_alt) and not
-              compare_versions(pdftops_v, '1.0')):
-            pass
-        else:
-            flag = False
-            warnings.warn(('matplotlibrc ps.usedistiller can not be set to '
-                           'xpdf unless xpdf-%s or later is installed on '
-                           'your system') % pdftops_req)
-
-    if flag:
-        return s
-    else:
+    if not get_executable_info("gs"):
+        warnings.warn(
+            "Setting matplotlibrc ps.usedistiller requires ghostscript.")
         return False
+    if s == "xpdf" and not get_executable_info("pdftops"):
+        warnings.warn(
+            "setting matplotlibrc ps.usedistiller to 'xpdf' requires xpdf.")
+        return False
+    return s
 
 
 def checkdep_usetex(s):
     if not s:
         return False
-
-    gs_req = '8.60'
-    dvipng_req = '1.6'
-    flag = True
-
-    if _backports.which("tex") is None:
-        flag = False
-        warnings.warn('matplotlibrc text.usetex option can not be used unless '
-                      'TeX is installed on your system')
-
-    dvipng_v = checkdep_dvipng()
-    if not compare_versions(dvipng_v, dvipng_req):
-        flag = False
-        warnings.warn('matplotlibrc text.usetex can not be used with *Agg '
-                      'backend unless dvipng-%s or later is installed on '
-                      'your system' % dvipng_req)
-
-    gs_exec, gs_v = checkdep_ghostscript()
-    if not compare_versions(gs_v, gs_req):
-        flag = False
-        warnings.warn('matplotlibrc text.usetex can not be used unless '
-                      'ghostscript-%s or later is installed on your system'
-                      % gs_req)
-
-    return flag
+    if not get_executable_info("tex"):
+        warnings.warn("Setting matplotlibrc text.usetex requires TeX.")
+        return False
+    if not get_executable_info("dvipng"):
+        warnings.warn("Setting matplotlibrc text.usetex requires dvipng.")
+        return False
+    if not get_executable_info("gs"):
+        warnings.warn(
+            "Setting matplotlibrc text.usetex requires ghostscript.")
+        return False
+    return True
 
 
 def _get_home():
diff --git a/lib/matplotlib/testing/compare.py b/lib/matplotlib/testing/compare.py
@@ -109,8 +109,8 @@ def get_file_hash(path, block_size=2 ** 20):
         from matplotlib import checkdep_ghostscript
         md5.update(checkdep_ghostscript()[1].encode('utf-8'))
     elif path.endswith('.svg'):
-        from matplotlib import checkdep_inkscape
-        md5.update(checkdep_inkscape().encode('utf-8'))
+        md5.update(str(matplotlib.get_executable_info("inkscape").version)
+                   .encode('utf-8'))
 
     return md5.hexdigest()
 
@@ -246,7 +246,7 @@ def cmd(old, new):
         converter['pdf'] = make_external_conversion_command(cmd)
         converter['eps'] = make_external_conversion_command(cmd)
 
-    if matplotlib.checkdep_inkscape() is not None:
+    if matplotlib.get_executable_info("inkscape"):
         converter['svg'] = _SVGConverter()
 
 
