പൈത്തണിന്റെ ഇമെയിൽ പാക്കേജ്: MIME സന്ദേശ നിർമ്മാണവും കാര്യക്ഷമമായ വിശകലനവും

വ്യക്തിഗത ആശയവിനിമയം, ബിസിനസ്സ് പ്രവർത്തനങ്ങൾ, ഓട്ടോമേറ്റഡ് സിസ്റ്റം അറിയിപ്പുകൾ എന്നിവയ്ക്ക് ഇമെയിൽ ഇപ്പോഴും ലോകമെമ്പാടുമുള്ള ആശയവിനിമയത്തിന്റെ ഒരു മൂലക്കല്ലായി തുടരുന്നു. ഓരോ സമ്പന്നമായ ടെക്സ്റ്റ് ഇമെയിലിനും, ഓരോ അറ്റാച്ച്‌മെന്റിനും, ഓരോ സൂക്ഷ്മമായി ഫോർമാറ്റ് ചെയ്ത ഒപ്പുപ perangkat യും പിന്നിൽ മൾട്ടിപർപ്പസ് ഇന്റർനെറ്റ് മെയിൽ എക്സ്റ്റൻഷനുകളുടെ (MIME) സങ്കീർണ്ണതയുണ്ട്. ഡെവലപ്പർമാർക്ക്, പ്രത്യേകിച്ച് പൈത്തൺ ഉപയോഗിക്കുന്നവർക്ക്, ഈ MIME സന്ദേശങ്ങൾ പ്രോഗ്രാമാറ്റിക്കായി നിർമ്മിക്കാനും വിശകലനം ചെയ്യാനും എങ്ങനെ മാസ്റ്റർ ചെയ്യാം എന്നത് ഒരു നിർണ്ണായക കഴിവാണ്.

പൈത്തണിന്റെ അന്തർനിർമ്മിതമായ email പാക്കേജ് ഇമെയിൽ സന്ദേശങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിന് ഒരു ശക്തവും സമഗ്രവുമായ ചട്ടക്കൂട് നൽകുന്നു. ഇത് ലളിതമായ ടെക്സ്റ്റ് അയയ്ക്കാൻ മാത്രമല്ല; MIME-യുടെ സങ്കീർണ്ണമായ വിശദാംശങ്ങൾ абстраക്ഷൻ ചെയ്യാനാണ് ഇത് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്, ഇത് നിങ്ങൾക്ക് വളരെ സങ്കീർണ്ണമായ ഇമെയിലുകൾ സൃഷ്ടിക്കാനും ഇൻകമിംഗ് ഇമെയിലുകളിൽ നിന്ന് ഡാറ്റ വളരെ കൃത്യതയോടെ നിഷ്കർഷിച്ചെടുക്കാനും അനുവദിക്കുന്നു. ഈ ഗൈഡ് ഈ പാക്കേജിന്റെ രണ്ട് പ്രധാന തലങ്ങളിലേക്ക് നിങ്ങളെ ആഴത്തിൽ കൊണ്ടുപോകും: അയയ്ക്കുന്നതിനുള്ള MIME സന്ദേശങ്ങൾ നിർമ്മിക്കുന്നതും ഡാറ്റാ നിഷ്കർഷണത്തിനായി അവ വിശകലനം ചെയ്യുന്നതും, മികച്ച സമ്പ്രദായങ്ങളെക്കുറിച്ചുള്ള ഒരു ലോകവീക്ഷണം നൽകുന്നു.

നിർമ്മാണവും വിശകലനവും മനസ്സിലാക്കുന്നത് നിർണായകമാണ്. നിങ്ങൾ ഒരു സന്ദേശം നിർമ്മിക്കുമ്പോൾ, മറ്റൊരു സിസ്റ്റം വ്യാഖ്യാനിക്കുന്നതിനായി അതിന്റെ ഘടനയും ഉള്ളടക്കവും നിർവചിക്കുകയാണ് നിങ്ങൾ ചെയ്യുന്നത്. നിങ്ങൾ വിശകലനം ചെയ്യുമ്പോൾ, മറ്റൊരു സിസ്റ്റം നിർവചിച്ച ഘടനയും ഉള്ളടക്കവും വ്യാഖ്യാനിക്കുകയാണ് നിങ്ങൾ ചെയ്യുന്നത്. ഒന്നിൽ ആഴത്തിലുള്ള ധാരണ മറ്റൊന്നിനെ മാസ്റ്റർ ചെയ്യാൻ വളരെയധികം സഹായിക്കുന്നു, ഇത് കൂടുതൽ പ്രതിരോധശേഷിയുള്ളതും പരസ്പരം പ്രവർത്തിക്കുന്നതുമായ ഇമെയിൽ ആപ്ലിക്കേഷനുകളിലേക്ക് നയിക്കുന്നു.

MIME മനസ്സിലാക്കുന്നു: ആധുനിക ഇമെയിലിന്റെ നട്ടെല്ല്

പൈത്തൺ സ്പെഷ്യലുകളിൽ കടക്കുന്നതിന് മുമ്പ്, MIME എന്താണെന്നും അത് എന്തുകൊണ്ട് അത്ര പ്രധാനമാണെന്നും മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്. യഥാർത്ഥത്തിൽ, ഇമെയിൽ സന്ദേശങ്ങൾ ലളിതമായ ടെക്സ്റ്റിലേക്ക് (7-ബിറ്റ് ASCII അക്ഷരങ്ങൾ) പരിമിതപ്പെടുത്തിയിരുന്നു. 1990-കളുടെ തുടക്കത്തിൽ അവതരിപ്പിച്ച MIME, ഇമെയിലിന്റെ കഴിവുകൾ വർദ്ധിപ്പിച്ചു:

• Non-ASCII അക്ഷരങ്ങൾ: അറബിക്, ചൈനീസ്, റഷ്യൻ, അല്ലെങ്കിൽ ASCII സെറ്റിന് പുറത്തുള്ള അക്ഷരങ്ങൾ ഉപയോഗിക്കുന്ന മറ്റേതെങ്കിലും ഭാഷയിലെ ടെക്സ്റ്റ് അനുവദിക്കുന്നു.
• അറ്റാച്ച്‌മെന്റുകൾ: ഡോക്യുമെന്റുകൾ, ചിത്രങ്ങൾ, ഓഡിയോ, വീഡിയോ പോലുള്ള ഫയലുകൾ അയയ്ക്കുന്നു.
• സമ്പന്നമായ ടെക്സ്റ്റ് ഫോർമാറ്റിംഗ്: ബോൾഡിംഗ്, ഇറ്റാലിക്സ്, നിറങ്ങൾ, ലേഔട്ടുകൾ എന്നിവയുള്ള HTML ഇമെയിലുകൾ.
• ഒന്നിലധികം ഭാഗങ്ങൾ: ഒരു ഇമെയിലിനുള്ളിൽ ലളിതമായ ടെക്സ്റ്റ്, HTML, അറ്റാച്ച്‌മെന്റുകൾ എന്നിവ സംയോജിപ്പിക്കുന്നു.

MIME ഇത് ഒരു ഇമെയിൽ സന്ദേശത്തിലേക്ക് പ്രത്യേക ഹെഡറുകൾ ചേർക്കുന്നതിലൂടെയും അതിന്റെ ബോഡി വിവിധ "ഭാഗങ്ങളായി" ഘടനാവൽക്കുന്നതിലൂടെയും നേടുന്നു. നിങ്ങൾ കാണുന്ന പ്രധാന MIME ഹെഡറുകളിൽ ഇവ ഉൾപ്പെടുന്നു:

