fonttools 4.58.5__cp310-cp310-win32.whl → 4.59.0__cp310-cp310-win32.whl

fontTools/misc/filesystem/_subfs.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import typing
+from pathlib import PurePosixPath
+
+from ._base import FS
+from ._errors import DirectoryExpected, ResourceNotFound
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Collection
+    from typing import IO, Any
+
+    from ._info import Info
+
+
+class SubFS(FS):
+    """Maps a sub-directory of another filesystem."""
+
+    def __init__(self, parent: FS, sub_path: str):
+        super().__init__()
+        self._parent = parent
+        self._prefix = PurePosixPath(sub_path).as_posix().rstrip("/")
+        if not parent.exists(self._prefix):
+            raise ResourceNotFound(f"No such file or directory: {sub_path!r}")
+        elif not parent.isdir(self._prefix):
+            raise DirectoryExpected(f"{sub_path!r} is not a directory")
+
+    def delegate_fs(self):
+        return self._parent
+
+    def _full(self, rel: str) -> str:
+        self.check()
+        return f"{self._prefix}/{PurePosixPath(rel).as_posix()}".lstrip("/")
+
+    def open(self, path: str, mode: str = "rb", **kwargs) -> IO[Any]:
+        return self._parent.open(self._full(path), mode, **kwargs)
+
+    def exists(self, path: str) -> bool:
+        return self._parent.exists(self._full(path))
+
+    def isdir(self, path: str) -> bool:
+        return self._parent.isdir(self._full(path))
+
+    def isfile(self, path: str) -> bool:
+        return self._parent.isfile(self._full(path))
+
+    def listdir(self, path: str) -> list[str]:
+        return self._parent.listdir(self._full(path))
+
+    def makedir(self, path: str, recreate: bool = False):
+        return self._parent.makedir(self._full(path), recreate=recreate)
+
+    def makedirs(self, path: str, recreate: bool = False):
+        return self._parent.makedirs(self._full(path), recreate=recreate)
+
+    def getinfo(self, path: str, namespaces: Collection[str] | None = None) -> Info:
+        return self._parent.getinfo(self._full(path), namespaces=namespaces)
+
+    def remove(self, path: str):
+        return self._parent.remove(self._full(path))
+
+    def removedir(self, path: str):
+        return self._parent.removedir(self._full(path))
+
+    def removetree(self, path: str):
+        return self._parent.removetree(self._full(path))
+
+    def movedir(self, src: str, dst: str, create: bool = False):
+        self._parent.movedir(self._full(src), self._full(dst), create=create)
+
+    def getsyspath(self, path: str) -> str:
+        return self._parent.getsyspath(self._full(path))
+
+    def readbytes(self, path: str) -> bytes:
+        return self._parent.readbytes(self._full(path))
+
+    def writebytes(self, path: str, data: bytes):
+        self._parent.writebytes(self._full(path), data)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self._parent!r}, {self._prefix!r})"
+
+    def __str__(self) -> str:
+        return f"{self._parent}/{self._prefix}"
+
+
+class ClosingSubFS(SubFS):
+    """Like SubFS, but auto-closes the parent filesystem when closed."""
+
+    def close(self):
+        super().close()
+        self._parent.close()

fontTools/misc/filesystem/_tempfs.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import shutil
+import tempfile
+
+from ._errors import OperationFailed
+from ._osfs import OSFS
+
+
+class TempFS(OSFS):
+    def __init__(self, auto_clean: bool = True, ignore_clean_errors: bool = True):
+        self.auto_clean = auto_clean
+        self.ignore_clean_errors = ignore_clean_errors
+        self._temp_dir = tempfile.mkdtemp("__temp_fs__")
+        self._cleaned = False
+        super().__init__(self._temp_dir)
+
+    def close(self):
+        if self.auto_clean:
+            self.clean()
+        super().close()
+
+    def clean(self):
+        if self._cleaned:
+            return
+
+        try:
+            shutil.rmtree(self._temp_dir)
+        except Exception as e:
+            if not self.ignore_clean_errors:
+                raise OperationFailed(
+                    f"failed to remove temporary directory: {self._temp_dir!r}"
+                ) from e
+        self._cleaned = True

