Travailler avec WOFF et Woff2 Web Fonts en Python à l'aide d'Aspose.Font FOSS | File Format Processing Plugins for C# .NET Core

Introduction

WOFF (Web Open Font Format) est le conteneur standard pour la livraison de phontres sur le web. Woff 1 enveloppe une phonte TrueType ou CFF avec compression zlib; WIFF 2 applique la composition Brotli au lieu, généralement atteignant 20-30% des taux de compresse meilleurs. Tous les formats sont soutenus par chaque navigateur moderne et sont le format de livraisons recommandé pour l’ typographie Web.

Aspose.Font FOSS for Python exposes WOFF and WOFF2 through the WoffFont et Woff2Font Les deux classes partagent la même API : elles exposent les propriétés de font (font_name, font_family, num_glyphsUne option metadata_xml Le bloc, un inner_font Un acteur qui remet le sous-sol TtfFont,Et A to_bytes() méthode de conversion.

La bibliothèque est publiée sur Pypi comme aspose-font Licencé par le MIT Licence sans dépendance commerciale obligatoire.

Fonctionnalités clés

Les fonctions WOFF et Woff2

Utiliser FontLoader.open pour télécharger un fichier WOFF ou WofF2. le chargement détecte le format De la fiche de bits magiques automatiquement :

from aspose_font.loader import FontLoader

# Load WOFF 1
woff = FontLoader.open("MyFont.woff")
print(f"Name   : {woff.font_name}")
print(f"Family : {woff.font_family}")
print(f"Style  : {woff.font_style}")
print(f"Glyphs : {woff.num_glyphs}")
print(f"Type   : {woff.font_type}")

# Load WOFF 2
woff2 = FontLoader.open("MyFont.woff2")
print(f"Name   : {woff2.font_name}")
print(f"Glyphs : {woff2.num_glyphs}")

FontLoader.open Retour à A WoffFont Pour .woff Les fichiers et a Woff2Font Pour .woff2 Les deux classes ont la même fonctionnalité Font L’interface de base est un code qui Les propriétés de lecture sont identiques pour les deux formats.

Vérification des méta-data WOFF

Les fichiers WOFF peuvent inclure un bloc de métadonnées XML facultatif contenant une licence. information, crédits et une description de la phonture.Accédez à elle par le biais du metadata_xml Propriété :

from aspose_font.loader import FontLoader

font = FontLoader.open("MyFont.woff")
# metadata_xml is a WoffFont-specific property
xml = getattr(font, "metadata_xml", None)
if xml:
    print("WOFF metadata XML:")
    print(xml[:500])
else:
    print("No metadata block in this WOFF file")

Le metadata_xml La propriété est de retour à str contenant le XML brut, ou None Si le Le fichier ne contient pas un bloc de métadonnées. WoffFont et Woff2Font Exposer cette propriété.

Accès à des tables TTF intérieures

WOFF et WofF2 envelopper une phonture TrueType. inner_font La propriété vous donne le sous-jacents TtfFont avec accès complet à son ensemble de table OpenType :

from aspose_font.loader import FontLoader

font = FontLoader.open("MyFont.woff")
# inner_font is a WoffFont-specific property returning the TtfFont
inner = getattr(font, "inner_font")
tables = inner.ttf_tables        # TtfTableSet

print(f"Units/em    : {tables.head.units_per_em}")
print(f"Ascender    : {tables.hhea.ascender}")
print(f"Num glyphs  : {tables.maxp.num_glyphs}")
print(f"Family name : {tables.name.best_name(1)}")

à travers inner_font.ttf_tables Vous pouvez accéder à toutes les tables OpenType : head, hhea, maxp, os2, name,et post.Pour les tables sans nom Accessoires, utilisation inner_font.get_blob(tag) Pour obtenir des bytes de base par OpenType tag.

Les paires de noyau d’un WOFF Font

get_kern_pairs() Retourner tous les paires de noyau intégrés dans le font. KernPair Porter left (le Glyphid est le cas), right (Glyphid) et value (en unités de font) :

from aspose_font.loader import FontLoader

font = FontLoader.open("MyFont.woff")
pairs = font.get_kern_pairs()
print(f"Kern pairs: {len(pairs)}")

for pair in pairs[:5]:
    print(f"  {pair.left} + {pair.right} = {pair.value}")

Les paires de noyau sont stockés dans le TTF intérieur kern Tableau. fonts avec OpenType GPOS Les caractéristiques de la base au lieu d’une kern La table retournera une liste vide de cette méthode.

Format de conversion

FontConverter.convert convertis entre les formats de texte. Utilisez le FontType Enum Pour définir le format cible, appelez-vous ensuite to_bytes() Pour sérialiser :

from aspose_font.loader import FontLoader
from aspose_font.converter import FontConverter
from aspose_font import FontType
from pathlib import Path

# TTF -> WOFF
ttf = FontLoader.open("MyFont.ttf")
woff = FontConverter.convert(ttf, FontType.WOFF)
Path("MyFont.woff").write_bytes(woff.to_bytes(FontType.WOFF))

# TTF -> WOFF2 (Brotli-compressed)
woff2 = FontConverter.convert(ttf, FontType.WOFF2)
Path("MyFont.woff2").write_bytes(woff2.to_bytes(FontType.WOFF2))

# WOFF -> WOFF2
existing_woff = FontLoader.open("MyFont.woff")
converted = FontConverter.convert(existing_woff, FontType.WOFF2)
Path("MyFont-from-woff.woff2").write_bytes(converted.to_bytes(FontType.WOFF2))

# WOFF2 -> WOFF (decompress back to WOFF 1)
existing_woff2 = FontLoader.open("MyFont.woff2")
woff1 = FontConverter.convert(existing_woff2, FontType.WOFF)
Path("MyFont-from-woff2.woff").write_bytes(woff1.to_bytes(FontType.WOFF))

Les quatre voies de conversion (TTF à WOFF, TTF au WofF2, WIFF aux W OFF2 et WUFF2) sont toutes en cours. Le FF est soutenu par le même FontConverter.convert API.

Créer un Web Font Package

WebFontBuilder.build générer un paquet de phonts Web complet à partir d’un TTF unique Il produit WOFF, WofF2, et un SVG de prévision facultatif dans une seule appel:

from aspose_font.web import WebFontBuilder
from aspose_font.loader import FontLoader
from pathlib import Path

# Load a TTF source font
font = FontLoader.open("MyFont.ttf")

# Build WOFF + WOFF2 output files
WebFontBuilder.build(
    font=font,
    file_stem="MyFont",
    include_woff=True,
    font_display="swap",
    preview_text="The quick brown fox",
    instance_coordinates=None,
    output_dir=Path("web-output"),
)

Après la convocation, web-output/ contenant MyFont.woff, MyFont.woff2,et Optionnellement a MyFont-preview.svg.Le font_display Les paramètres de la carte sont directement Le CSS font-display Descripteur et accepte "auto", "block", "swap", "fallback",ou "optional".

Démarrage rapide

Installation de la bibliothèque :

pip install "aspose-font>=1.0.0"

Cartez un fichier WOFF et convertit-le en Woff2 :

from aspose_font.loader import FontLoader
from aspose_font.converter import FontConverter
from aspose_font import FontType
from pathlib import Path

# Load WOFF
font = FontLoader.open("MyFont.woff")
print(f"Font   : {font.font_name}")
print(f"Glyphs : {font.num_glyphs}")
print(f"Type   : {font.font_type}")

# Inspect metadata (if present) — WoffFont-specific property
xml = getattr(font, "metadata_xml", None)
print(f"Has metadata: {xml is not None}")

# Access inner OpenType tables — WoffFont-specific property
inner = getattr(font, "inner_font")
tables = inner.ttf_tables
print(f"Units/em: {tables.head.units_per_em}")

# Convert to WOFF2
woff2 = FontConverter.convert(font, FontType.WOFF2)
Path("MyFont.woff2").write_bytes(woff2.to_bytes(FontType.WOFF2))
print("Converted to WOFF2")

Formats Web Fonts Soutenus

Formats	Extension	chargement	Convertir à WOFF	Convertir à WOFF2
TTF	.TFD	Oui	Oui	Oui
OTF	.OTP	Oui	Oui	Oui
WOFF	.Voff	Oui	—	Oui
WOFF2	.Le Wooff2	Oui	Oui	—
EOT	.EOT	Oui	Oui	Oui
CFF	.CFF	Oui	Oui	Oui
TYPE1	.pfb / pfa	Oui	Oui	Oui

Tous les formats source supportent la conversion à WOFF et WofF2 via FontConverter.convert.

Source ouverte et licence

Aspose.Font FOSS for Python is released under the MIT License. You can use it in des projets personnels, commerciaux et open source sans coût. le code source est disponible sur GitHub et le package est distribué via PyPI comme aspose-font.

Pour commencer

Ressources associées

Aspose.Font — Enterprise Blog

Introduction#

Fonctionnalités clés#

Les fonctions WOFF et Woff2#

Vérification des méta-data WOFF#

Accès à des tables TTF intérieures#

Les paires de noyau d’un WOFF Font#

Format de conversion#

Créer un Web Font Package#

Démarrage rapide#

Formats Web Fonts Soutenus#

Source ouverte et licence#

Pour commencer#

Ressources associées#