Py3fy mathtext.py.

anntzer · anntzer · commit 86a1f7829c73 · 2018-02-18T07:11:17.000-08:00
diff --git a/doc/api/next_api_changes/2018-02-15-AL-deprecations.rst b/doc/api/next_api_changes/2018-02-15-AL-deprecations.rst
@@ -1,4 +1,5 @@
 Deprecations
 ````````````
-``cbook.is_numlike`` is deprecated.  Use ``isinstance(..., numbers.Number)``
-instead.
+The following functions are deprecated:
+- ``cbook.is_numlike`` (use ``isinstance(..., numbers.Number)`` instead)
+- ``mathtext.unichr_safe`` (use ``chr`` instead)
diff --git a/lib/matplotlib/mathtext.py b/lib/matplotlib/mathtext.py
@@ -14,18 +14,13 @@
 arbitrary fonts, but results may vary without proper tweaking and
 metrics for those fonts.
 """
-from __future__ import (absolute_import, division, print_function,
-                        unicode_literals)
-
-import six
-from six import unichr
 
+import functools
+from io import StringIO
 import os
-from math import ceil
 import types
 import unicodedata
-from warnings import warn
-from functools import lru_cache
+import warnings
 
 import numpy as np
 
@@ -36,7 +31,7 @@
 
 ParserElement.enablePackrat()
 
-from matplotlib import _png, colors as mcolors, get_data_path, rcParams
+from matplotlib import _png, cbook, colors as mcolors, get_data_path, rcParams
 from matplotlib.afm import AFM
 from matplotlib.cbook import get_realpath_and_stat
 from matplotlib.ft2font import FT2Image, KERNING_DEFAULT, LOAD_NO_HINTING
@@ -81,14 +76,9 @@ def get_unicode_index(symbol, math=True):
 TeX/Type1 symbol"""%locals()
         raise ValueError(message)
 
-def unichr_safe(index):
-    """Return the Unicode character corresponding to the index,
-or the replacement character if this is a narrow build of Python
-and the requested character is outside the BMP."""
-    try:
-        return unichr(index)
-    except ValueError:
-        return unichr(0xFFFD)
+
+unichr_safe = cbook.deprecated("3.0")(chr)
+
 
 class MathtextBackend(object):
     """
@@ -166,7 +156,7 @@ def _update_bbox(self, x1, y1, x2, y2):
     def set_canvas_size(self, w, h, d):
         MathtextBackend.set_canvas_size(self, w, h, d)
         if self.mode != 'bbox':
-            self.image = FT2Image(ceil(w), ceil(h + max(d, 0)))
+            self.image = FT2Image(np.ceil(w), np.ceil(h + max(d, 0)))
 
     def render_glyph(self, ox, oy, info):
         if self.mode == 'bbox':
@@ -189,7 +179,7 @@ def render_rect_filled(self, x1, y1, x2, y2):
                 y = int(center - (height + 1) / 2.0)
             else:
                 y = int(y1)
-            self.image.draw_rect_filled(int(x1), y, ceil(x2), y + height)
+            self.image.draw_rect_filled(int(x1), y, np.ceil(x2), y + height)
 
     def get_results(self, box, used_characters):
         self.mode = 'bbox'
@@ -230,7 +220,7 @@ class MathtextBackendPs(MathtextBackend):
     backend.
     """
     def __init__(self):
-        self.pswriter = six.moves.cStringIO()
+        self.pswriter = StringIO()
         self.lastfont = None
 
     def render_glyph(self, ox, oy, info):
@@ -361,7 +351,7 @@ def __init__(self):
 
     def render_glyph(self, ox, oy, info):
         oy = oy - info.offset - self.height
-        thetext = unichr_safe(info.num)
+        thetext = chr(info.num)
         self.glyphs.append(
             (info.font, info.fontsize, thetext, ox, oy))
 
