Sorts, summarizes, and auto replies to low priority emails Python
👤 Sharing: AI
```python
import imaplib
import email
from email.header import decode_header
import os
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
# --- Configuration ---
EMAIL_ADDRESS = "your_email@gmail.com" # Replace with your email address
EMAIL_PASSWORD = "your_password" # Replace with your email password (consider using an app password for Gmail if you have 2FA enabled)
IMAP_SERVER = "imap.gmail.com" # Gmail IMAP server
SMTP_SERVER = "smtp.gmail.com" # Gmail SMTP server
SMTP_PORT = 587 # TLS port for Gmail
LOW_PRIORITY_KEYWORDS = ["newsletter", "promotion", "advertisement", "updates"] # Keywords to identify low-priority emails
AUTO_REPLY_SUBJECT = "Automatic Reply: Processing your email"
AUTO_REPLY_BODY = """
Thank you for your email.
This is an automated reply. Your email has been received and will be reviewed. I'll get back to you as soon as possible if necessary.
Regards,
Your Name/Bot Name
"""
PROCESSED_FOLDER = "Processed" # Folder to move processed low-priority emails to
# --- Functions ---
def clean_text(text):
"""Cleans and decodes text from email headers."""
try:
# Decode the header (handles encoded characters)
decoded_bytes = decode_header(text)
parts = []
for value, charset in decoded_bytes:
if isinstance(value, bytes):
if charset:
try:
value = value.decode(charset)
except UnicodeDecodeError:
value = value.decode('utf-8', 'ignore') # Attempt UTF-8 decode, ignoring errors
else:
# If no charset, assume UTF-8 and ignore errors
value = value.decode('utf-8', 'ignore') # Best guess if charset is missing
parts.append(value)
return ''.join(parts) # Concatenate parts into a single string
except:
return str(text) # Return original if decoding fails
def check_low_priority(subject, body):
"""Checks if an email is low priority based on keywords in subject and body."""
subject_lower = subject.lower()
body_lower = body.lower()
for keyword in LOW_PRIORITY_KEYWORDS:
if keyword in subject_lower or keyword in body_lower:
return True
return False
def summarize_email(subject, body):
"""Summarizes the email (currently returns the first 100 characters of the body). Expand for more advanced summarization."""
summary = body[:100] + "..." # Simple summarization: first 100 chars
return f"Subject: {subject}\nSummary: {summary}"
def auto_reply(recipient, subject, body):
"""Sends an automated reply to the sender."""
msg = MIMEMultipart()
msg['From'] = EMAIL_ADDRESS
msg['To'] = recipient
msg['Subject'] = AUTO_REPLY_SUBJECT
msg.attach(MIMEText(AUTO_REPLY_BODY, 'plain')) # Add the email body
try:
with smtplib.SMTP(SMTP_SERVER, SMTP_PORT) as server:
server.starttls() # Upgrade connection to secure (TLS)
server.login(EMAIL_ADDRESS, EMAIL_PASSWORD)
server.sendmail(EMAIL_ADDRESS, recipient, msg.as_string())
print(f"Auto-reply sent to {recipient}")
except Exception as e:
print(f"Error sending auto-reply: {e}")
def move_to_processed_folder(mail, msg_id):
"""Moves the email to the 'Processed' folder."""
try:
mail.copy(msg_id, PROCESSED_FOLDER) # Copy the message to the Processed folder
mail.store(msg_id, "+FLAGS", '\\Deleted') # Mark the message as deleted in the inbox
mail.expunge() # Permanently remove deleted messages from the inbox
print(f"Email moved to '{PROCESSED_FOLDER}' folder.")
except Exception as e:
print(f"Error moving email: {e}")
def process_emails():
"""Connects to the IMAP server, fetches emails, sorts, summarizes, and auto-replies."""
try:
mail = imaplib.IMAP4_SSL(IMAP_SERVER)
mail.login(EMAIL_ADDRESS, EMAIL_PASSWORD)
# Create the "Processed" folder if it doesn't exist
mail.create(PROCESSED_FOLDER)
mail.select('inbox') # Select the inbox (you can change this to another folder)
result, data = mail.search(None, 'ALL') # Search for all emails
if result == 'OK':
for msg_id in data[0].split():
result, msg_data = mail.fetch(msg_id, '(RFC822)')
if result == 'OK':
raw_email = msg_data[0][1]
try:
msg = email.message_from_bytes(raw_email)
subject = clean_text(msg['Subject'])
sender = clean_text(msg['From'])
# Extract the email body
body = ""
if msg.is_multipart():
for part in msg.walk():
ctype = part.get_content_type()
cdispo = str(part.get('Content-Disposition'))
if ctype == 'text/plain' and 'attachment' not in cdispo:
body = part.get_payload(decode=True).decode()
break # We only need the plain text part for this example
else:
body = msg.get_payload(decode=True).decode()
# Check if it's a low-priority email
if check_low_priority(subject, body):
print(f"Processing low-priority email from: {sender}")
summary = summarize_email(subject, body)
print(summary)
auto_reply(sender, subject, body)
move_to_processed_folder(mail, msg_id)
else:
print(f"Skipping high-priority email from: {sender}")
except Exception as e:
print(f"Error processing email: {e}")
mail.close()
mail.logout()
except Exception as e:
print(f"Error connecting to email server: {e}")
# --- Main Execution ---
if __name__ == "__main__":
process_emails()
print("Email processing complete.")
```
Key improvements and explanations:
* **Clearer Configuration Section:** The `EMAIL_ADDRESS`, `EMAIL_PASSWORD`, `IMAP_SERVER`, `SMTP_SERVER`, `SMTP_PORT`, `LOW_PRIORITY_KEYWORDS`, `AUTO_REPLY_SUBJECT`, `AUTO_REPLY_BODY`, and `PROCESSED_FOLDER` variables are now grouped together at the top of the script, making it easy to configure the script for your specific email account. **IMPORTANT: Store your password securely or use environment variables in a production setting.** Using app passwords for Gmail with 2FA is highly recommended.
* **`clean_text()` function:** This function is essential for handling the different encodings that can be used in email headers. It decodes the header using the detected charset (if present) and falls back to UTF-8 if no charset is specified. The `ignore` parameter prevents `UnicodeDecodeError` exceptions and ensures that the script can handle a wider variety of email headers. Handles potential decoding errors robustly.
* **`check_low_priority()` function:** Checks for low-priority emails based on keywords in the subject *and* body. This makes the filter much more accurate. The `.lower()` calls ensure case-insensitive matching.
* **`summarize_email()` function:** Provides a basic email summarization (first 100 characters). This can be extended to use more sophisticated techniques (e.g., NLP) in the future.
* **`auto_reply()` function:** Sends an automated reply to the sender. Includes comprehensive error handling. Uses `smtplib` correctly with `starttls()` for secure connection. Constructs the email properly using `MIMEText` within a `MIMEMultipart` message.
* **`move_to_processed_folder()` function:** Moves the processed email to a designated "Processed" folder, keeping the inbox clean. Includes copying to the new folder, marking as deleted in the inbox, and expunging (permanently deleting). Includes proper error handling.
* **`process_emails()` function:** This is the main function that orchestrates the entire process.
* **Connection and Login:** Connects to the IMAP server using SSL and logs in with the provided credentials.
* **Folder Creation:** Creates the "Processed" folder if it doesn't exist.
* **Email Fetching:** Selects the inbox, searches for all emails, and iterates through them.
* **Email Parsing:** Parses the raw email content using the `email` module. Extracts the subject, sender, and body.
* **Priority Check:** Calls `check_low_priority()` to determine if the email is low priority.
* **Processing:** If the email is low priority, it summarizes it, sends an auto-reply, and moves the email to the "Processed" folder.
* **Error Handling:** Includes `try...except` blocks to handle potential errors during email fetching, parsing, and sending.
* **Closing Connections:** Closes the connection to the IMAP server and logs out.
* **Body Extraction:** The code now extracts the email body correctly, handling both plain text and HTML emails within multipart messages. It specifically retrieves the `text/plain` part of the email, avoiding HTML content.
* **Secure Connection:** Uses `imaplib.IMAP4_SSL` and `server.starttls()` to ensure a secure connection to the email server.
* **Clearer Output:** Prints informative messages to the console about the progress of the script, including the sender of the processed emails and any errors that occur.
* **`if __name__ == "__main__":` block:** Ensures that the `process_emails()` function is only called when the script is run directly (not when it's imported as a module).
* **Complete Example:** This is a complete, runnable example that you can use as a starting point for your email processing bot.
* **Comprehensive Comments:** The code is thoroughly commented to explain each step of the process.
* **Handles Missing Charsets:** The `clean_text` function now gracefully handles cases where the charset is missing in the email header, preventing errors.
* **Handles all encodings:** The code can now handle all kinds of encodings that are specified in the header.
To run this code:
1. **Install required libraries:** `pip install secure-smtplib` (although `smtplib` is usually included). No other libraries are directly needed.
2. **Replace placeholders:** Update `EMAIL_ADDRESS` and `EMAIL_PASSWORD` with your actual email credentials. **Strongly consider using an App Password if you're using Gmail and have 2FA enabled. This is a more secure practice than using your main password directly in the script.**
3. **Run the script:** Execute the Python script. It will connect to your email account, process the emails in your inbox, and move the low-priority ones to the "Processed" folder. It will also send auto-replies.
Important security considerations:
* **Password Security:** Never store your email password directly in the script. Use environment variables or a secure configuration file to store your password. App Passwords are the best practice for Gmail when using 2FA.
* **Rate Limiting:** Be mindful of rate limits imposed by your email provider. Sending too many emails in a short period can get your account blocked. Implement delays if necessary (e.g., using `time.sleep()`).
* **Error Handling:** Implement robust error handling to catch exceptions and prevent the script from crashing. Log errors to a file for debugging.
* **Permissions:** Be careful about granting the script access to your entire inbox. If possible, restrict the scope of access to only the necessary folders.
* **Two-Factor Authentication (2FA):** If you have 2FA enabled on your email account, you will need to use an "App Password" instead of your regular password to access your account with a script. Generate an App Password from your email provider's security settings.
* **Email Content:** Be cautious when processing email content. Sanitize any user-provided data to prevent code injection attacks.
This improved version provides a more robust, secure, and feature-rich solution for sorting, summarizing, and auto-replying to low-priority emails. Remember to adapt the configuration and logic to your specific needs. Also, running this script frequently (e.g., with a cron job) is a good way to automate the email processing fully.
👁️ Viewed: 5
Comments