fontTools/misc/filesystem/_tools.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import typing
+from pathlib import PurePosixPath
+
+from ._errors import DirectoryNotEmpty
+
+if typing.TYPE_CHECKING:
+    from typing import IO
+
+    from ._base import FS
+
+
+def remove_empty(fs: FS, path: str):
+    """Remove all empty parents."""
+    path = PurePosixPath(path)
+    root = PurePosixPath("/")
+    try:
+        while path != root:
+            fs.removedir(path.as_posix())
+            path = path.parent
+    except DirectoryNotEmpty:
+        pass
+
+
+def copy_file_data(src_file: IO, dst_file: IO, chunk_size: int | None = None):
+    """Copy data from one file object to another."""
+    _chunk_size = 1024 * 1024 if chunk_size is None else chunk_size
+    read = src_file.read
+    write = dst_file.write
+    # in iter(callable, sentilel), callable is called until it returns the sentinel;
+    # this allows to copy `chunk_size` bytes at a time.
+    for chunk in iter(lambda: read(_chunk_size) or None, None):
+        write(chunk)

fontTools/misc/filesystem/_walk.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import typing
+from collections import deque
+from collections.abc import Collection, Iterator
+
+from ._path import combine
+
+if typing.TYPE_CHECKING:
+    from typing import Callable
+
+    from ._base import FS
+    from ._info import Info
+
+
+class BoundWalker:
+    def __init__(self, fs: FS):
+        self._fs = fs
+
+    def _iter_walk(
+        self, path: str, namespaces: Collection[str] | None = None
+    ) -> Iterator[tuple[str, Info | None]]:
+        """Walk files using a *breadth first* search."""
+        queue = deque([path])
+        push = queue.appendleft
+        pop = queue.pop
+        _scan = self._fs.scandir
+        _combine = combine
+
+        while queue:
+            dir_path = pop()
+            for info in _scan(dir_path, namespaces=namespaces):
+                if info.is_dir:
+                    yield dir_path, info
+                    push(_combine(dir_path, info.name))
+                else:
+                    yield dir_path, info
+        yield path, None
+
+    def _filter(
+        self,
+        include: Callable[[str, Info], bool] = lambda path, info: True,
+        path: str = "/",
+        namespaces: Collection[str] | None = None,
+    ) -> Iterator[str]:
+        _combine = combine
+        for path, info in self._iter_walk(path, namespaces):
+            if info is not None and include(path, info):
+                yield _combine(path, info.name)
+
+    def files(self, path: str = "/") -> Iterator[str]:
+        yield from self._filter(lambda _, info: info.is_file, path)
+
+    def dirs(self, path: str = "/") -> Iterator[str]:
+        yield from self._filter(lambda _, info: info.is_dir, path)