@@ -464,8 +454,9 @@ def set_canvas_size(self, w, h, d):
         Set the size of the buffer used to render the math expression.
         Only really necessary for the bitmap backends.
         """
-        self.width, self.height, self.depth = ceil(w), ceil(h), ceil(d)
-        self.mathtext_backend.set_canvas_size(self.width, self.height, self.depth)
+        self.width, self.height, self.depth = np.ceil([w, h, d])
+        self.mathtext_backend.set_canvas_size(
+            self.width, self.height, self.depth)
 
     def render_glyph(self, ox, oy, facename, font_class, sym, fontsize, dpi):
         """
@@ -661,7 +652,7 @@ def __init__(self, *args, **kwargs):
 
         TruetypeFonts.__init__(self, *args, **kwargs)
         self.fontmap = {}
-        for key, val in six.iteritems(self._fontmap):
+        for key, val in self._fontmap.items():
             fullpath = findfont(val)
             self.fontmap[key] = fullpath
             self.fontmap[val] = fullpath
@@ -801,9 +792,9 @@ def _get_glyph(self, fontname, font_class, sym, fontsize, math=True):
                 found_symbol = True
             except ValueError:
                 uniindex = ord('?')
-                warn("No TeX to unicode mapping for '%s'" %
-                     sym.encode('ascii', 'backslashreplace'),
-                     MathTextWarning)
+                warnings.warn(
+                    "No TeX to unicode mapping for {!a}.".format(sym),
+                    MathTextWarning)
 
         fontname, uniindex = self._map_virtual_font(
             fontname, font_class, uniindex)
@@ -815,7 +806,7 @@ def _get_glyph(self, fontname, font_class, sym, fontsize, math=True):
         if found_symbol:
             if fontname == 'it':
                 if uniindex < 0x10000:
-                    unistring = unichr(uniindex)
+                    unistring = chr(uniindex)
                     if (not unicodedata.category(unistring)[0] == "L"
                         or unicodedata.name(unistring).startswith("GREEK CAPITAL")):
                         new_fontname = 'rm'
@@ -831,8 +822,9 @@ def _get_glyph(self, fontname, font_class, sym, fontsize, math=True):
         if not found_symbol:
             if self.cm_fallback:
                 if isinstance(self.cm_fallback, BakomaFonts):
-                    warn("Substituting with a symbol from Computer Modern.",
-                         MathTextWarning)
+                    warnings.warn(
+                        "Substituting with a symbol from Computer Modern.",
+                        MathTextWarning)
                 if (fontname in ('it', 'regular') and
                         isinstance(self.cm_fallback, StixFonts)):
                     return self.cm_fallback._get_glyph(
@@ -841,14 +833,14 @@ def _get_glyph(self, fontname, font_class, sym, fontsize, math=True):
                     return self.cm_fallback._get_glyph(
                         fontname, font_class, sym, fontsize)
             else:
-                if fontname in ('it', 'regular') and isinstance(self, StixFonts):
+                if (fontname in ('it', 'regular')
+                        and isinstance(self, StixFonts)):
                     return self._get_glyph('rm', font_class, sym, fontsize)
-                warn("Font '%s' does not have a glyph for '%s' [U+%x]" %
-                     (new_fontname,
-                      sym.encode('ascii', 'backslashreplace').decode('ascii'),
-                      uniindex),
-                     MathTextWarning)
-                warn("Substituting with a dummy symbol.", MathTextWarning)
+                warnings.warn(
+                    "Font {!r} does not have a glyph for {!a} [U+{:x}], "
+                    "substituting with a dummy symbol.".format(
+                        new_fontname, sym, uniindex),
+                    MathTextWarning)
                 fontname = 'rm'
                 new_fontname = fontname
                 font = self._get_font(fontname)
@@ -885,7 +877,7 @@ def __init__(self, *args, **kwargs):
                  3 : 'STIXSizeThreeSym',
                  4 : 'STIXSizeFourSym',
                  5 : 'STIXSizeFiveSym'})
-        for key, name in six.iteritems(self._fontmap):
+        for key, name in self._fontmap.items():
             fullpath = findfont(name)
             self.fontmap[key] = fullpath
             self.fontmap[name] = fullpath
