பைதான் IMAP கிளையன்ட்: மின்னஞ்சல் மீட்டெடுப்பு மற்றும் அஞ்சல்பெட்டி மேலாண்மைக்கான விரிவான வழிகாட்டி

உலகம் முழுவதும் வணிகங்களுக்கும் தனிநபர்களுக்கும் டிஜிட்டல் தகவல்தொடர்புக்கு மின்னஞ்சல் ஒரு முக்கிய அங்கமாக உள்ளது. இருப்பினும், அதிக எண்ணிக்கையிலான மின்னஞ்சல்களை நிர்வகிப்பது நேரத்தைச் செலவழிக்கும் மற்றும் மீண்டும் மீண்டும் செய்யக்கூடிய பணியாகும். பில்களைச் செயலாக்குவது, அறிவிப்புகளை வடிகட்டுவது முதல் முக்கியமான உரையாடல்களைப் பாதுகாப்பது வரை, கையேடு முயற்சி விரைவாக மிகப்பெரியதாகிவிடும். இங்கிருந்துதான் நிரலாக்க ஆட்டோமேஷன் பிரகாசிக்கிறது, மேலும் பைதான், அதன் செழுமையான நிலையான நூலகத்துடன், உங்கள் இன்பாக்ஸைக் கட்டுப்படுத்த சக்திவாய்ந்த கருவிகளை வழங்குகிறது.

இந்த விரிவான வழிகாட்டி, உள்ளமைக்கப்பட்ட imaplib நூலகத்தைப் பயன்படுத்தி, அடிப்படையிலிருந்து ஒரு பைதான் IMAP கிளையன்ட்டை உருவாக்கும் செயல்முறையின் மூலம் உங்களை அழைத்துச் செல்லும். மின்னஞ்சல்களை எவ்வாறு மீட்டெடுப்பது என்பது மட்டுமல்லாமல், அவற்றின் உள்ளடக்கத்தைப் பிரிப்பது, இணைப்புகளைப் பதிவிறக்குவது மற்றும் செய்திகளைப் படித்ததாகக் குறிப்பது, நகர்த்துவது அல்லது நீக்குவதன் மூலம் உங்கள் அஞ்சல்பெட்டியை நிர்வகிப்பது எப்படி என்பதையும் நீங்கள் கற்றுக்கொள்வீர்கள். இந்தக் கட்டுரையின் முடிவில், உங்கள் மிகவும் சோர்வான மின்னஞ்சல் பணிகளைத் தானியங்குபடுத்தி, உங்கள் நேரத்தைச் சேமித்து, உங்கள் உற்பத்தித்திறனை அதிகரிக்கும் திறனைப் பெறுவீர்கள்.

நெறிமுறைகளைப் புரிந்துகொள்வது: IMAP vs. POP3 vs. SMTP

குறியீட்டிற்குள் நுழைவதற்கு முன், மின்னஞ்சலை நிர்வகிக்கும் அடிப்படை நெறிமுறைகளைப் புரிந்துகொள்வது அவசியம். நீங்கள் பெரும்பாலும் மூன்று சுருக்கெழுத்துக்களைக் கேட்பீர்கள்: SMTP, POP3 மற்றும் IMAP. ஒவ்வொன்றும் ஒரு தனித்துவமான நோக்கத்திற்கு சேவை செய்கிறது.

• SMTP (Simple Mail Transfer Protocol): இது மின்னஞ்சலை அனுப்புவதற்கான நெறிமுறை. உங்கள் கடிதத்தை எடுத்துக்கொண்டு பெறுநரின் அஞ்சல்பெட்டி சேவையகத்திற்கு அதை வழங்கும் அஞ்சல் சேவையாக SMTP-ஐ நினைத்துப் பாருங்கள். உங்கள் பைதான் ஸ்கிரிப்ட் ஒரு மின்னஞ்சலை அனுப்பும்போது, அது SMTP ஐப் பயன்படுத்துகிறது.
• POP3 (Post Office Protocol 3): இது மின்னஞ்சலை மீட்டெடுப்பதற்கான ஒரு நெறிமுறை. POP3 ஆனது ஒரு சேவையகத்துடன் இணைக்கப்பட்டு, அனைத்து புதிய செய்திகளையும் உங்கள் உள்ளூர் கிளையன்ட்டிற்கு பதிவிறக்கம் செய்யவும், பின்னர், இயல்பாக, அவற்றை சேவையகத்திலிருந்து நீக்கவும் வடிவமைக்கப்பட்டுள்ளது. இது அஞ்சல் அலுவலகத்திற்குச் சென்று, உங்கள் அனைத்து அஞ்சல்களையும் சேகரித்து, வீட்டிற்கு எடுத்துச் செல்வது போன்றது; உங்கள் வீட்டிற்கு வந்தவுடன், அது அஞ்சல் அலுவலகத்தில் இருக்காது. பல சாதனங்கள் கொண்ட உலகில் அதன் வரம்புகள் காரணமாக இந்த மாதிரி இன்று குறைவாகவே பயன்படுத்தப்படுகிறது.
• IMAP (Internet Message Access Protocol): இது மின்னஞ்சலை அணுகுவதற்கும் நிர்வகிப்பதற்கும் நவீன நெறிமுறை. POP3 போலல்லாமல், IMAP செய்திகளை சேவையகத்தில் விட்டுவிடுகிறது மற்றும் இணைக்கப்பட்ட அனைத்து கிளையன்ட்களிலும் நிலையை (படிக்கப்பட்டது, படிக்கப்படாதது, கொடியிடப்பட்டது, நீக்கப்பட்டது) ஒத்திசைக்கிறது. உங்கள் தொலைபேசியில் ஒரு மின்னஞ்சலைப் படிக்கும்போது, அது உங்கள் மடிக்கணினியில் படித்ததாகத் தோன்றும். உங்கள் ஸ்கிரிப்ட் அஞ்சல்பெட்டியுடன் மற்றொரு கிளையன்ட்டாக தொடர்பு கொள்ள முடியும் என்பதால் இந்த சேவையக மைய மாதிரி ஆட்டோமேஷனுக்கு ஏற்றது, மேலும் அது செய்யும் மாற்றங்கள் எல்லா இடங்களிலும் பிரதிபலிக்கும். இந்த வழிகாட்டிக்கு, IMAP இல் மட்டுமே கவனம் செலுத்துவோம்.

