NotYAFC 1.0.0__py3-none-any.whl

font_converter/__init__.py

@@ -0,0 +1,4 @@
+from font_converter.finder import FontFinder
+from font_converter.font import Font
+
+__all__ = ["Font", "FontFinder"]

font_converter/__main__.py

@@ -0,0 +1,45 @@
+import ctypes
+import logging
+import sys
+from pathlib import Path
+
+from PySide6.QtCore import QSize
+from PySide6.QtGui import QFontDatabase, QIcon
+from PySide6.QtWidgets import QApplication
+
+from font_converter.gui.window import ConverterWindow
+
+
+def _app_icon() -> QIcon:
+    assets = Path(__file__).parent / "assets"
+    ico = assets / "notyafc.ico"
+    if not ico.is_file():
+        return QIcon(str(assets / "ico.png"))
+    icon = QIcon(str(ico))
+    icon.addFile(str(assets / "ico.png"), QSize(512, 512))
+    return icon
+
+
+def _set_windows_app_id() -> None:
+    if sys.platform != "win32":
+        return
+    try:
+        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID("NotYAFC.NotYAFC")
+    except (AttributeError, OSError) as error:
+        logging.getLogger(__name__).warning("Could not set Windows application ID: %s", error)
+
+
+def main() -> int:
+    _set_windows_app_id()
+    app = QApplication(sys.argv)
+    app.setOrganizationName("NotYAFC")
+    app.setApplicationName("NotYAFC")
+    app.setWindowIcon(_app_icon())
+    app.setFont(QFontDatabase.systemFont(QFontDatabase.SystemFont.GeneralFont))
+    window = ConverterWindow()
+    window.showMaximized()
+    return app.exec()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

font_converter/assets/notyafc.svg

@@ -0,0 +1,15 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1024 1024" width="1024" height="1024" xmlns:c2pa="http://c2pa.org/manifest"><metadata><c2pa:manifest>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</c2pa:manifest></metadata>
+  <defs>
+    <linearGradient id="bg" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="#5875ff"/>
+      <stop offset="1" stop-color="#3451d1"/>
+    </linearGradient>
+  </defs>
+  <rect x="24" y="24" width="976" height="976" rx="224" fill="url(#bg)"/>
+  <path fill="#ffffff" d="M464.9 811.0Q392.4 811.0 345.2 786.9Q298.1 762.7 275.1 723.0Q252.1 683.4 252.1 636.2Q252.1 553.4 316.5 505.1Q380.9 456.8 500.5 456.8H650.0V446.5Q650.0 379.8 613.8 346.4Q577.5 313.1 520.0 313.1Q469.4 313.1 432.1 337.8Q394.7 362.5 386.6 410.8H264.8Q270.5 348.7 306.7 304.4Q343.0 260.2 398.7 236.6Q454.5 213.0 521.2 213.0Q640.8 213.0 706.3 275.7Q771.9 338.4 771.9 446.5V797.2H666.1L655.8 699.5Q631.6 746.6 585.6 778.8Q539.6 811.0 464.9 811.0ZM489.0 712.1Q538.5 712.1 572.4 688.5Q606.3 665.0 625.3 625.9Q644.2 586.8 648.8 539.6H513.1Q440.7 539.6 410.2 564.9Q379.8 590.2 379.8 628.2Q379.8 667.2 409.1 689.7Q438.4 712.1 489.0 712.1Z"/>
+  <line x1="371.2" y1="213.0" x2="671.2" y2="213.0" stroke="#ffb703" stroke-width="14"/>
+  <circle cx="371.2" cy="213.0" r="24" fill="#ffb703"/>
+  <circle cx="671.2" cy="213.0" r="24" fill="#ffb703"/>
+  <circle cx="521.2" cy="213.0" r="59" fill="#ffffff"/>
+  <circle cx="521.2" cy="213.0" r="46" fill="#ffb703"/>
+</svg>

font_converter/cli.py