@@ -972,7 +964,7 @@ class StixFonts(UnicodeFonts):
     def __init__(self, *args, **kwargs):
         TruetypeFonts.__init__(self, *args, **kwargs)
         self.fontmap = {}
-        for key, name in six.iteritems(self._fontmap):
+        for key, name in self._fontmap.items():
             fullpath = findfont(name)
             self.fontmap[key] = fullpath
             self.fontmap[name] = fullpath
@@ -1048,7 +1040,7 @@ def get_sized_alternatives_for_symbol(self, fontname, sym):
             font = self._get_font(i)
             glyphindex = font.get_char_index(uniindex)
             if glyphindex != 0:
-                alternatives.append((i, unichr_safe(uniindex)))
+                alternatives.append((i, chr(uniindex)))
 
         # The largest size of the radical symbol in STIX has incorrect
         # metrics that cause it to be disconnected from the stem.
@@ -1099,7 +1091,7 @@ def __init__(self, default_font_prop):
 
         self.fonts['default'] = default_font
         self.fonts['regular'] = default_font
-        self.pswriter = six.moves.cStringIO()
+        self.pswriter = StringIO()
 
     def _get_font(self, font):
         if font in self.fontmap:
@@ -1117,7 +1109,7 @@ def _get_font(self, font):
             self.fonts[cached_font.get_fontname()] = cached_font
         return cached_font
 
-    def _get_info (self, fontname, font_class, sym, fontsize, dpi, math=True):
+    def _get_info(self, fontname, font_class, sym, fontsize, dpi, math=True):
         'load the cmfont, metrics and glyph with caching'
         key = fontname, sym, fontsize, dpi
         tup = self.glyphd.get(key)
@@ -1128,8 +1120,7 @@ def _get_info (self, fontname, font_class, sym, fontsize, dpi, math=True):
         # Only characters in the "Letter" class should really be italicized.
         # This class includes greek letters, so we're ok
         if (fontname == 'it' and
-            (len(sym) > 1 or
-             not unicodedata.category(six.text_type(sym)).startswith("L"))):
+            (len(sym) > 1 or not unicodedata.category(sym).startswith("L"))):
             fontname = 'rm'
 
         found_symbol = False
@@ -1143,8 +1134,9 @@ def _get_info (self, fontname, font_class, sym, fontsize, dpi, math=True):
             num = ord(glyph)
             found_symbol = True
         else:
-            warn("No TeX to built-in Postscript mapping for {!r}".format(sym),
-                 MathTextWarning)
+            warnings.warn(
+                "No TeX to built-in Postscript mapping for {!r}".format(sym),
+                MathTextWarning)
 
         slanted = (fontname == 'it')
         font = self._get_font(fontname)
@@ -1153,8 +1145,10 @@ def _get_info (self, fontname, font_class, sym, fontsize, dpi, math=True):
             try:
                 symbol_name = font.get_name_char(glyph)
             except KeyError:
-                warn("No glyph in standard Postscript font {!r} for {!r}"
-                     .format(font.get_fontname(), sym), MathTextWarning)
+                warnings.warn(
+                    "No glyph in standard Postscript font {!r} for {!r}"
+                    .format(font.get_fontname(), sym),
+                    MathTextWarning)
                 found_symbol = False
 
         if not found_symbol:
@@ -1581,8 +1575,9 @@ def _set_glue(self, x, sign, totals, error_type):
             self.glue_ratio = 0.
         if o == 0:
             if len(self.children):
-                warn("%s %s: %r" % (error_type, self.__class__.__name__, self),
-                     MathTextWarning)
+                warnings.warn(
+                    "%s %s: %r" % (error_type, self.__class__.__name__, self),
+                    MathTextWarning)
 
     def shrink(self):
         for child in self.children:
