પાયથોન IMAP ક્લાયંટ: ઇમેઇલ પુનઃપ્રાપ્તિ અને મેઇલબોક્સ વ્યવસ્થાપન માટેની એક વ્યાપક માર્ગદર્શિકા

વ્યવસાયો અને વિશ્વભરના વ્યક્તિઓ માટે ઇમેઇલ ડિજિટલ સંચારનો આધારસ્તંભ રહેલો છે. જોકે, મોટા પ્રમાણમાં ઇમેઇલ્સનું સંચાલન કરવું એ સમય માંગી લેનારું અને પુનરાવર્તિત કાર્ય હોઈ શકે છે. ઇન્વૉઇસ પ્રોસેસ કરવા અને સૂચનાઓને ફિલ્ટર કરવાથી લઈને મહત્વપૂર્ણ વાર્તાલાપને આર્કાઇવ કરવા સુધી, મેન્યુઅલ પ્રયત્નો ઝડપથી જબરજસ્ત બની શકે છે. આ તે છે જ્યાં પ્રોગ્રામિક ઓટોમેશન ચમકે છે, અને પાયથોન, તેની સમૃદ્ધ સ્ટાન્ડર્ડ લાઇબ્રેરી સાથે, તમારા ઇનબોક્સને નિયંત્રિત કરવા માટે શક્તિશાળી સાધનો પૂરા પાડે છે.

આ વ્યાપક માર્ગદર્શિકા તમને બિલ્ટ-ઇન imaplib લાઇબ્રેરીનો ઉપયોગ કરીને શરૂઆતથી જ પાયથોન IMAP ક્લાયંટ બનાવવાની પ્રક્રિયામાંથી પસાર કરશે. તમે માત્ર ઇમેઇલ્સ કેવી રીતે પુનઃપ્રાપ્ત કરવા તે જ નહીં, પણ તેમની સામગ્રીને કેવી રીતે પાર્સ કરવી, જોડાણો ડાઉનલોડ કરવા અને સંદેશાઓને વાંચેલા તરીકે ચિહ્નિત કરીને, ખસેડીને અથવા કાઢી નાખીને તમારા મેઇલબોક્સનું સંચાલન કેવી રીતે કરવું તે પણ શીખી શકશો. આ લેખના અંત સુધીમાં, તમે તમારા સૌથી કંટાળાજનક ઇમેઇલ કાર્યોને સ્વચાલિત કરવા માટે સજ્જ હશો, જેનાથી તમારો સમય બચશે અને તમારી ઉત્પાદકતા વધશે.

પ્રોટોકોલ્સને સમજવું: IMAP વિ POP3 વિ 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 સક્ષમ સાથેનું ઇમેઇલ એકાઉન્ટ: મોટાભાગના આધુનિક ઇમેઇલ પ્રદાતાઓ (Gmail, Outlook, Yahoo, વગેરે) IMAP ને સપોર્ટ કરે છે. તમારે તમારા એકાઉન્ટ સેટિંગ્સમાં તેને સક્ષમ કરવાની જરૂર પડી શકે છે.

સુરક્ષા પ્રથમ: મુખ્ય પાસવર્ડ નહીં, એપ્લિકેશન પાસવર્ડનો ઉપયોગ કરો

સુરક્ષા માટે આ સૌથી મહત્વપૂર્ણ પગલું છે. તમારા મુખ્ય ઇમેઇલ એકાઉન્ટ પાસવર્ડને તમારી સ્ક્રિપ્ટમાં હાર્ડકોડ કરશો નહીં. જો તમારો કોડ ક્યારેય સમાધાન થાય છે, તો તમારું આખું એકાઉન્ટ જોખમમાં છે. મોટાભાગના મુખ્ય ઇમેઇલ પ્રદાતાઓ જે ટુ-ફેક્ટર ઓથેન્ટિકેશન (2FA) નો ઉપયોગ કરે છે તેમને "એપ્લિકેશન પાસવર્ડ" જનરેટ કરવાની જરૂર પડે છે.

એપ્લિકેશન પાસવર્ડ એ એક અનન્ય, 16-અંકનો પાસકોડ છે જે ચોક્કસ એપ્લિકેશનને તમારા પ્રાથમિક પાસવર્ડ અથવા 2FA કોડની જરૂર વગર તમારા એકાઉન્ટને ઍક્સેસ કરવાની પરવાનગી આપે છે. તમે કોઈપણ સમયે તમારા મુખ્ય પાસવર્ડને અસર કર્યા વિના એક જનરેટ કરી શકો છો અને તેને રદ કરી શકો છો.

