Introduzione
Il OpenType incorporato (EOT) è un formato di font compatto originariamente sviluppato per incorporare font TrueType nelle pagine web. Un file EOT avvolge un font TTF o OTF con un’intestazione a dimensione fissa contenente campi di metadati che descrivono le dimensioni del font, la versione, il set di caratteri e le autorizzazioni di incorporamento. Sebbene lo sviluppo web moderno sia in gran parte passato a WOFF/WOFF2, i file EOT rimangono in circolazione nei documenti legacy e nelle applicazioni aziendali.
Aspose.Font FOSS per Python fornisce accesso diretto agli internals dei font EOT tramite la classe EotFont e il suo compagno EotHeader. Puoi caricare un file EOT con FontLoader.open, leggere i campi dell’intestazione, attraversare l’interno TtfFont e serializzare il risultato nuovamente in byte o in un file usando Font.save. La libreria è pubblicata su PyPI come aspose-font e rilasciata sotto la MIT License. Non ha dipendenze commerciali obbligatorie e funziona con il runtime standard Python 3.
Caratteristiche principali
Caricamento dei font EOT
Usa FontLoader.open per caricare un file EOT da un percorso o da un oggetto bytes. Il metodo restituisce un’istanza EotFont quando rileva la firma EOT:
from aspose_font import FontLoader, EotFont
font = FontLoader.open("fonts/sample.eot")
assert isinstance(font, EotFont)
print(font.font_name) # e.g. "Roboto"
print(font.font_family) # e.g. "Roboto"
print(font.num_glyphs) # number of glyphs in the inner font
FontLoader.open legge l’estensione del file e il magic header per rilevare automaticamente il formato. Non è necessario alcun argomento font_type per i file di font comuni.
Lettura dei metadati EotHeader
EotFont espone i campi dell’intestazione direttamente come proprietà sulla classe. Corrispondono ai campi definiti nella specifica binaria EOT:
from aspose_font import FontLoader, EotFont, EotSerializer
# Load EOT — FontLoader returns an EotFont instance for .eot files
loaded = FontLoader.open("fonts/sample.eot")
# Serialize back to bytes to confirm the font loaded correctly
eot_bytes = EotSerializer.serialize(loaded)
print(f"EOT data loaded: {len(eot_bytes)} bytes")
# Base Font properties work on any loaded font
print("Font name:", loaded.font_name)
print("Glyphs :", loaded.num_glyphs)
La classe EotFont espone i seguenti metadati dell’intestazione come proprietà:
eot_version(int) — versione del formato EOT (ad es.0x00020002)flags(int) — flag di autorizzazione all’incorporamentocharset(int) — identificatore del set di caratteri (0 = ANSI, 1 = DEFAULT)italic(int) — flag corsivo (0 o 1)weight(int) — peso del font (ad es., 400 per Regular, 700 per Bold)fs_type(int) — OS/2 bit di incorporamento fsType
Usa flags e fs_type per determinare se il font consente il subsetting o l’embedding, il che è rilevante durante l’elaborazione dei font per le pipeline di redistribuzione.
Accesso all’TtfFont interno
Ogni EotFont avvolge un font standard TrueType. La proprietà inner_font restituisce l’istanza TtfFont, fornendoti l’accesso all’intero set di tabelle TrueType:
from aspose_font import FontLoader
loaded = FontLoader.open("fonts/sample.eot")
# Metrics are accessible directly from the loaded font
metrics = loaded.metrics
print("Units per em :", metrics.units_per_em)
print("Ascender :", metrics.ascender)
print("Descender :", metrics.descender)
print("Line gap :", metrics.line_gap)
La proprietà inner_font su EotFont restituisce l’istanza TtfFont avvolta, fornendo l’accesso all’intero set di tabelle TrueType, alle coppie di kern e alle tabelle di codifica.
Serializzare EOT in byte
EotSerializer.serialize converte qualsiasi oggetto Font in una stringa di byte EOT grezza:
from aspose_font import FontLoader, EotFont, EotSerializer
font = FontLoader.open("fonts/sample.eot")
assert isinstance(font, EotFont)
eot_bytes = EotSerializer.serialize(font)
with open("output/sample_copy.eot", "wb") as fh:
fh.write(eot_bytes)
print(f"Serialized {len(eot_bytes)} bytes")
Conversione da TTF a EOT
EotSerializer.serialize accetta qualsiasi istanza Font, così puoi caricare un TTF e serializzarlo direttamente in byte EOT:
from aspose_font import FontLoader, EotFont, EotSerializer
ttf = FontLoader.open("fonts/Roboto-Regular.ttf")
eot_bytes = EotSerializer.serialize(ttf)
with open("output/Roboto-Regular.eot", "wb") as fh:
fh.write(eot_bytes)
reloaded = FontLoader.open("output/Roboto-Regular.eot")
assert isinstance(reloaded, EotFont)
print("Converted and verified:", reloaded.font_name)
Metriche dei Font e Coppie di Kerning
Il EotFont eredita l’intera interfaccia Font, quindi metriche e codifica sono disponibili direttamente senza passare per inner_font:
from aspose_font import FontLoader
loaded = FontLoader.open("fonts/sample.eot")
metrics = loaded.metrics
print(f"Ascender : {metrics.ascender}")
print(f"Descender: {metrics.descender}")
print(f"Line gap : {metrics.line_gap}")
print(f"Underline: {metrics.underline_position}")
for pair in loaded.get_kern_pairs():
print(f" Kern: {pair}")
Guida rapida
Installa la libreria:
.venv/bin/pip install aspose-font
Carica e ispeziona un font EOT:
from aspose_font import FontLoader, EotFont, EotSerializer
loaded = FontLoader.open("sample.eot")
# Base font info
print(f"Font name : {loaded.font_name}")
print(f"Glyphs : {loaded.num_glyphs}")
# Metrics
metrics = loaded.metrics
print(f"UPM : {metrics.units_per_em}")
print(f"Ascender : {metrics.ascender}")
# Serialize the loaded font back to EOT bytes
eot_bytes = EotSerializer.serialize(loaded)
print(f"Serialized: {len(eot_bytes)} bytes")
Formati supportati
| Formato | Estensione | Leggi | Scrivi |
|---|---|---|---|
| TTF | .ttf | ✓ | — |
| OTF | .otf | ✓ | — |
| EOT | .eot | ✓ | — |
| CFF | .cff | ✓ | — |
| TYPE1 | .pfb/.pfa | ✓ | — |
| WOFF | .woff | ✓ | — |
| WOFF2 | .woff2 | ✓ | — |
Tutti i formati elencati sopra sono supportati per il caricamento tramite FontLoader.open. La scrittura in un formato specifico utilizza Font.save o EotSerializer.serialize per EOT.
Open Source & Licenze
Aspose.Font FOSS per Python è rilasciato sotto la Licenza MIT. Puoi usarlo in progetti personali, commerciali e open source senza costi. Il codice sorgente è disponibile su GitHub e il pacchetto è distribuito tramite PyPI come aspose-font.
