Remove "experimental" fontconfig font_manager backend.

anntzer · anntzer · commit bcba2334b51b · 2018-04-12T15:24:04.000-07:00
The "experimental" fontconfig backend for font_manager was never
publicly accessible: even if one does
`matplotlib.font_manager.USE_FONTCONFIG = True`, that didn't change the
already existing `findfont`.  The only way to access it was to edit the
source, or use `reload()`, neither of which really count as public
API...

Note that our "use" of "fontconfig-like" patterns actually has subtly
different semantics from actual fontconfig patterns, so it's not as if
that backend was correctly working anyways.

We don't need to set `fontManager.default_size` when loading it as
we already check that fontManager has the correct `__version__`
(and thus must have a correct `default_size`; moreover the only
use of `default_size` is in `sizeval1 = self.default_size *
font_scalings[size1]` so it's not as if a value of `None` (if it had
somehow been missing) was going to be helpful anyways...

`get_cachedir()` always returns a real directory (creating a temporary
one if necessary), so we can drop the code paths handling
`get_cachedir() == None`.

Note that we still rely on fontconfig to *list* fonts; the backend only
added an (non-publicly-accessible, per above) option to *match* fonts
using fontconfig.
diff --git a/doc/api/next_api_changes/2018-02-26-AL-removals.rst b/doc/api/next_api_changes/2018-02-26-AL-removals.rst
@@ -14,7 +14,8 @@ The following deprecated API elements have been removed:
   ``cbook.reverse_dict``, ``cbook.restrict_dict``, ``cbook.issubclass_safe``,
   ``cbook.recursive_remove``, ``cbook.unmasked_index_ranges``,
   ``cbook.Null``, ``cbook.RingBuffer``, ``cbook.Sorter``, ``cbook.Xlator``,
-- ``font_manager.weight_as_number``, ``font_manager.ttfdict_to_fnames``,
+- ``font_manager.ttfdict_to_fnames``, ``font_manager.weight_as_number``,
+  ``font_manager.USE_FONTCONFIG``, ``font_manager.cachedir``,
 - ``pyplot.colors``, ``pyplot.spectral``,
 - ``rcsetup.validate_negative_linestyle``,
   ``rcsetup.validate_negative_linestyle_legacy``,
diff --git a/lib/matplotlib/__init__.py b/lib/matplotlib/__init__.py
@@ -576,7 +576,7 @@ def _get_home():
     return None
 
 
-def _create_tmp_config_dir():
+def _create_tmp_config_or_cache_dir():
     """
     If the config directory can not be created, create a temporary
     directory.
@@ -624,7 +624,7 @@ def _get_config_or_cache_dir(xdg_base):
         configdir = os.path.abspath(configdir)
         Path(configdir).mkdir(parents=True, exist_ok=True)
         if not _is_writable_dir(configdir):
-            return _create_tmp_config_dir()
+            return _create_tmp_config_or_cache_dir()
         return configdir
 
     p = None
@@ -648,7 +648,7 @@ def _get_config_or_cache_dir(xdg_base):
             else:
                 return p
 
-    return _create_tmp_config_dir()
+    return _create_tmp_config_or_cache_dir()
 
 
 def _get_configdir():
diff --git a/lib/matplotlib/font_manager.py b/lib/matplotlib/font_manager.py
@@ -11,13 +11,6 @@
 The design is based on the `W3C Cascading Style Sheet, Level 1 (CSS1)
 font specification <http://www.w3.org/TR/1998/REC-CSS2-19980512/>`_.
 Future versions may implement the Level 2 or 2.1 specifications.
-
-Experimental support is included for using `fontconfig` on Unix
-variant platforms (Linux, OS X, Solaris).  To enable it, set the
-constant ``USE_FONTCONFIG`` in this file to ``True``.  Fontconfig has
-the advantage that it is the standard way to look up fonts on X11
-platforms, so if a font is installed, it is much more likely to be
-found.
 """
 
 # KNOWN ISSUES
@@ -42,14 +35,13 @@
 from threading import Timer
 import warnings
 
-from matplotlib import afm, cbook, ft2font, rcParams, get_cachedir
+import matplotlib as mpl
+from matplotlib import afm, cbook, ft2font, rcParams
 from matplotlib.fontconfig_pattern import (
     parse_fontconfig_pattern, generate_fontconfig_pattern)
 
 _log = logging.getLogger(__name__)
 