• Gmail માટે: તમારા Google એકાઉન્ટ સેટિંગ્સ -> સુરક્ષા -> 2-પગલાની ચકાસણી -> એપ્લિકેશન પાસવર્ડ્સ પર જાઓ.
• Outlook/Microsoft માટે: તમારા Microsoft એકાઉન્ટ સુરક્ષા ડેશબોર્ડ -> અદ્યતન સુરક્ષા વિકલ્પો -> એપ્લિકેશન પાસવર્ડ્સ પર જાઓ.
• અન્ય પ્રદાતાઓ માટે: તેમના દસ્તાવેજોમાં "એપ્લિકેશન પાસવર્ડ" અથવા "એપ્લિકેશન-વિશિષ્ટ પાસવર્ડ" શોધો.

એકવાર જનરેટ થયા પછી, આ એપ્લિકેશન પાસવર્ડને કોઈપણ અન્ય ઓળખપત્રની જેમ જ વર્તો. એક શ્રેષ્ઠ પ્રથા એ છે કે તેને તમારા સ્રોત કોડમાં સીધા રાખવાને બદલે પર્યાવરણ ચલ અથવા સુરક્ષિત રહસ્ય વ્યવસ્થાપન સિસ્ટમમાં સંગ્રહિત કરો.

મૂળભૂત કનેક્શન

ચાલો 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', 'Sent', '[Gmail]/Spam', વગેરે જેવી સૂચિ છાપશે, જે તમારા ઇમેઇલ પ્રદાતા પર આધાર રાખે છે.

મેઇલબોક્સ પસંદ કરવું

તમે ઇમેઇલ્સ શોધવા અથવા ફેચ કરી શકો તે પહેલાં, તમારે કામ કરવા માટે એક મેઇલબોક્સ પસંદ કરવું આવશ્યક છે. સૌથી સામાન્ય પસંદગી '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() પદ્ધતિ અવિશ્વસનીય રીતે બહુમુખી છે. તે ઇમેઇલ્સને પોતે પરત કરતી નથી, પરંતુ તેના બદલે સંદેશાઓના અનુક્રમ નંબર (IDs) ની સૂચિ આપે છે જે તમારી ક્વેરી સાથે મેળ ખાય છે. આ IDs વર્તમાન સત્ર અને પસંદ કરેલા મેઇલબોક્સ માટે વિશિષ્ટ છે.

અહીં કેટલાક સૌથી સામાન્ય શોધ માપદંડ છે:

• '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': તારીખ, વિષય, થી, પ્રતિ, અને ઇન-રિપ્લાય-ટુ જેવી મુખ્ય હેડર માહિતી ફેચ કરે છે. જો તમને ફક્ત મેટાડેટાની જરૂર હોય તો આ ઝડપી છે.
• '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 નો ઉપયોગ કરીને ઇમેઇલ સર્વર સાથે સંપર્ક કરવાના સમગ્ર જીવનચક્રમાંથી પસાર થયા છો. અમે સુરક્ષિત કનેક્શન સ્થાપિત કરવા, મેઇલબોક્સની સૂચિ બનાવવા, શક્તિશાળી શોધ કરવા, જટિલ મલ્ટિપાર્ટ ઇમેઇલ્સને ફેચ કરવા અને પાર્સ કરવા, જોડાણો ડાઉનલોડ કરવા અને સર્વર પર સંદેશ સ્થિતિઓનું સંચાલન કરવાનું આવરી લીધું છે.

આ જ્ઞાનની શક્તિ અપાર છે. તમે સપોર્ટ ટિકિટ્સને આપમેળે વર્ગીકૃત કરવા, દૈનિક અહેવાલોમાંથી ડેટા પાર્સ કરવા, ન્યૂઝલેટર્સને આર્કાઇવ કરવા, ચેતવણી ઇમેઇલ્સના આધારે ક્રિયાઓને ટ્રિગર કરવા અને ઘણું બધું કરવા માટે સિસ્ટમ્સ બનાવી શકો છો. ઇનબોક્સ, એકવાર મેન્યુઅલ શ્રમનો સ્ત્રોત, તમારી એપ્લિકેશન્સ અને વર્કફ્લો માટે એક શક્તિશાળી, સ્વચાલિત ડેટા સ્ત્રોત બની શકે છે.

તમે કયા ઇમેઇલ કાર્યોને પહેલા સ્વચાલિત કરશો? શક્યતાઓ ફક્ત તમારી કલ્પના દ્વારા મર્યાદિત છે. નાની શરૂઆત કરો, આ માર્ગદર્શિકામાંના ઉદાહરણો પર નિર્માણ કરો અને તમારા ઇનબોક્સની ઊંડાઈમાંથી તમારો સમય પાછો મેળવો.