DocumentReader के साथ हल्का दस्तावेज़ मॉडल बनाना

DocumentReader के साथ एक हल्का दस्तावेज़ मॉडल बनाना

DocumentReader Aspose.Words FOSS में DOCX फ़ाइलों को पढ़ने के लिए प्रवेश बिंदु है। यह इनपुट को फ़ाइल पथ, I/O स्ट्रीम, या कच्चे बाइट्स के रूप में स्वीकार करता है, फिर दस्तावेज़ को light_document_model.Document (LDM) के रूप में प्रस्तुत करता है — एक संरचित Python ऑब्जेक्ट ट्री जो निरीक्षण और रूपांतरण में आसान है।

आवश्यकताएँ

आवश्यकता	विवरण
Python	3.9 या बाद में
Package	`aspose-words-foss` (MIT-licensed)
Input	एक `.docx` फ़ाइल, स्ट्रीम, या `bytes`

pip install aspose-words-foss

फ़ाइल पथ से लोड करना

DocumentReader.load_file(filepath) पथ द्वारा DOCX फ़ाइल पढ़ता है। बाद में to_light_document() को कॉल करके LDM प्रतिनिधित्व प्राप्त करें।

from aspose.words_foss import DocumentReader

reader = DocumentReader()
reader.load_file("data/report.docx")
doc = reader.to_light_document()

print("Page count:", doc.page_count)
print("Sections:", len(doc.sections))

स्ट्रीम से लोड करना

DocumentReader.load_stream(stream) किसी भी फ़ाइल-सम जैसे ऑब्जेक्ट को स्वीकार करता है जिसमें read() मेथड हो। यह HTTP प्रतिक्रियाओं, ZIP अभिलेखों, या इन-मेमोरी बफ़र्स से आने वाले डेटा के लिए उपयोगी है।

from aspose.words_foss import DocumentReader

reader = DocumentReader()
with open("data/report.docx", "rb") as fh:
    reader.load_stream(fh)

doc = reader.to_light_document()
print("Paragraphs:", len(doc.all_paragraphs))

बाइट्स से लोड करना

DocumentReader.load_bytes(data) एक bytes या bytearray ऑब्जेक्ट को स्वीकार करता है। इसका उपयोग तब करें जब DOCX सामग्री पहले से ही मेमोरी में हो (उदाहरण के लिए, डेटाबेस से प्राप्त या प्रोग्रामेटिक रूप से निर्मित)।

from aspose.words_foss import DocumentReader

with open("data/report.docx", "rb") as fh:
    data = fh.read()

reader = DocumentReader()
reader.load_bytes(data)
doc = reader.to_light_document()
print("Text preview:", doc.text[:200])

LDM संरचना में नेविगेट करना

to_light_document() को कॉल करने के बाद, लौटाया गया Document ऑब्जेक्ट पूर्ण दस्तावेज़ ट्री को उजागर करता है:

from aspose.words_foss import DocumentReader

reader = DocumentReader()
reader.load_file("data/report.docx")
doc = reader.to_light_document()

# Sections
for section in doc.sections:
    print("Section paragraphs:", len(section.paragraphs))

# All paragraphs (flat list across all sections)
for para in doc.all_paragraphs:
    if para.text.strip():
        print(" -", para.text[:80])

# Headings
for heading in doc.headings(max_level=2):
    print("H:", heading.text)

पूरा दस्तावेज़ पाठ पढ़ना

Document.text दस्तावेज़ की संपूर्ण सादा-पाठ सामग्री लौटाता है, सभी अनुभागों में सभी पैराग्राफ़ टेक्स्ट को जोड़ते हुए:

reader = DocumentReader()
reader.load_file("data/report.docx")
doc = reader.to_light_document()
print(doc.text[:500])

टिप्स और सर्वोत्तम प्रथाएँ