• Content-Type: ഒരു ഭാഗത്തിലെ ഡാറ്റയുടെ തരം വ്യക്തമാക്കുന്നു (ഉദാഹരണത്തിന്, text/plain, text/html, image/jpeg, application/pdf, multipart/alternative). ഇത് പലപ്പോഴും ഒരു charset പാരാമീറ്ററും ഉൾക്കൊള്ളുന്നു (ഉദാഹരണത്തിന്, charset=utf-8).
• Content-Transfer-Encoding: ഇമെയിൽ ക്ലയന്റ് ഉള്ളടക്കം എങ്ങനെ ഡീക്കോഡ് ചെയ്യണം എന്ന് സൂചിപ്പിക്കുന്നു (ഉദാഹരണത്തിന്, ബൈനറി ഡാറ്റയ്ക്ക് base64, ASCII അല്ലാത്ത അക്ഷരങ്ങൾ അധികമുള്ള ടെക്സ്റ്റിന് quoted-printable).
• Content-Disposition: സ്വീകരിക്കുന്നവരുടെ ഇമെയിൽ ക്ലയന്റ് എങ്ങനെ ഭാഗം പ്രദർശിപ്പിക്കണം എന്ന് നിർദ്ദേശിക്കുന്നു (ഉദാഹരണത്തിന്, സന്ദേശ ബോഡിக்குள் പ്രദർശിപ്പിക്കുന്നതിന് inline, സംരക്ഷിക്കേണ്ട ഫയലിനായി attachment).

പൈത്തൺ email പാക്കേജ്: ഒരു ആഴത്തിലുള്ള പഠനം

പൈത്തണിന്റെ email പാക്കേജ് പ്രോഗ്രാമാറ്റിക്കായി ഇമെയിൽ സന്ദേശങ്ങൾ സൃഷ്ടിക്കുന്നതിനും വിശകലനം ചെയ്യുന്നതിനും പരിഷ്കരിക്കുന്നതിനും രൂപകൽപ്പന ചെയ്ത ഒരു സമഗ്ര ലൈബ്രറിയാണ്. ഇത് Message ഒബ്ജക്റ്റുകൾ എന്ന ആശയത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, ഇത് ഒരു ഇമെയിലിന്റെ ഘടനയെ പ്രതിനിധീകരിക്കുന്നു.

പാക്കേജിലെ പ്രധാന മൊഡ്യൂളുകളിൽ ഇവ ഉൾപ്പെടുന്നു:

• email.message: ഇമെയിൽ സന്ദേശങ്ങൾ സൃഷ്ടിക്കുന്നതിനും കൈകാര്യം ചെയ്യുന്നതിനും പ്രാഥമിക ഇന്റർഫേസ് ആയ EmailMessage ക്ലാസ് അടങ്ങിയിരിക്കുന്നു. ഇത് MIME വിശദാംശങ്ങൾ സ്വപ്രേരിതമായി കൈകാര്യം ചെയ്യുന്ന വളരെ സൗകര്യപ്രദമായ ഒരു ക്ലാസ് ആണ്.
• email.mime: MIME ഘടനയിൽ കൂടുതൽ വ്യക്തമായ നിയന്ത്രണം നൽകുന്ന ലെഗസി ക്ലാസുകൾ (MIMEText, MIMEMultipart പോലുള്ളവ) നൽകുന്നു. EmailMessage അതിന്റെ ലാളിത്യം കാരണം പുതിയ കോഡിന് സാധാരണയായി ഇഷ്ടപ്പെടുന്നുണ്ടെങ്കിലും, ഈ ക്ലാസുകളെക്കുറിച്ച് മനസ്സിലാക്കുന്നത് പ്രയോജനകരമാകും.
• email.parser: റോ ഇമെയിൽ ഡാറ്റ (ബൈറ്റ് അല്ലെങ്കിൽ സ്ട്രിംഗുകൾ) EmailMessage ഒബ്ജക്റ്റുകളിലേക്ക് മാറ്റാൻ BytesParser, Parser പോലുള്ള ക്ലാസുകൾ വാഗ്ദാനം ചെയ്യുന്നു.
• email.policy: ഇമെയിൽ സന്ദേശങ്ങൾ എങ്ങനെ നിർമ്മിക്കപ്പെടുന്നു, വിശകലനം ചെയ്യപ്പെടുന്നു എന്നിവ നിയന്ത്രിക്കുന്ന നയങ്ങൾ നിർവചിക്കുന്നു, ഹെഡർ എൻകോഡിംഗ്, ലൈൻ എൻഡിംഗുകൾ, പിശക് കൈകാര്യം ചെയ്യൽ എന്നിവയെ ബാധിക്കുന്നു.

ഏറ്റവും പുതിയ ഉപയോഗങ്ങൾക്ക്, നിർമ്മാണത്തിനും വിശകലനം ചെയ്ത സന്ദേശ ഒബ്ജക്റ്റിനും നിങ്ങൾ പ്രധാനമായും email.message.EmailMessage ക്ലാസുമായി ഇടപഴകും. അതിന്റെ മെത്തഡുകൾ പഴയ email.mime ക്ലാസുകളുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ വളരെ ലളിതമാക്കുന്നു.

MIME സന്ദേശ നിർമ്മാണം: കൃത്യതയോടെ ഇമെയിലുകൾ നിർമ്മിക്കുക

ഇമെയിലുകൾ നിർമ്മിക്കുന്നതിന് വിവിധ ഘടകങ്ങൾ (ടെക്സ്റ്റ്, HTML, അറ്റാച്ച്‌മെന്റുകൾ) സാധുവായ MIME ഘടനയിലേക്ക് കൂട്ടിച്ചേർക്കുന്നത് ഉൾപ്പെടുന്നു. EmailMessage ക്ലാസ് ഈ പ്രക്രിയയെ ഗണ്യമായി ലളിതമാക്കുന്നു.

ലളിതമായ ടെക്സ്റ്റ് ഇമെയിലുകൾ

ഏറ്റവും ലളിതമായ ഇമെയിൽ ലളിതമായ ടെക്സ്റ്റ് ആണ്. നിങ്ങൾക്ക് ഒരെണ്ണം സൃഷ്ടിക്കാനും അടിസ്ഥാന ഹെഡറുകൾ എളുപ്പത്തിൽ സജ്ജമാക്കാനും കഴിയും:

from email.message import EmailMessage

msg = EmailMessage()
msg['Subject'] = 'Greetings from Python'
msg['From'] = 'sender@example.com'
msg['To'] = 'recipient@example.com'
msg.set_content('Hello, this is a plain text email sent from Python.\n\nBest regards,\nYour Python Script')

print(msg.as_string())

വിശദീകരണം:

• EmailMessage() ഒരു ശൂന്യമായ സന്ദേശ ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നു.
• ഡിക്ഷണറി പോലെ ആക്സസ് ചെയ്യുന്നത് (msg['Subject'] = ...) സാധാരണ ഹെഡറുകൾ സജ്ജമാക്കുന്നു.
• set_content() ഇമെയിലിന്റെ പ്രാഥമിക ഉള്ളടക്കം ചേർക്കുന്നു. ഡിഫോൾട്ടായി, ഇത് Content-Type: text/plain; charset="utf-8" എന്ന് അനുമാനിക്കുന്നു.
• as_string() SMTP വഴി അയക്കുന്നതിനോ ഫയലിൽ സംരക്ഷിക്കുന്നതിനോ അനുയോജ്യമായ ഒരു സ്ട്രിംഗ് ഫോർമാറ്റിലേക്ക് സന്ദേശത്തെ സീരിയലൈസ് ചെയ്യുന്നു.

HTML ഉള്ളടക്കം ചേർക്കുന്നു

HTML ഇമെയിൽ അയയ്ക്കുന്നതിന്, set_content() വിളിക്കുമ്പോൾ നിങ്ങൾ ഉള്ളടക്ക തരം വ്യക്തമാക്കണം. HTML റെൻഡർ ചെയ്യാത്ത അല്ലെങ്കിൽ പ്രവേശനക്ഷമത കാരണങ്ങളാൽ സ്വീകരിക്കുന്നവർക്കായി ലളിതമായ ടെക്സ്റ്റ് ബദൽ നൽകുന്നത് നല്ല സമ്പ്രദായമാണ്.

from email.message import EmailMessage

msg = EmailMessage()
msg['Subject'] = 'Your HTML Newsletter'
msg['From'] = 'newsletter@example.com'
msg['To'] = 'subscriber@example.com'

html_content = """
<html>
    <head></head>
    <body>
        <h1>Welcome to Our Global Update!</h1>
        <p>Dear Subscriber,</p>
        <p>This is your <strong>latest update</strong> from around the world.</p>
        <p>Visit our <a href="http://www.example.com">website</a> for more.</p>
        <p>Best regards,<br>The Team</p>
    </body>
</html>
"""

