Introduktion
Inbäddad OpenType (EOT) är ett kompakt typsnittformat som ursprungligen utvecklades för att bädda in TrueType-typsnitt på webbsidor. En EOT-fil omsluter ett TTF- eller OTF-typsnitt med ett fast storlekshuvud som innehåller metadatafält som beskriver typsnittsdimensioner, version, teckenuppsättning och inbäddningsbehörigheter. Även om modern webbutveckling i stor utsträckning har gått över till WOFF/WOFF2, finns EOT-filer fortfarande i cirkulation i äldre dokument och företagsapplikationer.
Aspose.Font FOSS för Python ger direkt åtkomst till EOT-typsnittsinterna via klassen EotFont och dess komplement EotHeader. Du kan läsa in en EOT-fil med FontLoader.open, läsa headerfält, traversera den inre TtfFont och serialisera resultatet tillbaka till byte eller till en fil med Font.save. Biblioteket publiceras på PyPI som aspose-font och är licensierat under MIT-licensen. Den har inga obligatoriska kommersiella beroenden och fungerar med standard Python 3 runtime.
Nyckelfunktioner
Laddning av EOT-typsnitt
Använd FontLoader.open för att läsa in en EOT-fil från en sökväg eller ett bytes-objekt. Metoden returnerar en EotFont-instans när den upptäcker EOT-signaturen:
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 läser filändelsen och header-magiken för att automatiskt upptäcka formatet. Inget font_type-argument krävs för vanliga typsnittsfiler.
Läsning av EotHeader Metadata
EotFont exponerar rubrikfälten direkt som egenskaper på klassen. Dessa motsvarar fälten som definieras i EOT-binärspecifikationen:
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)
Klassen EotFont exponerar följande rubrikmetadata som egenskaper:
eot_version(int) — EOT-formatversion (t.ex.0x00020002)flags(int) — inbäddningsbehörighetsflaggorcharset(int) — teckenuppsättningsidentifierare (0 = ANSI, 1 = DEFAULT)italic(int) — kursivflagga (0 eller 1)weight(int) — typsnittsvikt (t.ex. 400 för Regular, 700 för Bold)fs_type(int) — OS/2 fsType inbäddningsbitar
Använd flags och fs_type för att avgöra om typsnittet tillåter delmängdsuttag eller inbäddning, vilket är relevant vid bearbetning av typsnitt för omdistributionspipelines.
Åtkomst till den inre TtfFont
Varje EotFont omger ett standard TrueType typsnitt. inner_font-egenskapen returnerar TtfFont-instansen och ger dig åtkomst till hela TrueType-tabelluppsättningen:
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)
inner_font-egenskapen på EotFont returnerar den omslagna TtfFont-instansen och ger åtkomst till hela TrueType-tabelluppsättningen, kerningpar och kodningstabeller.
Serialisering av EOT till bytes
EotSerializer.serialize konverterar vilket som helst Font-objekt till en rå EOT-byte-sträng:
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")
Konvertering av TTF till EOT
EotSerializer.serialize accepterar vilken som helst Font-instans, så du kan läsa in en TTF och serialisera den direkt till EOT-bytes:
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)
Typsnittsmått och kerningpar
Den EotFont ärver hela Font-gränssnittet, så mått och kodning är tillgängliga direkt utan att gå via 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}")
Snabbstart
Installera biblioteket:
.venv/bin/pip install aspose-font
Läs in och inspektera ett EOT-typsnitt:
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")
Stödda format
| Format | Filändelse | Läs | Skriv |
|---|---|---|---|
| TTF | .ttf | ✓ | — |
| OTF | .otf | ✓ | — |
| EOT | .eot | ✓ | — |
| CFF | .cff | ✓ | — |
| TYPE1 | .pfb/.pfa | ✓ | — |
| WOFF | .woff | ✓ | — |
| WOFF2 | .woff2 | ✓ | — |
Alla format som listas ovan stöds för inläsning via FontLoader.open. Skrivning till ett specifikt format använder Font.save eller EotSerializer.serialize för EOT.
Öppen källkod & licensiering
Aspose.Font FOSS för Python är släppt under MIT-licensen. Du kan använda den i personliga, kommersiella och projekt med öppen källkod utan kostnad. Källkoden finns på GitHub och paketet distribueras via PyPI som aspose-font.