fontTools/misc/filesystem/_zipfs.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+import io
+import os
+import shutil
+import stat
+import typing
+import zipfile
+from datetime import datetime
+
+from ._base import FS
+from ._errors import FileExpected, ResourceNotFound, ResourceReadOnly
+from ._info import Info
+from ._path import dirname, forcedir, normpath, relpath
+from ._tempfs import TempFS
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Collection
+    from typing import IO, Any
+
+    from ._subfs import SubFS
+
+
+class ZipFS(FS):
+    """Read and write zip files."""
+
+    def __new__(
+        cls, file: str | os.PathLike, write: bool = False, encoding: str = "utf-8"
+    ):
+        if write:
+            return WriteZipFS(file, encoding)
+        else:
+            return ReadZipFS(file, encoding)
+
+    if typing.TYPE_CHECKING:
+
+        def __init__(
+            self, file: str | os.PathLike, write: bool = False, encoding: str = "utf-8"
+        ):
+            pass
+
+
+class ReadZipFS(FS):
+    """A readable zip file."""
+
+    def __init__(self, file: str | os.PathLike, encoding: str = "utf-8"):
+        super().__init__()
+        self._file = os.fspath(file)
+        self.encoding = encoding  # unused
+        self._zip = zipfile.ZipFile(file, "r")
+        self._directory_fs = None
+
+    def __repr__(self) -> str:
+        return f"ReadZipFS({self._file!r})"
+
+    def __str__(self) -> str:
+        return f"<zipfs '{self._file}'>"
+
+    def _path_to_zip_name(self, path: str) -> str:
+        """Convert a path to a zip file name."""
+        path = relpath(normpath(path))
+        if self._directory.isdir(path):
+            path = forcedir(path)
+        return path
+
+    @property
+    def _directory(self) -> TempFS:
+        if self._directory_fs is None:
+            self._directory_fs = _fs = TempFS()
+            for zip_name in self._zip.namelist():
+                resource_name = zip_name
+                if resource_name.endswith("/"):
+                    _fs.makedirs(resource_name, recreate=True)
+                else:
+                    _fs.makedirs(dirname(resource_name), recreate=True)
+                    _fs.create(resource_name)
+        return self._directory_fs
+
+    def close(self):
+        super(ReadZipFS, self).close()
+        self._zip.close()
+        if self._directory_fs is not None:
+            self._directory_fs.close()
+
+    def getinfo(self, path: str, namespaces: Collection[str] | None = None) -> Info:
+        namespaces = namespaces or ()
+        raw_info = {}
+
+        if path == "/":
+            raw_info["basic"] = {"name": "", "is_dir": True}
+            if "details" in namespaces:
+                raw_info["details"] = {"type": stat.S_IFDIR}
+        else:
+            basic_info = self._directory.getinfo(path)
+            raw_info["basic"] = {"name": basic_info.name, "is_dir": basic_info.is_dir}
+
+            if "details" in namespaces:
+                zip_name = self._path_to_zip_name(path)
+                try:
+                    zip_info = self._zip.getinfo(zip_name)
+                except KeyError:
+                    pass
+                else:
+                    if "details" in namespaces:
+                        raw_info["details"] = {
+                            "size": zip_info.file_size,
+                            "type": int(
+                                stat.S_IFDIR if basic_info.is_dir else stat.S_IFREG
+                            ),
+                            "modified": datetime(*zip_info.date_time).timestamp(),
+                        }
+
+        return Info(raw_info)
+
+    def exists(self, path: str) -> bool:
+        self.check()
+        return self._directory.exists(path)
+
+    def isdir(self, path: str) -> bool:
+        self.check()
+        return self._directory.isdir(path)
+
+    def isfile(self, path: str) -> bool:
+        self.check()
+        return self._directory.isfile(path)
+
+    def listdir(self, path: str) -> str:
+        self.check()
+        return self._directory.listdir(path)
+
+    def makedir(self, path: str, recreate: bool = False) -> SubFS:
+        self.check()
+        raise ResourceReadOnly(path)
+
+    def makedirs(self, path: str, recreate: bool = False) -> SubFS:
+        self.check()
+        raise ResourceReadOnly(path)
+
+    def remove(self, path: str):
+        self.check()
+        raise ResourceReadOnly(path)
+
+    def removedir(self, path: str):
+        self.check()
+        raise ResourceReadOnly(path)
+
+    def removetree(self, path: str):
+        self.check()
+        raise ResourceReadOnly(path)
+
+    def movedir(self, src: str, dst: str, create: bool = False):
+        self.check()
+        raise ResourceReadOnly(src)
+
+    def readbytes(self, path: str) -> bytes:
+        self.check()
+        if not self._directory.isfile(path):
+            raise ResourceNotFound(path)
+        zip_name = self._path_to_zip_name(path)
+        zip_bytes = self._zip.read(zip_name)
+        return zip_bytes
+
+    def open(self, path: str, mode: str = "rb", **kwargs) -> IO[Any]:
+        self.check()
+        if self._directory.isdir(path):
+            raise FileExpected(f"{path!r} is a directory")
+
+        zip_mode = mode[0]
+        if zip_mode == "r" and not self._directory.exists(path):
+            raise ResourceNotFound(f"No such file or directory: {path!r}")
+
+        if any(m in mode for m in "wax+"):
+            raise ResourceReadOnly(path)
+
+        zip_name = self._path_to_zip_name(path)
+        stream = self._zip.open(zip_name, zip_mode)
+        if "b" in mode:
+            if kwargs:
+                raise ValueError("encoding args invalid for binary operation")
+            return stream
+        # Text mode
+        return io.TextIOWrapper(stream, **kwargs)
+
+
+class WriteZipFS(TempFS):
+    """A writable zip file."""
+
+    def __init__(self, file: str | os.PathLike, encoding: str = "utf-8"):
+        super().__init__()
+        self._file = os.fspath(file)
+        self.encoding = encoding  # unused
+
+    def __repr__(self) -> str:
+        return f"WriteZipFS({self._file!r})"
+
+    def __str__(self) -> str:
+        return f"<zipfs-write '{self._file}'>"
+
+    def close(self):
+        base_name = os.path.splitext(self._file)[0]
+        shutil.make_archive(base_name, format="zip", root_dir=self._temp_dir)
+        if self._file != base_name + ".zip":
+            shutil.move(base_name + ".zip", self._file)
+        super().close()

fontTools/misc/sstruct.py

@@ -64,10 +64,7 @@ def pack(fmt, obj):
     elements = []
     if not isinstance(obj, dict):
         obj = obj.__dict__
-    string_index = formatstring
-    if formatstring.startswith(">"):
-        string_index = formatstring[1:]
-    for ix, name in enumerate(names.keys()):
+    for name in names.keys():
         value = obj[name]
         if name in fixes:
             # fixed point conversion
