NotYAFC 1.0.0__py3-none-any.whl

font_converter/contours.py

@@ -0,0 +1,336 @@
+import itertools
+from collections.abc import Callable, Mapping
+
+import pathops
+from fontTools.cffLib import CFFFontSet
+from fontTools.misc.psCharStrings import T2CharString
+from fontTools.misc.roundTools import noRound, otRound
+from fontTools.pens.t2CharStringPen import T2CharStringPen
+from fontTools.pens.ttGlyphPen import TTGlyphPen
+from fontTools.ttLib import TTFont
+from fontTools.ttLib.tables import _g_l_y_f, _h_m_t_x
+from fontTools.ttLib.ttGlyphSet import _TTGlyph
+
+from font_converter.constants import T_CFF, T_GLYF, T_HMTX
+
+_TTGlyphMapping = Mapping[str, _TTGlyph]
+
+__all__ = ["correct_cff_contours", "correct_glyf_contours", "simplify_path"]
+
+
+class CorrectContoursError(Exception):
+    """Raised when an error occurs while correcting the contours of a TrueType font."""
+
+
+def _skia_path_from_glyph(glyph_name: str, glyph_set: _TTGlyphMapping) -> pathops.Path:
+    path = pathops.Path()
+    pen = path.getPen(glyphSet=glyph_set)
+    glyph_set[glyph_name].draw(pen)
+    return path
+
+
+def _skia_path_from_glyph_component(
+    component: _g_l_y_f.GlyphComponent, glyph_set: _TTGlyphMapping
+) -> pathops.Path:
+    base_glyph_name, transformation = component.getComponentInfo()
+    path = _skia_path_from_glyph(glyph_name=base_glyph_name, glyph_set=glyph_set)
+    return path.transform(*transformation)
+
+
+def _ttf_components_overlap(glyph: _g_l_y_f.Glyph, glyph_set: _TTGlyphMapping) -> bool:
+    if not glyph.isComposite():
+        raise ValueError("This method only works with TrueType composite glyphs")
+    if len(glyph.components) < 2:
+        return False
+
+    component_paths = {}
+
+    def _get_nth_component_path(index: int) -> pathops.Path:
+        if index not in component_paths:
+            component_paths[index] = _skia_path_from_glyph_component(
+                glyph.components[index], glyph_set
+            )
+        return component_paths[index]
+
+    return any(
+        pathops.op(
+            _get_nth_component_path(i),
+            _get_nth_component_path(j),
+            pathops.PathOp.INTERSECTION,
+            clockwise=True,  # type: ignore
+            fix_winding=True,  # type: ignore
+        )
+        for i, j in itertools.combinations(range(len(glyph.components)), 2)
+    )
+
+
+def _tt_glyph_from_skia_path(path: pathops.Path) -> _g_l_y_f.Glyph:
+    tt_pen = TTGlyphPen(glyphSet=None)
+    path.draw(tt_pen)
+    glyph = tt_pen.glyph()
+    glyph.recalcBounds(glyfTable=None)
+    return glyph
+
+
+def _t2_charstring_from_skia_path(
+    path: pathops.Path,
+    charstring: T2CharString,
+) -> T2CharString:
+    # https://github.com/fonttools/fonttools/commit/40b525c1e3cc20b4b64004b8e3224a67adc2adf1
+    # The width argument of `T2CharStringPen()` is inserted directly into the CharString
+    # program, so it must be relative to Private.nominalWidthX.
+    if charstring.width == charstring.private.defaultWidthX:
+        width = None
+    else:
+        width = charstring.width - charstring.private.nominalWidthX
+
+    t2_pen = T2CharStringPen(width=width, glyphSet=None)
+    path.draw(t2_pen)
+    charstring = t2_pen.getCharString(charstring.private, charstring.globalSubrs)
+    return charstring
+
+
+def _round_path(path: pathops.Path, rounder: Callable[[float], float] = otRound) -> pathops.Path:
+    rounded_path = pathops.Path()
+    for verb, points in path:
+        rounded_path.add(verb, *((rounder(p[0]), rounder(p[1])) for p in points))
+    return rounded_path
+
+
+def _same_path(path_1: pathops.Path, path_2: pathops.Path) -> bool:
+    """
+    Checks if two pathops paths are the same.
+
+    Args:
+        path_1 (pathops.Path): The first path
+        path_2 (pathops.Path): The second path
+
+    Returns:
+        bool: ``True`` if the paths are the same, ``False`` if the paths are different
+    """
+
+    return {tuple(c) for c in path_1.contours} == {tuple(c) for c in path_2.contours}
+
+
+def _remove_tiny_paths(path: pathops.Path, min_area: float) -> pathops.Path:
+    """
+    Removes tiny paths from a ``pathops.Path`` object. A path is considered tiny if its area is less
+    than the given minimum area (default is 25).
+
+    :param path: The path to clean.
+    :type path: pathops.Path
+    :param min_area: The minimum area of a contour to be considered. Defaults to 25.
+    :type min_area: int
+    :return: The cleaned path.
+    :rtype: pathops.Path
+    """
+
+    cleaned_path = pathops.Path()
+    for contour in path.contours:
+        if contour.area >= min_area:
+            cleaned_path.addPath(contour)
+    return cleaned_path
+
+
+def _correct_tt_glyph_contours(
+    glyph_name: str,
+    glyph_set: _TTGlyphMapping,
+    glyf_table: _g_l_y_f.table__g_l_y_f,
+    hmtx_table: _h_m_t_x.table__h_m_t_x,
+    remove_hinting: bool = True,
+    min_area: int = 25,
+) -> bool:
+    glyph: _g_l_y_f.Glyph = glyf_table[glyph_name]
+    # decompose composite glyphs only if components overlap each other
+    if (
+        glyph.numberOfContours > 0
+        or glyph.isComposite()
+        and _ttf_components_overlap(glyph=glyph, glyph_set=glyph_set)
+    ):
+        path = _skia_path_from_glyph(glyph_name, glyph_set)
+        path_2 = simplify_path(path, glyph_name, clockwise=True)
+        if min_area > 0:
+            path_2 = _remove_tiny_paths(path_2, min_area=min_area)
+
+        if not _same_path(path_1=path, path_2=path_2):
+            glyf_table[glyph_name] = glyph = _tt_glyph_from_skia_path(path_2)
+            width, lsb = hmtx_table[glyph_name]
+            if lsb != glyph.xMin:
+                hmtx_table[glyph_name] = (width, glyph.xMin)
+            return True
+
+    if remove_hinting:
+        glyph.removeHinting()
+    return False
+
+
+def _correct_charstring_contours(
+    glyph_name: str,
+    glyph_set: _TTGlyphMapping,
+    cff_font_set: CFFFontSet,
+    min_area: float = 25,
+) -> bool:
+    try:
+        path = _skia_path_from_glyph(glyph_name, glyph_set)
+        path_2 = simplify_path(path, glyph_name, clockwise=False)
+
+        if min_area > 0:
+            path_2 = _remove_tiny_paths(path_2, min_area=min_area)
+
+        if not _same_path(path_1=path, path_2=path_2):
+            charstrings = cff_font_set[0].CharStrings
+            charstrings[glyph_name] = _t2_charstring_from_skia_path(path_2, charstrings[glyph_name])
+            return True
+
+        return False
+    except Exception as e:
+        raise CorrectContoursError(f"Failed to correct contours of glyph {glyph_name!r}") from e
+
+
+def simplify_path(path: pathops.Path, glyph_name: str, clockwise: bool) -> pathops.Path:
+    """
+    Simplifies a ``pathops.Path`` by removing overlaps and correcting the direction of the contours.
+
+    :param path: The ``pathops.Path`` to simplify.
+    :type path: pathops.Path
+    :param glyph_name: The name of the glyph.
+    :type glyph_name: str
+    :param clockwise: Whether the contours should be clockwise.
+    :type clockwise: bool
+    :raises CorrectContoursError: If an error occurs while simplifying the path.
+    :return: The simplified path.
+    :rtype: pathops.Path
+    """
+
+    try:
+        return pathops.simplify(path, fix_winding=True, clockwise=clockwise)  # type: ignore
+    except pathops.PathOpsError:
+        pass
+
+    path = _round_path(path, rounder=noRound)
+    try:
+        path = pathops.simplify(path, fix_winding=True, clockwise=clockwise)  # type: ignore
+        return path
+    except pathops.PathOpsError as e:
+        raise CorrectContoursError(f"Failed to remove overlaps from glyph {glyph_name!r}") from e
+
+
+def correct_glyf_contours(
+    font: TTFont,
+    remove_hinting: bool,
+    ignore_errors: bool,
+    min_area: int = 25,
+) -> set[str]:
+    """
+    Corrects the contours of the given TrueType font by removing overlaps, correcting the direction
+    of the contours, and removing tiny paths. The function returns the list of modified glyphs.
+
+    :param font: The ``TTFont`` object.
+    :type font: TTFont
+    :param remove_hinting: Whether to remove hinting instructions.
+    :type remove_hinting: bool
+    :param ignore_errors: Whether to ignore errors.
+    :type ignore_errors: bool
+    :param min_area: The minimum area of a contour to be considered. Defaults to 25.
+    :type min_area: int
+    :raises CorrectContoursError: If an error occurs while correcting the contours.
+    :return: The list of modified glyphs.
+    :rtype: set[str]
+    """
+    glyph_names = font.getGlyphOrder()
+    glyph_set = font.getGlyphSet()
+    glyf_table = font[T_GLYF]
+    hmtx_table = font[T_HMTX]
+
+    # The minimum area is given in font units, so we need to convert it to em units
+    min_area = min_area / 1000 * font["head"].unitsPerEm
+
+    # process all simple glyphs first, then composites with increasing component depth,
+    # so that by the time we test for component intersections the respective base glyphs
+    # have already been simplified
+    glyph_names = sorted(
+        glyph_names,
+        key=lambda name: (
+            (
+                glyf_table[name].getCompositeMaxpValues(glyf_table).maxComponentDepth
+                if glyf_table[name].isComposite()
+                else 0
+            ),
+            name,
+        ),
+    )
+    modified_glyphs = set()
+    for glyph_name in glyph_names:
+        try:
+            if _correct_tt_glyph_contours(
+                glyph_name=glyph_name,
+                glyph_set=glyph_set,
+                glyf_table=glyf_table,
+                hmtx_table=hmtx_table,
+                remove_hinting=remove_hinting,
+                min_area=min_area,
+            ):
+                modified_glyphs.add(glyph_name)
+        except CorrectContoursError as e:
+            if not ignore_errors:
+                raise e
+
+    return modified_glyphs
+
+
+def correct_cff_contours(
+    font: TTFont,
+    remove_hinting: bool,
+    ignore_errors: bool,
+    remove_unused_subroutines: bool = True,
+    min_area: int = 25,
+) -> set[str]:
+    """
+    Corrects the contours of the given CFF font by removing overlaps, correcting the direction of
+    the contours, and removing tiny paths. The function returns the list of modified glyphs.
+
+    :param font: The ``TTFont`` object.
+    :type font: TTFont
+    :param remove_hinting: Whether to remove hinting instructions.
+    :type remove_hinting: bool
+    :param ignore_errors: Whether to ignore errors.
+    :type ignore_errors: bool
+    :param remove_unused_subroutines: Whether to remove unused subroutines. Defaults to True.
+    :type remove_unused_subroutines: bool
+    :param min_area: The minimum area of a contour to be considered. Defaults to 25.
+    :type min_area: int
+    :raises CorrectContoursError: If an error occurs while correcting the contours.
+    :return: The list of modified glyphs.
+    :rtype: set[str]
+    """
+    glyph_names = font.getGlyphOrder()
+    glyph_set = font.getGlyphSet()
+    cff_font_set: CFFFontSet = font[T_CFF].cff
+    modified_glyphs = set()
+
+    # The minimum area is given in font units, so we need to convert it to em units
+    min_area = min_area / 1000 * font["head"].unitsPerEm
+
+    for glyph_name in glyph_names:
+        try:
+            if _correct_charstring_contours(
+                glyph_name=glyph_name,
+                glyph_set=glyph_set,
+                cff_font_set=cff_font_set,
+                min_area=min_area,
+            ):
+                modified_glyphs.add(glyph_name)
+        except CorrectContoursError as e:
+            if not ignore_errors:
+                raise e
+
+    if not modified_glyphs:
+        return set()
+
+    if remove_hinting:
+        cff_font_set.remove_hints()
+
+    if remove_unused_subroutines:
+        cff_font_set.remove_unused_subroutines()
+
+    return modified_glyphs