பைத்தானின் imaplib உடன் தொடங்குதல்

பைத்தானின் நிலையான நூலகத்தில் imaplib உள்ளது, இது ஒரு IMAP சேவையகத்துடன் தொடர்பு கொள்ள தேவையான அனைத்து கருவிகளையும் வழங்கும் ஒரு மாட்யூல் ஆகும். தொடங்க எந்த வெளிப்புற தொகுப்புகளும் தேவையில்லை.

முன்நிபந்தனைகள்

1. பைதான் நிறுவப்பட்டது: உங்கள் கணினியில் பைத்தானின் சமீபத்திய பதிப்பு (3.6 அல்லது புதியது) நிறுவப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும்.
2. IMAP இயக்கப்பட்ட மின்னஞ்சல் கணக்கு: பெரும்பாலான நவீன மின்னஞ்சல் வழங்குநர்கள் (ஜிமெயில், அவுட்லுக், யாஹூ போன்றவை) IMAP ஐ ஆதரிக்கின்றன. உங்கள் கணக்கின் அமைப்புகளில் இதை இயக்க வேண்டியிருக்கலாம்.

பாதுகாப்பு முதலில்: ஆப் கடவுச்சொற்களைப் பயன்படுத்தவும், உங்கள் முக்கிய கடவுச்சொல்லை அல்ல

இது பாதுகாப்புக்கான மிக முக்கியமான படியாகும். உங்கள் முக்கிய மின்னஞ்சல் கணக்கு கடவுச்சொல்லை உங்கள் ஸ்கிரிப்ட்டில் கடினமாக குறியிட வேண்டாம். உங்கள் குறியீடு எப்போதாவது சமரசம் செய்யப்பட்டால், உங்கள் முழு கணக்கும் ஆபத்தில் உள்ளது. இரு-காரணி அங்கீகாரத்தைப் (2FA) பயன்படுத்தும் பெரும்பாலான பெரிய மின்னஞ்சல் வழங்குநர்கள் ஒரு "பயன்பாட்டு கடவுச்சொல்லை" உருவாக்க உங்களை அழைக்கிறார்கள்.

ஒரு பயன்பாட்டு கடவுச்சொல் என்பது ஒரு தனிப்பட்ட, 16 இலக்க கடவுச்சொல் ஆகும், இது உங்கள் முதன்மை கடவுச்சொல் அல்லது 2FA குறியீடுகள் தேவையில்லாமல் உங்கள் கணக்கை அணுக ஒரு குறிப்பிட்ட பயன்பாட்டிற்கு அனுமதி அளிக்கிறது. உங்கள் முக்கிய கடவுச்சொல்லைப் பாதிக்காமல் நீங்கள் எப்போது வேண்டுமானாலும் ஒன்றை உருவாக்கி ரத்து செய்யலாம்.

• ஜிமெயிலுக்கு: உங்கள் Google கணக்கு அமைப்புகளுக்குச் செல்லவும் -> பாதுகாப்பு -> 2-படி சரிபார்ப்பு -> பயன்பாட்டு கடவுச்சொற்கள்.
• அவுட்லுக்/மைக்ரோசாஃப்டுக்கு: உங்கள் மைக்ரோசாஃப்ட் கணக்கு பாதுகாப்பு டாஷ்போர்டுக்குச் செல்லவும் -> மேம்பட்ட பாதுகாப்பு விருப்பங்கள் -> பயன்பாட்டு கடவுச்சொற்கள்.
• மற்ற வழங்குநர்களுக்கு: அவர்களின் ஆவணங்களில் "பயன்பாட்டு கடவுச்சொல்" அல்லது "பயன்பாட்டு-குறிப்பிட்ட கடவுச்சொல்" என்று தேடவும்.