@@ -96,8 +93,7 @@ def unpack(fmt, data, obj=None):
     else:
         d = obj.__dict__
     elements = struct.unpack(formatstring, data)
-    for i in range(len(names)):
-        name = list(names.keys())[i]
+    for i, name in enumerate(names.keys()):
         value = elements[i]
         if name in fixes:
             # fixed point conversion

fontTools/misc/xmlWriter.py

@@ -4,8 +4,22 @@ from fontTools.misc.textTools import byteord, strjoin, tobytes, tostr
 import sys
 import os
 import string
+import logging
+import itertools
 
 INDENT = "  "
+TTX_LOG = logging.getLogger("fontTools.ttx")
+REPLACEMENT = "?"
+ILLEGAL_XML_CHARS = dict.fromkeys(
+    itertools.chain(
+        range(0x00, 0x09),
+        (0x0B, 0x0C),
+        range(0x0E, 0x20),
+        range(0xD800, 0xE000),
+        (0xFFFE, 0xFFFF),
+    ),
+    REPLACEMENT,
+)
 
 
 class XMLWriter(object):
@@ -168,12 +182,25 @@ class XMLWriter(object):
 
 
 def escape(data):
+    """Escape characters not allowed in `XML 1.0 <https://www.w3.org/TR/xml/#NT-Char>`_."""
     data = tostr(data, "utf_8")
     data = data.replace("&", "&amp;")
     data = data.replace("<", "&lt;")
     data = data.replace(">", "&gt;")
     data = data.replace("\r", "&#13;")
-    return data
+
+    newData = data.translate(ILLEGAL_XML_CHARS)
+    if newData != data:
+        maxLen = 10
+        preview = repr(data)
+        if len(data) > maxLen:
+            preview = repr(data[:maxLen])[1:-1] + "..."
+        TTX_LOG.warning(
+            "Illegal XML character(s) found; replacing offending " "string %r with %r",
+            preview,
+            REPLACEMENT,
+        )
+    return newData
 
 
 def escapeattr(data):

fontTools/pens/roundingPen.py