font_converter/css_kit.py

@@ -0,0 +1,77 @@
+"""Generate the CSS (``@font-face`` rules and feature classes) for converted web fonts."""
+
+import re
+from collections import defaultdict
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+
+CSS_FILE_NAME = "fonts.css"
+_FORMAT_ORDER = {"woff2": 0, "woff": 1}
+
+
+@dataclass(frozen=True)
+class WebFontEntry:
+    file: Path
+    format: str
+    family: str
+    weight: int = 400
+    italic: bool = False
+    features: tuple[str, ...] = ()
+
+
+def _slug(value: str) -> str:
+    return re.sub(r"[^a-z0-9_-]+", "-", value.lower()).strip("-") or "font"
+
+
+def _quote(value: str) -> str:
+    return '"' + value.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+def build_css(entries: Iterable[WebFontEntry]) -> str:
+    """Return the CSS with one ``@font-face`` per font and one class per family and feature."""
+    entries = sorted(entries, key=lambda e: (e.family, e.weight, e.italic, e.file.name))
+    # The formats of the same font share one rule, with the most efficient format first.
+    faces: dict[tuple[str, int, bool, str], list[WebFontEntry]] = {}
+    for entry in entries:
+        faces.setdefault((entry.family, entry.weight, entry.italic, entry.file.stem), []).append(
+            entry
+        )
+    blocks: list[str] = []
+    for (family, weight, italic, _), sources in faces.items():
+        sources.sort(key=lambda e: _FORMAT_ORDER.get(e.format, len(_FORMAT_ORDER)))
+        src = ",\n       ".join(
+            f"url({_quote(source.file.name)}) format({_quote(source.format)})" for source in sources
+        )
+        blocks.append(
+            "@font-face {\n"
+            f"  font-family: {_quote(family)};\n"
+            f"  src: {src};\n"
+            f"  font-weight: {weight};\n"
+            f"  font-style: {'italic' if italic else 'normal'};\n"
+            "  font-display: swap;\n"
+            "}"
+        )
+    for family in sorted({entry.family for entry in entries}):
+        blocks.append(f".family-{_slug(family)} {{ font-family: {_quote(family)}; }}")
+    features = sorted({tag for entry in entries for tag in entry.features})
+    for tag in features:
+        blocks.append(f'.ft-{_slug(tag)} {{ font-feature-settings: "{tag}" 1; }}')
+    return "\n\n".join(blocks) + "\n"
+
+
+def write_css_kits(entries: Iterable[WebFontEntry], overwrite: bool = True) -> list[Path]:
+    """Write one CSS file in each folder that contains converted web fonts."""
+    by_folder: dict[Path, list[WebFontEntry]] = defaultdict(list)
+    for entry in entries:
+        by_folder[entry.file.parent].append(entry)
+    written: list[Path] = []
+    for folder, folder_entries in by_folder.items():
+        path = folder / CSS_FILE_NAME
+        counter = 1
+        while not overwrite and path.exists():
+            path = folder / f"{Path(CSS_FILE_NAME).stem}#{counter}.css"
+            counter += 1
+        path.write_text(build_css(folder_entries), encoding="utf-8")
+        written.append(path)
+    return written

