Trabalhar com WOFF e WOff2 Web Fonts em Python usando Aspose.Font FOSS

Introdução

WOFF (Web Open Font Format) é o contêiner padrão para entregar fontes na web. WOff 1 envolve uma fonte TrueType ou CFF com compressão zlib; WOF 2 aplica a comprissão Brotli em vez disso, geralmente alcançando 20-30% melhores taxas de compressação. Ambos os formatos são suportados por todos os navegadores modernos e são o formato recomendado de entrega para tipografia da Web.

Aspose.Font FOSS for Python exposes WOFF and WOFF2 through the WoffFont e a) Woff2Font classes. Ambas as classes compartilham a mesma API: elas expõem propriedades de fonte (font_name, font_family, num_glyphs), um documento facultativo. metadata_xml bloco, um inner_font Acessório que retorna o subjacente TtfFont, e um to_bytes() método de conversão do formato.

A biblioteca é publicada no PyPI como: aspose-font e licenciado sob a MIT. Licença sem dependências comerciais obrigatórias.

Características principais

Carregamento de fontes WOFF e WOff2

Utilização: FontLoader.open O carregador detecta o formato de um arquivo WOFF ou WOff2. do arquivo bytes mágicos automaticamente:

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 retorna um WoffFont para o .woff Arquivos e um Woff2Font para o .woff2 ambas as classes implementam o mesmo Font interface base para código que Leia propriedades é idêntico para ambos os formatos.

Inspecção dos metadados WOFF

Os ficheiros WOFF podem incluir um bloco de metadados XML opcional que contenha licenças. Informações, créditos e uma descrição da fonte. metadata_xml propriedade:

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

A Comissão metadata_xml propriedade retorna um str contendo o XML bruto, ou None se: A fonte não inclui um bloco de metadados. WoffFont e a) Woff2Font exposição Esta propriedade.

Acesso a tabelas TTF internas

WOFF e WOff2 envolvem uma fonte TrueType. inner_font A propriedade lhe dá o Subjacente TtfFont com acesso total ao seu conjunto de tabelas 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)}")

Através de… inner_font.ttf_tables pode aceder a todas as tabelas OpenType padrão: head, hhea, maxp, os2, name, e post.Para mesas sem nome . acessório, utilização inner_font.get_blob(tag) para recuperar bytes brutos por OpenType tag.

Pares de núcleos a partir de uma fonte WOFF

get_kern_pairs() Retorna todos os pares de núcleos incorporados na fonte. Cada um KernPair carregado left (GlyphId), right (GlyphId) e value (int, em unidades de fonte):

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

Os pares de núcleo são armazenados no TTF interno. kern Fontes com OpenType GPOS características do núcleo em vez de um kern a tabela retornará uma lista vazia de: Este método.

Conversão de formato

FontConverter.convert Converte entre formatos de fonte. Use o FontType emum para especificar o formato de destino, em seguida, chamar to_bytes() para serialização:

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

Todas as quatro vias de conversão (TTF para WOFF, TTF para WWFF2, Woff para Wovff2, Woff2 para A Comissão Europeia tem em conta o facto de a sua proposta ser objecto de uma análise mais aprofundada. FontConverter.convert API.

Criar um pacote de fontes da Web

WebFontBuilder.build gera um pacote de fontes web completo a partir de uma única TTF. Produza WOFF, WOff2 e um SVG de pré-visualização opcional em uma chamada:

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

Depois da chamada, web-output/ contém: MyFont.woff, MyFont.woff2, e opcionalmente um MyFont-preview.svg.O . font_display mapas de parâmetros diretamente para o o CSS font-display Descrição e aceita "auto", "block", "swap", "fallback", ou "optional".

Começo rápido

Instalar a biblioteca:

pip install "aspose-font>=1.0.0"

Carregar uma fonte WOFF e convertê-la para 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")

Formatações de fontes suportadas na Web

Todos os formatos de origem suportam conversão para WOFF e WOff2 via FontConverter.convert.

Fonte aberta e licença

Aspose.Font FOSS for Python is released under the MIT License. You can use it in O código-fonte é o código de acesso a todos os projetos pessoais, comerciais e open source sem custo. disponível no GitHub e o pacote é distribuído via PyPI como aspose-font.

Começar a Fazer

• Começar a Fazer
• Guia de Desenvolvedores
• KB Artigos
• WOFF Guia de instruções
• Referência API

Recursos relacionados

• Aspose.Font — Enterprise Blog