# HTML പതിപ്പ് ചേർക്കുക
msg.add_alternative(html_content, subtype='html')

# ഒരു ലളിതമായ ടെക്സ്റ്റ് ഫോൾബാക്ക് ചേർക്കുക
plain_text_content = (
    "Welcome to Our Global Update!\n\n"
    "Dear Subscriber,\n\n"
    "This is your latest update from around the world.\n"
    "Visit our website for more: http://www.example.com\n\n"
    "Best regards,\nThe Team"
)
msg.add_alternative(plain_text_content, subtype='plain')

print(msg.as_string())

വിശദീകരണം:

• add_alternative() എന്നത് *ഒരേ* ഉള്ളടക്കത്തിന്റെ വ്യത്യസ്ത രൂപങ്ങൾ ചേർക്കാൻ ഉപയോഗിക്കുന്നു. കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന "ഏറ്റവും മികച്ച" ഒന്ന് ഇമെയിൽ ക്ലയന്റ് പ്രദർശിപ്പിക്കും (സാധാരണയായി HTML).
• ഇത് സ്വപ്രേരിതമായി ഒരു multipart/alternative MIME ഘടന സൃഷ്ടിക്കുന്നു.

അറ്റാച്ച്‌മെന്റുകൾ കൈകാര്യം ചെയ്യുന്നു

add_attachment() ഉപയോഗിച്ച് ഫയലുകൾ അറ്റാച്ച് ചെയ്യുന്നത് ലളിതമാണ്. നിങ്ങൾക്ക് ഏത് തരം ഫയലും അറ്റാച്ച് ചെയ്യാൻ കഴിയും, പാക്കേജ് ഉചിതമായ MIME തരങ്ങളും എൻകോഡിംഗുകളും (സാധാരണയായി base64) കൈകാര്യം ചെയ്യുന്നു.

from email.message import EmailMessage
from pathlib import Path

