We Keep Coding

How to send emails from CPanel email using python script

Hope you are doing well.
I am a developer that has not enough experiences in CPanel.
There are some problems to send email from CPanel and have tried a lot times but couldn't resolved, so I asked help of experienced veterans.
Recently days, I made simple project to send email in python and checked it on my local pc.
It worked well, so I posted it on CPanel, but some problems were occurred.
When I ran python code, it works without error but there is a problem for receiving.
I tested it with 2 kinds of email, one is outlook email, one is gmail.
First problem is a big latency. Outlook email was arrived after 2hours from I sent it in python. Also sometimes they was not arrived.
Second problem is occurred in gmail, gmail never arrives.
I searched many blog and post, but couldn't find solution.
Best similar contents is Sending emails from CPanel email using python script, but has not correct answer.
Additional
I use godaddy cpanel and can not use WHM. Also asked questions to support team before 4days, but they did not give me correct solution. Following image is a information that I used to send email.
I want to get the solution if I can send email directly to smtp.gmail.com on cpanel using python or if this is impossible, how to send email from ***#<domain.com> of cpanel to gmail accounts.
Thank you.

Is there a method for automating emails with SMTP or otherwise?

I've been writing some python scripts in order to do some automation for my work. One of the scripts is intended to gather some test results, compile the string of results with a "message" string, and send it as an email every 12-24 hours (if there are results) to each individual who needs this information. Additionally, we're running this script on Linux; either in a Jenkins pipeline, or in a crontab (this script will most likely be run via crontab).
I was initially using gmail's SMTP server (smtp.gmail.com, port 587) to send these since we're working off of our own personal gmail server anyways, and it worked for a bit once I gave the script an "App Password" since it was a "less secure app" to Google. However, after about an hour of testing with it, Google disabled the account for spam. Any subsequent accounts I try to set up for the same purpose are disabled on the spot, as well (the moment I try to send an email with it, it's halted and disabled). It's been a few days since I requested reviews on both of the accounts; but I don't think they'll get back to me any time soon, nor will it be a result in my favor.
Since Google was no longer viable, I looked online and saw that there are plenty of SMTP hosting options available, but we're not looking for a paid service just to send an email once every few days or so. In terms of free options, I was able to find one other post related to PHP/Ruby sending emails without SMTP (Send email without external SMTP service), but if possible I'd like to keep this within Linux/Python only unless there is a simpler way, or a way that links well with Linux/Python. Even then, I'm still concerned that using SMTP is necessary for our gmail accounts to receive these emails. If I'm wrong, please correct me; because it certainly seems that way to me.
Based off of the situation, how could I adjust my strategy in order to automate email updates of this nature?

Sending emails through python

I wish to setup a subscribe form. The user will fill his/her email address and on submit an email should be sent to the provided email address for verification. The verification email will have a link on which the user can click to verify the email address.
This form will be in a website which I plan to host at Bluehost.
I read this tutorial about how it can be done in Python. Following is a snippet from the tutorial
import smtplib
s = smtplib.SMTP(host='your_host_address_here', port=your_port_here)
s.starttls()
s.login(MY_ADDRESS, PASSWORD)
My question is will I able to make this work on Bluehost ?,
My understanding is that host and port can be obtained as described
in this link.
Also,is there any third-party service that allows me create such subscribe form as described above?

While this could technically work, I highly recommend using a third-party service to send the actual emails. These days, the chance of your email getting delivered if it's being sent from a random Bluehost server is quite low due to its low "email sender reputation".
Snippet from this link explaining it:
An email sender reputation is a score that an Internet Service Provider (ISP) assigns to an organization that sends email. It’s a crucial component of your email deliverability. The higher the score, the more likely an ISP will deliver emails to the inboxes of recipients on their network. If the score falls below a certain threshold, the ISP may send messages to recipients’ spam folders or even reject them outright.
Some email sending services include SendGrid or Amazon SES.

If your website is static, then please go for third party service beacuse it will be difficult for you to handle the backend and integration part. So, look for some third party applications to do it for you for example SendPulse
If your website is dynamic, i.e if its having some backend server part as well, then this email sending part can be done easily depending upon which language you are using at backend. Most languages has support for sending emails.

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.

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.