உருவாக்கப்பட்டதும், இந்த பயன்பாட்டு கடவுச்சொல்லை வேறு எந்த அங்கீகாரச் சான்றையும் போலவே நடத்துங்கள். ஒரு சிறந்த நடைமுறை என்னவென்றால், அதை உங்கள் மூலக் குறியீட்டில் நேரடியாகச் சேமிப்பதற்குப் பதிலாக, ஒரு சூழல் மாறி அல்லது பாதுகாப்பான ரகசிய மேலாண்மை அமைப்பில் சேமிப்பதாகும்.

அடிப்படை இணைப்பு

ஒரு IMAP சேவையகத்துடன் பாதுகாப்பான இணைப்பை ஏற்படுத்தி, உள்நுழைந்து, பின்னர் அழகாக வெளியேற நமது முதல் குறியீட்டை எழுதுவோம். எங்கள் இணைப்பு குறியாக்கம் செய்யப்பட்டுள்ளது என்பதை உறுதிப்படுத்த imaplib.IMAP4_SSL ஐப் பயன்படுத்துவோம்.

            
import imaplib
import os

# --- Credentials ---
# It's best to load these from environment variables or a config file
# For this example, we'll define them here. Replace with your details.
EMAIL_ACCOUNT = "your_email@example.com"
APP_PASSWORD = "your_16_digit_app_password"
IMAP_SERVER = "imap.example.com" # e.g., "imap.gmail.com"

# --- Connect to the IMAP server ---
# We use a try...finally block to ensure we logout gracefully
conn = None
try:
    # Connect using SSL for a secure connection
    conn = imaplib.IMAP4_SSL(IMAP_SERVER)
    
    # Login to the account
    status, messages = conn.login(EMAIL_ACCOUNT, APP_PASSWORD)
    
    if status == 'OK':
        print("Successfully logged in!")
        # We will add more logic here later
    else:
        print(f"Login failed: {messages}")

finally:
    if conn:
        # Always logout and close the connection
        conn.logout()
        print("Logged out and connection closed.")

            

              
                Copy
              
            
          

இந்த ஸ்கிரிப்ட் ஒரு அடித்தளத்தை உருவாக்குகிறது. try...finally தொகுதி மிகவும் முக்கியமானது, ஏனெனில் இது conn.logout() அழைக்கப்படுவதை உறுதி செய்கிறது, எங்கள் செயல்பாடுகளின் போது ஒரு பிழை ஏற்பட்டாலும், சேவையகத்துடனான அமர்வை மூடுகிறது.

உங்கள் அஞ்சல்பெட்டியை வழிநடத்துதல்

உள்நுழைந்ததும், உங்கள் கணக்கிலுள்ள அஞ்சல்பெட்டிகளுடன் (பெரும்பாலும் கோப்புறைகள் என்று அழைக்கப்படும்) நீங்கள் தொடர்பு கொள்ளத் தொடங்கலாம்.

அனைத்து அஞ்சல்பெட்டிகளையும் பட்டியலிடுதல்

எந்த அஞ்சல்பெட்டிகள் கிடைக்கின்றன என்பதைப் பார்க்க, நீங்கள் conn.list() முறையைப் பயன்படுத்தலாம். வெளியீடு சற்று குழப்பமாக இருக்கலாம், எனவே பெயர்களின் சுத்தமான பட்டியலைப் பெற சற்று பிரித்தல் தேவை.

            
# Inside the 'try' block after a successful login:

status, mailbox_list = conn.list()
if status == 'OK':
    print("Available Mailboxes:")
    for mailbox in mailbox_list:
        # The raw mailbox entry is a byte string that needs decoding
        # It's often formatted like: (\\HasNoChildren) "/" "INBOX"
        # We can do some basic parsing to clean it up
        parts = mailbox.decode().split(' "/" ')
        if len(parts) == 2:
            mailbox_name = parts[1].strip('"')
            print(f"- {mailbox_name}")

            

              
                Copy
              
            
          

இது உங்கள் மின்னஞ்சல் வழங்குநரைப் பொறுத்து 'INBOX', 'அனுப்பப்பட்டவை', '[Gmail]/ஸ்பேம்' போன்ற பட்டியலை அச்சிடும்.

ஒரு அஞ்சல்பெட்டியைத் தேர்ந்தெடுப்பது

மின்னஞ்சல்களைத் தேடுவதற்கு அல்லது மீட்டெடுப்பதற்கு முன், நீங்கள் பணிபுரிய ஒரு அஞ்சல்பெட்டியைத் தேர்ந்தெடுக்க வேண்டும். மிகவும் பொதுவான தேர்வு 'INBOX' ஆகும். conn.select() முறை ஒரு அஞ்சல்பெட்டியை செயலில் ஆக்குகிறது. மாற்றங்களைச் செய்ய விரும்பவில்லை என்றால் (மின்னஞ்சல்களைப் படித்ததாகக் குறிப்பது போன்றவை) அதை படிக்க-மட்டுமே பயன்முறையில் திறக்கலாம்.

            
# Select the 'INBOX' to work with.
# Use readonly=True if you don't want to change email flags (e.g., from UNSEEN to SEEN)
status, messages = conn.select('INBOX', readonly=False)

if status == 'OK':
    total_messages = int(messages[0])
    print(f"INBOX selected. Total messages: {total_messages}")
