Revert "Merge pull request #9677 from anntzer/more-lru_cache"

tacaswell · tacaswell · commit ead1bb32f5c6 · 2018-03-15T19:57:05.000-04:00
This reverts commit 5730794, reversing changes made to 1ca3d1a. Fixes #10740 by avoiding suspected bugs in backports.lru_cache
diff --git a/lib/matplotlib/backends/backend_agg.py b/lib/matplotlib/backends/backend_agg.py
@@ -31,6 +31,8 @@
 from matplotlib import cbook, rcParams, __version__
 from matplotlib.backend_bases import (
     _Backend, FigureCanvasBase, FigureManagerBase, RendererBase, cursors)
+from matplotlib.cbook import maxdict
+from matplotlib.figure import Figure
 from matplotlib.font_manager import findfont, get_font
 from matplotlib.ft2font import (LOAD_FORCE_AUTOHINT, LOAD_NO_HINTING,
                                 LOAD_DEFAULT, LOAD_NO_AUTOHINT)
diff --git a/lib/matplotlib/backends/backend_svg.py b/lib/matplotlib/backends/backend_svg.py
@@ -22,6 +22,7 @@
 from matplotlib.backend_bases import (
      _Backend, FigureCanvasBase, FigureManagerBase, RendererBase)
 from matplotlib.backends.backend_mixed import MixedModeRenderer
+from matplotlib.cbook import is_writable_file_like, maxdict
 from matplotlib.colors import rgb2hex
 from matplotlib.font_manager import findfont, get_font
 from matplotlib.ft2font import LOAD_NO_HINTING
@@ -259,6 +260,9 @@ def generate_css(attrib={}):
 
 _capstyle_d = {'projecting' : 'square', 'butt' : 'butt', 'round': 'round',}
 class RendererSVG(RendererBase):
+    FONT_SCALE = 100.0
+    fontd = maxdict(50)
+
     def __init__(self, width, height, svgwriter, basename=None, image_dpi=72):
         self.width = width
         self.height = height
diff --git a/lib/matplotlib/colors.py b/lib/matplotlib/colors.py
@@ -111,7 +111,8 @@ def _is_nth_color(c):
 
 def is_color_like(c):
     """Return whether *c* can be interpreted as an RGB(A) color."""
-    # Special-case nth color syntax because it cannot be parsed during setup.
+    # Special-case nth color syntax because it cannot be parsed during
+    # setup.
     if _is_nth_color(c):
         return True
     try:
diff --git a/lib/matplotlib/font_manager.py b/lib/matplotlib/font_manager.py
@@ -994,7 +994,6 @@ def _normalize_font_family(family):
     return family
 
 
-@cbook.deprecated("2.2")
 class TempCache(object):
     """
     A class to store temporary caches that are (a) not saved to disk
@@ -1279,20 +1278,6 @@ def findfont(self, prop, fontext='ttf', directory=None,
         <http://www.w3.org/TR/1998/REC-CSS2-19980512/>`_ documentation
         for a description of the font finding algorithm.
         """
-        # Pass the relevant rcParams (and the font manager, as `self`) to
-        # _findfont_cached so to prevent using a stale cache entry after an
-        # rcParam was changed.
-        rc_params = tuple(tuple(rcParams[key]) for key in [
-            "font.serif", "font.sans-serif", "font.cursive", "font.fantasy",
-            "font.monospace"])
-        return self._findfont_cached(
-            prop, fontext, directory, fallback_to_default, rebuild_if_missing,
-            rc_params)
-
-    @lru_cache()
-    def _findfont_cached(self, prop, fontext, directory, fallback_to_default,
-                         rebuild_if_missing, rc_params):
-
         if not isinstance(prop, FontProperties):
             prop = FontProperties(prop)
         fname = prop.get_file()
