Support WOFF and WOFF2 fonts (#1660)

* issue fixed

* Fix: optional imports and generator contextmanager typing in fpdf.py

* Fix type checking and performance issues in fonts.py and fpdf.py

- fpdf/fonts.py:
  * Added explanatory comment for TYPE_CHECKING block clarifying it's for static type checkers only
  * Optimized hbfont property to avoid performance hit for non-WOFF fonts by checking file extension
  * For WOFF/WOFF2: uses byte buffer decompression (required for HarfBuzz)
  * For TTF/OTF: loads directly from file path (faster, no extra serialization)
  * Removed invalid fallback for WOFF/WOFF2 that would fail anyway
  * Added logging for failed temp file cleanup to track orphaned files

- fpdf/fpdf.py:
  * Removed unnecessary TYPE_CHECKING block for optional dependencies
  * Fixed table() method return type from Iterator[Table] to ContextManager[Table]

* support woff and woff2

* copy is_compressed attribute

* docs and changelog

* remove some comments

---------

Co-authored-by: Anderson Herzogenrath da Costa <[email protected]>

Author: BharathPESU

CHANGELOG.md

@@ -20,6 +20,7 @@ This can also be enabled programmatically with `warnings.simplefilter('default',
 ### Added
 * support for SVG `<linearGradient>` and `<radialGradient>` elements - _cf._ [issue #1580](https://github.com/py-pdf/fpdf2/issues/1580) - thanks to @Ani07-05
 * mypy and pyright checks in the CI pipeline to enforce strict typing
+* support WOFF and WOFF2 fonts - thanks to @BharathPESU
 ### Fixed
 * the `A5` value that could be specified as page `format` to the `FPDF` constructor was slightly incorrect, and the corresponding page dimensions have been fixed. This could lead to a minor change in your documents dimensions if you used this `A5` page format. - _cf._ [issue #1699](https://github.com/py-pdf/fpdf2/issues/1699)
 * a bug when rendering empty tables with `INTERNAL` layout, that caused an extra border to be rendered due to an erroneous use of `list.index()` - _cf._ [issue #1669](https://github.com/py-pdf/fpdf2/issues/1669)

docs/Unicode.md

@@ -18,6 +18,10 @@ FreeSerif, FreeMono
 
 To use a Unicode font in your program, use the [`add_font()`](https://py-pdf.github.io/fpdf2/fpdf/fpdf.html#fpdf.fpdf.FPDF.add_font), and then the  [`set_font()`](https://py-pdf.github.io/fpdf2/fpdf/fpdf.html#fpdf.fpdf.FPDF.set_font) method calls.
 
+### Web fonts (WOFF and WOFF2) ###
+
+WOFF and WOFF2 are web-optimized, compressed containers for TrueType and OpenType fonts, designed to reduce download size for browsers. `fpdf2` supports these formats by decompressing them before embedding the resulting font data into the generated PDF.
+
 
 ### Built-in Fonts vs. Unicode Fonts ###
 

fpdf/fonts.py

@@ -20,6 +20,7 @@
 from copy import deepcopy
 from dataclasses import dataclass, replace
 from functools import cache
+from io import BytesIO
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
@@ -341,6 +342,7 @@ class TTFFont:
         "color_font",
         "unicode_range",
         "palette_index",
+        "is_compressed",
     )
 
     def __init__(
@@ -356,18 +358,35 @@ def __init__(
         self.i = len(fpdf.fonts) + 1
         self.type = "TTF"
         self.ttffile = font_file_path
+        self.is_compressed = str(self.ttffile).lower().endswith((".woff", ".woff2"))
         self._hbfont: Optional["HarfBuzzFont"] = None
         self.fontkey = fontkey
         self.biggest_size_pt: float = 0
 
         # recalcTimestamp=False means that it doesn't modify the "modified" timestamp in head table
         # if we leave recalcTimestamp=True the tests will break every time
-        self.ttfont = ttLib.TTFont(
-            self.ttffile, recalcTimestamp=False, fontNumber=0, lazy=True
-        )
+        try:
+            self.ttfont = ttLib.TTFont(
+                self.ttffile, recalcTimestamp=False, fontNumber=0, lazy=True
+            )
+        except (
+            ImportError,
+            RuntimeError,
+        ) as exc:  # pragma: no cover - defensive messaging
+            # If the user passed a WOFF2 file but brotli is not installed, fontTools
+            # raises an ImportError/RuntimeError during parsing. Provide a clearer hint
+            # only for that specific situation. Allow other exceptions (e.g. FileNotFoundError,
+            # OSError, parsing errors) to propagate normally so they aren't masked here.
+            fname_str = str(self.ttffile).lower()
+            if fname_str.endswith(".woff2"):
+                raise RuntimeError(
+                    "Could not open WOFF2 font. WOFF2 support requires an external Brotli "
+                    "library (install 'brotli' or 'brotlicffi'). Original error: "
+                    f"{exc!s}"
+                ) from exc
+            raise
 
         if axes_dict is not None:
-            # Check if variable font.
             if "fvar" not in self.ttfont:
                 raise AttributeError(f"{self.ttffile} is not a variable font")
 
@@ -377,6 +396,9 @@ def __init__(
                 inplace=True,
                 static=True,
             )
+        if self.is_compressed:
+            # Normalize to SFNT output for embedding and HarfBuzz.
+            self.ttfont.flavor = None
         upem: float = float(self.ttfont["head"].unitsPerEm)
         self.scale: float = 1000 / upem
 
@@ -516,7 +538,50 @@ def __init__(
     @property
     def hbfont(self) -> "HarfBuzzFont":
         if not self._hbfont:
-            self._hbfont = HarfBuzzFont(hb.Face(hb.Blob.from_file_path(self.ttffile)))
+            if self.is_compressed:
+                # HarfBuzz cannot load compressed WOFF/WOFF2 files directly, so we
+                # re-serialize the fontTools TTFont to a raw SFNT byte buffer.
+                buf = BytesIO()
+                self.ttfont.save(buf)
+                buf.seek(0)
+                ttfont_bytes = buf.read()
+
+                # Try to create a HarfBuzz blob from bytes; if not available, write a
+                # temporary file as a last resort.
+                try:
+                    blob = hb.Blob.from_bytes(ttfont_bytes)
+                    face = hb.Face(blob)
+                except (AttributeError, RuntimeError):
+                    import tempfile, os  # pylint: disable=import-outside-toplevel
+
+                    tmp_name = None
+                    try:
+                        with tempfile.NamedTemporaryFile(
+                            suffix=".ttf", delete=False
+                        ) as tmp:
+                            tmp_name = tmp.name
+                            tmp.write(ttfont_bytes)
+                            tmp.flush()
+                        face = hb.Face(hb.Blob.from_file_path(tmp_name))
+                    finally:
+                        if tmp_name:
+                            try:
+                                os.unlink(tmp_name)
+                            except OSError as cleanup_error:
+                                # Log warning about failed cleanup - orphaned temp file may cause disk issues
+                                LOGGER.warning(
+                                    "Failed to clean up temporary font file '%s': %s. This may leave an orphaned file on disk.",
+                                    tmp_name,
+                                    cleanup_error,
+                                )
+
+                self._hbfont = HarfBuzzFont(face)
+            else:
+                # For regular TTF/OTF fonts, load directly from file path (faster)
+                self._hbfont = HarfBuzzFont(
+                    hb.Face(hb.Blob.from_file_path(self.ttffile))
+                )
+
         return self._hbfont
 
     def __repr__(self) -> str:
@@ -542,6 +607,7 @@ def __deepcopy__(self: "TTFFont", memo: dict[int, Any]) -> "TTFFont":
         copy.sp = self.sp
         copy.ss = self.ss
         copy.emphasis = self.emphasis
+        copy.is_compressed = self.is_compressed
         # Attributes shared, to improve FPDFRecorder performances:
         copy.ttfont = self.ttfont
         copy.cmap = self.cmap

fpdf/fpdf.py

@@ -2513,7 +2513,7 @@ def add_font(
             raise ValueError('"fname" parameter is required')
 
         ext = splitext(str(fname))[1].lower()
-        if ext not in (".otf", ".otc", ".ttf", ".ttc"):
+        if ext not in (".otf", ".otc", ".ttf", ".ttc", ".woff", ".woff2"):
             raise ValueError(
                 f"Unsupported font file extension: {ext}."
                 " add_font() used to accept .pkl file as input, but for security reasons"

pyproject.toml

@@ -71,6 +71,7 @@ docs = [
   "pdoc3",
 ]
 test = [
+  "brotli",
   "camelot-py[base]",
   "endesive[full]",
   "pytest",