Práce s webovými fonty WOFF a WOFF2 v Python pomocí Aspose.Font FOSS

Úvod

WOFF (Web Open Font Format) je standardní kontejner pro doručování fontů na webu. WOFF1 zabaluje font TrueType nebo CFF pomocí komprese zlib; WOFF2 místo toho používá kompresi Brotli, což obvykle dosahuje o 20-30% lepších kompresních poměrů. Oba formáty jsou podporovány všemi moderními prohlížeči a nadále zůstávají doporučeným formátem pro doručování webové typografie.

Aspose.Font FOSS pro Python nyní zpřístupňuje WOFF a WOFF2 prostřednictvím sjednocené Font třídy. Třída poskytuje stejnou sadu vlastností (font_name, font_family, num_glyphs), volitelný metadata_xml blok, inner_font přístupový prvek, který vrací podkladový TtfFont, a to_bytes() metodu pro konverzi formátu.

Knihovna je publikována na PyPI jako aspose-font a je licencována pod licencí MIT License bez povinných komerčních závislostí.

Klíčové vlastnosti

Načítání fontů WOFF a WOFF2

Použijte FontLoader.open k načtení souboru WOFF nebo WOFF2. Načítadlo automaticky detekuje formát podle magických bajtů souboru:

from aspose_font 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 vrací WoffFont pro soubory .woff a Woff2Font pro soubory .woff2. Obě třídy implementují stejný Font základní rozhraní, takže kód, který čte vlastnosti, je pro oba formáty stejný.

Prohlížení metadat WOFF

Soubory WOFF mohou obsahovat volitelný XML blok metadat, který obsahuje informace o licencování, poděkování a popis písma. Přistupujte k němu přes vlastnost metadata_xml:

from aspose_font.loader import FontLoader

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

Vlastnost metadata_xml vrací str s nezpracovaným XML, nebo None, pokud písmo neobsahuje blok metadat. Obě WoffFont i Woff2Font tuto vlastnost vystavují.

Přístup k vnitřním tabulkám TTF

WOFF a WOFF2 zapouzdřují písmo TrueType. Vlastnost inner_font poskytuje podkladové TtfFont s plným přístupem k jeho OpenType sadě tabulek:

from aspose_font.loader import FontLoader

font = FontLoader.open("MyFont.woff")
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)}")

Pomocí inner.ttf_tables můžete přistupovat ke všem standardním tabulkám OpenType: head, hhea, maxp, os2, name a post. Pro tabulky bez pojmenovaného přístupu použijte inner.get_blob(tag) k získání surových bajtů podle značky OpenType.

Páry kerningu z písma WOFF

get_kern_pairs() vrací všechny páry kerningu vložené ve fontu. Každý KernPair obsahuje left (GlyphId), right (GlyphId) a value (int, ve fontových jednotkách):

from aspose_font 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}")

Páry kerningu jsou uloženy v vnitřní tabulce kern souboru TTF. Písma, která poskytují OpenType GPOS funkce kerningu místo tabulky kern, stále vrátí prázdný seznam z této metody.

Konverze formátu

FontConverter.convert provádí konverzi mezi formáty fontů. Použijte výčet FontType k určení cílového formátu a poté zavolejte to_bytes() pro serializaci:

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))

Všechny čtyři konverzní cesty (TTF na WOFF, TTF na WOFF2, WOFF na WOFF2, WOFF2 na WOFF) jsou podporovány stejným FontConverter.convert API.

Vytvoření webového balíčku fontů

WebFontBuilder.build generuje kompletní webový balíček fontů z jediného zdroje TTF a vrací WebFontBundle s CSS, HTML a fontovými assety. Zavolejte write_to na balíček pro uložení balíčku na disk:

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

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

# Build the web font bundle (WOFF + WOFF2 assets, CSS, HTML)
bundle = WebFontBuilder.build(
    font=font,
    file_stem="MyFont",
    include_woff=True,
    font_display="swap",
    preview_text="The quick brown fox",
    instance_coordinates=None,
)

# Write the bundle's assets, CSS, and HTML to disk
written_paths = bundle.write_to("web-output")
print(f"Wrote {len(written_paths)} files to web-output/")

write_to vrací seznam cest k souborům, které zapsal. Parametr font_display mapuje přímo na popisovač CSS font-display a přijímá "auto", "block", "swap", "fallback" nebo "optional".

Rychlý start

Nainstalujte knihovnu:

git clone https://github.com/aspose-font-foss/Aspose.Font-FOSS-for-Python.git
cd Aspose.Font-FOSS-for-Python
pip install -e .

Načtěte font WOFF a převěďte jej na 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")

Podporované formáty webových fontů

Všechny zdrojové formáty podporují převod na WOFF a WOFF2 pomocí FontConverter.convert.

Open Source a licencování

Aspose.Font FOSS pro Python je vydáno pod licencí MIT. Můžete jej použít v osobních, komerčních i open-source projektech bez poplatku. Zdrojový kód je dostupný na GitHub a balíček je distribuován přes PyPI jako aspose-font.

Začínáme

• Začínáme
• Průvodce vývojáře
• Články KB
• Průvodce WOFF Jak na to
• API Reference

Související zdroje

• Aspose.Font — Enterprise Blog