else:
    print(f"Failed to select INBOX: {messages}")

            

              
                Copy
              
            
          

நீங்கள் ஒரு அஞ்சல்பெட்டியைத் தேர்ந்தெடுக்கும்போது, சேவையகம் அதில் உள்ள மொத்த செய்திகளின் எண்ணிக்கையைத் திரும்பப் பெறுகிறது. தேடுதல் மற்றும் மீட்டெடுப்பதற்கான அடுத்தடுத்த அனைத்து கட்டளைகளும் இந்த தேர்ந்தெடுக்கப்பட்ட அஞ்சல்பெட்டிக்கு பொருந்தும்.

மின்னஞ்சல்களைத் தேடுதல் மற்றும் மீட்டெடுத்தல்

இது மின்னஞ்சல் மீட்டெடுப்பின் மையமாகும். இந்த செயல்முறை இரண்டு படிகளை உள்ளடக்கியது: முதலில், குறிப்பிட்ட அளவுகோல்களுடன் பொருந்தக்கூடிய செய்திகளைத் தேடி அவற்றின் தனிப்பட்ட IDகளைப் பெறுவது, இரண்டாவதாக, அவற்றின் IDகளைப் பயன்படுத்தி அந்த செய்திகளின் உள்ளடக்கத்தைப் பெறுவது.

search() இன் சக்தி

search() முறை நம்பமுடியாத அளவுக்கு பல்துறை திறன் கொண்டது. இது மின்னஞ்சல்களைத் தானே திரும்பப் பெறாது, மாறாக உங்கள் வினவலுடன் பொருந்தக்கூடிய செய்தி வரிசை எண்களின் (IDகள்) பட்டியலைத் திரும்பப் பெறுகிறது. இந்த IDகள் தற்போதைய அமர்வு மற்றும் தேர்ந்தெடுக்கப்பட்ட அஞ்சல்பெட்டிக்கு குறிப்பிட்டவை.

மிகவும் பொதுவான தேடல் அளவுகோல்கள் இங்கே:

• 'ALL': அஞ்சல்பெட்டியில் உள்ள அனைத்து செய்திகளும்.
• 'UNSEEN': இன்னும் படிக்கப்படாத செய்திகள்.
• 'SEEN': படிக்கப்பட்ட செய்திகள்.
• 'FROM "sender@example.com"': ஒரு குறிப்பிட்ட அனுப்புநரிடமிருந்து வந்த செய்திகள்.
• 'TO "recipient@example.com"': ஒரு குறிப்பிட்ட பெறுநருக்கு அனுப்பப்பட்ட செய்திகள்.
• 'SUBJECT "Your Subject Line"': ஒரு குறிப்பிட்ட தலைப்பு கொண்ட செய்திகள்.
• 'BODY "a keyword in the body"': உடலில் ஒரு குறிப்பிட்ட சரத்தைக் கொண்ட செய்திகள்.
• 'SINCE "01-Jan-2024"': ஒரு குறிப்பிட்ட தேதி அன்று அல்லது அதற்குப் பிறகு பெறப்பட்ட செய்திகள்.
• 'BEFORE "31-Jan-2024"': ஒரு குறிப்பிட்ட தேதிக்கு முன் பெறப்பட்ட செய்திகள்.

நீங்கள் அளவுகோல்களையும் இணைக்கலாம். எடுத்துக்காட்டாக, ஒரு குறிப்பிட்ட அனுப்புநரிடமிருந்து ஒரு குறிப்பிட்ட தலைப்புடன் படிக்கப்படாத அனைத்து மின்னஞ்சல்களையும் கண்டுபிடிக்க, நீங்கள் '(UNSEEN FROM "alerts@example.com" SUBJECT "System Alert")' என்று தேடுவீர்கள்.

செயல்பாட்டில் பார்ப்போம்:

            
# Search for all unread emails in the INBOX
status, message_ids = conn.search(None, 'UNSEEN')

if status == 'OK':
    # message_ids is a list of byte strings, e.g., [b'1 2 3']
    # We need to split it into individual IDs
    email_id_list = message_ids[0].split()
    if email_id_list:
        print(f"Found {len(email_id_list)} unread emails.")
    else:
        print("No unread emails found.")
else:
    print("Search failed.")

            

              
                Copy
              
            
          

fetch() மூலம் மின்னஞ்சல் உள்ளடக்கத்தைப் பெறுதல்

இப்போது உங்களிடம் செய்தி IDகள் இருப்பதால், உண்மையான மின்னஞ்சல் தரவை மீட்டெடுக்க fetch() முறையைப் பயன்படுத்தலாம். மின்னஞ்சலின் எந்தப் பகுதிகளை நீங்கள் விரும்புகிறீர்கள் என்பதைக் குறிப்பிட வேண்டும்.

