We Keep Coding

Differences in approaches to sending Outlook email using Python

I am new to Python and have recently tried out two approaches to automating the sending out of an email on Outlook 365, one with greater success than the other. I'd like to ask what the key differences are since they look quite vastly different.
The first method is that essentially outlined in the Automate the Boring Stuff book, using SMTP or IMAP. I tried this, but didn't get it to work perhaps because of authentication issues using an office computer.
The second method, which has worked for me, doesn't involve authentication, and I simply import the win32com client and the following code:
outlook = client.Dispatch('Outlook.Application')
message = outlook.CreateItem(0)
message.Display()
message.To = "redacted"
message.CC = "redacted"
message.Subject = "Hello"
I'd like to ask what are the main ways in which the two methods differ. It seems that the second might rely on Outlook being open and me being logged on, but would the first also work if my computer were put on sleep?
Why go through the first approach which involves authentication when I'm already logged on to Windows and have access to Outlook without needing to enter my user id and password?
I think this is a question that might be useful to others new to Python and email automation, as they may also encounter the two approaches in their search for solutions.

tldr; if you need to send mail from different mailboxes, use smtplib. If you are automating stuff that you can do manually using outlook, use win32com.client.
SMTP
Referencing the official python docs for SMTP, the methods described there simply allow you to send a mail. (yes, that's it. You cannot even look at the inbox. You'll need imaplib or poplib.)
To me the advantage of smtp is that you can send emails from another person's mailbox if you have his/her credentials. If you were to use win32com.client, you will need to sign out of your own outlook, sign in to that specific person's outlook, then run the code. And for me, I faced the issue where I had to wait for his/her inbox to finish loading before anything gets sent. This is not feasible if you only need to send mail (and not interested in any other functionality such as read or delete mail) from many mailboxes.
[Update] I've recently used smtplib and email (a python builtin package) in a personal project. As it is a personal project, I didn't want to use my office email, hence I decided to use smtplib instead. While there is a need to setup an initial connection, it is very straightforward. Since there is no way to save the email as a draft before sending, the logical workaround is to send it to your own email addresses (or any other 'safe' emails) to test if it works as intended.
import smtplib
from email.message import EmailMessage
msg = EmailMessage()
msg['From'] = 'YOUR_EMAIL#GMAIL.COM'
msg['Subject'] = 'Some subject here'
msg['To'] = ', '.join(['adam#gmail.com','bob#gmail.com','candice#gmail.com'])
msg.set_content('Some text here')
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp:
smtp.login('YOUR_EMAIL#GMAIL.COM', 'PASSWORD123')
smtp.send_message(msg)
print('Email sent!')
win32com.client (focusing on the Outlook application)
You should use this library if you want to automate what you can do on outlook mailboxes that you have access to. Syntax tends to be simpler and it allows you to do stuff that is not possible using only smtplib.
Here are 2 examples to illustrate my point.
Example 1: Automate sending of a calendar invite.
If you were to do it using SMTP, you'll require more code and another library email, specifically .MIMEMultipart, .MIMEBase, .MIMEText, .Utils. The syntax looks intimidating, to say the least. Just take a look at the ical variable of the following stackoverflow answer:
ical = "BEGIN:VCALENDAR"+CRLF+"PRODID:pyICSParser"+CRLF+"VERSION:2.0"+CRLF+"CALSCALE:GREGORIAN"+CRLF
ical+="METHOD:REQUEST"+CRLF+"BEGIN:VEVENT"+CRLF+"DTSTART:"+dtstart+CRLF+"DTEND:"+dtend+CRLF+"DTSTAMP:"+dtstamp+CRLF+organizer+CRLF
ical+= "UID:FIXMEUID"+dtstamp+CRLF
ical+= attendee+"CREATED:"+dtstamp+CRLF+description+"LAST-MODIFIED:"+dtstamp+CRLF+"LOCATION:"+CRLF+"SEQUENCE:0"+CRLF+"STATUS:CONFIRMED"+CRLF
ical+= "SUMMARY:test "+ddtstart.strftime("%Y%m%d # %H:%M")+CRLF+"TRANSP:OPAQUE"+CRLF+"END:VEVENT"+CRLF+"END:VCALENDAR"+CRLF
win32com.client is so much easier (phew~). There are code examples all over the internet (here and here), and here's a simple example:
ol = w32.Dispatch('Outlook.Application')
appt = ol.CreateItem(1)
appt.Start = '2021-02-06 15:00'
appt.Save()
Example 2: Saving an email as a draft
I often end up automating work for colleagues and when you are sending emails as a batch, it is highly recommended to test by saving the created mail items as a draft. win32com.client allows you to save the mail item as a draft (i.e. .Save()) but smtplib doesn't allow you to do that (reiterate, it only allows you to send a mail.)
[Disclaimer] I done some automation work on outlook and I've always used win32com.client and I have only recently started to use smtplib for a personal project. This question intrigued me and I decided that it is time to at least read a bit more about smtplib.

Checking folders different than inbox using poplib in Python

