Einleitung
Embedded OpenType (EOT) ist ein kompaktes Schriftformat, das ursprünglich für die Einbettung von TrueType-Schriften in Webseiten entwickelt wurde. Eine EOT-Datei umschließt eine TTF- oder OTF-Schrift mit einem Header fester Größe, der Metadatenfelder enthält, die Schriftabmessungen, Version, Zeichensatz und Einbettungsrechte beschreiben. Obwohl die moderne Webentwicklung weitgehend zu WOFF/WOFF2 übergegangen ist, sind EOT-Dateien nach wie vor in Legacy-Dokumenten und Unternehmensanwendungen im Umlauf.
Aspose.Font FOSS für Python bietet direkten Zugriff auf die internen Strukturen von EOT-Schriften über die Klasse EotFont und ihr Begleitobjekt EotHeader. Sie können eine EOT-Datei mit FontLoader.open laden, Header-Felder lesen, das innere TtfFont durchlaufen und das Ergebnis mit Font.save wieder in Bytes oder in eine Datei serialisieren. Die Bibliothek wird auf PyPI als aspose-font veröffentlicht und steht unter der MIT-Lizenz. Es hat keine zwingenden kommerziellen Abhängigkeiten und funktioniert mit dem Standard Python 3 Runtime.
Hauptmerkmale
Laden von EOT-Schriften
Verwenden Sie FontLoader.open, um eine EOT-Datei aus einem Pfad oder einem Bytes-Objekt zu laden. Die Methode gibt eine EotFont-Instanz zurück, wenn sie die EOT-Signatur erkennt:
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 liest die Dateierweiterung und den Header-Magic, um das Format automatisch zu erkennen. Für gängige Schriftdateien ist kein font_type-Argument erforderlich.
Lesen von EotHeader-Metadaten
EotFont stellt die Header-Felder direkt als Eigenschaften in der Klasse bereit. Diese entsprechen den im EOT-Binärspezifikation definierten Feldern:
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)
Die EotFont-Klasse stellt die folgenden Header-Metadaten als Eigenschaften bereit:
eot_version(int) — EOT-Formatversion (z.B.0x00020002)flags(int) — Einbettungsberechtigungs-Flagscharset(int) — Zeichensatz-Identifikator (0 = ANSI, 1 = DEFAULT)italic(int) — Kursiv-Flag (0 oder 1)weight(int) — Schriftgewicht (z.B. 400 für Regular, 700 für Bold)fs_type(int) — OS/2 fsType-Einbettungsbits
Verwenden Sie flags und fs_type, um festzustellen, ob die Schriftart das Subsetzen oder Einbetten zulässt, was bei der Verarbeitung von Schriften für Redistribuierungs-Pipelines relevant ist.
Zugriff auf das innere TtfFont
Jedes EotFont umschließt eine Standard-TrueType-Schrift. Die inner_font-Eigenschaft gibt die TtfFont-Instanz zurück und ermöglicht den Zugriff auf das vollständige TrueType-Tabellenset:
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)
Die inner_font-Eigenschaft von EotFont gibt die umschlossene TtfFont-Instanz zurück und ermöglicht den Zugriff auf das vollständige TrueType-Tabellenset, Kerning-Paare und Kodierungstabellen.
Serialisierung von EOT in Bytes
EotSerializer.serialize konvertiert jedes Font-Objekt in eine rohe EOT-Byte-Zeichenkette:
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")
Konvertierung von TTF zu EOT
EotSerializer.serialize akzeptiert jede Font-Instanz, sodass Sie ein TTF laden und es direkt in EOT-Bytes serialisieren können:
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)
Schriftmetriken und Kerning-Paare
Der EotFont erbt die vollständige Font-Schnittstelle, sodass Metriken und Kodierung direkt verfügbar sind, ohne inner_font zu durchlaufen:
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}")
Schnellstart
Bibliothek installieren:
.venv/bin/pip install aspose-font
Ein EOT-Schrift laden und untersuchen:
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")
Unterstützte Formate
| Format | Erweiterung | Lesen | Schreiben |
|---|---|---|---|
| TTF | .ttf | ✓ | — |
| OTF | .otf | ✓ | — |
| EOT | .eot | ✓ | — |
| CFF | .cff | ✓ | — |
| TYPE1 | .pfb/.pfa | ✓ | — |
| WOFF | .woff | ✓ | — |
| WOFF2 | .woff2 | ✓ | — |
Alle oben aufgeführten Formate werden zum Laden über FontLoader.open unterstützt. Das Schreiben in ein bestimmtes Format verwendet Font.save oder EotSerializer.serialize für EOT.
Open Source & Lizenzierung
Aspose.Font FOSS für Python wird unter der MIT-Lizenz veröffentlicht. Sie können es kostenlos in privaten, kommerziellen und Open-Source-Projekten nutzen. Der Quellcode ist auf GitHub verfügbar und das Paket wird über PyPI als aspose-font verteilt.
