Call kpsewhich with more arguments at one time

jkseppan · jkseppan · commit 45142123dafb · 2018-01-14T08:46:36.000+02:00
This should improve performance if there is a significant startup cost to running kpsewhich, as reported by some users in #4880.
diff --git a/lib/matplotlib/dviread.py b/lib/matplotlib/dviread.py
@@ -23,7 +23,6 @@
 from six.moves import xrange
 
 from collections import namedtuple
-from contextlib import closing
 from functools import partial, wraps
 import logging
 import numpy as np
@@ -185,8 +184,7 @@ def wrapper(self, byte):
 class Dvi(object):
     """
     A reader for a dvi ("device-independent") file, as produced by TeX.
-    The current implementation can only iterate through pages in order,
-    and does not even attempt to verify the postamble.
+    The current implementation can only iterate through pages in order.
 
     This class can be used as a context manager to close the underlying
     file upon exit. Pages can be read via iteration. Here is an overly
@@ -195,33 +193,55 @@ class Dvi(object):
     >>> with matplotlib.dviread.Dvi('input.dvi', 72) as dvi:
     >>>     for page in dvi:
     >>>         print ''.join(unichr(t.glyph) for t in page.text)
+
+    Parameters
+    ----------
+
+    filename : str
+        dvi file to read
+    dpi : number or None
+        Dots per inch, can be floating-point; this affects the
+        coordinates returned. Use None to get TeX's internal units
+        which are likely only useful for debugging.
+    cache : _tex_support_cache instance, optional
+        Support file cache instance, defaults to the _tex_support_cache
+        singleton.
     """
     # dispatch table
     _dtable = [None for _ in xrange(256)]
     dispatch = partial(_dispatch, _dtable)
 
-    def __init__(self, filename, dpi):
+    def __init__(self, filename, dpi, cache=None):
         """
         Read the data from the file named *filename* and convert
         TeX's internal units to units of *dpi* per inch.
         *dpi* only sets the units and does not limit the resolution.
         Use None to return TeX's internal units.
         """
         _log.debug('Dvi: %s', filename)
+        if cache is None:
+            cache = _tex_support_cache.get_cache()
+        self.cache = cache
         self.file = open(filename, 'rb')
         self.dpi = dpi
         self.fonts = {}
         self.state = _dvistate.pre
         self.baseline = self._get_baseline(filename)
+        self.fontnames = sorted(set(self._read_fonts()))
+        # populate kpsewhich cache with font pathnames
+        find_tex_files([x + suffix for x in self.fontnames
+                        for suffix in ('.tfm', '.vf', '.pfb')],
+                       cache)
+        cache.optimize()
 
     def _get_baseline(self, filename):
         if rcParams['text.latex.preview']:
             base, ext = os.path.splitext(filename)
             baseline_filename = base + ".baseline"
             if os.path.exists(baseline_filename):
                 with open(baseline_filename, 'rb') as fd:
-                    l = fd.read().split()
-                height, depth, width = l
+                    line = fd.read().split()
+                height, depth, width = line
                 return float(depth)
         return None
 
@@ -308,6 +328,62 @@ def _output(self):
         return Page(text=text, boxes=boxes, width=(maxx-minx)*d,
                     height=(maxy_pure-miny)*d, descent=descent)
 
+    def _read_fonts(self):
+        """Read the postamble of the file and return a list of fonts used."""
+
+        file = self.file
+        offset = -1
+        while offset > -100:
+            file.seek(offset, 2)
+            byte = ord(file.read(1)[0])
+            if byte != 223:
+                break
+            offset -= 1
+        if offset >= -4:
+            raise ValueError(
+                "malformed dvi file %s: too few 223 bytes" % file.name)
+        if byte != 2:
+            raise ValueError(
+                ("malformed dvi file %s: post-postamble "
+                 "identification byte not 2") % file.name)
+        file.seek(offset - 4, 2)
+        offset = struct.unpack('!I', file.read(4))[0]
+        file.seek(offset, 0)
+        try:
+            byte = ord(file.read(1)[0])
+        except TypeError:
+            # "ord() expected a character, but string of length 0 found"
+            raise ValueError(
+                "malformed dvi file %s: postamble offset %d out of range"
+                % (file.name, offset))
+        if byte != 248:
+            raise ValueError(
+                "malformed dvi file %s: postamble not found at offset %d"
+                % (file.name, offset))
+
+        fonts = []
+        file.seek(28, 1)
+        while True:
+            byte = ord(file.read(1)[0])
+            if 243 <= byte <= 246:
+                _, _, _, _, a, length = (
+                    _arg_olen1(self, byte-243),
+                    _arg(4, False, self, None),
+                    _arg(4, False, self, None),
+                    _arg(4, False, self, None),
+                    _arg(1, False, self, None),
+                    _arg(1, False, self, None))
+                fontname = file.read(a + length)[-length:].decode('ascii')
+                fonts.append(fontname)
+            elif byte == 249:
+                break
+            else:
+                raise ValueError(
+                    "malformed dvi file %s: opcode %d in postamble"
+                    % (file.name, byte))
+        file.seek(0, 0)
+        return fonts
+
     def _read(self):
         """
         Read one page from the file. Return True if successful,
@@ -616,6 +692,10 @@ class Vf(Dvi):
     ----------
 
     filename : string or bytestring
+        vf file to read
+    cache : _tex_support_cache instance, optional
+        Support file cache instance, defaults to the _tex_support_cache
+        singleton.
 
     Notes
     -----
@@ -626,8 +706,8 @@ class Vf(Dvi):
     but replaces the `_read` loop and dispatch mechanism.
     """
 