हमेशा load_file(), load_stream(), या load_bytes() को to_light_document() को कॉल करने से पहले कॉल करें — अनलोडेड रीडर पर to_light_document() को कॉल करने से त्रुटि उत्पन्न हो सकती है या खाली दस्तावेज़ लौट सकता है।
जब आप मेमोरी में दस्तावेज़ जीवनचक्र को नियंत्रित करते हैं तो load_bytes() का उपयोग करें; यह फ़ाइल हैंडल खोलने से बचाता है।
सभी पैराग्राफ़ों पर सपाट इटरेशन के लिए doc.all_paragraphs का उपयोग करें; जब आपको सेक्शन-दर-सेक्शन काम करने की आवश्यकता हो तो doc.sections का उपयोग करें।
DocumentReader LdmBuilderMixin को लागू करता है, जिसका अर्थ है कि to_light_document() मिक्सिन मेथड के रूप में उपलब्ध है — वही इंटरफ़ेस लाइब्रेरी में अन्य रीडर क्लासेस के साथ साझा किया जाता है।

सामान्य समस्याएँ

समस्या	कारण	समाधान
लोड के बाद `doc.sections` खाली है	फ़ाइल एक मान्य DOCX नहीं है	जाँचें कि फ़ाइल Word में खुलती है; देखें कि वह पासवर्ड-सुरक्षित नहीं है
`doc.all_paragraphs` खाली है	दस्तावेज़ में कोई बॉडी टेक्स्ट नहीं है (जैसे केवल हेडर/फ़ूटर)	इसके बजाय `doc.header_paragraphs` और `doc.footer_paragraphs` जाँचें
`AttributeError` `to_light_document()` पर	रूपांतरण से पहले लोड मेथड को कॉल नहीं किया गया	पहले `load_file()`, `load_stream()`, या `load_bytes()` में से किसी एक को कॉल करें

FAQ

LDM क्या है?

लाइट डॉक्यूमेंट मॉडल (light_document_model.Document) एक एब्स्ट्रैक्टेड, Python-नेटीव ऑब्जेक्ट ट्री है जो एक Word दस्तावेज़ का प्रतिनिधित्व करता है। यह दस्तावेज़ लॉजिक को DOCX बाइनरी फ़ॉर्मेट से अलग करता है और आसान प्रोग्रामेटिक हेरफेर के लिए डिज़ाइन किया गया है।

क्या मैं LDM को संशोधित करके इसे फिर से DOCX में लिख सकता हूँ?

हां। संशोधित करने के बाद doc ऑब्जेक्ट, इसे पास करें LdmDocxWriter.write(doc, path) एक अपडेटेड DOCX फ़ाइल बनाने के लिए। देखें LdmDocxWriter गाइड विवरण के लिए।

`LdmBuilderMixin` क्या जोड़ता है?

LdmBuilderMixin to_light_document() मेथड प्रदान करता है। DocumentReader इससे विरासत में प्राप्त करता है इसलिए आप हमेशा इस मेथड को रीडर इंस्टेंस के माध्यम से एक्सेस करते हैं।

API Reference सारांश

क्लास / मेथड	विवरण
`DocumentReader`	DOCX इनपुट को पढ़ता है और LDM प्रतिनिधित्व बनाता है
`DocumentReader.load_file(filepath)`	पथ द्वारा एक DOCX फ़ाइल लोड करता है
`DocumentReader.load_stream(stream)`	फ़ाइल-समतुल्य स्ट्रीम से लोड करता है
`DocumentReader.load_bytes(data)`	एक `bytes` ऑब्जेक्ट से लोड करता है
`DocumentReader.to_light_document()`	लोड किया गया दस्तावेज़ LDM `Document` के रूप में लौटाता है
`LdmBuilderMixin`	एक Mixin जो `to_light_document()` प्रदान करता है
`Document.sections`	दस्तावेज़ में अनुभागों की सूची
`Document.all_paragraphs`	सभी पैराग्राफ़ की सपाट सूची
`Document.text`	दस्तावेज़ की पूर्ण साधारण-पाठ सामग्री
`Document.page_count`	पृष्ठों की संख्या
`Document.headings(max_level)`	हेडिंग पैराग्राफ़ की सूची `max_level` तक

यह भी देखें

Aspose.Words for Python — Enterprise Documentation