-USE_FONTCONFIG = False
-
 font_scalings = {
     'xx-small' : 0.579,
     'x-small'  : 0.694,
@@ -102,12 +94,10 @@
 MSFolders = \
     r'Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders'
 
-
 MSFontDirectories = [
     r'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts',
     r'SOFTWARE\Microsoft\Windows\CurrentVersion\Fonts']
 
-
 X11FontDirectories = [
     # an old standard installation point
     "/usr/X11R6/lib/X11/fonts/TTF/",
@@ -118,21 +108,20 @@
     "/usr/local/share/fonts/",
     # common application, not really useful
     "/usr/lib/openoffice/share/fonts/truetype/",
-    ]
+    # user fonts
+    str(Path.home() / ".fonts"),
+]
 
 OSXFontDirectories = [
     "/Library/Fonts/",
     "/Network/Library/Fonts/",
     "/System/Library/Fonts/",
     # fonts installed via MacPorts
-    "/opt/local/share/fonts"
-    ""
+    "/opt/local/share/fonts",
+    # user fonts
+    str(Path.home() / "Library/Fonts"),
 ]
 
-if not USE_FONTCONFIG and sys.platform != 'win32':
-    OSXFontDirectories.append(str(Path.home() / "Library/Fonts"))
-    X11FontDirectories.append(str(Path.home() / ".fonts"))
-
 
 def get_fontext_synonyms(fontext):
     """
@@ -1136,7 +1125,7 @@ def score_size(self, size1, size2):
             sizeval2 = float(size2)
         except ValueError:
             return 1.0
-        return abs(sizeval1 - sizeval2) / 72.0
+        return abs(sizeval1 - sizeval2) / 72
 
     def findfont(self, prop, fontext='ttf', directory=None,
                  fallback_to_default=True, rebuild_if_missing=True):
@@ -1245,6 +1234,7 @@ def _findfont_cached(self, prop, fontext, directory, fallback_to_default,
 
         return result
 
+
 @lru_cache()
 def is_opentype_cff_font(filename):
     """
@@ -1258,94 +1248,35 @@ def is_opentype_cff_font(filename):
     else:
         return False
 
-fontManager = None
-_fmcache = None
-
 
 _get_font = lru_cache(64)(ft2font.FT2Font)
+_fmcache = os.path.join(mpl.get_cachedir(), 'fontList.json')
+fontManager = None
+
 
 def get_font(filename, hinting_factor=None):
     if hinting_factor is None:
         hinting_factor = rcParams['text.hinting_factor']
     return _get_font(filename, hinting_factor)
 
 
-# The experimental fontconfig-based backend.
-if USE_FONTCONFIG and sys.platform != 'win32':
+def _rebuild():
+    global fontManager
+    fontManager = FontManager()
+    with cbook._lock_path(_fmcache):
+        json_dump(fontManager, _fmcache)
+    _log.info("generated new fontManager")
 
-    def fc_match(pattern, fontext):
-        fontexts = get_fontext_synonyms(fontext)
-        ext = "." + fontext
-        try:
-            pipe = subprocess.Popen(
-                ['fc-match', '-s', '--format=%{file}\\n', pattern],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE)
-            output = pipe.communicate()[0]
-        except OSError:
-            return None
-
-        # The bulk of the output from fc-list is ascii, so we keep the
-        # result in bytes and parse it as bytes, until we extract the
-        # filename, which is in sys.filesystemencoding().
-        if pipe.returncode == 0:
-            for fname in map(os.fsdecode, output.split(b'\n')):
-                if os.path.splitext(fname)[1][1:] in fontexts:
-                    return fname
-        return None
-
-    _fc_match_cache = {}
-
-    def findfont(prop, fontext='ttf'):
-        if not isinstance(prop, str):
-            prop = prop.get_fontconfig_pattern()
-        cached = _fc_match_cache.get(prop)
-        if cached is not None:
-            return cached
-
-        result = fc_match(prop, fontext)
-        if result is None:
-            result = fc_match(':', fontext)
-
-        _fc_match_cache[prop] = result
-        return result
 
+try:
+    fontManager = json_load(_fmcache)
+except Exception:
+    _rebuild()
 else:
-    _fmcache = None
-
-    cachedir = get_cachedir()
-    if cachedir is not None:
-        _fmcache = os.path.join(cachedir, 'fontList.json')
-
-    fontManager = None
-
-    def _rebuild():
-        global fontManager
-
-        fontManager = FontManager()
-
-        if _fmcache:
-            with cbook._lock_path(_fmcache):
-                json_dump(fontManager, _fmcache)
-        _log.info("generated new fontManager")
-
-    if _fmcache:
-        try:
-            fontManager = json_load(_fmcache)
-            if (not hasattr(fontManager, '_version') or
-                fontManager._version != FontManager.__version__):
-                _rebuild()
-            else:
-                fontManager.default_size = None
-                _log.debug("Using fontManager instance from %s", _fmcache)
-        except TimeoutError:
-            raise
-        except Exception:
-            _rebuild()
-    else:
+    if getattr(fontManager, '_version', object()) != FontManager.__version__:
         _rebuild()
+    else:
+        _log.debug("Using fontManager instance from %s", _fmcache)
+
 
-    def findfont(prop, **kw):
-        global fontManager
-        font = fontManager.findfont(prop, **kw)
-        return font
+findfont = fontManager.findfont