# ഡെമോൺസ്ട്രേഷനായി ഡമ്മി ഫയലുകൾ സൃഷ്ടിക്കുക
Path('report.pdf').write_bytes(b'%PDF-1.4\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj\n2 0 obj<</Count 0>>endobj\nxref\n0 3\n0000000000 65535 f\n0000000009 00000 n\n0000000052 00000 n\ntrailer<</Size 3/Root 1 0 R>>startxref\n104\n%%EOF') # ഒരു വളരെ അടിസ്ഥാനമായ, സാധുതയില്ലാത്ത PDF പ്ലെയ്‌സ്ഹോൾഡർ
Path('logo.png').write_bytes(b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\x0cIDAT\x08\x99c`\x00\x00\x00\x02\x00\x01\xe2!\x00\xa0\x00\x00\x00\x00IEND\xaeB`\x82') # 1x1 സുതാര്യമായ PNG പ്ലെയ്‌സ്ഹോൾഡർ

msg = EmailMessage()
msg['Subject'] = 'Important Document and Image'
msg['From'] = 'sender@example.com'
msg['To'] = 'recipient@example.com'
msg.set_content('Please find the attached report and company logo.')

# ഒരു PDF ഫയൽ അറ്റാച്ച് ചെയ്യുക
with open('report.pdf', 'rb') as f:
    file_data = f.read()
    msg.add_attachment(
        file_data,
        maintype='application',
        subtype='pdf',
        filename='Annual_Report_2024.pdf'
    )

# ഒരു ചിത്ര ഫയൽ അറ്റാച്ച് ചെയ്യുക
with open('logo.png', 'rb') as f:
    image_data = f.read()
    msg.add_attachment(
        image_data,
        maintype='image',
        subtype='png',
        filename='CompanyLogo.png'
    )

print(msg.as_string())

# ഡമ്മി ഫയലുകൾ വൃത്തിയാക്കുക
Path('report.pdf').unlink()
Path('logo.png').unlink()

വിശദീകരണം:

• add_attachment() ഫയലിന്റെ ഉള്ളടക്കത്തിന്റെ റോ ബൈറ്റുകൾ എടുക്കുന്നു.
• maintype, subtype എന്നിവ MIME തരം വ്യക്തമാക്കുന്നു (ഉദാഹരണത്തിന്, application/pdf, image/png). സ്വീകരിക്കുന്നവരുടെ ഇമെയിൽ ക്ലയന്റ് അറ്റാച്ച്‌മെന്റ് ശരിയായി തിരിച്ചറിയാനും കൈകാര്യം ചെയ്യാനും ഇത് നിർണായകമാണ്.
• filename സ്വീകരിക്കുന്നയാൾ വഴി അറ്റാച്ച്‌മെന്റ് സംരക്ഷിക്കുന്ന പേര് നൽകുന്നു.
• ഇത് സ്വപ്രേരിതമായി ഒരു multipart/mixed ഘടന സജ്ജമാക്കുന്നു.

മൾട്ടിപാർട്ട് സന്ദേശങ്ങൾ സൃഷ്ടിക്കുന്നു

HTML ബോഡി, ലളിതമായ ടെക്സ്റ്റ് ഫോൾബാക്ക്, ഇൻലൈൻ ചിത്രങ്ങൾ അല്ലെങ്കിൽ അനുബന്ധ ഫയലുകൾ എന്നിവയുള്ള സന്ദേശം നിങ്ങൾക്ക് ഉള്ളപ്പോൾ, നിങ്ങൾക്ക് കൂടുതൽ സങ്കീർണ്ണമായ മൾട്ടിപാർട്ട് ഘടന ആവശ്യമായി വരും. EmailMessage ക്ലാസ് add_related(), add_alternative() എന്നിവ ഉപയോഗിച്ച് ഇത് ബുദ്ധിപൂർവ്വം കൈകാര്യം ചെയ്യുന്നു.

HTML-നുള്ളിൽ നേരിട്ട് ഒരു ചിത്രം ഉൾക്കൊള്ളുന്ന (ഒരു "ഇൻലൈൻ" ചിത്രം) ഒരു HTML ഇമെയിൽ സാധാരണയായി സംഭവിക്കുന്നതാണ്. ഇത് multipart/related ഉപയോഗിക്കുന്നു.

from email.message import EmailMessage
from pathlib import Path

# ഡെമോൺസ്ട്രേഷനായി ഒരു ഡമ്മി ചിത്ര ഫയൽ സൃഷ്ടിക്കുക (1x1 സുതാര്യമായ PNG)
Path('banner.png').write_bytes(b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\x0cIDAT\x08\x99c`\x00\x00\x00\x02\x00\x01\xe2!\x00\xa0\x00\x00\x00\x00IEND\xaeB`\x82')

msg = EmailMessage()
msg['Subject'] = 'Inline Image Example'
msg['From'] = 'sender@example.com'
msg['To'] = 'recipient@example.com'

# ലളിതമായ ടെക്സ്റ്റ് പതിപ്പ് (ഫോൾബാക്ക്)
plain_text = 'Check out our amazing banner!\n\n[Image: Banner.png]\n\nVisit our site.'
msg.set_content(plain_text, subtype='plain') # പ്രാരംഭ ലളിതമായ ടെക്സ്റ്റ് ഉള്ളടക്കം സജ്ജമാക്കുക

# HTML പതിപ്പ് (CID ഉപയോഗിച്ച് ഇൻലൈൻ ചിത്രത്തിനായി)
html_content = """
<html>
    <head></head>
    <body>
        <h1>Our Latest Offer!</h1>
        <p>Dear Customer,</p>
        <p>Don't miss out on our special global promotion:</p>
        <img src="cid:my-banner-image" alt="Promotion Banner">
        <p>Click <a href="http://www.example.com">here</a> to learn more.</p>
    </body>
</html>
"""

msg.add_alternative(html_content, subtype='html') # HTML ബദൽ ചേർക്കുക

# ഇൻലൈൻ ചിത്രം ചേർക്കുക (അനുബന്ധ ഉള്ളടക്കം)
with open('banner.png', 'rb') as img_file:
    image_data = img_file.read()
    msg.add_related(
        image_data,
        maintype='image',
        subtype='png',
        cid='my-banner-image' # HTML-ലെ 'src' യുമായി ഈ CID യോജിക്കുന്നു
    )

print(msg.as_string())

# ഡമ്മി ഫയൽ വൃത്തിയാക്കുക
Path('banner.png').unlink()

വിശദീകരണം:

• set_content() പ്രാരംഭ ഉള്ളടക്കം സ്ഥാപിക്കുന്നു (ഇവിടെ, ലളിതമായ ടെക്സ്റ്റ്).
• add_alternative() HTML പതിപ്പ് ചേർക്കുന്നു, ഇത് ലളിതമായ ടെക്സ്റ്റും HTML ഭാഗങ്ങളും അടങ്ങിയ ഒരു multipart/alternative ഘടന സൃഷ്ടിക്കുന്നു.
• add_related() സന്ദേശ ഭാഗങ്ങളുമായി "അനുബന്ധമായ" ഉള്ളടക്കത്തിനായി ഉപയോഗിക്കുന്നു, സാധാരണയായി HTML-ൽ ഇൻലൈൻ ചിത്രങ്ങൾ. ഇത് ഒരു cid (Content-ID) പാരാമീറ്റർ എടുക്കുന്നു, അത് HTML <img src="cid:my-banner-image"> ടാഗിൽ റഫർ ചെയ്യപ്പെടുന്നു.
• അന്തിമ ഘടന multipart/mixed ആയിരിക്കും (ബാഹ്യ അറ്റാച്ച്‌മെന്റുകൾ ഉണ്ടെങ്കിൽ), അതിൽ multipart/alternative ഭാഗം അടങ്ങിയിരിക്കും, അതിൽ multipart/related ഭാഗം അടങ്ങിയിരിക്കും. multipart/related ഭാഗത്തിൽ HTML-ഉം ഇൻലൈൻ ചിത്രവും അടങ്ങിയിരിക്കും. EmailMessage ക്ലാസ് ഈ നെസ്റ്റിംഗ് സങ്കീർണ്ണത നിങ്ങൾക്ക് വേണ്ടി കൈകാര്യം ചെയ്യുന്നു.

ആഗോള ലഭ്യതയ്ക്കുള്ള എൻകോഡിംഗും ക്യാരക്ടർ സെറ്റുകളും

അന്താരാഷ്ട്ര ആശയവിനിമയത്തിന്, ശരിയായ ക്യാരക്ടർ എൻകോഡിംഗ് പരമപ്രധാനമാണ്. email പാക്കേജ്, ഡിഫോൾട്ടായി, UTF-8 ഉപയോഗിക്കുന്നതിൽ വളരെ നിർബന്ധമാണ്, ഇത് ലോകമെമ്പാടുമുള്ള വൈവിധ്യമാർന്ന ക്യാരക്ടർ സെറ്റുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള സാർവത്രിക നിലവാരമാണ്.

from email.message import EmailMessage

msg = EmailMessage()
msg['Subject'] = 'Global Characters: こんにちは, Привет, नमस्ते'
msg['From'] = 'global_sender@example.com'
msg['To'] = 'global_recipient@example.com'

# ജാപ്പനീസ്, റഷ്യൻ, ഹിന്ദി അക്ഷരങ്ങൾ
content = "This message contains diverse global characters:\n"
content += "こんにちは (Japanese)\n"
content += "Привет (Russian)\n"
content += "नमस्ते (Hindi)\n\n"
content += "The 'email' package handles UTF-8 gracefully."

msg.set_content(content)

print(msg.as_string())

വിശദീകരണം:

• set_content() ഒരു പൈത്തൺ സ്ട്രിംഗ് സ്വീകരിക്കുമ്പോൾ, അത് സ്വപ്രേരിതമായി UTF-8 ആയി എൻകോഡ് ചെയ്യുകയും Content-Type: text/plain; charset="utf-8" ഹെഡർ സജ്ജമാക്കുകയും ചെയ്യുന്നു.
• ഉള്ളടക്കത്തിന് അത് ആവശ്യമെങ്കിൽ (ഉദാഹരണത്തിന്, ധാരാളം ASCII അല്ലാത്ത അക്ഷരങ്ങൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ), പഴയ ഇമെയിൽ സിസ്റ്റങ്ങൾ വഴി സുരക്ഷിതമായ കൈമാറ്റത്തിന് ഇത് Content-Transfer-Encoding: quoted-printable അല്ലെങ്കിൽ base64 പ്രയോഗിക്കുകയും ചെയ്തേക്കാം. തിരഞ്ഞെടുത്ത നയം അനുസരിച്ച് പാക്കേജ് ഇത് സ്വപ്രേരിതമായി കൈകാര്യം ചെയ്യുന്നു.

ഇഷ്ടാനുസൃത ഹെഡറുകളും നയങ്ങളും

നിങ്ങൾക്ക് ഇമെയിലിലേക്ക് ഏതെങ്കിലും ഇഷ്ടാനുസൃത ഹെഡർ ചേർക്കാൻ കഴിയും. നയങ്ങൾ (email.policy-ൽ നിന്ന്) സന്ദേശങ്ങൾ എങ്ങനെ കൈകാര്യം ചെയ്യപ്പെടുന്നു എന്ന് നിർവചിക്കുന്നു, ഹെഡർ എൻകോഡിംഗ്, ലൈൻ എൻഡിംഗുകൾ, പിശക് കൈകാര്യം ചെയ്യൽ എന്നിവയെ ബാധിക്കുന്നു. ഡിഫോൾട്ട് നയം സാധാരണയായി നല്ലതാണ്, പക്ഷേ കർശനമായ SMTP അനുസരണത്തിനായി നിങ്ങൾക്ക് `SMTP` തിരഞ്ഞെടുക്കാനോ ഇഷ്ടാനുസൃതമായവ നിർവചിക്കാനോ കഴിയും.

from email.message import EmailMessage
from email import policy

msg = EmailMessage(policy=policy.SMTP)
msg['Subject'] = 'Email with Custom Header'
msg['From'] = 'info@example.org'
msg['To'] = 'user@example.org'
msg['X-Custom-Header'] = 'This is a custom value for tracking'
msg['Reply-To'] = 'support@example.org'
msg.set_content('This email demonstrates custom headers and policies.')

print(msg.as_string())

വിശദീകരണം:

• policy=policy.SMTP ഉപയോഗിക്കുന്നത് SMTP നിലവാരങ്ങളുമായി കർശനമായ അനുസരണം ഉറപ്പാക്കുന്നു, ഇത് ഡെലിവറിക്ക് നിർണായകമാകും.
• ഇഷ്ടാനുസൃത ഹെഡറുകൾ സ്റ്റാൻഡേർഡ് ഹെഡറുകൾ പോലെയാണ് ചേർക്കുന്നത്. നോൺ-സ്റ്റാൻഡേർഡ് ഹെഡറുകളെ സൂചിപ്പിക്കാൻ അവ പലപ്പോഴും X- ൽ ആരംഭിക്കുന്നു.

MIME സന്ദേശ വിശകലനം: ഇൻകമിംഗ് ഇമെയിലുകളിൽ നിന്ന് വിവരങ്ങൾ നിഷ്കർഷിച്ചെടുക്കുക

വിശകലനം ചെയ്യുന്നത് റോ ഇമെയിൽ ഡാറ്റ (സാധാരണയായി IMAP വഴിയോ ഫയലിൽ നിന്നോ ലഭിക്കുന്നത്) എടുത്ത് നിങ്ങൾക്ക് എളുപ്പത്തിൽ പരിശോധിക്കാനും കൈകാര്യം ചെയ്യാനും കഴിയുന്ന ഒരു `EmailMessage` ഒബ്ജക്റ്റിലേക്ക് മാറ്റുന്നത് ഉൾപ്പെടുന്നു.

ലോഡിംഗും പ്രാരംഭ വിശകലനവും

നിങ്ങൾക്ക് സാധാരണയായി ബൈറ്റുകളായി ഇമെയിലുകൾ ലഭിക്കും. email.parser.BytesParser (അല്ലെങ്കിൽ email.message_from_bytes() പോലുള്ള സൗകര്യപ്രദമായ ഫംഗ്ഷനുകൾ) ഇതിനായി ഉപയോഗിക്കുന്നു.

from email.parser import BytesParser
from email.policy import default

raw_email_bytes = b"""
From: sender@example.com
To: recipient@example.com
Subject: Test Email with Basic Headers
Date: Mon, 1 Jan 2024 10:00:00 +0000
Content-Type: text/plain; charset=\"utf-8\" 

This is the body of the email.
It's a simple test.
"""

# BytesParser ഉപയോഗിച്ച്
parser = BytesParser(policy=default)
msg = parser.parsebytes(raw_email_bytes)

# അല്ലെങ്കിൽ സൗകര്യപ്രദമായ ഫംഗ്ഷൻ ഉപയോഗിച്ച്
# from email import message_from_bytes
# msg = message_from_bytes(raw_email_bytes, policy=default)

print(f"Subject: {msg['subject']}")
print(f"From: {msg['from']}")
print(f"Content-Type: {msg['Content-Type']}")

വിശദീകരണം:

• BytesParser റോ ബൈറ്റ് ഡാറ്റ (ഇമെയിലുകൾ കൈമാറുന്ന രീതി) എടുത്ത് ഒരു EmailMessage ഒബ്ജക്റ്റ് നൽകുന്നു.
• policy=default വിശകലന നിയമങ്ങൾ വ്യക്തമാക്കുന്നു.

ഹെഡറുകൾ ആക്സസ് ചെയ്യുന്നു

ഹെഡറുകൾ ഡിക്ഷണറി പോലുള്ള കീകളിലൂടെ എളുപ്പത്തിൽ ലഭ്യമാണ്. എൻകോഡ് ചെയ്ത ഹെഡറുകൾ (ഉദാഹരണത്തിന്, അന്താരാഷ്ട്ര അക്ഷരങ്ങളുള്ള വിഷയങ്ങൾ) ഡീക്കോഡ് ചെയ്യുന്നത് പാക്കേജ് സ്വപ്രേരിതമായി കൈകാര്യം ചെയ്യുന്നു.

# ... (മുമ്പത്തെ വിശകലന ഉദാഹരണത്തിലെ 'msg' ഒബ്ജക്റ്റ് ഉപയോഗിച്ച്)

print(f"Date: {msg['date']}")
print(f"Message ID: {msg['Message-ID'] if 'Message-ID' in msg else 'N/A'}")

# ഒന്നിലധികം ഹെഡറുകൾ കൈകാര്യം ചെയ്യുന്നു (ഉദാഹരണത്തിന്, 'Received' ഹെഡറുകൾ)
# from email.message import EmailMessage # ഇതുവരെ ഇറക്കുമതി ചെയ്തിട്ടില്ലെങ്കിൽ
# from email import message_from_string # ഒരു ദ്രുത സ്ട്രിംഗ് ഉദാഹരണത്തിനായി

multi_header_email = message_from_string(
    """
From: a@example.com
To: b@example.com
Subject: Multi-header Test
Received: from client.example.com (client.example.com [192.168.1.100])
        by server.example.com (Postfix) with ESMTP id 123456789
        for <b@example.com>; Mon, 1 Jan 2024 10:00:00 +0000 (GMT)
Received: from mx.another.com (mx.another.com [192.168.1.101])
        by server.example.com (Postfix) with ESMTP id 987654321
        for <b@example.com>; Mon, 1 Jan 2024 09:59:00 +0000 (GMT)

Body content here.
"""
)

received_headers = multi_header_email.get_all('received')
if received_headers:
    print("\nReceived Headers:")
    for header in received_headers:
        print(f"- {header}")

വിശദീകരണം:

• ഒരു ഹെഡർ ആക്സസ് ചെയ്യുന്നത് ഒരു സ്ട്രിംഗായി അതിന്റെ മൂല്യം നൽകുന്നു.
• get_all('header-name') ഒന്നിലധികം തവണ പ്രത്യക്ഷപ്പെടുന്ന ഹെഡറുകൾക്ക് (Received പോലുള്ളവ) ഉപയോഗപ്രദമാണ്.
• ഹെഡർ ഡീക്കോഡിംഗ് പാക്കേജ് കൈകാര്യം ചെയ്യുന്നു, അതിനാൽ Subject: =?utf-8?Q?Global_Characters:_=E3=81=93=E3=82=93=E3=81=AB=E3=81=A1=E3=81=AF?= പോലുള്ള മൂല്യങ്ങൾ വായിക്കാവുന്ന സ്ട്രിംഗുകളായി യാന്ത്രികമായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു.

ബോഡി ഉള്ളടക്കം നിഷ്കർഷിച്ചെടുക്കുക

യഥാർത്ഥ സന്ദേശ ബോഡി നിഷ്കർഷിച്ചെടുക്കുന്നതിന് സന്ദേശം മൾട്ടിപാർട്ട് ആണോ എന്ന് പരിശോധിക്കേണ്ടതുണ്ട്. മൾട്ടിപാർട്ട് സന്ദേശങ്ങൾക്ക്, നിങ്ങൾ അതിന്റെ ഭാഗങ്ങളിലൂടെ സഞ്ചരിക്കും.

from email.message import EmailMessage
from email import message_from_string

multipart_email_raw = """
From: multi@example.com
To: user@example.com
Subject: Test Multipart Email
Content-Type: multipart/alternative; boundary="_----------=_12345"

--_----------=_12345
Content-Type: text/plain; charset="utf-8"

Hello from the plain text part!

--_----------=_12345
Content-Type: text/html; charset="utf-8"

<html>
<body>
<h1>Hello from the HTML part!</h1>
<p>This is a <strong>rich text</strong> email.</p>
</body>
</html>

--_----------=_12345--
"""

msg = message_from_string(multipart_email_raw)

if msg.is_multipart():
    print("\n--- Multipart Email Body ---")
    for part in msg.iter_parts():
        content_type = part.get_content_type()
        charset = part.get_content_charset() or 'utf-8' # വ്യക്തമാക്കിയട്ടില്ലെങ്കിൽ utf-8 ലേക്ക് ഡിഫോൾട്ട് ചെയ്യുക
        payload = part.get_payload(decode=True) # പേലോഡ് ബൈറ്റുകൾ ഡീക്കോഡ് ചെയ്യുക

        try:
            decoded_content = payload.decode(charset)
            print(f"Content-Type: {content_type}, Charset: {charset}\nContent:\n{decoded_content}\n")
        except UnicodeDecodeError:
            print(f"Content-Type: {content_type}, Charset: {charset}\nContent: (Binary or undecodable data)\n")
            # ബൈനറി ഡാറ്റ കൈകാര്യം ചെയ്യുക, അല്ലെങ്കിൽ ഒരു ഫോൾബാക്ക് എൻകോഡിംഗ് ശ്രമിക്കുക
else:
    print("\n--- Single Part Email Body ---")
    charset = msg.get_content_charset() or 'utf-8'
    payload = msg.get_payload(decode=True)
    try:
        decoded_content = payload.decode(charset)
        print(f"Content-Type: {msg.get_content_type()}, Charset: {charset}\nContent:\n{decoded_content}\n")
    except UnicodeDecodeError:
        print(f"Content: (Binary or undecodable data)\n")

വിശദീകരണം:

• is_multipart() ഇമെയിലിന് ഒന്നിലധികം ഭാഗങ്ങൾ ഉണ്ടോ എന്ന് നിർണ്ണയിക്കുന്നു.
• iter_parts() മൾട്ടിപാർട്ട് സന്ദേശത്തിന്റെ എല്ലാ ഉപഭാഗങ്ങളിലൂടെയും സഞ്ചരിക്കുന്നു.
• get_content_type() പൂർണ്ണമായ MIME തരം നൽകുന്നു (ഉദാഹരണത്തിന്, text/plain).
• get_content_charset() Content-Type ഹെഡറിൽ നിന്ന് charset വേർതിരിച്ചെടുക്കുന്നു.
• get_payload(decode=True) നിർണായകമാണ്: ഇത് ഡീക്കോഡ് ചെയ്ത ഉള്ളടക്കം ബൈറ്റുകളായി നൽകുന്നു. പൈത്തൺ സ്ട്രിംഗായി ലഭിക്കാൻ നിങ്ങൾ ഈ ബൈറ്റുകൾ ശരിയായ charset ഉപയോഗിച്ച് .decode() ചെയ്യേണ്ടതുണ്ട്.

വിശകലനം ചെയ്യുമ്പോൾ അറ്റാച്ച്‌മെന്റുകൾ കൈകാര്യം ചെയ്യുന്നു

അറ്റാച്ച്‌മെന്റുകൾ മൾട്ടിപാർട്ട് സന്ദേശത്തിന്റെ ഭാഗങ്ങൾ കൂടിയാണ്. അവയുടെ Content-Disposition ഹെഡർ ഉപയോഗിച്ച് അവയെ തിരിച്ചറിയാനും അവയുടെ ഡീക്കോഡ് ചെയ്ത പേലോഡ് സംരക്ഷിക്കാനും കഴിയും.

from email.message import EmailMessage
from email import message_from_string
import os

# ഒരു ലളിതമായ അറ്റാച്ച്‌മെന്റുള്ള ഉദാഹരണ ഇമെയിൽ
email_with_attachment = """
From: attach@example.com
To: user@example.com
Subject: Document Attached
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="_----------=_XYZ"

--_----------=_XYZ
Content-Type: text/plain; charset="utf-8"

Here is your requested document.

--_----------=_XYZ
Content-Type: application/pdf
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="document.pdf"

JVBERi0xLjQKMSAwIG9iagpbL1BERi9UZXh0L0ltYWdlQy9JbWFnZUkvSW1hZ0VCXQplbmRvYmoK

--_----------=_XYZ--
"""

msg = message_from_string(email_with_attachment)

output_dir = 'parsed_attachments'
os.makedirs(output_dir, exist_ok=True)

print("\n--- Processing Attachments ---")
for part in msg.iter_attachments():
    filename = part.get_filename()
    if filename:
        filepath = os.path.join(output_dir, filename)
        try:
            with open(filepath, 'wb') as f:
                f.write(part.get_payload(decode=True))
            print(f"Saved attachment: {filepath} (Type: {part.get_content_type()})")
        except Exception as e:
            print(f"Error saving {filename}: {e}")
    else:
        print(f"Found an attachment without a filename (Content-Type: {part.get_content_type()})")

# ഔട്ട്പുട്ട് ഡയറക്ടറി വൃത്തിയാക്കുക
# import shutil
# shutil.rmtree(output_dir)

വിശദീകരണം:

• iter_attachments() പ്രത്യേകമായി അറ്റാച്ച്‌മെന്റുകൾ ആകാൻ സാധ്യതയുള്ള ഭാഗങ്ങൾ നൽകുന്നു (അതായത്, Content-Disposition: attachment ഹെഡർ ഉള്ളവ അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും വർഗ്ഗീകരിക്കാത്തവ).
• get_filename() Content-Disposition ഹെഡറിൽ നിന്ന് ഫയലിന്റെ പേര് വേർതിരിച്ചെടുക്കുന്നു.
• part.get_payload(decode=True) അറ്റാച്ച്‌മെന്റിന്റെ റോ ബൈനറി ഉള്ളടക്കം വീണ്ടെടുക്കുന്നു, ഇത് base64 അല്ലെങ്കിൽ quoted-printable-ൽ നിന്ന് ഇതിനകം ഡീക്കോഡ് ചെയ്തതാണ്.

എൻകോഡിംഗുകളും ക്യാരക്ടർ സെറ്റുകളും ഡീക്കോഡ് ചെയ്യുന്നു

email പാക്കേജ് get_payload(decode=True) വിളിക്കുമ്പോൾ സാധാരണ ട്രാൻസ്ഫർ എൻകോഡിംഗുകൾ (base64, quoted-printable പോലുള്ളവ) സ്വപ്രേരിതമായി ഡീക്കോഡ് ചെയ്യുന്നതിൽ മികച്ച ജോലി ചെയ്യുന്നു. ടെക്സ്റ്റ് ഉള്ളടക്കത്തിനായി, ഇത് Content-Type ഹെഡറിൽ വ്യക്തമാക്കിയ charset ഉപയോഗിക്കാൻ ശ്രമിക്കുന്നു. charset വ്യക്തമാക്കുകയോ സാധുതയില്ലാത്തതോ ആണെങ്കിൽ, നിങ്ങൾക്ക് അത് സുരക്ഷിതമായി കൈകാര്യം ചെയ്യേണ്ടി വന്നേക്കാം.

from email.message import EmailMessage
from email import message_from_string

# ഒരു പ്രശ്ന സാധ്യതയുള്ള charset ഉള്ള ഉദാഹരണം
email_latin1 = """
From: legacy@example.com
To: new_system@example.com
Subject: Special characters: àéíóú
Content-Type: text/plain; charset="iso-8859-1"

This message contains Latin-1 characters: àéíóú
"""

msg = message_from_string(email_latin1)

if msg.is_multipart():
    for part in msg.iter_parts():
        payload = part.get_payload(decode=True)
        charset = part.get_content_charset() or 'utf-8'
        try:
            print(f"Decoded (Charset: {charset}): {payload.decode(charset)}")
        except UnicodeDecodeError:
            print(f"Failed to decode with {charset}. Trying fallback...")
            # ഒരു സാധാരണ charset ലേക്ക് അല്ലെങ്കിൽ അത് പ്രതീക്ഷിക്കുന്നുണ്ടെങ്കിൽ 'latin-1' ലേക്ക് ഫോൾബാക്ക് ചെയ്യുക
            print(f"Decoded (Fallback Latin-1): {payload.decode('latin-1', errors='replace')}")
else:
    payload = msg.get_payload(decode=True)
    charset = msg.get_content_charset() or 'utf-8'
    try:
        print(f"Decoded (Charset: {charset}): {payload.decode(charset)}")
    except UnicodeDecodeError:
        print(f"Failed to decode with {charset}. Trying fallback...")
        print(f"Decoded (Fallback Latin-1): {payload.decode('latin-1', errors='replace')}")

വിശദീകരണം:

• എപ്പോഴും Content-Type ഹെഡറിൽ വ്യക്തമാക്കിയ charset ഉപയോഗിക്കാൻ ശ്രമിക്കുക.
• UnicodeDecodeError പോലുള്ള പിശകുകൾ കൈകാര്യം ചെയ്യാൻ robust ആയ try-except ബ്ലോക്ക് ഉപയോഗിക്കുക, പ്രത്യേകിച്ച് വിവിധവും സാധ്യമായ നോൺ-സ്റ്റാൻഡേർഡ് ഉറവിടങ്ങളിൽ നിന്നുള്ള ഇമെയിലുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ.
• errors='replace' അല്ലെങ്കിൽ errors='ignore' എന്നിവ .decode()-മായി ഉപയോഗിക്കാം, ലക്ഷ്യ എൻകോഡിംഗിലേക്ക് മാപ്പ് ചെയ്യാൻ കഴിയാത്ത അക്ഷരങ്ങൾ കൈകാര്യം ചെയ്യാൻ, ക്രാഷ് ചെയ്യുന്നത് തടയാൻ.

വിപുലമായ വിശകലന സാഹചര്യങ്ങൾ

യഥാർത്ഥ ലോക ഇമെയിലുകൾ നെസ്റ്റഡ് മൾട്ടിപാർട്ട് ഘടനകളോടെ വളരെ സങ്കീർണ്ണമായേക്കാം. email പാക്കേജിന്റെ റീകസീവ് സ്വഭാവം ഇവയെ എളുപ്പത്തിൽ നാവിഗേറ്റ് ചെയ്യാൻ സഹായിക്കുന്നു. ആഴത്തിൽ നെസ്റ്റഡ് സന്ദേശങ്ങളിലൂടെ സഞ്ചരിക്കാൻ നിങ്ങൾക്ക് is_multipart()-മായി iter_parts() സംയോജിപ്പിക്കാൻ കഴിയും.

from email.message import EmailMessage
from email import message_from_string

def parse_email_part(part, indent=0):
    prefix = "  " * indent
    content_type = part.get_content_type()
    charset = part.get_content_charset() or 'N/A'
    print(f"{prefix}Part Type: {content_type}, Charset: {charset}")

    if part.is_multipart():
        for subpart in part.iter_parts():
            parse_email_part(subpart, indent + 1)
    elif part.get_filename(): # ഇത് ഒരു അറ്റാച്ച്‌മെന്റ് ആണ്
        print(f"{prefix}  Attachment: {part.get_filename()} (Size: {len(part.get_payload(decode=True))} bytes)")
    else: # ഇത് ഒരു സാധാരണ ടെക്സ്റ്റ്/എച്ച്ടിഎംഎൽ ബോഡി ഭാഗമാണ്
        payload = part.get_payload(decode=True)
        try:
            decoded_content = payload.decode(charset)
            # print(f"{prefix}  Content (first 100 chars): {decoded_content[:100]}...") # സംക്ഷിപ്തതയ്ക്കായി
        except UnicodeDecodeError:
            print(f"{prefix}  Content: (Binary or undecodable text)")

complex_email_raw = """
From: complex@example.com
To: receiver@example.com
Subject: Complex Email with HTML, Plain, and Attachment
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="outer_boundary"

--outer_boundary
Content-Type: multipart/alternative; boundary="inner_boundary"

--inner_boundary
Content-Type: text/plain; charset="utf-8"

Plain text content.

--inner_boundary
Content-Type: text/html; charset="utf-8"

<html><body><h2>HTML Content</h2></body></html>

--inner_boundary--

--outer_boundary
Content-Type: application/octet-stream
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="data.bin"

SGVsbG8gV29ybGQh

--outer_boundary--
"""

msg = message_from_string(complex_email_raw)
print("\n--- Traversing Complex Email Structure ---")
parse_email_part(msg)

വിശദീകരണം:

• റീകസീവ് ഫംഗ്ഷൻ parse_email_part മെസ്സേജ് ട്രീയിലൂടെ സഞ്ചരിക്കാനുള്ള ഒരു മാർഗ്ഗം കാണിക്കുന്നു, മൾട്ടിപാർട്ട് ഭാഗങ്ങൾ, അറ്റാച്ച്‌മെന്റുകൾ, ഓരോ തലത്തിലും ബോഡി ഉള്ളടക്കം എന്നിവ തിരിച്ചറിയുന്നു.
• ഈ പാറ്റേൺ ആഴത്തിൽ നെസ്റ്റഡ് ഇമെയിലുകളിൽ നിന്ന് പ്രത്യേക തരം ഉള്ളടക്കം നിഷ്കർഷിച്ചെടുക്കുന്നതിന് വളരെ സൗകര്യപ്രദമാണ്.

നിർമ്മാണം vs. വിശകലനം: ഒരു താരതമ്യ കാഴ്ച

വ്യത്യസ്ത പ്രവർത്തനങ്ങളാണെങ്കിലും, നിർമ്മാണവും വിശകലനവും ഒരേ നാണയത്തിന്റെ രണ്ട് വശങ്ങളാണ്: MIME സന്ദേശ കൈകാര്യം ചെയ്യൽ. ഒന്ന് മനസ്സിലാക്കുന്നത് മറ്റൊന്നിനെ ഒഴിച്ചുകൂടാനാവാതെ സഹായിക്കുന്നു.

നിർമ്മാണം (അയയ്ക്കൽ):

• ശ്രദ്ധ: ഹെഡറുകൾ, ഉള്ളടക്കം, അറ്റാച്ച്‌മെന്റുകൾ എന്നിവ സ്റ്റാൻഡേർഡ്-കംപ്ലൈന്റ് MIME ഘടനയിലേക്ക് ശരിയായി കൂട്ടിച്ചേർക്കുക.
• പ്രധാന ഉപകരണം: set_content(), add_attachment(), add_alternative(), add_related() പോലുള്ള മെത്തഡുകളുള്ള email.message.EmailMessage.
• പ്രധാന വെല്ലുവിളികൾ: ശരിയായ MIME തരങ്ങൾ, charset-കൾ (ലോകമെമ്പാടുമുള്ള ലഭ്യതയ്ക്കായി പ്രത്യേകിച്ച് UTF-8), `Content-Transfer-Encoding`, ശരിയായ ഹെഡർ ഫോർമാറ്റിംഗ് എന്നിവ ഉറപ്പാക്കുക. തെറ്റുകൾ ഇമെയിലുകൾ ശരിയായി പ്രദർശിപ്പിക്കാതിരിക്കാനോ, അറ്റാച്ച്‌മെന്റുകൾ കേടാവാനോ, സന്ദേശങ്ങൾ സ്പാം ആയി ഫ്ലാഗ് ചെയ്യാനോ കാരണമാകും.

വിശകലനം (സ്വീകരിക്കുന്നു):

• ശ്രദ്ധ: ഒരു റോ ഇമെയിൽ ബൈറ്റ് സ്ട്രീം അതിന്റെ ഘടക ഭാഗങ്ങളിലേക്ക് ഡിസ്അസംബിൾ ചെയ്യുക, പ്രത്യേക ഹെഡറുകൾ, ബോഡി ഉള്ളടക്കം, അറ്റാച്ച്‌മെന്റുകൾ എന്നിവ നിഷ്കർഷിച്ചെടുക്കുക.
• പ്രധാന ഉപകരണം: email.parser.BytesParser അല്ലെങ്കിൽ email.message_from_bytes(), തുടർന്ന് ഫലമായുണ്ടാകുന്ന EmailMessage ഒബ്ജക്റ്റ് is_multipart(), iter_parts(), get_payload(), get_filename(), ഹെഡർ ആക്സസ് എന്നിവ ഉപയോഗിച്ച് നാവിഗേറ്റ് ചെയ്യുക.
• പ്രധാന വെല്ലുവിളികൾ: തെറ്റായ ഫോർമാറ്റിലുള്ള ഇമെയിലുകൾ കൈകാര്യം ചെയ്യുക, ക്യാരക്ടർ എൻകോഡിംഗുകൾ ശരിയായി തിരിച്ചറിയുക (പ്രത്യേകിച്ച് അവ അവ്യക്തമായിരിക്കുമ്പോൾ), കാണാതായ ഹെഡറുകൾ കൈകാര്യം ചെയ്യുക, വിവിധ MIME ഘടനകളിൽ നിന്ന് ഡാറ്റ ശക്തമായി നിഷ്കർഷിച്ചെടുക്കുക.

EmailMessage ഉപയോഗിച്ച് നിങ്ങൾ നിർമ്മിക്കുന്ന ഒരു സന്ദേശം BytesParser വഴി പൂർണ്ണമായും വിശകലനം ചെയ്യാൻ കഴിയും. അതുപോലെ, വിശകലനം ചെയ്യുമ്പോൾ ഉത്പാദിപ്പിക്കപ്പെടുന്ന MIME ഘടന മനസ്സിലാക്കുന്നത് സങ്കീർണ്ണമായ സന്ദേശങ്ങൾ സ്വയം നിർമ്മിക്കാൻ നിങ്ങൾക്ക് ഉൾക്കാഴ്ച നൽകുന്നു.

പൈത്തൺ ഉപയോഗിച്ച് ആഗോള ഇമെയിൽ കൈകാര്യം ചെയ്യുന്നതിനുള്ള മികച്ച സമ്പ്രദായങ്ങൾ

ലോകമെമ്പാടുമുള്ള പ്രേക്ഷകരുമായി ഇടപഴകുന്ന അല്ലെങ്കിൽ വൈവിധ്യമാർന്ന ഇമെയിൽ ഉറവിടങ്ങൾ കൈകാര്യം ചെയ്യുന്ന ആപ്ലിക്കേഷനുകൾക്ക്, ഈ മികച്ച സമ്പ്രദായങ്ങൾ പരിഗണിക്കുക:

• UTF-8 സ്റ്റാൻഡേർഡൈസ് ചെയ്യുക: എല്ലാ ടെക്സ്റ്റ് ഉള്ളടക്കങ്ങൾക്കും, നിർമ്മിക്കുമ്പോഴും വിശകലനം ചെയ്യുമ്പോൾ പ്രതീക്ഷിക്കുമ്പോഴും എപ്പോഴും UTF-8 ഉപയോഗിക്കുക. ഇത് ക്യാരക്ടർ എൻകോഡിംഗിനുള്ള ആഗോള നിലവാരമാണ്, മോജിബൈക്ക് (അവ്യക്തമായ ടെക്സ്റ്റ്) ഒഴിവാക്കുന്നു.
• ഇമെയിൽ വിലാസങ്ങൾ സാധൂകരിക്കുക: അയയ്ക്കുന്നതിന് മുമ്പ്, സ്വീകർത്താവിന്റെ ഇമെയിൽ വിലാസങ്ങൾ സാധൂകരിക്കുക. വിശകലനം ചെയ്യുമ്പോൾ, From, To, അല്ലെങ്കിൽ Cc ഹെഡറുകളിൽ സാധ്യമായ തെറ്റായ അല്ലെങ്കിൽ മോശം ഫോർമാറ്റിലുള്ള വിലാസങ്ങൾക്ക് തയ്യാറാകുക.
• കഠിനമായി പരീക്ഷിക്കുക: വിവിധ ഇമെയിൽ ക്ലയന്റുകളിലും (Gmail, Outlook, Apple Mail, Thunderbird) പ്ലാറ്റ്ഫോമുകളിലും HTML, അറ്റാച്ച്‌മെന്റുകൾ എന്നിവയുടെ സ്ഥിരമായ റെൻഡറിംഗ് ഉറപ്പാക്കാൻ നിങ്ങളുടെ ഇമെയിൽ നിർമ്മാണം പരീക്ഷിക്കുക. വിശകലനത്തിനായി, അസാധാരണമായ എൻകോഡിംഗുകൾ, കാണാതായ ഹെഡറുകൾ, അല്ലെങ്കിൽ സങ്കീർണ്ണമായ നെസ്റ്റഡ് ഘടനകൾ എന്നിവയുള്ള വിവിധ സാമ്പിൾ ഇമെയിലുകളുമായി പരീക്ഷിക്കുക.
• വിശകലനം ചെയ്ത ഇൻപുട്ട് സാനിറ്റൈസ് ചെയ്യുക: ഇൻകമിംഗ് ഇമെയിലുകളിൽ നിന്ന് നിഷ്കർഷിച്ചെടുത്ത ഉള്ളടക്കം എപ്പോഴും വിശ്വസനീയമല്ലാത്തതായി കണക്കാക്കുക. നിങ്ങൾ ഒരു വെബ് ആപ്ലിക്കേഷനിൽ പ്രദർശിപ്പിക്കുകയാണെങ്കിൽ XSS ആക്രമണങ്ങൾ തടയാൻ HTML ഉള്ളടക്കം സാനിറ്റൈസ് ചെയ്യുക. ഫയലുകൾ സംരക്ഷിക്കുമ്പോൾ പാത്ത് ട്രാവേർസൽ അല്ലെങ്കിൽ മറ്റ് സുരക്ഷാ പ്രശ്നങ്ങൾ തടയുന്നതിന് അറ്റാച്ച്‌മെന്റ് ഫയൽനാമങ്ങളും തരങ്ങളും സാധൂകരിക്കുക.
• ശക്തമായ പിശക് കൈകാര്യം ചെയ്യൽ: പേലോഡുകൾ ഡീക്കോഡ് ചെയ്യുമ്പോൾ അല്ലെങ്കിൽ സാധ്യമായ കാണാതായ ഹെഡറുകൾ ആക്സസ് ചെയ്യുമ്പോൾ സമഗ്രമായ try-except ബ്ലോക്കുകൾ നടപ്പിലാക്കുക. UnicodeDecodeError അല്ലെങ്കിൽ KeyError എന്നിവ സുരക്ഷിതമായി കൈകാര്യം ചെയ്യുക.
• വലിയ അറ്റാച്ച്‌മെന്റുകൾ കൈകാര്യം ചെയ്യുക: അറ്റാച്ച്‌മെന്റ് വലുപ്പങ്ങളെക്കുറിച്ച് ബോധവാന്മാരായിരിക്കുക, നിർമ്മിക്കുമ്പോഴും (മെയിൽ സെർവർ പരിധികൾ കവിയുന്നത് ഒഴിവാക്കാൻ) വിശകലനം ചെയ്യുമ്പോഴും (അമിതമായ മെമ്മറി ഉപയോഗം അല്ലെങ്കിൽ ഡിസ്ക് സ്പേസ് ഉപഭോഗം തടയാൻ). പിന്തുണയ്ക്കുന്ന സിസ്റ്റം ആണെങ്കിൽ വലിയ അറ്റാച്ച്‌മെന്റുകൾ സ്ട്രീം ചെയ്യുന്നത് പരിഗണിക്കുക.
• email.policy ഉപയോഗിക്കുക: നിർണായക ആപ്ലിക്കേഷനുകൾക്ക്, ഇമെയിൽ നിലവാരങ്ങളുമായി കർശനമായ അനുസരണം ഉറപ്പാക്കാൻ ഒരു `email.policy` (ഉദാഹരണത്തിന്, `policy.SMTP`) വ്യക്തമായി തിരഞ്ഞെടുക്കുക, ഇത് ഡെലിവറിക്ക് കാര്യമായ സംഭാവന നൽകിയേക്കാം.
• മെറ്റാഡാറ്റ സംരക്ഷണം: വിശകലനം ചെയ്യുമ്പോൾ, നിങ്ങൾക്ക് ഒരു മെയിൽ ആർക്കൈവ് അല്ലെങ്കിൽ ഫോർവേഡിംഗ് സിസ്റ്റം നിർമ്മിക്കുകയാണെങ്കിൽ, ഏത് മെറ്റാഡാറ്റ (ഹെഡറുകൾ, യഥാർത്ഥ ബൗണ്ടറി സ്ട്രിംഗുകൾ) സംരക്ഷിക്കേണ്ടത് പ്രധാനമാണെന്ന് തീരുമാനിക്കുക.

ഉപസംഹാരം

പ്രോഗ്രാമാറ്റിക്കായി ഇമെയിലുമായി ഇടപഴകേണ്ട ആർക്കും പൈത്തണിന്റെ email പാക്കേജ് വളരെ ശക്തവും സൗകര്യപ്രദവുമായ ഒരു ലൈബ്രറിയാണ്. MIME സന്ദേശങ്ങൾ നിർമ്മിക്കുന്നതും ഇൻകമിംഗ് ഇമെയിലുകൾ ശക്തമായി വിശകലനം ചെയ്യുന്നതും മാസ്റ്റർ ചെയ്യുന്നതിലൂടെ, നിങ്ങൾക്ക് സങ്കീർണ്ണമായ ഇമെയിൽ ഓട്ടോമേഷൻ സിസ്റ്റങ്ങൾ സൃഷ്ടിക്കാനും, ഇമെയിൽ ക്ലയന്റുകൾ നിർമ്മിക്കാനും, ഇമെയിൽ ഡാറ്റ വിശകലനം ചെയ്യാനും, ഏത് അപ്ലിക്കേഷനിലേക്കും ഇമെയിൽ പ്രവർത്തനങ്ങൾ സംയോജിപ്പിക്കാനും കഴിയും.

പാക്കേജ് MIME-യുടെ അടിസ്ഥാന സങ്കീർണ്ണതകളെ ബുദ്ധിപൂർവ്വം കൈകാര്യം ചെയ്യുന്നു, ഇത് ഡെവലപ്പർമാർക്ക് അവരുടെ ഇമെയിൽ ഇടപെടലുകളുടെ ഉള്ളടക്കത്തിലും ലോജിക്കിലും ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ അനുവദിക്കുന്നു. ലോകമെമ്പാടുമുള്ള പ്രേക്ഷകർക്ക് വ്യക്തിഗത വാർത്താക്കുറിപ്പുകൾ അയയ്ക്കുകയാണെങ്കിലും അല്ലെങ്കിൽ ഓട്ടോമേറ്റഡ് സിസ്റ്റം റിപ്പോർട്ടുകളിൽ നിന്ന് നിർണായക ഡാറ്റ നിഷ്കർഷിച്ചെടുക്കുകയാണെങ്കിലും, email പാക്കേജിൽ ആഴത്തിലുള്ള ധാരണ വിശ്വസനീയവും, പരസ്പരം പ്രവർത്തിക്കുന്നതും, ലോകത്തെക്കുറിച്ച് ബോധവാന്മാരുമായ ഇമെയിൽ പരിഹാരങ്ങൾ നിർമ്മിക്കുന്നതിൽ വളരെ വിലപ്പെട്ടതായിരിക്കും.