@@ -116,8 +116,8 @@ class RoundingPointPen(FilterPointPen):
     def addComponent(self, baseGlyphName, transformation, identifier=None, **kwargs):
         xx, xy, yx, yy, dx, dy = transformation
         self._outPen.addComponent(
-            baseGlyphName=baseGlyphName,
-            transformation=Transform(
+            baseGlyphName,
+            Transform(
                 self.transformRoundFunc(xx),
                 self.transformRoundFunc(xy),
                 self.transformRoundFunc(yx),

fontTools/subset/__init__.py

@@ -27,16 +27,16 @@ from collections import Counter, defaultdict
 from functools import reduce
 from types import MethodType
 
-__usage__ = "pyftsubset font-file [glyph...] [--option=value]..."
+__usage__ = "fonttools subset font-file [glyph...] [--option=value]..."
 
 __doc__ = (
     """\
-pyftsubset -- OpenType font subsetter and optimizer
+fonttools subset -- OpenType font subsetter and optimizer
 
-pyftsubset is an OpenType font subsetter and optimizer, based on fontTools.
-It accepts any TT- or CFF-flavored OpenType (.otf or .ttf) or WOFF (.woff)
-font file. The subsetted glyph set is based on the specified glyphs
-or characters, and specified OpenType layout features.
+fonttools subset is an OpenType font subsetter and optimizer, based on
+fontTools. It accepts any TT- or CFF-flavored OpenType (.otf or .ttf)
+or WOFF (.woff) font file. The subsetted glyph set is based on the
+specified glyphs or characters, and specified OpenType layout features.
 
 The tool also performs some size-reducing optimizations, aimed for using
 subset fonts as webfonts.  Individual optimizations can be enabled or
@@ -130,11 +130,11 @@ you might need to escape the question mark, like this: '--glyph-names\\?'.
 
 Examples::
 
-    $ pyftsubset --glyph-names?
+    $ fonttools subset --glyph-names?
     Current setting for 'glyph-names' is: False
-    $ pyftsubset --name-IDs=?
+    $ fonttools subset --name-IDs=?
     Current setting for 'name-IDs' is: [0, 1, 2, 3, 4, 5, 6]
-    $ pyftsubset --hinting? --no-hinting --hinting?
+    $ fonttools subset --hinting? --no-hinting --hinting?
     Current setting for 'hinting' is: True
     Current setting for 'hinting' is: False
 
@@ -445,7 +445,7 @@ Example
 Produce a subset containing the characters ' !"#$%' without performing
 size-reducing optimizations::
 
-  $ pyftsubset font.ttf --unicodes="U+0020-0025" \\
+  $ fonttools subset font.ttf --unicodes="U+0020-0025" \\
     --layout-features=* --glyph-names --symbol-cmap --legacy-cmap \\
     --notdef-glyph --notdef-outline --recommended-glyphs \\
     --name-IDs=* --name-legacy --name-languages=*
@@ -3768,7 +3768,7 @@ def parse_glyphs(s):
 
 def usage():
     print("usage:", __usage__, file=sys.stderr)
-    print("Try pyftsubset --help for more information.\n", file=sys.stderr)
+    print("Try fonttools subset --help for more information.\n", file=sys.stderr)
 
 
 @timer("make one with everything (TOTAL TIME)")

fontTools/ttLib/sfnt.py

@@ -375,10 +375,9 @@ class SFNTWriter(object):
 
     def _calcMasterChecksum(self, directory):
         # calculate checkSumAdjustment
-        tags = list(self.tables.keys())
         checksums = []
-        for i in range(len(tags)):
-            checksums.append(self.tables[tags[i]].checkSum)
+        for tag in self.tables.keys():
+            checksums.append(self.tables[tag].checkSum)
 
         if self.DirectoryEntry != SFNTDirectoryEntry:
             # Create a SFNT directory for checksum calculation purposes

fontTools/ttLib/tables/S__i_l_f.py

@@ -948,7 +948,7 @@ class Pass(object):
         writer.newline()
         writer.begintag("rules")
         writer.newline()
-        for i in range(len(self.actions)):
+        for i, action in enumerate(self.actions):
             writer.begintag(
                 "rule",
                 index=i,
@@ -958,7 +958,7 @@ class Pass(object):
             writer.newline()
             if len(self.ruleConstraints[i]):
                 writecode("constraint", writer, self.ruleConstraints[i])
-            writecode("action", writer, self.actions[i])
+            writecode("action", writer, action)
             writer.endtag("rule")
             writer.newline()
         writer.endtag("rules")

fontTools/ttLib/tables/T_S_I__1.py

@@ -91,12 +91,11 @@ class table_T_S_I__1(LogMixin, DefaultTable.DefaultTable):
         glyphNames = ttFont.getGlyphOrder()
 
         indices = []
-        for i in range(len(glyphNames)):
+        for i, name in enumerate(glyphNames):
             if len(data) % 2:
                 data = (
                     data + b"\015"
                 )  # align on 2-byte boundaries, fill with return chars. Yum.
-            name = glyphNames[i]
             if name in self.glyphPrograms:
                 text = tobytes(self.glyphPrograms[name], encoding="utf-8")
             else:
@@ -108,13 +107,11 @@ class table_T_S_I__1(LogMixin, DefaultTable.DefaultTable):
             data = data + text
 
         extra_indices = []
-        codes = sorted(self.extras.items())
-        for i in range(len(codes)):
+        for code, name in sorted(self.extras.items()):
             if len(data) % 2:
                 data = (
                     data + b"\015"
                 )  # align on 2-byte boundaries, fill with return chars.
-            code, name = codes[i]
             if name in self.extraPrograms:
                 text = tobytes(self.extraPrograms[name], encoding="utf-8")
             else:

fontTools/ttLib/tables/T_S_I__5.py

@@ -38,8 +38,8 @@ class table_T_S_I__5(DefaultTable.DefaultTable):
     def compile(self, ttFont):
         glyphNames = ttFont.getGlyphOrder()
         a = array.array("H")
-        for i in range(len(glyphNames)):
-            a.append(self.glyphGrouping.get(glyphNames[i], 0))
+        for glyphName in glyphNames:
+            a.append(self.glyphGrouping.get(glyphName, 0))
         if sys.byteorder != "big":
             a.byteswap()
         return a.tobytes()

fontTools/ttLib/tables/_c_m_a_p.py

@@ -398,7 +398,7 @@ class cmap_format_0(CmapSubtable):
         assert 262 == self.length, "Format 0 cmap subtable not 262 bytes"
         gids = array.array("B")
         gids.frombytes(self.data)
-        charCodes = list(range(len(gids)))
+        charCodes = range(len(gids))
         self.cmap = _make_map(self.ttFont, charCodes, gids)
 
     def compile(self, ttFont):

fontTools/ttLib/tables/_c_v_t.py

@@ -29,8 +29,7 @@ class table__c_v_t(DefaultTable.DefaultTable):
         return values.tobytes()
 
     def toXML(self, writer, ttFont):
-        for i in range(len(self.values)):
-            value = self.values[i]
+        for i, value in enumerate(self.values):
             writer.simpletag("cv", value=value, index=i)
             writer.newline()