font_converter/finder.py

@@ -0,0 +1,213 @@
+from collections.abc import Callable, Generator
+from dataclasses import dataclass
+from pathlib import Path
+
+from fontTools.ttLib.ttCollection import TTCollection
+from fontTools.ttLib.ttFont import TTLibError
+
+from font_converter.font import Font
+
+__all__ = ["FinderError", "FinderFilter", "FinderOptions", "FontFinder"]
+
+
+@dataclass
+class FinderOptions:
+    """A class that specifies the options to pass to the FontFinder class."""
+
+    recursive: bool = False
+    lazy: bool | None = None
+    recalc_bboxes: bool = True
+    recalc_timestamp: bool = False
+
+
+@dataclass
+class FinderFilter:
+    """A class that specifies which fonts to filter out when searching for fonts."""
+
+    filter_out_tt: bool = False
+    filter_out_ps: bool = False
+    filter_out_woff: bool = False
+    filter_out_woff2: bool = False
+    filter_out_sfnt: bool = False
+    filter_out_static: bool = False
+    filter_out_variable: bool = False
+
+
+class FinderError(Exception):
+    """An exception raised by the FontFinder class."""
+
+
+class FontFinder:
+    """
+    A class that finds fonts in a given path. It can search for fonts in a directory and its
+    subdirectories, and can also handle a single font file.
+
+    The class allows for filtering based on various criteria such as outline format (TrueType or
+    PostScript), font variations (static or variable), and font flavor ('woff', 'woff2' or
+    ``None``).
+
+    The class returns a list or a generator of Font objects that meet the specified criteria.
+
+    The returned ``Font`` and ``TTCollection`` objects keep their files open until they are closed
+    by the caller (``close()`` or a ``with`` block). Prefer the generator methods when processing
+    many files, so that only one font at a time is open::
+
+        for font in finder.generate_fonts():
+            with font:
+                ...
+    """
+
+    def __init__(
+        self,
+        input_path: str | Path,
+        options: FinderOptions | None = None,
+        filter_: FinderFilter | None = None,
+    ) -> None:
+        """
+        Initializes the ``FontFinder`` class.
+
+        :param input_path: The file system path to be processed. This path is resolved to an
+            absolute path. If the path is invalid, a FinderError is raised.
+        :type input_path: Union[str, Path]
+        :param options: Options for customizing the behavior of the finder. If not provided,
+            defaults to a FinderOptions instance.
+        :type options: Optional[FinderOptions]
+        :param filter_: Filter criteria for selecting files or directories. If not provided,
+            defaults to a FinderFilter instance.
+        :type filter_: Optional[FinderFilter]
+        """
+        try:
+            self.input_path = Path(input_path).resolve(strict=True)
+        except Exception as e:
+            raise FinderError(f"Invalid input path: {input_path}") from e
+
+        self.filter = filter_ or FinderFilter()
+        self.options = options or FinderOptions()
+        self._filter_conditions = self._generate_filter_conditions(self.filter)
+        self._validate_filter_conditions()
+
+    def find_fonts(self) -> list[Font]:
+        """
+        Finds fonts in the given input path.
+
+        :return: A list of ``Font`` objects generated by the generate_fonts method.
+        :rtype: list[Font]
+        """
+        return list(self.generate_fonts())
+
+    def find_collections(self) -> list[TTCollection]:
+        """
+        Finds TTCollections in the given input path.
+
+        :return: A list of ``TTCollection`` objects generated by the generate_collections method.
+        :rtype: list[TTCollection]
+        """
+        return list(self.generate_collections())
+
+    def generate_fonts(self) -> Generator[Font, None, None]:
+        """
+        Generates a sequence of ``Font`` objects from the files generated by the ``_generate_files``
+        method. Filters out fonts based on specified conditions in ``_filter_conditions``.
+
+        :return: A generator yielding Font objects
+        :rtype: Generator[Font, None, None]
+        """
+        # Collect the paths first, so that files saved while iterating are not found again.
+        files = list(self._generate_files())
+        for file in files:
+            try:
+                font = Font(
+                    file,
+                    lazy=self.options.lazy,
+                    recalc_timestamp=self.options.recalc_timestamp,
+                    recalc_bboxes=self.options.recalc_bboxes,
+                )
+            except (TTLibError, PermissionError):
+                continue
+            if any(condition and func(font) for condition, func in self._filter_conditions):
+                font.close()
+            else:
+                yield font
+
+    def generate_collections(self) -> Generator[TTCollection, None, None]:
+        """
+        Generates a sequence of ``TTCollection`` objects from the files generated by the
+        ``_generate_files`` method.
+
+        :return: A generator yielding TTCollection objects
+        :rtype: Generator[TTCollection, None, None]
+        """
+        files = list(self._generate_files())
+        for file in files:
+            try:
+                ttc = TTCollection(file)
+            except (TTLibError, PermissionError):
+                continue
+            yield ttc
+
+    def _generate_files(self) -> Generator[Path, None, None]:
+        is_file = self.input_path.is_file()
+        is_dir = self.input_path.is_dir()
+
+        if is_file:
+            yield self.input_path
+        elif is_dir:
+            if self.options.recursive:
+                yield from (x for x in self.input_path.rglob("*") if x.is_file())
+            else:
+                yield from (x for x in self.input_path.glob("*") if x.is_file())
+
+    def _validate_filter_conditions(self) -> None:
+        if self.filter.filter_out_tt and self.filter.filter_out_ps:
+            raise FinderError("Cannot filter out both TrueType and PostScript fonts.")
+        if (
+            self.filter.filter_out_woff
+            and self.filter.filter_out_woff2
+            and self.filter.filter_out_sfnt
+        ):
+            raise FinderError("Cannot filter out WOFF, WOFF2 and SFNT fonts at the same time.")
+        if self.filter.filter_out_static and self.filter.filter_out_variable:
+            raise FinderError("Cannot filter out both static and variable fonts.")
+
+    @staticmethod
+    def _generate_filter_conditions(
+        filter_: FinderFilter,
+    ) -> list[tuple[bool, Callable[[Font], bool]]]:
+        conditions: list[tuple[bool, Callable[[Font], bool]]] = [
+            (filter_.filter_out_tt, _is_tt),
+            (filter_.filter_out_ps, _is_ps),
+            (filter_.filter_out_woff, _is_woff),
+            (filter_.filter_out_woff2, _is_woff2),
+            (filter_.filter_out_sfnt, _is_sfnt),
+            (filter_.filter_out_static, _is_static),
+            (filter_.filter_out_variable, _is_variable),
+        ]
+        return conditions
+
+
+def _is_woff(font: Font) -> bool:
+    return font.is_woff
+
+
+def _is_woff2(font: Font) -> bool:
+    return font.is_woff2
+
+
+def _is_sfnt(font: Font) -> bool:
+    return font.is_sfnt
+
+
+def _is_ps(font: Font) -> bool:
+    return font.is_ps
+
+
+def _is_tt(font: Font) -> bool:
+    return font.is_tt
+
+
+def _is_static(font: Font) -> bool:
+    return font.is_static
+
+
+def _is_variable(font: Font) -> bool:
+    return font.is_variable