Added keyword argument to PsfontsMap to allow find_tex_file

oscargus · oscargus · commit d345e26d3a98 · 2022-01-08T14:39:38.000+01:00
diff --git a/doc/api/next_api_changes/deprecations/22127-OG.rst b/doc/api/next_api_changes/deprecations/22127-OG.rst
@@ -0,0 +1,22 @@
+Classes, functions, and named tuples in ``dviread`` deprecated
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The classes
+- ``DviFont``,
+- ``Vf``,
+- ``Tfm``,
+the function
+- ``find_tex_file``
+and the named tuples
+- ``Box``,
+- ``Page``,
+- ``Text``
+from the module ``matplotlib.dviread`` are considered internal and public
+access is deprecated.
+
+
+Module ``texmanager`` deprecated
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The module ``matplotlib.texmanager`` is considered internal and public access
+is deprecated.
diff --git a/lib/matplotlib/_dviread.py b/lib/matplotlib/_dviread.py
@@ -18,7 +18,6 @@
 """
 
 from collections import namedtuple
-import enum
 from functools import lru_cache, partial, wraps
 import logging
 import os
@@ -297,186 +296,6 @@ def __init__(self, filename):
             self.depth[char] = depths[byte1 & 0xf]
 
 
-PsFont = namedtuple('PsFont', 'texname psname effects encoding filename')
-
-
-class PsfontsMap:
-    """
-    A psfonts.map formatted file, mapping TeX fonts to PS fonts.
-
-    Parameters
-    ----------
-    filename : str or path-like
-
-    Notes
-    -----
-    For historical reasons, TeX knows many Type-1 fonts by different
-    names than the outside world. (For one thing, the names have to
-    fit in eight characters.) Also, TeX's native fonts are not Type-1
-    but Metafont, which is nontrivial to convert to PostScript except
-    as a bitmap. While high-quality conversions to Type-1 format exist
-    and are shipped with modern TeX distributions, we need to know
-    which Type-1 fonts are the counterparts of which native fonts. For
-    these reasons a mapping is needed from internal font names to font
-    file names.
-
-    A texmf tree typically includes mapping files called e.g.
-    :file:`psfonts.map`, :file:`pdftex.map`, or :file:`dvipdfm.map`.
-    The file :file:`psfonts.map` is used by :program:`dvips`,
-    :file:`pdftex.map` by :program:`pdfTeX`, and :file:`dvipdfm.map`
-    by :program:`dvipdfm`. :file:`psfonts.map` might avoid embedding
-    the 35 PostScript fonts (i.e., have no filename for them, as in
-    the Times-Bold example above), while the pdf-related files perhaps
-    only avoid the "Base 14" pdf fonts. But the user may have
-    configured these files differently.
-
-    Examples
-    --------
-    >>> map = PsfontsMap(find_tex_file('pdftex.map'))
-    >>> entry = map[b'ptmbo8r']
-    >>> entry.texname
-    b'ptmbo8r'
-    >>> entry.psname
-    b'Times-Bold'
-    >>> entry.encoding
-    '/usr/local/texlive/2008/texmf-dist/fonts/enc/dvips/base/8r.enc'
-    >>> entry.effects
-    {'slant': 0.16700000000000001}
-    >>> entry.filename
-    """
-    __slots__ = ('_filename', '_unparsed', '_parsed')
-
-    # Create a filename -> PsfontsMap cache, so that calling
-    # `PsfontsMap(filename)` with the same filename a second time immediately
-    # returns the same object.
-    @lru_cache()
-    def __new__(cls, filename):
-        self = object.__new__(cls)
-        self._filename = os.fsdecode(filename)
-        # Some TeX distributions have enormous pdftex.map files which would
-        # take hundreds of milliseconds to parse, but it is easy enough to just
-        # store the unparsed lines (keyed by the first word, which is the
-        # texname) and parse them on-demand.
-        with open(filename, 'rb') as file:
-            self._unparsed = {}
-            for line in file:
-                tfmname = line.split(b' ', 1)[0]
-                self._unparsed.setdefault(tfmname, []).append(line)
-        self._parsed = {}
-        return self
-
-    def __getitem__(self, texname):
-        assert isinstance(texname, bytes)
-        if texname in self._unparsed:
-            for line in self._unparsed.pop(texname):
-                if self._parse_and_cache_line(line):
-                    break
-        try:
-            return self._parsed[texname]
-        except KeyError:
-            raise LookupError(
-                f"An associated PostScript font (required by Matplotlib) "
-                f"could not be found for TeX font {texname.decode('ascii')!r} "
-                f"in {self._filename!r}; this problem can often be solved by "
-                f"installing a suitable PostScript font package in your TeX "
-                f"package manager") from None
-
-    def _parse_and_cache_line(self, line):
-        """
-        Parse a line in the font mapping file.
-
-        The format is (partially) documented at
-        http://mirrors.ctan.org/systems/doc/pdftex/manual/pdftex-a.pdf
-        https://tug.org/texinfohtml/dvips.html#psfonts_002emap
-        Each line can have the following fields:
-
-        - tfmname (first, only required field),
-        - psname (defaults to tfmname, must come immediately after tfmname if
-          present),
-        - fontflags (integer, must come immediately after psname if present,
-          ignored by us),
-        - special (SlantFont and ExtendFont, only field that is double-quoted),
-        - fontfile, encodingfile (optional, prefixed by <, <<, or <[; << always
-          precedes a font, <[ always precedes an encoding, < can precede either
-          but then an encoding file must have extension .enc; < and << also
-          request different font subsetting behaviors but we ignore that; < can
-          be separated from the filename by whitespace).
-
-        special, fontfile, and encodingfile can appear in any order.
-        """
-        # If the map file specifies multiple encodings for a font, we
-        # follow pdfTeX in choosing the last one specified. Such
-        # entries are probably mistakes but they have occurred.
-        # https://tex.stackexchange.com/q/10826/
-
-        if not line or line.startswith((b" ", b"%", b"*", b";", b"#")):
-            return
-        tfmname = basename = special = encodingfile = fontfile = None
-        is_subsetted = is_t1 = is_truetype = False
-        matches = re.finditer(br'"([^"]*)(?:"|$)|(\S+)', line)
-        for match in matches:
-            quoted, unquoted = match.groups()
-            if unquoted:
-                if unquoted.startswith(b"<<"):  # font
-                    fontfile = unquoted[2:]
-                elif unquoted.startswith(b"<["):  # encoding
-                    encodingfile = unquoted[2:]
-                elif unquoted.startswith(b"<"):  # font or encoding
-                    word = (
-                        # <foo => foo
-                        unquoted[1:]
-                        # < by itself => read the next word
-                        or next(filter(None, next(matches).groups())))
-                    if word.endswith(b".enc"):
-                        encodingfile = word
-                    else:
-                        fontfile = word
-                        is_subsetted = True
-                elif tfmname is None:
-                    tfmname = unquoted
-                elif basename is None:
-                    basename = unquoted
-            elif quoted:
-                special = quoted
-        effects = {}
-        if special:
-            words = reversed(special.split())
-            for word in words:
-                if word == b"SlantFont":
-                    effects["slant"] = float(next(words))
-                elif word == b"ExtendFont":
-                    effects["extend"] = float(next(words))
-
-        # Verify some properties of the line that would cause it to be ignored
-        # otherwise.
-        if fontfile is not None:
-            if fontfile.endswith((b".ttf", b".ttc")):
-                is_truetype = True
-            elif not fontfile.endswith(b".otf"):
-                is_t1 = True
-        elif basename is not None:
-            is_t1 = True
-        if is_truetype and is_subsetted and encodingfile is None:
-            return
-        if not is_t1 and ("slant" in effects or "extend" in effects):
-            return
-        if abs(effects.get("slant", 0)) > 1:
-            return
-        if abs(effects.get("extend", 0)) > 2:
-            return
-
-        if basename is None:
-            basename = tfmname
-        if encodingfile is not None:
-            encodingfile = _find_tex_file(encodingfile)
-        if fontfile is not None:
-            fontfile = _find_tex_file(fontfile)
-        self._parsed[tfmname] = PsFont(
-            texname=tfmname, psname=basename, effects=effects,
-            encoding=encodingfile, filename=fontfile)
-        return True
-
-
 def _parse_enc(path):
     r"""
     Parse a \*.enc file referenced from a psfonts.map style file.
diff --git a/lib/matplotlib/backends/backend_pdf.py b/lib/matplotlib/backends/backend_pdf.py
@@ -26,7 +26,7 @@
 from PIL import Image
 
 import matplotlib as mpl
-from matplotlib import _api, _text_helpers, cbook
+from matplotlib import _api, _dviread, _text_helpers, cbook, dviread
 from matplotlib._pylab_helpers import Gcf
 from matplotlib.backend_bases import (
     _Backend, FigureCanvasBase, FigureManagerBase, GraphicsContextBase,
@@ -36,8 +36,6 @@
 from matplotlib.font_manager import findfont, get_font
 from matplotlib.afm import AFM
 import matplotlib.type1font as type1font
-import matplotlib._dviread as _dviread
-import matplotlib.dviread as dviread
 from matplotlib.ft2font import (FIXED_WIDTH, ITALIC, LOAD_NO_SCALE,
                                 LOAD_NO_HINTING, KERNING_UNFITTED, FT2Font)
 from matplotlib.mathtext import MathTextParser
@@ -892,8 +890,7 @@ def dviFontName(self, dvifont):
         if dvi_info is not None:
             return dvi_info.pdfname
 
-        tex_font_map = _dviread.PsfontsMap(
-            _dviread._find_tex_file('pdftex.map'))
+        tex_font_map = dviread.PsfontsMap()
         psfont = tex_font_map[dvifont.texname]
         if psfont.filename is None:
             raise ValueError(
diff --git a/lib/matplotlib/dviread.py b/lib/matplotlib/dviread.py
@@ -26,10 +26,27 @@
 
 import numpy as np
 
-from matplotlib import _api, cbook, _dviread, _dviread_vf
+from matplotlib import _api, _dviread
 
 _log = logging.getLogger(__name__)
 
+
+@_api.caching_module_getattr
+class __getattr__:
+    locals().update({
+        name: _api.deprecated("3.6")(
+            property(lambda self, _mod=_dviread,
+                     _name=name: getattr(_mod, _name)))
+        for name in ["Book", "Page", "Text", "DviFont", "Tfm",
+                    "find_tex_file"]})
+
+@_api.deprecated("3.6")
+class Vf:
+    def __init__(self, filename):
+        from matplotlib import _vf
+        return _vf.Vf(filename)
+
+
 # Many dvi related files are looked for by external processes, require
 # additional parsing, and are used many times per rendering, which is why they
 # are cached using lru_cache().
@@ -357,7 +374,8 @@ def _fnt_def_real(self, k, c, s, d, a, l):
         if c != 0 and tfm.checksum != 0 and c != tfm.checksum:
             raise ValueError('tfm checksum mismatch: %s' % n)
         try:
-            vf = _dviread_vf._vffile(fontname)
+            from matplotlib._vf import _vffile
+            vf = _vffile(fontname)
         except FileNotFoundError:
             vf = None
         self.fonts[k] = _dviread.DviFont(scale=s, tfm=tfm, texname=n, vf=vf)
@@ -406,6 +424,10 @@ class PsfontsMap:
     ----------
     filename : str or path-like
 
+    find_tex_file : bool (default False)
+        If ``True``, *filename* is looked up in the tex build directory.
+        If ``False`` (default), *filename* must be a fully qualified path.
+
     Notes
     -----
     For historical reasons, TeX knows many Type-1 fonts by different
@@ -430,7 +452,7 @@ class PsfontsMap:
 
     Examples
     --------
-    >>> map = PsfontsMap(find_tex_file('pdftex.map'))
+    >>> map = PsfontsMap('pdftex.map', find_tex_file=True)
     >>> entry = map[b'ptmbo8r']
     >>> entry.texname
     b'ptmbo8r'
@@ -448,9 +470,12 @@ class PsfontsMap:
     # `PsfontsMap(filename)` with the same filename a second time immediately
     # returns the same object.
     @lru_cache()
-    def __new__(cls, filename):
+    def __new__(cls, filename, *, find_tex_file=False):
         self = object.__new__(cls)
-        self._filename = os.fsdecode(filename)
+        if find_tex_file:
+            self._filename = os.fsdecode(_dviread.find_tex_file(filename))
+        else:
+            self._filename = os.fsdecode(filename)
         # Some TeX distributions have enormous pdftex.map files which would
         # take hundreds of milliseconds to parse, but it is easy enough to just
         # store the unparsed lines (keyed by the first word, which is the
@@ -584,7 +609,7 @@ def _parse_and_cache_line(self, line):
     parser.add_argument("dpi", nargs="?", type=float, default=None)
     args = parser.parse_args()
     with Dvi(args.filename, args.dpi) as dvi:
-        fontmap = PsfontsMap(_dviread._find_tex_file('pdftex.map'))
+        fontmap = PsfontsMap("pdftex.map", find_tex_file=True)
         for page in dvi:
             print(f"=== new page === "
                   f"(w: {page.width}, h: {page.height}, d: {page.descent})")
diff --git a/lib/matplotlib/textpath.py b/lib/matplotlib/textpath.py
@@ -279,7 +279,7 @@ def get_glyphs_tex(self, prop, s, glyph_map=None,
     @staticmethod
     @functools.lru_cache(50)
     def _get_ps_font_and_encoding(texname):
-        tex_font_map = dviread.get_tex_font_map('pdftex.map')
+        tex_font_map = dviread.PsfontsMap('pdftex.map', find_tex_file=True)
         psfont = tex_font_map[texname]
         if psfont.filename is None:
             raise ValueError(