• 'RFC822': இது அனைத்து தலைப்புகள் மற்றும் உடல் பகுதிகள் உட்பட முழுமையான மூல மின்னஞ்சல் உள்ளடக்கத்தையும் பெறுகிறது. இது மிகவும் பொதுவான மற்றும் விரிவான விருப்பமாகும்.
• 'BODY[]': `RFC822` இன் ஒத்த சொல்.
• 'ENVELOPE': தேதி, தலைப்பு, அனுப்புநர், பெறுநர் மற்றும் In-Reply-To போன்ற முக்கிய தலைப்பு தகவல்களைப் பெறுகிறது. உங்களுக்கு மெட்டாடேட்டா மட்டுமே தேவைப்பட்டால் இது வேகமாக இருக்கும்.
• 'BODY[HEADER]': தலைப்புகளை மட்டுமே பெறுகிறது.

நாம் கண்டுபிடித்த முதல் படிக்கப்படாத மின்னஞ்சலின் முழு உள்ளடக்கத்தைப் பெறுவோம்:

            
if email_id_list:
    first_email_id = email_id_list[0]
    
    # Fetch the email data for the given ID
    # 'RFC822' is a standard that specifies the format of text messages
    status, msg_data = conn.fetch(first_email_id, '(RFC822)')
    
    if status == 'OK':
        for response_part in msg_data:
            # The fetch command returns a tuple, where the second part is the email content
            if isinstance(response_part, tuple):
                raw_email = response_part[1]
                # Now we have the raw email data as bytes
                # The next step is to parse it
                print("Successfully fetched an email.")
                # We will process `raw_email` in the next section
    else:
        print("Fetch failed.")

            

              
                Copy
              
            
          

email மாட்யூல் மூலம் மின்னஞ்சல் உள்ளடக்கத்தைப் பிரித்தெடுத்தல்

fetch() மூலம் திரும்பப் பெறப்படும் மூலத் தரவு RFC 822 தரநிலையின்படி வடிவமைக்கப்பட்ட ஒரு பைட் சரமாகும். இது எளிதில் படிக்கக்கூடியது அல்ல. பைத்தானின் உள்ளமைக்கப்பட்ட email மாட்யூல் இந்த மூல செய்திகளை பயனர் நட்பு பொருள் அமைப்பாகப் பிரிக்க குறிப்பாக வடிவமைக்கப்பட்டுள்ளது.

ஒரு Message பொருளை உருவாக்குதல்

முதல் படி, மூல பைட் சரத்தை email.message_from_bytes() ஐப் பயன்படுத்தி ஒரு Message பொருளாக மாற்றுவதாகும்.

            
import email
from email.header import decode_header

# Assuming `raw_email` contains the byte data from the fetch command
email_message = email.message_from_bytes(raw_email)

            

              
                Copy
              
            
          

முக்கிய தகவல்களை (தலைப்புகள்) பிரித்தெடுத்தல்

உங்களிடம் Message பொருள் கிடைத்ததும், ஒரு அகராதியைப் போல அதன் தலைப்புகளை அணுகலாம்.

            
# Get subject, from, to, and date
subject = email_message["Subject"]
from_ = email_message["From"]
to_ = email_message["To"]
date_ = email_message["Date"]

# Email headers can contain non-ASCII characters, so we need to decode them
def decode_email_header(header):
    decoded_parts = decode_header(header)
    header_str = ""
    for part, encoding in decoded_parts:
        if isinstance(part, bytes):
            # If there's an encoding, use it. Otherwise, default to utf-8.
            header_str += part.decode(encoding or 'utf-8')
        else:
            header_str += part
    return header_str

subject = decode_email_header(subject)
from_ = decode_email_header(from_)

print(f"Subject: {subject}")
print(f"From: {from_}")

            

              
                Copy
              
            
          

decode_email_header உதவி செயல்பாடு முக்கியமானது, ஏனெனில் சர்வதேச எழுத்துத் தொகுப்புகளைக் கையாள தலைப்புகள் பெரும்பாலும் குறியாக்கம் செய்யப்படுகின்றன. நீங்கள் அதை சரியாக டிகோட் செய்யவில்லை என்றால் email_message["Subject"] ஐ அணுகுவது குழப்பமான எழுத்து வரிசைகளுடன் ஒரு சரத்தை உங்களுக்கு வழங்கலாம்.

மின்னஞ்சல் உடல்கள் மற்றும் இணைப்புகளைக் கையாளுதல்

நவீன மின்னஞ்சல்கள் பெரும்பாலும் "பல்வேறு பகுதிகள்" கொண்டவை, அதாவது அவை உள்ளடக்கத்தின் வெவ்வேறு பதிப்புகள் (எடுத்துக்காட்டாக, எளிய உரை மற்றும் HTML) மற்றும் இணைப்புகளையும் கொண்டிருக்கலாம். நாம் எதைத் தேடுகிறோம் என்பதைக் கண்டறிய இந்தப் பகுதிகள் வழியாகச் செல்ல வேண்டும்.

