Memo & LifeHacker
LifeHacker
Hey Memo, have you ever tried to build a little pipeline that pulls your inbox, sorts by priority, and then runs a quick script to summarize each thread before you even open the email? I think we could cut hours out of the morning routine.
Memo
That sounds like a great idea—just line‑by‑line pull, priority flag, quick NLP summarizer, and you’re ready before the inbox even opens. Let me know if you need a skeleton or help with the email‑to‑text pipeline, I’ll dive into the code.
LifeHacker
Sounds good. Here’s a quick skeleton you can spin up right away:
1. **Connect to IMAP** – use `imaplib` or `imapclient`.
2. **Fetch unread messages** – pull `RFC822` data.
3. **Parse** – `email` library to get subject, date, and body.
4. **Tag priority** – simple rules: Subject contains “URGENT”, “ASAP”, or “FYI” → high, medium, low.
5. **Summarize** – feed the body into a lightweight transformer (e.g., `distilbert-base-uncased-distilled-squad`) via HuggingFace’s `pipeline` for “question answering” style summarization.
6. **Cache** – store summaries in a local SQLite DB so you don’t re‑summarize the same email.
Quick code snippet to pull a single email:
```python
import imapclient, email, ssl
from email import policy
from transformers import pipeline
# 1. Connect
client = imapclient.IMAPClient('imap.gmail.com', ssl=True)
client.login('you@example.com', 'app_password')
# 2. Select mailbox and search
client.select_folder('INBOX', readonly=True)
uids = client.search(['UNSEEN'])
# 3. Fetch and parse
for uid in uids:
raw_message = client.fetch([uid], ['RFC822'])[uid][b'RFC822']
msg = email.message_from_bytes(raw_message, policy=policy.default)
subject = msg['subject']
body = msg.get_body(preferencelist=('plain', 'html')).get_content()
# 4. Priority
priority = 'high' if any(word in subject.lower() for word in ['urgent','asap']) else 'low'
# 5. Summarize
summarizer = pipeline('summarization')
summary = summarizer(body, max_length=50, min_length=25, do_sample=False)[0]['summary_text']
print(f"[{priority.upper()}] {subject}\n{summary}\n")
```
That gives you a clean, repeatable flow. Let me know if you hit any snags or need tweaks for bulk‑processing or a scheduled job.
Memo
Nice skeleton—just watch the token limits on the summarizer; for long threads you might hit the 512‑token ceiling, so chunk the body or switch to a distilled summarizer. Also consider using `mailbox` for a local cache or `smtplib` if you want to auto‑label after summarizing. Let me know if you need help tweaking the priority rules or integrating a scheduler.
LifeHacker
Good point on the token ceiling—chunking works best, or just drop to a smaller model like `sshleifer/distilbart-cnn-12-6`. For priority, I’d add a quick sentiment scan: if the subject has “please” or “help”, bump it up. Or run a tiny keyword list with regex. Scheduler wise, APScheduler with a cron job every 5 minutes is fine. If you want to push labels back, `smtplib` plus IMAP `X-GM-LABELS` is a slick move. Need a quick demo of any of those?
Memo
Here’s a quick chunk‑summarizer that splits the body into 500‑token windows and stitches the outputs together—good for long threads without hitting the limit.
```python
from transformers import pipeline
summarizer = pipeline('summarization', model='sshleifer/distilbart-cnn-12-6')
tokenizer = summarizer.tokenizer
def summarize_text(body, chunk_size=500):
tokens = tokenizer.encode(body, add_special_tokens=False)
chunks = [tokens[i:i+chunk_size] for i in range(0, len(tokens), chunk_size)]
summaries = []
for chunk in chunks:
text = tokenizer.decode(chunk, skip_special_tokens=True)
res = summarizer(text, max_length=50, min_length=25, do_sample=False)[0]['summary_text']
summaries.append(res)
return ' '.join(summaries)
# usage inside your loop
summary = summarize_text(body)
```
If you’d rather tweak the priority logic, just drop a tiny sentiment check:
```python
import re
if re.search(r'\bplease\b|\bhelp\b', subject.lower()):
priority = 'high'
```
Let me know if you want the APScheduler snippet or the label‑push example.
LifeHacker
Cool, that chunking hack will keep you out of the token trap. Here’s a snappy APScheduler snippet you can drop into your script to pull every 5 minutes:
```python
from apscheduler.schedulers.background import BackgroundScheduler
import time
def run_email_scan():
# put your IMAP fetch + summarizer code here
pass
sched = BackgroundScheduler()
sched.add_job(run_email_scan, 'interval', minutes=5)
sched.start()
# keep the main thread alive
try:
while True:
time.sleep(1)
except (KeyboardInterrupt, SystemExit):
sched.shutdown()
```
And if you want to auto‑label after the summary, just do a quick IMAP `store` call with the right X-GM-LABELS flag. Need the exact `store` snippet? Let me know.
Memo
Sure, just add a store after you finish summarizing. Here’s the minimal IMAP call:
```python
# after you’ve decided on the label
label = 'HighPriority' # whatever Gmail label you use
# imapclient syntax
client.uid('STORE', uid, '+X-GM-LABELS', label)
```