@@ -1824,19 +1819,19 @@ def __init__(self, state):
 class Glue(Node):
     """
     Most of the information in this object is stored in the underlying
-    :class:`GlueSpec` class, which is shared between multiple glue objects.  (This
-    is a memory optimization which probably doesn't matter anymore, but it's
-    easier to stick to what TeX does.)
+    :class:`GlueSpec` class, which is shared between multiple glue objects.
+    (This is a memory optimization which probably doesn't matter anymore, but
+    it's easier to stick to what TeX does.)
     """
     def __init__(self, glue_type, copy=False):
         Node.__init__(self)
         self.glue_subtype   = 'normal'
-        if isinstance(glue_type, six.string_types):
+        if isinstance(glue_type, str):
             glue_spec = GlueSpec.factory(glue_type)
         elif isinstance(glue_type, GlueSpec):
             glue_spec = glue_type
         else:
-            raise ValueError("glue_type must be a glue spec name or instance.")
+            raise ValueError("glue_type must be a glue spec name or instance")
         if copy:
             glue_spec = glue_spec.copy()
         self.glue_spec      = glue_spec
@@ -2515,11 +2510,10 @@ def parse(self, s, fonts_object, fontsize, dpi):
         try:
             result = self._expression.parseString(s)
         except ParseBaseException as err:
-            raise ValueError("\n".join([
-                        "",
-                        err.line,
-                        " " * (err.column - 1) + "^",
-                        six.text_type(err)]))
+            raise ValueError("\n".join(["",
+                                        err.line,
+                                        " " * (err.column - 1) + "^",
+                                        str(err)]))
         self._state_stack = None
         self._em_width_cache = {}
         self._expression.resetCache()
@@ -2641,14 +2635,11 @@ def symbol(self, s, loc, toks):
         if c in self._spaced_symbols:
             # iterate until we find previous character, needed for cases
             # such as ${ -2}$, $ -2$, or $   -2$.
-            for i in six.moves.xrange(1, loc + 1):
-                prev_char = s[loc-i]
-                if prev_char != ' ':
-                    break
+            prev_char = next((c for c in s[:loc][::-1] if c != ' '), '')
             # Binary operators at start of string should not be spaced
             if (c in self._binary_operators and
                     (len(s[:loc].split()) == 0 or prev_char == '{' or
-                        prev_char in self._left_delim)):
+                     prev_char in self._left_delim)):
                 return [char]
             else:
                 return [Hlist([self._make_space(0.2),
@@ -2659,20 +2650,13 @@ def symbol(self, s, loc, toks):
 
             # Do not space commas between brackets
             if c == ',':
-                prev_char, next_char = '', ''
-                for i in six.moves.xrange(1, loc + 1):
-                    prev_char = s[loc - i]
-                    if prev_char != ' ':
-                        break
-                for i in six.moves.xrange(1, len(s) - loc):
-                    next_char = s[loc + i]
-                    if next_char != ' ':
-                        break
-                if (prev_char == '{' and next_char == '}'):
+                prev_char = next((c for c in s[:loc][::-1] if c != ' '), '')
+                next_char = next((c for c in s[loc + 1:] if c != ' '), '')
+                if prev_char == '{' and next_char == '}':
                     return [char]
 
             # Do not space dots as decimal separators
-            if (c == '.' and s[loc - 1].isdigit() and s[loc + 1].isdigit()):
+            if c == '.' and s[loc - 1].isdigit() and s[loc + 1].isdigit():
                 return [char]
             else:
                 return [Hlist([char,
@@ -2857,7 +2841,7 @@ def subsuper(self, s, loc, toks):
         napostrophes = 0
         new_toks = []
         for tok in toks[0]:
-            if isinstance(tok, six.string_types) and tok not in ('^', '_'):
+            if isinstance(tok, str) and tok not in ('^', '_'):
                 napostrophes += len(tok)
             elif isinstance(tok, Char) and tok.c == "'":
                 napostrophes += 1
@@ -3249,7 +3233,7 @@ def __init__(self, output):
         """
         self._output = output.lower()
 
-    @lru_cache(50)
+    @functools.lru_cache(50)
     def parse(self, s, dpi = 72, prop = None):
         """
         Parse the given math expression *s* at the given *dpi*.  If