@@ -1306,7 +1291,11 @@ def _findfont_cached(self, prop, fontext, directory, fallback_to_default,
         else:
             fontlist = self.ttflist
 
-        if directory is not None:
+        if directory is None:
+            cached = _lookup_cache[fontext].get(prop)
+            if cached is not None:
+                return cached
+        else:
             directory = os.path.normcase(directory)
 
         best_score = 1e64
@@ -1364,20 +1353,26 @@ def _findfont_cached(self, prop, fontext, directory, fallback_to_default,
             else:
                 raise ValueError("No valid font could be found")
 
+        if directory is None:
+            _lookup_cache[fontext].set(prop, result)
         return result
 
-@lru_cache()
+_is_opentype_cff_font_cache = {}
 def is_opentype_cff_font(filename):
     """
     Returns True if the given font is a Postscript Compact Font Format
     Font embedded in an OpenType wrapper.  Used by the PostScript and
     PDF backends that can not subset these fonts.
     """
     if os.path.splitext(filename)[1].lower() == '.otf':
-        with open(filename, 'rb') as fd:
-            return fd.read(4) == b"OTTO"
-    else:
-        return False
+        result = _is_opentype_cff_font_cache.get(filename)
+        if result is None:
+            with open(filename, 'rb') as fd:
+                tag = fd.read(4)
+            result = (tag == b'OTTO')
+            _is_opentype_cff_font_cache[filename] = result
+        return result
+    return False
 
 fontManager = None
 _fmcache = None
@@ -1444,6 +1439,11 @@ def findfont(prop, fontext='ttf'):
 
     fontManager = None
 
+    _lookup_cache = {
+        'ttf': TempCache(),
+        'afm': TempCache()
+    }
+
     def _rebuild():
         global fontManager
 
diff --git a/lib/matplotlib/mathtext.py b/lib/matplotlib/mathtext.py
@@ -25,11 +25,7 @@
 import unicodedata
 from warnings import warn
 
-try:
-    from functools import lru_cache
-except ImportError:  # Py2
-    from backports.functools_lru_cache import lru_cache
-
+from numpy import inf, isinf
 import numpy as np
 
 from pyparsing import (
@@ -3251,8 +3247,8 @@ def __init__(self, output):
         Create a MathTextParser for the given backend *output*.
         """
         self._output = output.lower()
+        self._cache = maxdict(50)
 
-    @lru_cache(50)
     def parse(self, s, dpi = 72, prop = None):
         """
         Parse the given math expression *s* at the given *dpi*.  If
@@ -3264,10 +3260,16 @@ def parse(self, s, dpi = 72, prop = None):
         The results are cached, so multiple calls to :meth:`parse`
         with the same expression should be fast.
         """
-
+        # There is a bug in Python 3.x where it leaks frame references,
+        # and therefore can't handle this caching
         if prop is None:
             prop = FontProperties()
 
+        cacheKey = (s, dpi, hash(prop))
+        result = self._cache.get(cacheKey)
+        if result is not None:
+            return result
+
         if self._output == 'ps' and rcParams['ps.useafm']:
             font_output = StandardPsFonts(prop)
         else:
@@ -3290,7 +3292,9 @@ def parse(self, s, dpi = 72, prop = None):
 
         box = self._parser.parse(s, font_output, fontsize, dpi)
         font_output.set_canvas_size(box.width, box.height, box.depth)
-        return font_output.get_results(box)
+        result = font_output.get_results(box)
+        self._cache[cacheKey] = result
+        return result
 
     def to_mask(self, texstr, dpi=120, fontsize=14):
         """
diff --git a/lib/matplotlib/path.py b/lib/matplotlib/path.py
@@ -16,11 +16,6 @@
 
 from weakref import WeakValueDictionary
 
-try:
-    from functools import lru_cache
-except ImportError:  # Py2
-    from backports.functools_lru_cache import lru_cache
-
 import numpy as np
 
 from . import _path, rcParams
@@ -940,17 +935,27 @@ def wedge(cls, theta1, theta2, n=None):
         """
         return cls.arc(theta1, theta2, n, True)
 
-    @staticmethod
-    @lru_cache(8)
-    def hatch(hatchpattern, density=6):
+    _hatch_dict = maxdict(8)
+
+    @classmethod
+    def hatch(cls, hatchpattern, density=6):
         """
         Given a hatch specifier, *hatchpattern*, generates a Path that
         can be used in a repeated hatching pattern.  *density* is the
         number of lines per unit square.
         """
         from matplotlib.hatch import get_path
-        return (get_path(hatchpattern, density)
-                if hatchpattern is not None else None)
+
+        if hatchpattern is None:
+            return None
+
+        hatch_path = cls._hatch_dict.get((hatchpattern, density))
+        if hatch_path is not None:
+            return hatch_path
+
+        hatch_path = get_path(hatchpattern, density)
+        cls._hatch_dict[(hatchpattern, density)] = hatch_path
+        return hatch_path
 
     def clip_to_bbox(self, bbox, inside=True):
         """
diff --git a/lib/matplotlib/textpath.py b/lib/matplotlib/textpath.py
@@ -33,6 +33,9 @@ class TextToPath(object):
     DPI = 72
 
     def __init__(self):
+        """
+        Initialization
+        """
         self.mathtext_parser = MathTextParser('path')
         self.tex_font_map = None
 
@@ -489,7 +492,8 @@ def _revalidate_path(self):
         necessary.
 
         """
-        if self._invalid or self._cached_vertices is None:
+        if (self._invalid or
+            (self._cached_vertices is None)):
             tr = Affine2D().scale(
                     self._size / text_to_path.FONT_SCALE,
                     self._size / text_to_path.FONT_SCALE).translate(*self._xy)
