Remove font preamble caching in TexManager.

anntzer · anntzer · commit a77ef75ded0b · 2019-04-25T22:44:10.000+02:00
TexManager has a complex caching machinery (... among other caching
layers) to map font-related rcParams to a tex preamble (see `_rc_cache`,
`_rc_cache_keys`, `_reinit`) but that's just a matter of a few dict
lookups which are negligible compared to invoking the subprocess; so
just strip out that caching and always regenerate the font-related
preamble.

That caching also set some attributes (`texmanager.serif`, etc.) as a
side-effect via `setattr`/`getattr`, which are used nowhere else (and
it's hard to know they even exist other than figuring out the relevant
`setattr` calls); just deprecate them.
diff --git a/doc/api/next_api_changes/2019-04-25-AL.rst b/doc/api/next_api_changes/2019-04-25-AL.rst
@@ -0,0 +1,5 @@
+Deprecations
+````````````
+
+The ``TexManager.serif``, ``TexManager.sans_serif``, ``TexManager.cursive`` and
+``TexManager.monospace`` attributes are deprecated.
diff --git a/lib/matplotlib/texmanager.py b/lib/matplotlib/texmanager.py
@@ -89,25 +89,40 @@ class TexManager(object):
         'monospace': ('cmtt', ''),
         'computer modern roman': ('cmr', ''),
         'computer modern sans serif': ('cmss', ''),
-        'computer modern typewriter': ('cmtt', '')}
-
-    _rc_cache = None
-    _rc_cache_keys = (
-        ('text.latex.preamble', 'text.latex.unicode', 'text.latex.preview',
-         'font.family') + tuple('font.' + n for n in font_families))
+        'computer modern typewriter': ('cmtt', ''),
+    }
 
     @functools.lru_cache()  # Always return the same instance.
     def __new__(cls):
-        self = object.__new__(cls)
-        self._reinit()
-        return self
-
-    def _reinit(self):
-        if self.texcache is None:
+        if cls.texcache is None:
             raise RuntimeError('Cannot create TexManager, as there is no '
                                'cache directory available')
+        Path(cls.texcache).mkdir(parents=True, exist_ok=True)
+        return object.__new__(cls)
+
+    _fonts = {}  # Only for deprecation period.
+
+    @cbook.deprecated("3.2")
+    @property
+    def serif(self):
+        return self._fonts["serif"]
+
+    @cbook.deprecated("3.2")
+    @property
+    def sans_serif(self):
+        return self._fonts["sans-serif"]
+
+    @cbook.deprecated("3.2")
+    @property
+    def cursive(self):
+        return self._fonts["cursive"]
 
-        Path(self.texcache).mkdir(parents=True, exist_ok=True)
+    @cbook.deprecated("3.2")
+    @property
+    def monospace(self):
+        return self._fonts["monospace"]
+
+    def get_font_config(self):
         ff = rcParams['font.family']
         if len(ff) == 1 and ff[0].lower() in self.font_families:
             self.font_family = ff[0].lower()
@@ -121,11 +136,9 @@ def _reinit(self):
 
         fontconfig = [self.font_family]
         for font_family in self.font_families:
-            font_family_attr = font_family.replace('-', '_')
             for font in rcParams['font.' + font_family]:
                 if font.lower() in self.font_info:
-                    setattr(self, font_family_attr,
-                            self.font_info[font.lower()])
+                    self._fonts[font_family] = self.font_info[font.lower()]
                     _log.debug('family: %s, font: %s, info: %s',
                                font_family, font, self.font_info[font.lower()])
                     break
@@ -135,22 +148,25 @@ def _reinit(self):
             else:
                 _log.info('No LaTeX-compatible font found for the %s font '
                           'family in rcParams. Using default.', font_family)
-                setattr(self, font_family_attr, self.font_info[font_family])
-            fontconfig.append(getattr(self, font_family_attr)[0])
-        # Add a hash of the latex preamble to self._fontconfig so that the
+                self._fonts[font_family] = self.font_info[font_family]
+            fontconfig.append(self._fonts[font_family][0])
+        # Add a hash of the latex preamble to fontconfig so that the
         # correct png is selected for strings rendered with same font and dpi
         # even if the latex preamble changes within the session
         preamble_bytes = self.get_custom_preamble().encode('utf-8')
         fontconfig.append(hashlib.md5(preamble_bytes).hexdigest())
-        self._fontconfig = ''.join(fontconfig)
 
         # The following packages and commands need to be included in the latex
         # file's preamble:
-        cmd = [self.serif[1], self.sans_serif[1], self.monospace[1]]
+        cmd = [self._fonts['serif'][1],
+               self._fonts['sans-serif'][1],
+               self._fonts['monospace'][1]]
         if self.font_family == 'cursive':
-            cmd.append(self.cursive[1])
+            cmd.append(self._fonts['cursive'][1])
         self._font_preamble = '\n'.join(
-            [r'\usepackage{type1cm}'] + cmd + [r'\usepackage{textcomp}'])
+            [r'\usepackage{type1cm}', *cmd, r'\usepackage{textcomp}'])
+
+        return ''.join(fontconfig)
 
     def get_basefile(self, tex, fontsize, dpi=None):
         """
@@ -161,24 +177,6 @@ def get_basefile(self, tex, fontsize, dpi=None):
         return os.path.join(
             self.texcache, hashlib.md5(s.encode('utf-8')).hexdigest())
 
-    def get_font_config(self):
-        """Reinitializes self if relevant rcParams on have changed."""
-        if self._rc_cache is None:
-            self._rc_cache = dict.fromkeys(self._rc_cache_keys)
-        changed = [par for par in self._rc_cache_keys
-                   if rcParams[par] != self._rc_cache[par]]
-        if changed:
-            _log.debug('following keys changed: %s', changed)
-            for k in changed:
-                _log.debug('%-20s: %-10s -> %-10s',
-                           k, self._rc_cache[k], rcParams[k])
-                # deepcopy may not be necessary, but feels more future-proof
-                self._rc_cache[k] = copy.deepcopy(rcParams[k])
-            _log.debug('RE-INIT\nold fontconfig: %s', self._fontconfig)
-            self._reinit()
-        _log.debug('fontconfig: %s', self._fontconfig)
-        return self._fontconfig
-
     def get_font_preamble(self):
         """
         Return a string containing font configuration for the tex preamble.