msg.is_multipart() முறை ஒரு மின்னஞ்சலில் பல பகுதிகள் உள்ளதா என்பதை நமக்குத் தெரிவிக்கிறது, மேலும் msg.walk() அவற்றை வரிசைப்படுத்த ஒரு எளிய வழியை வழங்குகிறது.

            
def process_email_body(msg):
    body = ""
    attachments = []

    if msg.is_multipart():
        # Iterate through email parts
        for part in msg.walk():
            content_type = part.get_content_type()
            content_disposition = str(part.get("Content-Disposition"))

            try:
                # Get the email body
                if content_type == "text/plain" and "attachment" not in content_disposition:
                    payload = part.get_payload(decode=True)
                    charset = part.get_content_charset() or 'utf-8'
                    body = payload.decode(charset)
                # Get attachments
                elif "attachment" in content_disposition:
                    filename = part.get_filename()
                    if filename:
                        # Decode filename if needed
                        decoded_filename = decode_email_header(filename)
                        attachments.append({
                            'filename': decoded_filename,
                            'data': part.get_payload(decode=True)
                        })
            except Exception as e:
                print(f"Error processing part: {e}")
    else:
        # Not a multipart message, just get the payload
        payload = msg.get_payload(decode=True)
        charset = msg.get_content_charset() or 'utf-8'
        body = payload.decode(charset)
    
    return body, attachments

# Using the function with our fetched message
email_body, email_attachments = process_email_body(email_message)

print("\n--- Email Body ---")
print(email_body)

if email_attachments:
    print("\n--- Attachments ---")
    for att in email_attachments:
        print(f"Filename: {att['filename']}")
        # Example of saving an attachment
        with open(att['filename'], 'wb') as f:
            f.write(att['data'])
        print(f"Saved attachment: {att['filename']}")

            

              
                Copy
              
            
          

இந்தச் செயல்பாடு, ஒவ்வொரு பகுதியின் Content-Type மற்றும் Content-Disposition தலைப்புகளை ஆய்வு செய்வதன் மூலம் எளிய உரை உள்ளடக்கம் மற்றும் கோப்பு இணைப்புகளுக்கு இடையில் புத்திசாலித்தனமாக வேறுபடுத்துகிறது.

மேம்பட்ட அஞ்சல்பெட்டி மேலாண்மை

மின்னஞ்சல்களை மீட்டெடுப்பது பாதிப் பணிதான். உண்மையான ஆட்டோமேஷன் என்பது சேவையகத்தில் உள்ள செய்திகளின் நிலையை மாற்றுவதை உள்ளடக்கியது. store() கட்டளை இதற்கான உங்கள் முதன்மை கருவியாகும்.

மின்னஞ்சல்களைக் குறித்தல் (படித்தது, படிக்கப்படாதது, கொடியிடப்பட்டது)

ஒரு செய்தியில் கொடிகளைச் சேர்க்கலாம், நீக்கலாம் அல்லது மாற்றலாம். மிகவும் பொதுவான கொடி \Seen ஆகும், இது படித்த/படிக்காத நிலையை கட்டுப்படுத்துகிறது.

• படித்ததாகக் குறிக்கவும்: conn.store(msg_id, '+FLAGS', '\Seen')
• படிக்காததாகக் குறிக்கவும்: conn.store(msg_id, '-FLAGS', '\Seen')
• ஒரு மின்னஞ்சலைக் கொடியிடவும்/நட்சத்திரமிடவும்: conn.store(msg_id, '+FLAGS', '\Flagged')
• ஒரு மின்னஞ்சலின் கொடியை நீக்கவும்: conn.store(msg_id, '-FLAGS', '\Flagged')

மின்னஞ்சல்களை நகலெடுத்தல் மற்றும் நகர்த்துதல்

IMAP இல் நேரடி "நகர்த்து" கட்டளை இல்லை. ஒரு மின்னஞ்சலை நகர்த்துவது இரண்டு-படி செயல்முறை:

1. conn.copy() ஐப் பயன்படுத்தி செய்தியை இலக்கு அஞ்சல்பெட்டிக்கு நகலெடுக்கவும்.
2. \Deleted கொடியைப் பயன்படுத்தி அசல் செய்தியை நீக்குவதற்காகக் குறிக்கவும்.

            
# Assuming `msg_id` is the ID of the email to move
# 1. Copy to the 'Archive' mailbox
status, _ = conn.copy(msg_id, 'Archive')
if status == 'OK':
    print(f"Message {msg_id.decode()} copied to Archive.")
    # 2. Mark the original for deletion
    conn.store(msg_id, '+FLAGS', '\\Deleted')
    print(f"Message {msg_id.decode()} marked for deletion.")

            

              
                Copy
              
            
          

மின்னஞ்சல்களை நிரந்தரமாக நீக்குதல்

\Deleted உடன் ஒரு செய்தியைக் குறிப்பது உடனடியாக அதை அகற்றாது. இது பெரும்பாலான மின்னஞ்சல் கிளையன்ட்களில் பார்வையில் இருந்து அதை மறைக்கிறது. தற்போது தேர்ந்தெடுக்கப்பட்ட அஞ்சல்பெட்டியில் நீக்குவதற்காகக் குறிக்கப்பட்ட அனைத்து செய்திகளையும் நிரந்தரமாக அகற்ற, நீங்கள் expunge() முறையை அழைக்க வேண்டும்.

