Introducción
El formato de fonts compacto (EOT) se ha desarrollado originalmente para incorporar las fuentes TrueType en páginas web. Un archivo EOT ropa una fuente TTF o OTF con un título de tamaño fijo que contiene campos de metadatos que describen las dimensiones de la letra, la versión, el carcete y los permisos de incorporarse. Aunque el desarrollo moderno de Internet ha cambiado en gran medida a WOFF/WOF F2, los archivos EO permanecen en circulación en documentos heredados y aplicaciones empresariales.
Aspose.Font FOSS for Python provides direct access to EOT font internals through the EotFont clase y su compañero EotHeader.Puedes cargar un archivo de EOT con FontLoader.open, leer los campos de cabeza, cruzar el interior TtfFont,y serializar el devolver a los bajos o a un archivo que se utiliza Font.save.
La biblioteca se publica en Pypi como aspose-font Licenciado bajo la licencia MIT. No tiene dependencias comerciales obligatorias y funciona con el tiempo de trabajo Python 3 estándar.
Características clave
Cargar Fontes EOT
Uso FontLoader.open para cargar un archivo EOT de un objeto de ruta o bytes. Devolver una EotFont El caso cuando detecta 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 lea la extensión de archivo y el título mágico para detectar el formato Automaticamente no. font_type El argumento es necesario para los archivos de fontos comunes.
El uso de metadatos EotHeader
EotFont exponer los campos de título directamente como propiedades en la clase. corresponde a los campos definidos en la especificación binaria de 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)
El EotFont La clase exponerá los siguientes metadatos de la cabeza como propiedades:
eot_version(intVersión de formato EOT (por ejemplo,.0x00020002)flags(int- Implementación de banderas de permisocharset(intIdentificador de los personajes (0 = ANSI, 1 = DEFAULT)italic(int• Bandera italiana (0 o 1)weight(int- peso de la letra (por ejemplo, 400 para regular, 700 para Bold)fs_type(int2) - OS/2 fsType bits de embotamiento
Uso flags y fs_type para determinar si la letra permite suspensión o la incorporación, que es relevante al procesar las fuentes para los tubos de redistribución.
Acceso al TtfFont Interior
Cada uno EotFont se desprende de una letra TrueType estándar. el inner_font La propiedad devuelve El de TtfFont Por ejemplo, le dará acceso al conjunto de tablas TrueType completo:
from aspose_font import FontLoader, EotFont
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)
El inner_font Propiedad en EotFont devolver el envuelto TtfFont El caso, proporcionar Acceso al conjunto de tablas TrueType completo, pares de núcleo y las tabulas de codificación.
Serialización de EOT a Bytes
EotSerializer.serialize Convertir cualquier Font Objeto a una línea de byte EOT cruda:
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")
Convertir TTF en EOT
EotSerializer.serialize Acepta cualquier Font por ejemplo, para que pueda cargar un TTF y Sería en el 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)
Métriques de fontos y pares de núcleos
El EotFont heredados los llenos Font interfaz, así que las métricas y el codificación son Disponible sin pasar por 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}")
Inicio rápido
Instalar la biblioteca:
.venv/bin/pip install aspose-font
Cargar y inspeccionar una fuente 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")
Formatos apoyados
| Formato | Extensiones | Leer | Escribe |
|---|---|---|---|
| TTF | .TF | ✓ | — |
| OTF | .OTV | ✓ | — |
| EOT | .El EOT | ✓ | — |
| CFF | .cff | ✓ | — |
| TYPE1 | .pfb / pfa | ✓ | — |
| WOFF | .Woff | ✓ | — |
| WOFF2 | .El WooF2 | ✓ | — |
Todos los formatos listados anteriormente están apoyados para cargar a través de FontLoader.open.Escribir Para un formato específico se utiliza Font.save o EotSerializer.serialize para el EOT.
Open Source y Licenciación
Aspose.Font FOSS for Python is released under the MIT License. You can use it in Proyectos personales, comerciales y de código abierto sin costo. el código fuente es disponible en GitHub y el paquete se distribuye a través de PyPI como: aspose-font.
