Python में Aspose.Font FOSS का उपयोग करके EOT फ़ॉन्ट्स के साथ काम करना

परिचय

एम्बेडेड OpenType (EOT) एक कॉम्पैक्ट फ़ॉन्ट फ़ॉर्मेट है जिसे मूल रूप से वेब पेजों में TrueType फ़ॉन्ट्स को एम्बेड करने के लिए विकसित किया गया था। एक EOT फ़ाइल TTF या OTF फ़ॉन्ट को एक निश्चित आकार के हेडर के साथ लपेटती है जिसमें मेटाडेटा फ़ील्ड होते हैं जो फ़ॉन्ट आयाम, संस्करण, कैरेक्टर सेट, और एम्बेडिंग अनुमतियों का वर्णन करते हैं। यद्यपि आधुनिक वेब विकास ने मुख्य रूप से WOFF/WOFF2 की ओर रुख किया है, EOT फ़ाइलें अभी भी लेगेसी दस्तावेज़ों और एंटरप्राइज़ एप्लिकेशनों में प्रचलित हैं।

Aspose.Font FOSS Python के लिए EOT फ़ॉन्ट आंतरिक भागों तक सीधे पहुँच प्रदान करता है, जो EotFont क्लास और उसके साथी EotHeader के माध्यम से संभव है। आप FontLoader.open के साथ एक EOT फ़ाइल लोड कर सकते हैं, हेडर फ़ील्ड पढ़ सकते हैं, अंदरूनी TtfFont को ट्रैवर्स कर सकते हैं, और परिणाम को बाइट्स में या फ़ाइल में Font.save का उपयोग करके सीरियलाइज़ कर सकते हैं। लाइब्रेरी PyPI पर aspose-font के रूप में प्रकाशित की गई है और MIT License के तहत लाइसेंस प्राप्त है। इसमें कोई अनिवार्य व्यावसायिक निर्भरताएँ नहीं हैं और यह मानक Python 3 रनटाइम के साथ काम करता है।

मुख्य विशेषताएँ

EOT फ़ॉन्ट्स लोड करना

FontLoader.open का उपयोग करके किसी पथ या बाइट्स ऑब्जेक्ट से EOT फ़ाइल लोड करें। जब यह EOT सिग्नेचर का पता लगाता है तो यह विधि एक EotFont इंस्टेंस लौटाती है:

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 फ़ाइल एक्सटेंशन और हेडर मैजिक को पढ़कर फ़ॉर्मेट का स्वचालित रूप से पता लगाता है। सामान्य फ़ॉन्ट फ़ाइलों के लिए कोई font_type आर्ग्यूमेंट आवश्यक नहीं है।

EotHeader मेटाडेटा पढ़ना

EotFont हेडर फ़ील्ड्स को सीधे क्लास की प्रॉपर्टीज़ के रूप में उजागर करता है। ये 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)

EotFont क्लास निम्नलिखित हेडर मेटाडेटा को प्रॉपर्टीज़ के रूप में उजागर करती है:

• eot_version (int) — EOT फ़ॉर्मेट संस्करण (उदा. 0x00020002)
• flags (int) — एम्बेडिंग अनुमति फ्लैग्स
• charset (int) — कैरेक्टर सेट पहचानकर्ता (0 = ANSI, 1 = DEFAULT)
• italic (int) — इटैलिक फ़्लैग (0 या 1)
• weight (int) — फ़ॉन्ट वज़न (उदा., Regular के लिए 400, Bold के लिए 700)
• fs_type (int) — OS/2 fsType एम्बेडिंग बिट्स

flags और fs_type का उपयोग करके निर्धारित करें कि फ़ॉन्ट उपसेटिंग या एम्बेडिंग की अनुमति देता है या नहीं, जो फ़ॉन्ट्स को पुनर्वितरण पाइपलाइन में प्रोसेस करते समय प्रासंगिक है।

भीतर के TtfFont को एक्सेस करना

प्रत्येक EotFont एक मानक TrueType फ़ॉन्ट को रैप करता है। inner_font प्रॉपर्टी TtfFont इंस्टेंस लौटाती है, जिससे आपको पूर्ण 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)

EotFont पर inner_font प्रॉपर्टी रैप किया हुआ TtfFont इंस्टेंस लौटाती है, जो पूर्ण TrueType टेबल सेट, kern पेयर्स, और एन्कोडिंग टेबल्स तक पहुँच प्रदान करती है।

EOT को बाइट्स में सीरियलाइज़ करना

EotSerializer.serialize किसी भी Font ऑब्जेक्ट को कच्चे EOT बाइट स्ट्रिंग में परिवर्तित करता है:

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

TTF को EOT में परिवर्तित करना

EotSerializer.serialize किसी भी Font इंस्टेंस को स्वीकार करता है, इसलिए आप TTF लोड करके उसे सीधे 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)

फ़ॉन्ट मीट्रिक्स और कर्न युग्म

EotFont पूर्ण Font इंटरफ़ेस को विरासत में लेता है, इसलिए मीट्रिक्स और एन्कोडिंग सीधे उपलब्ध हैं बिना 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}")

त्वरित प्रारंभ

लाइब्रेरी स्थापित करें:

.venv/bin/pip install aspose-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")

समर्थित फ़ॉर्मेट

उपरोक्त सूचीबद्ध सभी फ़ॉर्मेट FontLoader.open के माध्यम से लोड करने के लिए समर्थित हैं। किसी विशिष्ट फ़ॉर्मेट में लिखने के लिए EOT के लिए Font.save या EotSerializer.serialize का उपयोग किया जाता है।

ओपन सोर्स और लाइसेंसिंग

Aspose.Font FOSS for Python MIT लाइसेंस के तहत जारी किया गया है। आप इसे व्यक्तिगत, व्यावसायिक और ओपन-सोर्स प्रोजेक्ट्स में बिना किसी लागत के उपयोग कर सकते हैं। स्रोत कोड GitHub पर उपलब्ध है और पैकेज PyPI के माध्यम से aspose-font के रूप में वितरित किया जाता है।

शुरूआत

• शुरूआत
• डेवलपर गाइड
• केबी लेख
• API Reference

संबंधित संसाधन

• Aspose.Font — Enterprise Blog