Some time ago I ve written a Python script, using poplib library, which retrieves messages from my pop3 email account. Now I would like to use it to retrieve emails from different mail server which works with IMAP. It works well, but only to retrieve messages from Inbox. Is there any way to also get emails from other folders like Spam, Sent etc? I know I could use imaplib and rewrite the script, but my questions is if it's possible to obtain that with poplib.

No.
POP is a single folder protocol. It is very simple and was not designed for multiple folders.
You will need to use IMAP or other advanced protocols to access additional folders.

Choosing "From" field using python win32com outlook

I am trying to automate emails using python. Unfortunately, the network administrators at my work have blocked SMTP relay, so I cannot use that approach to send the emails (they are addressed externally).
I am therefore using win32com to automatically send these emails via outlook. This is working fine except for one thing. I want to choose the "FROM" field within my python code, but I simply cannot figure out how to do this.
Any insight would be greatly appreciated.

If you configured a separate POP3/SMTP account, set the MailItem.SendUsingAccount property to an account from the Namespace.Accounts collection.
If you are sending on behalf of an Exchange user, set the MailItem.SentOnBehalfOfName property

Linux email server, how to know a new email has arrived

I am developing an email parsing application using python POP3 library on a linux server using Dovecot email server. I have parsed the emails to get the contents and the attachments etc. using POP3 library.
Now the issue is how to notify a user or actually the application that a new email has arrived? I guess there should be some notification system on email server itself which I am missing or something on linux which we can use to implement the same.
Please suggest.
Thanks in advance.

POP3 does not have push ability. Like a regular ol' post office you need to actually go to check your e-mail. IMAP does have functionality similar to (but not exactly the same as) mail pushing. I'd suggest taking a look at it.

Integrate postfix mail into my (python)webapp

I have a postfix server listening and receiving all emails received at mywebsite.com Now I want to show these postfix emails in a customized interface and that too for each user
To be clear, all the users of mywebsite.com will be given mail addresses like someguy#mywebsite.com who receives email on my production machine but he sees them in his own console built into his dashboard at mywebsite.com.
So to make the user see the mail he received, I need to create an email replica of the postfix mail so that mywebsite(which runs on django-python) will be reflecting them readily. How do I achieve this. To be precise this is my question, how do I convert a postfix mail to a python mail object(so that my system/website)understands it?
Just to be clear I have written psuedo code to achieve what I want:
email_as_python_object = postfix_email_convertor(postfix_email)
attachments_list = email_as_python_object.attachments
body = email_as_python_object.body # be it html or whatever
And by the way I have tried default email module which comes with python but thats not handy for all the cases. And even I need to deal with mail attachments manually(which I hate). I just need a simple way to deal with cases like these(I was wondering how postfix understands a email received. ie.. how it automatically figures out different headers,attachments etc..). Please help me.

You want to have postfix deliver to a local mailbox, and then use a webmail system for people to access that stored mail.
Don't get hung up on postfix - it just a transfer agent - it takes messages from one place, and puts them somewhere else, it doesn't store messages.
So postfix will take the messages over SMTP, and put them in local mail files.
Then IMAP or some webmail system will display those messages to your users.
If you want the mail integrated in your webapp, then you should probably run an IMAP server, and use python IMAP libraries to get the messages.

First of all, Postfix mail routing rules can be very complex and your presumably preferred solution involves a lot of trickery in the wrong places. You do not want to accidentally show some user anothers mails, do you? Second, although Postfix can do almost anything, it shouldn't as it only is a MDA (mail delivery agent).
Your solution is best solved by using a POP3 or IMAP server (Cyrus IMAPd, Courier, etc). IMAP servers can have "superuser accounts" who can read mails of all users. Your web application can then connect to the users mailbox and retreive the headers and bodys.
If you only want to show the subject-line you can fetch those with a special IMAP command and very low overhead. The Python IMAP library has not the easiest to understand API though. I'll give it a shot (not checked!) with an example taken from the standard library:
import imaplib
sess = imaplib.IMAP4()
sess.login('superuser', 'password')
# Honor the mailbox syntax of your server!
sess.select('INBOX/Luke') # Or something similar.
typ, data = sess.search(None, 'ALL') # All Messages.
subjectlines = []
for num in data[0].split():
typ, msgdata = sess.fetch(num, '(RFC822.SIZE BODY[HEADER.FIELDS (SUBJECT)])')
subject = msgdata[0][1].lstrip('Subject: ').strip()
subjectlines.append(subject)
This logs into the IMAP server, selects the users mailbox, fetches all the message-ids then fetches (hopefully) only the subjectlines and appends the resulting data onto the subjectlines list.
To fetch other parts of the mail vary the line with sess.fetch. For the specific syntax of fetch have a look at RFC 2060 (Section 6.4.5).
Good luck!

I'm not sure that I understand the question.
If you want your remote web application to be able to view users' mailbox, you could install a pop or imap server and use a mail client (you should be able to find one off the shelf) to read the emails. Alternatively, you could write something to interrogate the pop/imap server using the relevant libraries that come with Python itself.
If you want to replicate the mail to another machine, you could use procmail and set up actions to do this. Postfix can be set up to invoke procmail in this wayy.