@@ -0,0 +1,543 @@
+"""Command-line interface for converting fonts."""
+
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+
+from font_converter.inspection import inspect_font
+from font_converter.service import (
+    ConversionRequest,
+    ConversionResult,
+    ConversionSettings,
+    ConverterService,
+    FontOutcome,
+    FontOutcomeKind,
+    InstanceSpec,
+    OtfToTtfOptions,
+    SfntToWebOptions,
+    TtcToSfntOptions,
+    TtfToOtfOptions,
+    VarToStaticOptions,
+    Woff2ToSfntOptions,
+    WoffToSfntOptions,
+)
+
+app = typer.Typer(
+    no_args_is_help=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+    help="Convert font files from the command line.",
+    rich_markup_mode="markdown",
+    pretty_exceptions_enable=False,
+)
+
+Inputs = Annotated[
+    list[Path],
+    typer.Argument(help="Input font files or folders. Folder scans are non-recursive by default."),
+]
+OutputDir = Annotated[
+    Path | None,
+    typer.Option(
+        "--output-dir",
+        help="Folder for converted files (defaults to each input folder).",
+        rich_help_panel="General options",
+    ),
+]
+Recursive = Annotated[
+    bool,
+    typer.Option(
+        "--recursive/--no-recursive",
+        help="Scan input folders recursively.",
+        rich_help_panel="General options",
+    ),
+]
+Overwrite = Annotated[
+    bool,
+    typer.Option(
+        "--overwrite/--no-overwrite",
+        help="Replace existing output files (default: keep existing files with numbered copies).",
+        rich_help_panel="General options",
+    ),
+]
+RecalcBboxes = Annotated[
+    bool,
+    typer.Option(
+        "--recalc-bboxes/--no-recalc-bboxes",
+        help="Recalculate glyph bounding boxes.",
+        rich_help_panel="General options",
+    ),
+]
+RecalcTimestamp = Annotated[
+    bool,
+    typer.Option(
+        "--recalc-timestamp/--no-recalc-timestamp",
+        help="Set a fresh modified timestamp on output fonts.",
+        rich_help_panel="General options",
+    ),
+]
+ReorderTables = Annotated[
+    bool,
+    typer.Option(
+        "--reorder-tables/--no-reorder-tables",
+        help="Reorder tables when saving fonts.",
+        rich_help_panel="General options",
+    ),
+]
+Tolerance = Annotated[
+    float,
+    typer.Option(
+        "--tolerance",
+        min=0,
+        max=3,
+        help="Curve-conversion tolerance.",
+        rich_help_panel="OTF to TTF options",
+    ),
+]
+TtfToOtfTolerance = Annotated[
+    float,
+    typer.Option(
+        "--tolerance",
+        min=0.1,
+        max=3,
+        help="Curve-conversion tolerance (minimum 0.1).",
+        rich_help_panel="TTF to OTF options",
+    ),
+]
+TargetUpmTtfToOtf = Annotated[
+    int | None,
+    typer.Option(
+        "--target-upm",
+        min=16,
+        max=16384,
+        help="Scale output fonts to this units-per-em value.",
+        rich_help_panel="TTF to OTF options",
+    ),
+]
+TargetUpmOtfToTtf = Annotated[
+    int | None,
+    typer.Option(
+        "--target-upm",
+        min=16,
+        max=16384,
+        help="Scale output fonts to this units-per-em value.",
+        rich_help_panel="OTF to TTF options",
+    ),
+]
+TargetUpmVarToStatic = Annotated[
+    int | None,
+    typer.Option(
+        "--target-upm",
+        min=16,
+        max=16384,
+        help="Scale output fonts to this units-per-em value.",
+        rich_help_panel="Variable to static options",
+    ),
+]
+
+
+def _common_options(
+    output_dir: Path | None,
+    recursive: bool,
+    overwrite: bool,
+    recalc_bboxes: bool,
+    recalc_timestamp: bool,
+    reorder_tables: bool,
+) -> dict[str, Any]:
+    return {
+        "output_dir": output_dir,
+        "recursive": recursive,
+        "overwrite": overwrite,
+        "recalc_bboxes": recalc_bboxes,
+        "recalc_timestamp": recalc_timestamp,
+        "reorder_tables": reorder_tables,
+    }
+
+
+def _input_files(inputs: tuple[Path, ...], recursive: bool) -> list[Path]:
+    files: dict[Path, None] = {}
+    for source in inputs:
+        if source.is_file():
+            files[source.resolve()] = None
+        elif source.is_dir():
+            paths = source.rglob("*") if recursive else source.glob("*")
+            files.update((path.resolve(), None) for path in paths if path.is_file())
+    return list(files)
+
+
+def _named_instances(
+    inputs: tuple[Path, ...], recursive: bool
+) -> tuple[tuple[tuple[Path, tuple[InstanceSpec, ...]], ...], frozenset[Path]]:
+    selected: list[tuple[Path, tuple[InstanceSpec, ...]]] = []
+    default_paths: set[Path] = set()
+    for path in _input_files(inputs, recursive):
+        info = inspect_font(path)
+        if info is None or not info.variable:
+            continue
+        specs = tuple(
+            InstanceSpec(instance.coordinates, instance.name) for instance in info.instances
+        )
+        if specs:
+            selected.append((path, specs))
+        else:
+            selected.append((path, (InstanceSpec(()),)))
+            default_paths.add(path)
+            typer.echo(
+                f"Warning: {path.name} has no named instances; exporting its default instance.",
+                err=True,
+            )
+    return tuple(selected), frozenset(default_paths)
+
+
+def _report_outcome(outcome: FontOutcome, default_paths: frozenset[Path]) -> None:
+    if outcome.kind is FontOutcomeKind.CONVERTED:
+        for output in outcome.output_paths:
+            typer.echo(f"Converted: {outcome.input_path} -> {output}", err=True)
+    elif outcome.kind is FontOutcomeKind.FAILED:
+        typer.echo(f"Failed: {outcome.input_path}: {outcome.error}", err=True)
+        if outcome.input_path.resolve() in default_paths:
+            typer.echo(
+                "The default instance could not be exported; continuing with the next font.",
+                err=True,
+            )
+
+
+def _run(
+    conversion: str,
+    inputs: list[Path],
+    output_dir: Path | None,
+    recursive: bool,
+    overwrite: bool,
+    recalc_bboxes: bool,
+    recalc_timestamp: bool,
+    reorder_tables: bool,
+    settings_type: type[ConversionSettings],
+    **profile_options: Any,
+) -> None:
+    input_paths = tuple(path.resolve() for path in inputs)
+    common = _common_options(
+        output_dir, recursive, overwrite, recalc_bboxes, recalc_timestamp, reorder_tables
+    )
+    default_paths: frozenset[Path] = frozenset()
+    if conversion == "var2static":
+        instances, default_paths = _named_instances(input_paths, recursive)
+        profile_options["instances"] = instances
+
+    settings = settings_type(**common, **profile_options)
+    request = ConversionRequest(input_paths, settings)
+
+    def report_progress(progress: Any) -> None:
+        typer.echo(
+            f"\rProgress: {progress.done}/{progress.total}",
+            err=True,
+            nl=progress.done == progress.total,
+        )
+
+    typer.echo(f"Starting {conversion} conversion for {len(input_paths)} input(s).", err=True)
+    result: ConversionResult = ConverterService().convert(
+        request,
+        on_log=lambda message: typer.echo(message, err=True),
+        on_outcome=lambda outcome: _report_outcome(outcome, default_paths),
+        on_progress=report_progress,
+    )
+    if result.error:
+        typer.echo(f"Error: {result.error}", err=True)
+    typer.echo(
+        f"Summary: {result.converted_count} converted, {result.skipped_count} skipped, "
+        f"{result.failed_count} failed.",
+    )
+    if not result.ok:
+        raise typer.Exit(code=1)
+
+
+@app.command("ttf2otf")
+def ttf2otf(
+    inputs: Inputs,
+    tolerance: TtfToOtfTolerance = 1.0,
+    target_upm: TargetUpmTtfToOtf = None,
+    subroutinize: Annotated[
+        bool,
+        typer.Option(
+            "--subroutinize/--no-subroutinize",
+            help="Subroutinize CFF outlines.",
+            rich_help_panel="TTF to OTF options",
+        ),
+    ] = True,
+    optimize_contours: Annotated[
+        int,
+        typer.Option(
+            "--optimize-contours",
+            min=0,
+            max=3,
+            help="Contour simplification level (0 disables it).",
+            rich_help_panel="TTF to OTF options",
+        ),
+    ] = 0,
+    output_dir: OutputDir = None,
+    recursive: Recursive = False,
+    overwrite: Overwrite = False,
+    recalc_bboxes: RecalcBboxes = True,
+    recalc_timestamp: RecalcTimestamp = False,
+    reorder_tables: ReorderTables = True,
+) -> None:
+    """Convert static TrueType outlines to PostScript outlines (TTF to OTF)."""
+    _run(
+        "ttf2otf",
+        inputs,
+        output_dir,
+        recursive,
+        overwrite,
+        recalc_bboxes,
+        recalc_timestamp,
+        reorder_tables,
+        TtfToOtfOptions,
+        tolerance=tolerance,
+        target_upm=target_upm,
+        subroutinize=subroutinize,
+        optimize_contours=optimize_contours,
+    )
+
+
+@app.command("otf2ttf")
+def otf2ttf(
+    inputs: Inputs,
+    tolerance: Tolerance = 1.0,
+    target_upm: TargetUpmOtfToTtf = None,
+    autohint: Annotated[
+        bool,
+        typer.Option(
+            "--autohint/--no-autohint",
+            help="Add TrueType hinting instructions.",
+            rich_help_panel="OTF to TTF options",
+        ),
+    ] = True,
+    output_dir: OutputDir = None,
+    recursive: Recursive = False,
+    overwrite: Overwrite = False,
+    recalc_bboxes: RecalcBboxes = True,
+    recalc_timestamp: RecalcTimestamp = False,
+    reorder_tables: ReorderTables = True,
+) -> None:
+    """Convert static PostScript outlines to TrueType outlines (OTF to TTF)."""
+    _run(
+        "otf2ttf",
+        inputs,
+        output_dir,
+        recursive,
+        overwrite,
+        recalc_bboxes,
+        recalc_timestamp,
+        reorder_tables,
+        OtfToTtfOptions,
+        tolerance=tolerance,
+        target_upm=target_upm,
+        autohint=autohint,
+    )
+
+
+@app.command("ft2wf")
+def ft2wf(
+    inputs: Inputs,
+    woff: Annotated[
+        bool,
+        typer.Option(
+            "--woff/--no-woff",
+            help="Create WOFF output.",
+            rich_help_panel="SFNT to WOFF options",
+        ),
+    ] = True,
+    woff2: Annotated[
+        bool,
+        typer.Option(
+            "--woff2/--no-woff2",
+            help="Create WOFF2 output.",
+            rich_help_panel="SFNT to WOFF options",
+        ),
+    ] = True,
+    obfuscate_names: Annotated[
+        bool,
+        typer.Option(
+            "--obfuscate-names/--no-obfuscate-names",
+            help="Replace identifying font names with hashes.",
+            rich_help_panel="SFNT to WOFF options",
+        ),
+    ] = False,
+    remove_unused_glyphs: Annotated[
+        bool,
+        typer.Option(
+            "--remove-unused-glyphs/--no-remove-unused-glyphs",
+            help="Remove glyphs unused by the cmap and OpenType features.",
+            rich_help_panel="SFNT to WOFF options",
+        ),
+    ] = False,
+    remove_non_windows_names: Annotated[
+        bool,
+        typer.Option(
+            "--remove-non-windows-names/--no-remove-non-windows-names",
+            help="Remove name records whose platform ID is not Windows.",
+            rich_help_panel="SFNT to WOFF options",
+        ),
+    ] = False,
+    remove_dsig: Annotated[
+        bool,
+        typer.Option(
+            "--remove-dsig/--no-remove-dsig",
+            help="Remove the DSIG table from WOFF output.",
+            rich_help_panel="SFNT to WOFF options",
+        ),
+    ] = False,
+    css_kit: Annotated[
+        bool,
+        typer.Option(
+            "--css-kit/--no-css-kit",
+            help="Generate fonts.css.",
+            rich_help_panel="SFNT to WOFF options",
+        ),
+    ] = False,
+    output_dir: OutputDir = None,
+    recursive: Recursive = False,
+    overwrite: Overwrite = False,
+    recalc_bboxes: RecalcBboxes = True,
+    recalc_timestamp: RecalcTimestamp = False,
+    reorder_tables: ReorderTables = True,
+) -> None:
+    """Convert SFNT fonts (TTF or OTF) to WOFF and/or WOFF2."""
+    if not woff and not woff2:
+        raise typer.BadParameter("Select at least one output format with --woff or --woff2.")
+    _run(
+        "ft2wf",
+        inputs,
+        output_dir,
+        recursive,
+        overwrite,
+        recalc_bboxes,
+        recalc_timestamp,
+        reorder_tables,
+        SfntToWebOptions,
+        format="woff" if woff and not woff2 else "woff2" if woff2 and not woff else None,
+        obfuscate_names=obfuscate_names,
+        remove_unused_glyphs=remove_unused_glyphs,
+        remove_non_windows_names=remove_non_windows_names,
+        remove_dsig=remove_dsig and woff,
+        css_kit=css_kit,
+    )
+
+
+@app.command("woff2ft")
+def woff2ft(
+    inputs: Inputs,
+    output_dir: OutputDir = None,
+    recursive: Recursive = False,
+    overwrite: Overwrite = False,
+    recalc_bboxes: RecalcBboxes = True,
+    recalc_timestamp: RecalcTimestamp = False,
+    reorder_tables: ReorderTables = True,
+) -> None:
+    """Convert WOFF fonts back to SFNT (TTF or OTF)."""
+    _run(
+        "woff2ft",
+        inputs,
+        output_dir,
+        recursive,
+        overwrite,
+        recalc_bboxes,
+        recalc_timestamp,
+        reorder_tables,
+        WoffToSfntOptions,
+    )
+
+
+@app.command("woff22ft")
+def woff22ft(
+    inputs: Inputs,
+    output_dir: OutputDir = None,
+    recursive: Recursive = False,
+    overwrite: Overwrite = False,
+    recalc_bboxes: RecalcBboxes = True,
+    recalc_timestamp: RecalcTimestamp = False,
+    reorder_tables: ReorderTables = True,
+) -> None:
+    """Convert WOFF2 fonts back to SFNT (TTF or OTF)."""
+    _run(
+        "woff22ft",
+        inputs,
+        output_dir,
+        recursive,
+        overwrite,
+        recalc_bboxes,
+        recalc_timestamp,
+        reorder_tables,
+        Woff2ToSfntOptions,
+    )
+
+
+@app.command("ttc2sfnt")
+def ttc2sfnt(
+    inputs: Inputs,
+    output_dir: OutputDir = None,
+    recursive: Recursive = False,
+    overwrite: Overwrite = False,
+    recalc_bboxes: RecalcBboxes = True,
+    recalc_timestamp: RecalcTimestamp = False,
+    reorder_tables: ReorderTables = True,
+) -> None:
+    """Extract each font from TrueType Collections (TTC) as a separate SFNT font."""
+    _run(
+        "ttc2sfnt",
+        inputs,
+        output_dir,
+        recursive,
+        overwrite,
+        recalc_bboxes,
+        recalc_timestamp,
+        reorder_tables,
+        TtcToSfntOptions,
+    )
+
+
+@app.command("var2static")
+def var2static(
+    inputs: Inputs,
+    target_upm: TargetUpmVarToStatic = None,
+    autohint: Annotated[
+        bool,
+        typer.Option(
+            "--autohint/--no-autohint",
+            help="Autohint TrueType instances.",
+            rich_help_panel="Variable to static options",
+        ),
+    ] = True,
+    subroutinize: Annotated[
+        bool,
+        typer.Option(
+            "--subroutinize/--no-subroutinize",
+            help="Subroutinize PostScript instances.",
+            rich_help_panel="Variable to static options",
+        ),
+    ] = True,
+    output_dir: OutputDir = None,
+    recursive: Recursive = False,
+    overwrite: Overwrite = False,
+    recalc_bboxes: RecalcBboxes = True,
+    recalc_timestamp: RecalcTimestamp = False,
+    reorder_tables: ReorderTables = True,
+) -> None:
+    """Export all named instances from variable fonts as static fonts."""
+    _run(
+        "var2static",
+        inputs,
+        output_dir,
+        recursive,
+        overwrite,
+        recalc_bboxes,
+        recalc_timestamp,
+        reorder_tables,
+        VarToStaticOptions,
+        target_upm=target_upm,
+        autohint=autohint,
+        subroutinize=subroutinize,
+    )
+
+
+def main() -> None:
+    """Run the font converter command-line application."""
+    app()

font_converter/constants.py

@@ -0,0 +1,27 @@
+PS_SFNT_VERSION = "OTTO"
+TT_SFNT_VERSION = "\0\1\0\0"
+
+WOFF_FLAVOR = "woff"
+WOFF2_FLAVOR = "woff2"
+OTF_EXTENSION = ".otf"
+TTF_EXTENSION = ".ttf"
+WOFF_EXTENSION = ".woff"
+WOFF2_EXTENSION = ".woff2"
+
+MIN_UPM = 16
+MAX_UPM = 16384
+
+# Table tags
+T_CFF = "CFF "
+T_DSIG = "DSIG"
+T_FPGM = "fpgm"
+T_FVAR = "fvar"
+T_GLYF = "glyf"
+T_HEAD = "head"
+T_HMTX = "hmtx"
+T_LOCA = "loca"
+T_MAXP = "maxp"
+T_NAME = "name"
+T_OS_2 = "OS/2"
+T_POST = "post"
+T_VORG = "VORG"