எச்சரிக்கை: expunge() மீளப்பெற முடியாதது. ஒருமுறை அழைக்கப்பட்டால், தரவு நிரந்தரமாக போய்விடும்.

            
# This will permanently delete all messages with the \\Deleted flag
status, response = conn.expunge()
if status == 'OK':
    print(f"{len(response)} messages expunged (permanently deleted).")

            

              
                Copy
              
            
          

expunge() இன் ஒரு முக்கியமான பக்க விளைவு என்னவென்றால், அது அஞ்சல்பெட்டியில் உள்ள அடுத்தடுத்த அனைத்து செய்திகளுக்கான செய்தி IDகளை மீண்டும் எண்ணிட முடியும். இதனால், நீங்கள் செயலாக்க விரும்பும் அனைத்து செய்திகளையும் அடையாளம் கண்டு, உங்கள் செயல்பாடுகளை (நகலெடுத்தல் மற்றும் நீக்குவதற்காகக் குறிப்பது போன்றவை) செய்து, பின்னர் உங்கள் அமர்வின் முடிவில் ஒருமுறை expunge() ஐ அழைப்பது சிறந்தது.

அனைத்தையும் ஒன்றிணைத்தல்: ஒரு நடைமுறை எடுத்துக்காட்டு

ஒரு முழுமையான ஸ்கிரிப்டை உருவாக்குவோம், இது ஒரு உண்மையான உலகப் பணியைச் செய்கிறது: "invoices@mycorp.com" இலிருந்து படிக்கப்படாத மின்னஞ்சல்களுக்காக இன்பாக்ஸை ஸ்கேன் செய்யவும், எந்த PDF இணைப்புகளையும் பதிவிறக்கவும், மேலும் செயலாக்கப்பட்ட மின்னஞ்சலை "Processed-Invoices" எனப்படும் அஞ்சல்பெட்டிக்கு நகர்த்தவும்.

            
import imaplib
import email
from email.header import decode_header
import os

# --- Configuration ---
EMAIL_ACCOUNT = "your_email@example.com"
APP_PASSWORD = "your_16_digit_app_password"
IMAP_SERVER = "imap.gmail.com"
TARGET_SENDER = "invoices@mycorp.com"
DESTINATION_MAILBOX = "Processed-Invoices"
DOWNLOAD_DIR = "invoices"

# Create download directory if it doesn't exist
if not os.path.isdir(DOWNLOAD_DIR):
    os.mkdir(DOWNLOAD_DIR)

def decode_email_header(header):
    # (Same function as defined earlier)
    decoded_parts = decode_header(header)
    header_str = ""
    for part, encoding in decoded_parts:
        if isinstance(part, bytes):
            header_str += part.decode(encoding or 'utf-8')
        else:
            header_str += part
    return header_str

conn = None
try:
    # --- Connect and Login ---
    conn = imaplib.IMAP4_SSL(IMAP_SERVER)
    conn.login(EMAIL_ACCOUNT, APP_PASSWORD)
    print("Login successful.")

    # --- Select INBOX ---
    conn.select('INBOX')
    print("INBOX selected.")

    # --- Search for emails ---
    search_criteria = f'(UNSEEN FROM "{TARGET_SENDER}")'
    status, message_ids = conn.search(None, search_criteria)
    
    if status != 'OK':
        raise Exception("Search failed")

    email_id_list = message_ids[0].split()
    if not email_id_list:
        print("No new invoices found.")
    else:
        print(f"Found {len(email_id_list)} new invoices to process.")

    # --- Process Each Email ---
    for email_id in email_id_list:
        print(f"\\nProcessing email ID: {email_id.decode()}")
        
        # Fetch the email
        status, msg_data = conn.fetch(email_id, '(RFC822)')
        if status != 'OK':
            print(f"Failed to fetch email ID {email_id.decode()}")
            continue
        
        raw_email = msg_data[0][1]
        email_message = email.message_from_bytes(raw_email)
        
        subject = decode_email_header(email_message["Subject"])
        print(f"  Subject: {subject}")

        # Look for attachments
        for part in email_message.walk():
            if part.get_content_maintype() == 'multipart':
                continue
            if part.get('Content-Disposition') is None:
                continue
            
            filename = part.get_filename()
            if filename and filename.lower().endswith('.pdf'):
                decoded_filename = decode_email_header(filename)
                filepath = os.path.join(DOWNLOAD_DIR, decoded_filename)
                # Save the attachment
                with open(filepath, 'wb') as f:
                    f.write(part.get_payload(decode=True))
                print(f"  -> Downloaded attachment: {decoded_filename}")

        # --- Move the processed email ---
        # 1. Copy to destination mailbox
        status, _ = conn.copy(email_id, DESTINATION_MAILBOX)
        if status == 'OK':
            # 2. Mark original for deletion
            conn.store(email_id, '+FLAGS', '\\Deleted')
            print(f"  Email moved to '{DESTINATION_MAILBOX}'.")

    # --- Expunge and Clean Up ---
    if email_id_list:
        conn.expunge()
        print("\\nExpunged deleted emails.")

except Exception as e:
    print(f"An error occurred: {e}")
finally:
    if conn:
        conn.logout()
        print("Logged out.")

            

              
                Copy
              
            
          

சிறந்த நடைமுறைகள் மற்றும் பிழை கையாளுதல்

