NotYAFC 1.0.0__py3-none-any.whl

font_converter/service.py

@@ -0,0 +1,729 @@
+"""Interface-independent request and result types for font conversions."""
+
+import re
+import time
+from collections.abc import Callable
+from dataclasses import dataclass, replace
+from enum import Enum
+from pathlib import Path
+from typing import ClassVar, Literal, TypeAlias, TypeVar
+
+from fontTools.misc.cliTools import makeOutputFileName
+from fontTools.ttLib import TTFont, TTLibError
+from fontTools.ttLib.ttCollection import TTCollection
+from pathvalidate import sanitize_filename
+
+from font_converter import Font
+from font_converter import constants as const
+from font_converter.constants import WOFF2_FLAVOR, WOFF_FLAVOR
+from font_converter.css_kit import WebFontEntry, write_css_kits
+
+ConversionKind: TypeAlias = Literal[
+    "ttf2otf", "otf2ttf", "ft2wf", "woff2ft", "woff22ft", "ttc2sfnt", "var2static"
+]
+WebFormat: TypeAlias = Literal["woff", "woff2"]
+
+
+@dataclass(frozen=True)
+class ConversionOptions:
+    recursive: bool = False
+    output_dir: Path | None = None
+    overwrite: bool = False
+    recalc_bboxes: bool = True
+    recalc_timestamp: bool = False
+    reorder_tables: bool = False
+    organize_output: bool = False
+    organize_by_family: bool = False
+    organization_levels: tuple[tuple[str, ...], ...] = ()
+
+
+@dataclass(frozen=True)
+class TtfToOtfOptions(ConversionOptions):
+    tolerance: float = 1.0
+    target_upm: int | None = None
+    subroutinize: bool = True
+    optimize_contours: int = 0
+
+
+@dataclass(frozen=True)
+class OtfToTtfOptions(ConversionOptions):
+    tolerance: float = 1.0
+    target_upm: int | None = None
+    autohint: bool = True
+
+
+@dataclass(frozen=True)
+class SfntToWebOptions(ConversionOptions):
+    format: WebFormat | None = None
+    obfuscate_names: bool = False
+    remove_unused_glyphs: bool = False
+    remove_non_windows_names: bool = False
+    css_kit: bool = False
+    remove_dsig: bool = False  # WOFF only: WOFF2 does not support the DSIG table
+
+
+@dataclass(frozen=True)
+class WebToSfntOptions(ConversionOptions):
+    format: ClassVar[WebFormat | None] = None
+
+
+@dataclass(frozen=True)
+class WoffToSfntOptions(WebToSfntOptions):
+    format: ClassVar[WebFormat | None] = "woff"
+
+
+@dataclass(frozen=True)
+class Woff2ToSfntOptions(WebToSfntOptions):
+    format: ClassVar[WebFormat | None] = "woff2"
+
+
+@dataclass(frozen=True)
+class TtcToSfntOptions(ConversionOptions):
+    pass
+
+
+@dataclass(frozen=True)
+class InstanceSpec:
+    """A location in the design space; ``name`` is set for instances defined in the fvar table."""
+
+    coordinates: tuple[tuple[str, float], ...]
+    name: str | None = None
+
+
+@dataclass(frozen=True)
+class VarToStaticOptions(ConversionOptions):
+    # Instances to export for each input font; a font without an entry exports its default.
+    instances: tuple[tuple[Path, tuple[InstanceSpec, ...]], ...] = ()
+    target_upm: int | None = None
+    autohint: bool = True  # TrueType outlines only
+    subroutinize: bool = True  # PostScript outlines only
+
+
+ConversionSettings: TypeAlias = (
+    TtfToOtfOptions
+    | OtfToTtfOptions
+    | SfntToWebOptions
+    | WebToSfntOptions
+    | TtcToSfntOptions
+    | VarToStaticOptions
+)
+
+
+def _format_organization_number(value: float) -> str:
+    return f"{value:g}"
+
+
+def organization_level_name(criteria: tuple[str, ...], values: dict[str, str]) -> str:
+    """Build a safe directory name from the selected organization criteria."""
+    parts = []
+    for criterion in criteria:
+        if criterion not in values:
+            raise ValueError(f"Organization criterion is not available: {criterion}")
+        value = values[criterion]
+        if criterion in ("upm", "tolerance", "simplify"):
+            value = f"{criterion}_{value}"
+        parts.append(value)
+    if not parts:
+        raise ValueError("Organization levels must contain at least one criterion.")
+    return sanitize_filename("_".join(parts)).strip() or "Unknown"
+
+
+_CONVERSION_BY_SETTINGS: dict[type[ConversionOptions], ConversionKind] = {
+    VarToStaticOptions: "var2static",
+    TtfToOtfOptions: "ttf2otf",
+    OtfToTtfOptions: "otf2ttf",
+    SfntToWebOptions: "ft2wf",
+    WoffToSfntOptions: "woff2ft",
+    Woff2ToSfntOptions: "woff22ft",
+    TtcToSfntOptions: "ttc2sfnt",
+}
+
+
+@dataclass(frozen=True)
+class ConversionRequest:
+    input_paths: tuple[Path, ...]
+    settings: ConversionSettings
+
+    @property
+    def conversion(self) -> ConversionKind:
+        return _CONVERSION_BY_SETTINGS[type(self.settings)]
+
+
+class FontOutcomeKind(Enum):
+    CONVERTED = "converted"
+    SKIPPED = "skipped"
+    FAILED = "failed"
+
+
+@dataclass(frozen=True)
+class FontOutcome:
+    """Outcome for one font; a collection can produce multiple outcomes per input path."""
+
+    input_path: Path
+    kind: FontOutcomeKind
+    output_paths: tuple[Path, ...] = ()
+    error: str | None = None
+    elapsed: float = 0.0
+
+
+@dataclass(frozen=True)
+class ConversionProgress:
+    """Batch progress measured in fonts, including each member of a collection."""
+
+    done: int
+    total: int
+
+
+ProgressCallback: TypeAlias = Callable[[ConversionProgress], None]
+OutcomeCallback: TypeAlias = Callable[[FontOutcome], None]
+FontStartCallback: TypeAlias = Callable[[Path], None]
+CancellationCheck: TypeAlias = Callable[[], bool]
+LogCallback: TypeAlias = Callable[[str], None]
+PauseWait: TypeAlias = Callable[[], None]
+
+
+@dataclass(frozen=True)
+class ConversionResult:
+    """Structured batch result, independent of CLI output and GUI presentation."""
+
+    outcomes: tuple[FontOutcome, ...] = ()
+    error: str | None = None
+    cancelled: bool = False
+
+    @property
+    def elapsed(self) -> float:
+        """Total conversion time in seconds: the sum of per-font times, so pauses are excluded."""
+        return sum(outcome.elapsed for outcome in self.outcomes)
+
+    @property
+    def converted_count(self) -> int:
+        return sum(outcome.kind is FontOutcomeKind.CONVERTED for outcome in self.outcomes)
+
+    @property
+    def skipped_count(self) -> int:
+        return sum(outcome.kind is FontOutcomeKind.SKIPPED for outcome in self.outcomes)
+
+    @property
+    def failed_count(self) -> int:
+        return sum(outcome.kind is FontOutcomeKind.FAILED for outcome in self.outcomes)
+
+    @property
+    def saved_files(self) -> list[Path]:
+        return [
+            path
+            for outcome in self.outcomes
+            if outcome.kind is FontOutcomeKind.CONVERTED
+            for path in outcome.output_paths
+        ]
+
+    @property
+    def ok(self) -> bool:
+        return self.error is None and self.failed_count == 0
+
+
+def build_output_file_name(font: Font, output_dir: Path | None, overwrite: bool = True) -> Path:
+    """Build the output name for a TrueType-to-PostScript conversion."""
+    flavor = font.ttfont.flavor
+    extension = font.get_file_ext() if flavor is not None else ".otf"
+    return font.get_file_path(output_dir=output_dir, overwrite=overwrite, extension=extension)
+
+
+_S = TypeVar("_S")
+
+
+def instance_label(coordinates: tuple[tuple[str, float], ...]) -> str:
+    """Describe an instance location from its axis values, e.g. ``opsz11 wght450``."""
+    return " ".join(f"{tag}{value:g}" for tag, value in coordinates)
+
+
+def instance_stem(input_path: Path, name: str | None, label: str) -> str:
+    """File name (without extension) of an instance: named ones use the name, others the label."""
+    suffix = re.sub(r"\s+", "", name) if name else label.replace(" ", "-")
+    base_stem = re.sub(r"\[.*?\]", "", input_path.stem)
+    return f"{base_stem}-{sanitize_filename(suffix)}"
+
+
+def _expect_settings(settings: object, kind: type[_S]) -> _S:
+    """Return settings as the expected type, or raise if the request is inconsistent."""
+    if not isinstance(settings, kind):
+        raise TypeError(f"Expected {kind.__name__}, got {type(settings).__name__}")
+    return settings
+
+
+class ConverterService:
+    """Run font conversions without depending on Qt, Click, or CLI output."""
+
+    def convert(
+        self,
+        request: ConversionRequest,
+        on_progress: ProgressCallback | None = None,
+        on_outcome: OutcomeCallback | None = None,
+        on_log: LogCallback | None = None,
+        should_cancel: CancellationCheck | None = None,
+        on_font_start: FontStartCallback | None = None,
+        wait_if_paused: PauseWait | None = None,
+    ) -> ConversionResult:
+        def stop_requested() -> bool:
+            if wait_if_paused is not None:
+                wait_if_paused()
+            return should_cancel is not None and should_cancel()
+
+        if not request.input_paths:
+            return ConversionResult(error="Select at least one input file or folder.")
+
+        try:
+            if request.settings.output_dir is not None:
+                request.settings.output_dir.mkdir(parents=True, exist_ok=True)
+            candidates = self._find_candidates(request)
+        except (OSError, ValueError, TTLibError) as error:
+            return ConversionResult(error=f"{type(error).__name__}: {error}")
+        if not candidates:
+            return ConversionResult(error="No compatible fonts found in the selected inputs.")
+
+        outcomes: list[FontOutcome] = []
+        web_entries: list[WebFontEntry] = []
+        has_compatible_fonts = any(compatible for _, _, compatible in candidates)
+        progress = ConversionProgress(0, sum(weight for _, weight, _ in candidates))
+        if on_progress is not None:
+            on_progress(progress)
+
+        for input_path, weight, compatible in candidates:
+            if stop_requested():
+                self._write_css_kit(web_entries, request.settings, on_log)
+                return ConversionResult(tuple(outcomes), cancelled=True)
+            if not compatible:
+                outcome = FontOutcome(input_path, FontOutcomeKind.SKIPPED)
+                outcomes.append(outcome)
+                self._report(outcome, on_outcome)
+                progress = ConversionProgress(progress.done + weight, progress.total)
+                if on_progress is not None:
+                    on_progress(progress)
+                continue
+            if request.conversion == "ttc2sfnt":
+                try:
+                    collection = TTCollection(input_path)
+                except (OSError, TTLibError) as error:
+                    return ConversionResult(
+                        tuple(outcomes), error=f"{type(error).__name__}: {error}"
+                    )
+                try:
+                    for member in collection.fonts:
+                        if stop_requested():
+                            return ConversionResult(tuple(outcomes), cancelled=True)
+                        if on_font_start is not None:
+                            on_font_start(input_path)
+                        outcome = self._extract_collection_member(
+                            input_path, member, request.settings
+                        )
+                        outcomes.append(outcome)
+                        self._report(outcome, on_outcome)
+                        progress = ConversionProgress(progress.done + 1, progress.total)
+                        if on_progress is not None:
+                            on_progress(progress)
+                finally:
+                    collection.close()
+                continue
+            if request.conversion == "var2static":
+                var_settings = _expect_settings(request.settings, VarToStaticOptions)
+                used_stems: set[str] = set()
+                for spec in self._instances_for(request.settings, input_path):
+                    if stop_requested():
+                        return ConversionResult(tuple(outcomes), cancelled=True)
+                    if on_font_start is not None:
+                        on_font_start(input_path)
+                    outcome = self._convert_instance(
+                        input_path, spec, var_settings, used_stems, on_log
+                    )
+                    outcomes.append(outcome)
+                    self._report(outcome, on_outcome)
+                    progress = ConversionProgress(progress.done + 1, progress.total)
+                    if on_progress is not None:
+                        on_progress(progress)
+                continue
+
+            for _ in range(weight):
+                if stop_requested():
+                    self._write_css_kit(web_entries, request.settings, on_log)
+                    return ConversionResult(tuple(outcomes), cancelled=True)
+                if on_font_start is not None:
+                    on_font_start(input_path)
+                started = time.perf_counter()
+                try:
+                    font = Font(
+                        input_path,
+                        recalc_bboxes=request.settings.recalc_bboxes,
+                        recalc_timestamp=request.settings.recalc_timestamp,
+                    )
+                    with font:
+                        output_paths = self._convert_font(
+                            font, request.settings, on_log, web_entries
+                        )
+                    outcome = FontOutcome(
+                        input_path,
+                        FontOutcomeKind.CONVERTED,
+                        tuple(output_paths),
+                        elapsed=time.perf_counter() - started,
+                    )
+                except Exception as error:
+                    outcome = FontOutcome(
+                        input_path,
+                        FontOutcomeKind.FAILED,
+                        error=f"{type(error).__name__}: {error}",
+                        elapsed=time.perf_counter() - started,
+                    )
+                outcomes.append(outcome)
+                self._report(outcome, on_outcome)
+                progress = ConversionProgress(progress.done + 1, progress.total)
+                if on_progress is not None:
+                    on_progress(progress)
+
+        self._write_css_kit(web_entries, request.settings, on_log)
+        no_compatible_error = (
+            None if has_compatible_fonts else "No compatible fonts found in the selected inputs."
+        )
+        return ConversionResult(tuple(outcomes), error=no_compatible_error)
+
+    @staticmethod
+    def _write_css_kit(
+        entries: list[WebFontEntry], settings: ConversionSettings, on_log: LogCallback | None
+    ) -> None:
+        if not entries or not isinstance(settings, SfntToWebOptions):
+            return
+        try:
+            for path in write_css_kits(entries, overwrite=settings.overwrite):
+                ConverterService._log(on_log, f"CSS saved to {path}")
+        except OSError as error:
+            ConverterService._log(on_log, f"Could not write the CSS: {error}")
+
+    def _find_candidates(self, request: ConversionRequest) -> list[tuple[Path, int, bool]]:
+        files: dict[Path, None] = {}
+        for source in request.input_paths:
+            if not source.exists():
+                raise FileNotFoundError(f"Input path does not exist: {source}")
+            if source.is_file():
+                files[source.resolve()] = None
+            elif source.is_dir():
+                paths = source.rglob("*") if request.settings.recursive else source.glob("*")
+                files.update((path.resolve(), None) for path in paths if path.is_file())
+
+        candidates: list[tuple[Path, int, bool]] = []
+        for path in files:
+            if request.conversion == "ttc2sfnt":
+                try:
+                    collection = TTCollection(path)
+                except (OSError, TTLibError, AssertionError):
+                    continue
+                count = len(collection.fonts)
+                collection.close()
+                if count:
+                    candidates.append((path, count, True))
+                continue
+
+            try:
+                font = Font(
+                    path,
+                    recalc_bboxes=request.settings.recalc_bboxes,
+                    recalc_timestamp=request.settings.recalc_timestamp,
+                )
+            except (OSError, TTLibError, PermissionError):
+                continue
+            with font:
+                compatible = self._is_compatible(font, request)
+            weight = 1
+            if compatible and request.conversion == "var2static":
+                weight = len(self._instances_for(request.settings, path))
+            candidates.append((path, weight, compatible))
+        return candidates
+
+    @staticmethod
+    def _is_compatible(font: Font, request: ConversionRequest) -> bool:
+        conversion = request.conversion
+        if conversion == "ttf2otf":
+            return font.is_tt and font.is_static
+        if conversion == "otf2ttf":
+            return font.is_ps and font.is_static
+        if conversion == "var2static":
+            return font.is_variable
+        if conversion == "ft2wf":
+            return font.is_sfnt
+        if conversion in ("woff2ft", "woff22ft"):
+            settings = _expect_settings(request.settings, WebToSfntOptions)
+            return (font.is_woff or font.is_woff2) and font.ttfont.flavor == settings.format
+        return False
+
+    @staticmethod
+    def _output_dir(
+        font: Font,
+        settings: ConversionOptions,
+        flavor: str | None,
+        is_tt: bool,
+    ) -> Path | None:
+        if (
+            not settings.organization_levels
+            and not settings.organize_output
+            and not settings.organize_by_family
+        ):
+            return settings.output_dir
+        base_dir = settings.output_dir or (font.file.parent if font.file is not None else None)
+        if base_dir is None:
+            raise ValueError("Cannot organize output without an output directory or input file.")
+        output_dir = base_dir
+        if settings.organization_levels:
+            family = str(font.ttfont[const.T_NAME].getBestFamilyName() or "")
+            format_name = {None: "opentype", "woff": "woff", "woff2": "woff2"}.get(flavor)
+            if format_name is None:
+                raise ValueError(f"Unsupported output font format: {flavor}")
+            values = {
+                "family": family or "Unknown family",
+                "format": format_name,
+                "outline": "tt" if is_tt else "ps",
+                "upm": str(getattr(settings, "target_upm", None) or font.units_per_em),
+            }
+            if hasattr(settings, "tolerance"):
+                values["tolerance"] = _format_organization_number(settings.tolerance)
+            if hasattr(settings, "optimize_contours"):
+                values["simplify"] = str(settings.optimize_contours)
+            for level in settings.organization_levels:
+                output_dir /= organization_level_name(level, values)
+        else:
+            if settings.organize_by_family:
+                family = str(font.ttfont[const.T_NAME].getBestFamilyName() or "")
+                output_dir = output_dir / (sanitize_filename(family).strip() or "Unknown family")
+            if settings.organize_output:
+                format_name = {None: "opentype", "woff": "woff", "woff2": "woff2"}.get(flavor)
+                if format_name is None:
+                    raise ValueError(f"Unsupported output font format: {flavor}")
+                output_dir = output_dir / f"{format_name}-{'tt' if is_tt else 'ps'}"
+        output_dir.mkdir(parents=True, exist_ok=True)
+        return output_dir
+
+    def _convert_font(
+        self,
+        font: Font,
+        settings: ConversionSettings,
+        on_log: LogCallback | None,
+        web_entries: list[WebFontEntry] | None = None,
+    ) -> list[Path]:
+        conversion = _CONVERSION_BY_SETTINGS[type(settings)]
+        if conversion == "ttf2otf":
+            settings = _expect_settings(settings, TtfToOtfOptions)
+            flavor = font.ttfont.flavor
+            output_dir = self._output_dir(font, settings, flavor, is_tt=False)
+            output = build_output_file_name(
+                font,
+                output_dir=output_dir,
+                overwrite=settings.overwrite,
+            )
+            font.ttfont.flavor = None
+            if settings.target_upm:
+                self._log(on_log, f"Scaling UPM to {settings.target_upm}...")
+                font.scale_upm(settings.target_upm)
+            tolerance = settings.tolerance / 1000 * font.units_per_em
+            self._log(on_log, "Converting to OTF...")
+            font.to_otf(tolerance=tolerance, optimize_contours=settings.optimize_contours)
+            if settings.subroutinize:
+                self._log(on_log, "Subroutinizing...")
+                font.subroutinize()
+            font.ttfont.flavor = flavor
+            font.save(output, reorder_tables=settings.reorder_tables)
+            return [Path(output)]
+
+        if conversion == "otf2ttf":
+            settings = _expect_settings(settings, OtfToTtfOptions)
+            flavor = font.ttfont.flavor
+            output_dir = self._output_dir(font, settings, flavor, is_tt=True)
+            extension = font.get_file_ext() if flavor is not None else ".ttf"
+            output = font.get_file_path(
+                output_dir=output_dir,
+                overwrite=settings.overwrite,
+                extension=extension,
+            )
+            tolerance = settings.tolerance / 1000 * font.units_per_em
+            self._log(on_log, "Converting to TTF...")
+            font.to_ttf(max_err=tolerance, reverse_direction=True)
+            if settings.target_upm:
+                self._log(on_log, f"Scaling UPM to {settings.target_upm}...")
+                font.scale_upm(settings.target_upm)
+            if settings.autohint:
+                self._log(on_log, "Autohinting...")
+                font.ttf_autohint()
+            font.save(output)
+            return [Path(output)]
+
+        if conversion in ("woff2ft", "woff22ft"):
+            settings = _expect_settings(settings, WebToSfntOptions)
+            output_dir = self._output_dir(font, settings, None, font.is_tt)
+            output = font.get_file_path(
+                output_dir=output_dir,
+                overwrite=settings.overwrite,
+                extension=".ttf" if font.is_tt else ".otf",
+            )
+            font.to_sfnt()
+            font.save(output, reorder_tables=settings.reorder_tables)
+            return [Path(output)]
+
+        if conversion == "ft2wf":
+            settings = _expect_settings(settings, SfntToWebOptions)
+            formats = (settings.format,) if settings.format else (WOFF_FLAVOR, WOFF2_FLAVOR)
+            if settings.remove_unused_glyphs:
+                self._log(on_log, "Removing unused glyphs...")
+                removed = font.remove_unused_glyphs()
+                self._log(on_log, f"Removed {removed} unused glyphs")
+            source_file = font.file
+            family = ""
+            if settings.obfuscate_names:
+                self._log(on_log, "Obfuscating names...")
+                family, ps_name = font.obfuscate_names()
+                if source_file is not None:
+                    source_file = source_file.with_name(ps_name)
+            entry_data: tuple[str, int, bool, tuple[str, ...]] | None = None
+            if settings.css_kit:
+                family = family or str(font.ttfont[const.T_NAME].getBestFamilyName() or "")
+                weight = int(getattr(font.ttfont.get(const.T_OS_2), "usWeightClass", 400))
+                italic = bool(font.ttfont[const.T_HEAD].macStyle & 0b10)
+                entry_data = (family, weight, italic, font.get_features())
+            if settings.remove_non_windows_names:
+                removed_names = font.remove_non_windows_names()
+                self._log(on_log, f"Removed {removed_names} non-Windows name records")
+            outputs = []
+            for format_ in formats:
+                self._log(on_log, f"Converting to {format_.upper()}")
+                if format_ == WOFF_FLAVOR:
+                    if settings.remove_dsig and font.remove_dsig():
+                        self._log(on_log, "Removed the DSIG table")
+                    font.to_woff()
+                else:
+                    font.to_woff2()
+                output_dir = self._output_dir(font, settings, format_, font.is_tt)
+                output = font.get_file_path(
+                    file=source_file, output_dir=output_dir, overwrite=settings.overwrite
+                )
+                font.save(output, reorder_tables=settings.reorder_tables)
+                outputs.append(Path(output))
+                if entry_data is not None and web_entries is not None:
+                    web_entries.append(WebFontEntry(Path(output), format_, *entry_data))
+            return outputs
+        raise ValueError(f"Unsupported conversion: {conversion}")
+
+    @staticmethod
+    def _instances_for(settings: ConversionSettings, path: Path) -> tuple[InstanceSpec, ...]:
+        """Return the instances to export from a font; the default instance if none is given."""
+        settings = _expect_settings(settings, VarToStaticOptions)
+        for instance_path, specs in settings.instances:
+            if instance_path.resolve() == path and specs:
+                return specs
+        return (InstanceSpec(()),)
+
+    def _convert_instance(
+        self,
+        input_path: Path,
+        spec: InstanceSpec,
+        settings: VarToStaticOptions,
+        used_stems: set[str],
+        on_log: LogCallback | None,
+    ) -> FontOutcome:
+        """Export one instance of a variable font."""
+        started = time.perf_counter()
+        try:
+            with Font(
+                input_path,
+                recalc_bboxes=settings.recalc_bboxes,
+                recalc_timestamp=settings.recalc_timestamp,
+            ) as font:
+                axis_tags = {axis.axisTag for axis in font.axes}
+                coordinates = {tag: value for tag, value in spec.coordinates if tag in axis_tags}
+                if spec.coordinates and not coordinates:
+                    raise ValueError("The instance does not match the axes of this font.")
+                flavor = font.ttfont.flavor
+                label = font.to_static(coordinates, name=spec.name)
+                self._log(on_log, f"Instancing {spec.name or label}...")
+                if settings.target_upm:
+                    self._log(on_log, f"Scaling UPM to {settings.target_upm}...")
+                    font.scale_upm(settings.target_upm)
+                self._log(on_log, "Correcting contours...")
+                font.correct_contours()
+                if font.is_tt and settings.autohint:
+                    self._log(on_log, "Autohinting...")
+                    font.ttf_autohint()
+                elif font.is_ps and settings.subroutinize:
+                    self._log(on_log, "Subroutinizing...")
+                    font.subroutinize()
+                stem = instance_stem(input_path, spec.name, label)
+                if stem in used_stems:
+                    stem = f"{stem}-{len(used_stems)}"
+                used_stems.add(stem)
+                output_dir = self._output_dir(font, settings, flavor, font.is_tt)
+                extension = font.get_file_ext()
+                output = font.get_file_path(
+                    file=input_path.with_name(stem + extension),
+                    output_dir=output_dir,
+                    overwrite=settings.overwrite,
+                    extension=extension,
+                )
+                font.save(output, reorder_tables=settings.reorder_tables)
+            return FontOutcome(
+                input_path,
+                FontOutcomeKind.CONVERTED,
+                (Path(output),),
+                elapsed=time.perf_counter() - started,
+            )
+        except Exception as error:
+            return FontOutcome(
+                input_path,
+                FontOutcomeKind.FAILED,
+                error=f"{type(error).__name__}: {error}",
+                elapsed=time.perf_counter() - started,
+            )
+
+    def _extract_collection_member(
+        self,
+        input_path: Path,
+        member: TTFont,
+        settings: ConversionOptions,
+    ) -> FontOutcome:
+        started = time.perf_counter()
+        try:
+            member.recalcBBoxes = settings.recalc_bboxes
+            member.recalcTimestamp = settings.recalc_timestamp
+            font = Font(member)
+            font.ensure_postscript_name()
+            name = sanitize_filename(font.get_postscript_name())
+            extension = font.get_file_ext()
+            member_settings = replace(
+                settings,
+                output_dir=settings.output_dir or input_path.parent,
+            )
+            output_dir = self._output_dir(font, member_settings, None, font.is_tt)
+            output = makeOutputFileName(
+                name,
+                outputDir=output_dir or input_path.parent,
+                overWrite=member_settings.overwrite,
+                extension=extension,
+            )
+            font.save(output, reorder_tables=settings.reorder_tables)
+            return FontOutcome(
+                input_path,
+                FontOutcomeKind.CONVERTED,
+                (Path(output),),
+                elapsed=time.perf_counter() - started,
+            )
+        except Exception as error:
+            return FontOutcome(
+                input_path,
+                FontOutcomeKind.FAILED,
+                error=f"{type(error).__name__}: {error}",
+                elapsed=time.perf_counter() - started,
+            )
+
+    @staticmethod
+    def _report(
+        outcome: FontOutcome,
+        callback: OutcomeCallback | None,
+    ) -> None:
+        if callback is not None:
+            callback(outcome)
+
+    @staticmethod
+    def _log(callback: LogCallback | None, message: str) -> None:
+        if callback is not None:
+            callback(message)