-    def __init__(self, filename):
-        Dvi.__init__(self, filename, 0)
+    def __init__(self, filename, cache=None):
+        Dvi.__init__(self, filename, dpi=0, cache=cache)
         try:
             self._first_font = None
             self._chars = {}
@@ -638,6 +718,27 @@ def __init__(self, filename):
     def __getitem__(self, code):
         return self._chars[code]
 
+    def _read_fonts(self):
+        """Read through the font-definition section of the vf file
+        and return the list of font names."""
+        fonts = []
+        self.file.seek(0, 0)
+        while True:
+            byte = ord(self.file.read(1)[0])
+            if byte <= 242 or byte >= 248:
+                break
+            elif 243 <= byte <= 246:
+                _ = self._arg(byte - 242)
+                _, _, _, a, length = [self._arg(x) for x in (4, 4, 4, 1, 1)]
+                fontname = self.file.read(a + length)[-length:].decode('ascii')
+                fonts.append(fontname)
+            elif byte == 247:
+                _, k = self._arg(1), self._arg(1)
+                _ = self.file.read(k)
+                _, _ = self._arg(4), self._arg(4)
+        self.file.seek(0, 0)
+        return fonts
+
     def _read(self):
         """
         Read one page from the file. Return True if successful,
@@ -674,8 +775,8 @@ def _read(self):
                 self._init_packet(packet_len)
             elif 243 <= byte <= 246:
                 k = self._arg(byte - 242, byte == 246)
-                c, s, d, a, l = [self._arg(x) for x in (4, 4, 4, 1, 1)]
-                self._fnt_def_real(k, c, s, d, a, l)
+                c, s, d, a, length = [self._arg(x) for x in (4, 4, 4, 1, 1)]
+                self._fnt_def_real(k, c, s, d, a, length)
                 if self._first_font is None:
                     self._first_font = k
             elif byte == 247:       # preamble
diff --git a/lib/matplotlib/tests/baseline_images/dviread/virtual.vf b/lib/matplotlib/tests/baseline_images/dviread/virtual.vf
diff --git a/lib/matplotlib/tests/baseline_images/dviread/virtual.vpl b/lib/matplotlib/tests/baseline_images/dviread/virtual.vpl
@@ -0,0 +1,23 @@
+(FAMILY TESTING)
+(COMMENT Test data for matplotlib)
+(COMMENT Run vptovf virtual.vpl to obtain virtual.vf)
+(FACE O 352)
+(CODINGSCHEME TEX TEXT)
+(DESIGNSIZE R 10.0)
+(FONTDIMEN
+   (SLANT R 0.0)
+   (SPACE R 0.333334)
+   (STRETCH R 0.166667)
+   (SHRINK R 0.111112)
+   (XHEIGHT R 0.430555)
+   (QUAD R 1.000003)
+   (EXTRASPACE R 0.111112)
+   )
+(MAPFONT D 0
+   (FONTNAME cmr10)
+   (FONTDSIZE R 10.0)
+   )
+(MAPFONT D 1
+   (FONTNAME cmex10)
+   (FONTDSIZE R 10.0)
+   )
diff --git a/lib/matplotlib/tests/test_dviread.py b/lib/matplotlib/tests/test_dviread.py
@@ -80,6 +80,16 @@ def test_dviread():
     assert data == correct
 
 
+@skip_if_command_unavailable(["kpsewhich", "-version"])
+def test_dviread_get_fonts():
+    dir = os.path.join(os.path.dirname(__file__), 'baseline_images', 'dviread')
+    with dr.Dvi(os.path.join(dir, 'test.dvi'), None) as dvi:
+        assert dvi.fontnames == \
+            ['cmex10', 'cmmi10', 'cmmi5', 'cmr10', 'cmr5', 'cmr7']
+    with dr.Vf(os.path.join(dir, 'virtual.vf')) as vf:
+        assert vf.fontnames == ['cmex10', 'cmr10']
+
+
 def test_tex_support_cache(tmpdir):
     dbfile = str(tmpdir / "test.db")
     cache = dr._tex_support_cache(filename=dbfile)