கடினமான ஆட்டோமேஷன் ஸ்கிரிப்ட்களை உருவாக்கும்போது, பின்வரும் சிறந்த நடைமுறைகளைக் கவனியுங்கள்:

• வலுவான பிழை கையாளுதல்: உள்நுழைவு தோல்விகள் (imaplib.IMAP4.error), பிணையச் சிக்கல்கள் அல்லது பகுப்பாய்வு பிழைகள் போன்ற சாத்தியமான சிக்கல்களைப் பிடிக்க உங்கள் குறியீட்டை try...except தொகுதிகளில் சுற்றவும்.
• கட்டமைப்பு மேலாண்மை: சான்றுகளை ஒருபோதும் கடினமாகக் குறியிடாதீர்கள். சூழல் மாறிகள் (os.getenv()), ஒரு கட்டமைப்பு கோப்பு (எ.கா., INI அல்லது YAML), அல்லது ஒரு பிரத்யேக ரகசிய மேலாளரைப் பயன்படுத்தவும்.
• பதிவு செய்தல்: print() கூற்றுகளுக்குப் பதிலாக, பைத்தானின் logging மாட்யூலைப் பயன்படுத்தவும். இது உங்கள் வெளியீட்டின் சொற்பொழிவைக் கட்டுப்படுத்தவும், கோப்புகளுக்கு எழுதவும், நேரமுத்திரைகளைச் சேர்க்கவும் உங்களை அனுமதிக்கிறது, இது கவனிக்கப்படாமல் இயங்கும் ஸ்கிரிப்ட்களை பிழைத்திருத்த மிகவும் பயனுள்ளதாக இருக்கும்.
• வீத வரம்பு: ஒரு நல்ல இணையக் குடிமகனாக இருங்கள். மின்னஞ்சல் சேவையகத்தை அதிகமாக விசாரிக்க வேண்டாம். புதிய அஞ்சலை அடிக்கடி சரிபார்க்க வேண்டும் என்றால், சில நிமிட இடைவெளிகளைக் கருத்தில் கொள்ளவும், வினாடிகள் அல்ல.
• எழுத்து குறியீடுகள்: மின்னஞ்சல் ஒரு உலகளாவிய தரநிலை, மேலும் நீங்கள் பல்வேறு எழுத்து குறியீடுகளை எதிர்கொள்வீர்கள். மின்னஞ்சல் பகுதியிலிருந்து எப்போதும் எழுத்துத் தொகுப்பை (part.get_content_charset()) தீர்மானிக்க முயற்சிக்கவும், மேலும் `UnicodeDecodeError` ஐத் தவிர்க்க ஒரு பின்னடைவைக் (எ.கா., 'utf-8') கொண்டிருக்கவும்.

முடிவுரை

பைத்தானின் imaplib ஐப் பயன்படுத்தி மின்னஞ்சல் சேவையகத்துடன் தொடர்புகொள்வதன் முழு வாழ்க்கைச் சுழற்சியின் மூலம் நீங்கள் இப்போது பயணித்துள்ளீர்கள். பாதுகாப்பான இணைப்பை உருவாக்குவது, அஞ்சல்பெட்டிகளைப் பட்டியலிடுவது, சக்திவாய்ந்த தேடல்களைச் செய்வது, சிக்கலான பல பகுதி மின்னஞ்சல்களைப் பெறுவது மற்றும் பிரிப்பது, இணைப்புகளைப் பதிவிறக்குவது மற்றும் சேவையகத்தில் செய்தி நிலைகளை நிர்வகிப்பது போன்றவற்றை நாங்கள் விவாதித்தோம்.

இந்த அறிவின் சக்தி immense. ஆதரவு டிக்கெட்டுகளை தானாக வகைப்படுத்துவதற்கும், தினசரி அறிக்கைகளிலிருந்து தரவுகளைப் பிரித்தெடுப்பதற்கும், செய்திமடல்களை ஆவணப்படுத்துவதற்கும், எச்சரிக்கை மின்னஞ்சல்களின் அடிப்படையில் செயல்களைத் தூண்டுவதற்கும், மேலும் பலவற்றிற்கும் நீங்கள் அமைப்புகளை உருவாக்கலாம். முன்பு கையேடு உழைப்பின் ஆதாரமாக இருந்த இன்பாக்ஸ், உங்கள் பயன்பாடுகள் மற்றும் பணிப்பாய்வுகளுக்கான சக்திவாய்ந்த, தானியங்கு தரவு ஆதாரமாக மாறும்.

முதலில் எந்த மின்னஞ்சல் பணிகளை தானியங்குபடுத்துவீர்கள்? உங்கள் கற்பனைக்கு மட்டுமே சாத்தியங்கள் வரம்பிடப்பட்டுள்ளன. சிறியதாகத் தொடங்கி, இந்த வழிகாட்டியில் உள்ள எடுத்துக்காட்டுகளின் அடிப்படையில் உருவாக்குங்கள், மேலும் உங்கள் இன்பாக்ஸின் ஆழத்திலிருந்து உங்கள் நேரத்தை மீட்டெடுக்கவும்.