def main(args):
message = email.message.EmailMessage(email.policy.SMTP)
message['To'] = 'Test Recipient <*****@*****.**>'
message['From'] = 'Test Sender <*****@*****.**>'
message['Subject'] = 'Foundations of Python Network Programming'
message['Date'] = email.utils.formatdate(localtime=True)
message['Message-ID'] = email.utils.make_msgid()
if not args.i:
message.set_content(html, subtype='html')
message.add_alternative(plain)
else:
cid = email.utils.make_msgid() # RFC 2392: must be globally unique!
message.set_content(html + img.format(cid.strip('<>')), subtype='html')
message.add_related(blue_dot, 'image', 'gif', cid=cid,
filename='blue-dot.gif')
message.add_alternative(plain)
for filename in args.filename:
mime_type, encoding = mimetypes.guess_type(filename)
if encoding or (mime_type is None):
mime_type = 'application/octet-stream'
main, sub = mime_type.split('/')
if main == 'text':
with open(filename, encoding='utf-8') as f:
text = f.read()
message.add_attachment(text, sub, filename=filename)
else:
with open(filename, 'rb') as f:
data = f.read()
message.add_attachment(data, main, sub, filename=filename)
sys.stdout.buffer.write(message.as_bytes())
def main():
message = email.message.EmailMessage(email.policy.SMTP)
message['To'] = 'Böðvarr <*****@*****.**>'
message['From'] = 'Eardstapa <*****@*****.**>'
message['Subject'] = 'Four lines from The Wanderer'
message['Date'] = email.utils.formatdate(localtime=True)
message.set_content(text, cte='quoted-printable')
sys.stdout.buffer.write(message.as_bytes())
def main():
message = email.message.EmailMessage(email.policy.SMTP)
message['To'] = '*****@*****.**'
message['From'] = 'Test Sender <*****@*****.**>'
message['Subject'] = 'Test Message, Chapter 12'
message['Date'] = email.utils.formatdate(localtime=True)
message['Message-ID'] = email.utils.make_msgid()
message.set_content(text)
sys.stdout.buffer.write(message.as_bytes())
def main():
message = email.message.EmailMessage(email.policy.SMTP)
message["To"] = "*****@*****.**"
message["From"] = "Test Sender <*****@*****.**>"
message["Subject"] = "Test Message, Chapter 12"
message["Date"] = email.utils.formatdate(localtime=True)
message["Message-ID"] = email.utils.make_msgid()
message.set_content(text)
sys.stdout.buffer.write(message.as_bytes())
def send_report(self):
if self.report == 'never':
return
if self.report == 'error' and self._backup_successful():
return
if self.email == None or len(self.email) == 0:
logger.error('{}: Not sending backup report since email configuration is missing or empty'.format(self.name))
return
logger.info('{}: Sending backup report to {}'.format(self.name, self.email))
if self._backup_successful():
status = 'SUCCESS'
else:
status = 'FAILURE'
timestamp = datetime.datetime.now(datetime.timezone.utc).replace(microsecond=0).isoformat()
content = []
content.append('Backup report')
content.append('')
content.append('Host: {}'.format(platform.node()))
content.append('Node: {}'.format(self.name))
content.append('Date: {}'.format(timestamp))
content.append('Status: {}'.format(status))
if args.dry_run:
content.append('')
content.append('Backup performed in dry-run mode')
content.append('No data was stored')
if len(self.output) > 0:
content.append('')
content.append('Output:')
content += self.output
content.append('')
content.append('/Your friendly backup robot')
message = email.message.EmailMessage()
message['Subject'] = 'Backup report for {}: {}'.format(self.name, status)
message['From'] = 'Backup Robot <*****@*****.**>'
message['To'] = self.email
message['Reply-To'] = 'Backup Operators <*****@*****.**>'
message.set_content('\n'.join(content))
logger.debug('The following message will be sent to {}:'.format(self.email))
for line in message.as_string().rstrip().split('\n'):
logger.debug(line)
try:
with smtplib.SMTP('localhost') as smtp:
smtp.send_message(message)
except:
logger.error('{}: Sending backup report to {} failed'.format(self.name, self.email))
def email_message(self):
message = email.message.EmailMessage()
message['Subject'] = self.subject
if self.sender:
message['From'] = self.sender.email
if self.recipient:
message['To'] = self.recipient.email
if self.replyto:
message['Reply-To'] = self.replyto.email
# CTE: https://en.wikipedia.org/wiki/MIME#Content-Transfer-Encoding
message.set_content(self.html_body, subtype='html', cte='quoted-printable')
return message
def generate(sender, recipient, subject, body, attachment_path):
"""Creates an email with an attachment"""
# Basic Email formatting
message = email.message.EmailMessage()
message["From"] = sender
message["To"] = recipient
message["Subject"] = subject
message.set_content(body)
# Process the attachment and add it to the email
attachment_filename = os.path.basename(attachment_path)
mime_type, _ = mimetypes.guess_type(attachment_path)
mime_type, mime_subtype = mime_type.split('/'. 1)
with open(attachment_path, 'rb') as ap:
message.add_attachment(ap.read(),
maintype=mime_type,
subtype=mime_subtype,
filename=attachment_filename)
return message
def generate_email(sender, recipient, subject, body, attachment_path=None):
''' Generates email with an attachment'''
message = email.message.EmailMessage()
message['From'] = sender
message['To'] = recipient
message['Subject'] = subject
message.set_content(body)
# Attachment
if attachment_path:
attachment_filename = os.path.basename(attachment_path)
mime_type, _ = mimetypes.guess_type(attachment_path)
mime_type, mime_subtype = mime_type.split('/', 1)
with open(attachment_path, 'rb') as ap:
message.add_attachment(ap.read(),
maintype=mime_type,
subtype=mime_subtype,
filename=attachment_filename)
return message
def generate(sender, recipient, subject, body, attachment_path):
"""Creates an email with an attachement."""
# Basic Email formatting
message = email.message.EmailMessage()
message["From"] = sender
message["To"] = recipient
message["Subject"] = subject
message.set_content(body)
# Making attachment_path optional, if the attachment variable is
# empty string, no email will be sent.
if not attachment_path == "":
# Process the attachment and add it to the email
attachment_filename = os.path.basename(attachment_path)
mime_type, _ = mimetypes.guess_type(attachment_path)
mime_type, mime_subtype = mime_type.split('/', 1)
with open(attachment_path, 'rb') as ap:
message.add_attachment(ap.read(),
maintype=mime_type,
subtype=mime_subtype,
filename=attachment_filename)
return message
def generate(sender, recipient, subject, body, attachment_path): # generate the email
"""Creates an email with an attachment."""
# Basic Email formatting
message = email.message.EmailMessage() # create message object
message["From"] = sender # set From to sender
message["To"] = recipient # set To to recipient
message["Subject"] = subject # set Subject to subject
message.set_content(body) # set the message body to body
# Process the attachment and add it to the email
attachment_filename = os.path.basename(attachment_path) # set attachment file
mime_type, _ = mimetypes.guess_type(attachment_path) # automatically guess the mimetype
mime_type, mime_subtype = mime_type.split('/', 1) # split and set the mimetype / subtype
with open(attachment_path, 'rb') as ap: # open the attachment
message.add_attachment(ap.read(), # read in the attachment
maintype=mime_type, # set the mimetype
subtype=mime_subtype, # set the mime subtype
filename=attachment_filename) # give the attachment filename
return message # returns the finished message
def generate_email(recipient,
sender="*****@*****.**",
subject=default_subject,
body=default_body,
attachment_path="/tmp/processed.pdf"):
"""Generate an email """
message = email.message.EmailMessage()
message["From"] = sender
message["To"] = recipient
message["Subject"] = subject
message.set_content(body)
#Add attachment (pdf report)
attachment_filename = os.path.basename(attachment_path)
mime_type, _ = mimetypes.guess_type(attachment_path)
mime_type, mime_subtype = mime_type.split('/', 1)
with open(attachment_path, 'rb') as ap:
message.add_attachment(ap.read(),
maintype=mime_type,
subtype=mime_subtype,
filename=attachment_filename)
return message
def generateEmail(sender, recipient, subject, body, attachment_path):
#Basic Email formatting
message = email.message.EmailMessage()
message['From'] = sender
message['To'] = recipient
message['Subject'] = subject
message.set_content(body)
#Process the attachment if any and add it to mail
if not attachment_path == "":
attachment_filename = os.path.basename(attachment_path)
mime_type, _ = mimetypes.guess_type(attachment_path)
mime_type, mime_subtype = mime_type.split('/', 1)
with open(attachment_path, 'rb') as ap:
message.add_attachment(ap.read(),
maintype=mime_type,
subtype=mime_subtype,
filename=attachment_filename)
return message
def test_from_emailmessage(self):
message = EmailMessage()
body = 'message that is not urgent'
try:
message.set_content(body)
except AttributeError:
# Python2
message.set_payload(body)
message.set_default_type('text/plain')
message['Subject'] = 'URGENT TITLE'
message['From'] = '*****@*****.**'
message['To'] = '*****@*****.**'
mail = Mail.from_EmailMessage(message)
self.assertEqual(mail.subject.get(), 'URGENT TITLE')
self.assertEqual(mail.from_email.email, '*****@*****.**')
self.assertEqual(len(mail.personalizations), 1)
self.assertEqual(len(mail.personalizations[0].tos), 1)
self.assertEqual(mail.personalizations[0].tos[0], {'email': '*****@*****.**'})
self.assertEqual(len(mail.contents), 1)
content = mail.contents[0]
self.assertEqual(content.type, 'text/plain')
self.assertEqual(content.value, 'message that is not urgent')
def generate_email(sender, recipient, subject="", body="", attachment_path=""):
"""Creates an email with an attachement."""
# Basic Email formatting
message = email.message.EmailMessage()
message["From"] = sender
message["To"] = recipient
message["Subject"] = subject
message.set_content(body)
# Add attachment if she exist
if attachment_path:
# Process the attachment and add it to the email
attachment_file = Path(attachment_path)
mime_type, _ = mimetypes.guess_type(attachment_path)
mime_type, mime_subtype = mime_type.split('/', 1)
with open(attachment_path, 'rb') as ap:
message.add_attachment(ap.read(),
maintype=mime_type,
subtype=mime_subtype,
filename=attachment_file.name)
return message
def generate_email(msg_sender,
msg_recipient,
msg_subject,
msg_body,
attachment_path=None):
"""Generate email, default is with no attachment"""
# Basic Email formatting
message = email.message.EmailMessage()
message['Subject'] = msg_subject
message['From'] = msg_sender
message['To'] = msg_recipient
message.set_content(msg_body)
if attachment_path != None:
attachment_name = os.path.basename(attachment_path)
mime_type, _ = mimetypes.guess_type(attachment_path)
mime_type, mime_subtype = mime_type.split("/", 1)
with open(attachment_path, 'rb') as ap:
message.add_attachment(ap.read(),
maintype=mime_type,
subtype=mime_subtype,
filename=attachment_name)
return message
def main(args):
message = email.message.EmailMessage(email.policy.SMTP)
message['To'] = 'Test Recipient <*****@*****.**>'
message['From'] = 'Test Sender <*****@*****.**>'
message['Subject'] = 'Foundations of Python Networking Programming'
message['Date'] = email.utils.formatdate(localtime=True)
message['Message-ID'] = email.utils.make_msgid()
if not args.i:
message.set_content(html, subtype='html')
message.add_alternative(plain)
else:
# RFC 2392: must be globally unique!
cid = email.utils.make_msgid()
message.set_content(html + img.format(cid.strip('<>')), subtype='html')
message.add_related(blue_dot,
'image',
'gif',
cid=cid,
filename='blue-dot.gif')
message.add_alternative(plain)
for filename in args.filename:
mime_type, encoding = mimetypes.guess_type(filename)
if encoding or (mime_type is None):
mime_type = 'application/octet-stream'
main, sub = mime_type.split('/')
if main == 'text':
with open(filename, encoding='utf-8') as f:
text = f.read()
message.add_attachment(text, sub, filename=filename)
else:
with open(filename, 'rb') as f:
data = f.read()
message.add_attachment(data, main, sub, filename=filename)
sys.stdout.buffer.write(message.as_bytes())
def generate(sender, recipient, subject, body, attachment_path=False):
"""
This function receives 4 mandatory and 1 optional arguments
Example:
>> mandatory:
sender = gerardo.ocampos
recipient = juan.perez
subject = 'A simple subject'
body = 'content of the mail'
>> optional:
attachment_path = '/tmp/example.pdf'
generate('gerardo.ocampos','juan.perez','A simple subject', 'content of the mail', '/tmo/example.pdf')
RETURN:
message object
"""
message = email.message.EmailMessage()
message['From'] = sender
message['To'] = recipient
message['Subject'] = subject
message.set_content(body)
if attachment_path:
attachment_file = os.path.basename(attachment_path)
mime_type, _ = mimetypes.guess_type(attachment_path)
mime_type, mime_subtype = mime_type.split('/', 1)
with open(attachment_path, 'rb') as ap:
message.add_attachment(ap.read(),
maintype=mime_type,
subtype=mime_subtype,
filename=attachment_file)
return message
async def send_email(critic: api.critic.Critic, request: Request, sender: str) -> None:
if request.method != "POST":
raise HTTPBadRequest("Expected method: POST")
payload = cast(Mapping[str, Any], await request.json())
if not isinstance(cast(object, payload), dict):
raise HTTPBadRequest(f"Invalid payload: must be object (got: {payload!r})")
recipient = payload.get("recipient")
if not isinstance(recipient, str):
raise HTTPBadRequest(
f"Invalid payload['recipient']: must be string (got: {recipient!r})"
)
subject = payload.get("subject")
if not isinstance(subject, str):
raise HTTPBadRequest(
f"Invalid payload['subject']: must be string (got: {subject!r})"
)
message_id = payload.get("message_id")
if message_id is not None and not isinstance(message_id, str):
raise HTTPBadRequest(
f"Invalid payload['message_id']: must be string (got: {subject!r})"
)
api.PermissionDenied.raiseUnlessAdministrator(critic)
feedback: Optional[Feedback] = None
async with pubsub.connect("EmailDelivery/send_email") as pubsub_client:
delivery_notification: Optional[DeliveryNotification] = None
message = email.message.EmailMessage()
message["From"] = sender
message["To"] = recipient
message["Subject"] = subject
if message_id is not None:
message["Message-Id"] = f"<{message_id}>"
delivery_notification = DeliveryNotification()
await pubsub_client.subscribe(
pubsub.ChannelName(f"email/sent/{message_id}"), delivery_notification
)
message.set_content(await request.text())
async with critic.transaction() as cursor:
await pubsub_client.publish(
cursor,
pubsub.PublishMessage(
pubsub.ChannelName("email/outgoing"), pubsub.Payload(message)
),
)
if delivery_notification:
try:
feedback = cast(
Feedback,
(await asyncio.wait_for(delivery_notification.wait(), 10)).payload,
)
except asyncio.TimeoutError as error:
feedback = {
"sent": False,
"reason": "Timeout waiting for delivery notification",
"error": str(error),
}
if feedback is None:
raise HTTPNoContent
else:
await request.json_response(payload=feedback)
#!/usr/bin/env python3
import psutil
import shutil
import socket
import email.message
import smtplib
Error = ""
total, used, free = shutil.disk_usage("/")
disk_free = (free / total) * 100
if psutil.cpu_percent() > 80:
Error = "Error - CPU usage is over 80%"
elif psutil.virtual_memory().available < 500 * 1000000:
Error = "Error - Available memory is less than 500MB"
elif disk_free < 20:
Error = "Error - Available disk space is less than 20%"
elif socket.gethostbyname("localhost") != "127.0.0.1":
Error = "Error - localhost cannot be resolved to 127.0.0.1"
#print(Error)
message = email.message.EmailMessage()
message["From"] = "*****@*****.**"
message["To"] = "*****@*****.**"
message["Subject"] = Error
message.set_content(
"Plase check your system and resolve the issue as soon as possible")
"""Sends the message to the configured SMTP server."""
mail_server = smtplib.SMTP('localhost')
mail_server.send_message(message)
mail_server.quit()
#! /usr/bin/env python3
import email.message
import mimetypes
import os.path
import smtplib
def generate_email(sender, recipient, subject, body)
message = email.message.EmailMessage()
message["From"] = sender
message["To"] = recipient
message["Subject"] = subject
message.set_content(body)
return message
def generate_email_with_attachment(sender, recipient, subject, body, attachment_path):
message = email.message.EmailMessage()
message["From"] = sender
message["To"] = recipient
message["Subject"] = subject
message.set_content(body)
attachment_filename = os.path.basename(attachment_path)
mime_type, _ = mimetypes.guess_type(attachment_path)
mime_type, mime_subtype = mime_type.split('/', 1)
with open(attachment_path, 'rb') as ap:
message.add_attachment(ap.read(),
maintype=mime_type,
subtype=mime_subtype,
filename=attachment_filename)
def create(item, codec=Codec):
"""Create an email.message.EmailMessage object using given codec
"""
message = email.message.EmailMessage()
identifier = codec.get_id(item)
issuer = codec.get_issuer(item)
sender, domain = email.utils.parseaddr(issuer)[1].split("@")
message.add_header("From", issuer)
message.add_header("To", codec.get_recipient(item))
message.add_header("Message-ID", "<{}@{}>".format(uuid.uuid4(), domain))
message.add_header("References", "<{}@{}>".format(identifier, domain))
message.add_header("Reply-To", "{}+{}@{}".format(sender, identifier,
domain))
message.add_header(
"Subject",
"".join(
"[{}]".format(t)
for t in [codec.get_human_id(item),
codec.get_external_id(item)] if t) + " " +
codec.get_subject(item),
)
context = codec.get_context(item)
plain = codec.render_template(codec.get_text_template(item), context)
message.set_content(plain)
message.add_alternative(
json.dumps(context).encode("utf-8"), "application", "json")
message.add_alternative(
codec.render_template(
codec.get_html_template(item),
{
"markup": codec.text_to_html(plain),
"context": context
},
),
"html",
)
for file_ in codec.get_attachments(item) or []:
filename = os.path.basename(file_.name)
maintype, subtype = mimetypes.guess_type(filename)[0].split("/", 1)
content = file_.read()
if maintype == "text":
charset = "utf-8"
try:
content = content.decode(charset)
except UnicodeDecodeError:
charset = chardet.detect(content).get("encoding")
try:
content = content.decode(charset)
except UnicodeDecodeError:
maintype, subtype = "application", "octet-stream"
if maintype == "text":
message.add_attachment(content,
maintype,
charset=charset,
filename=filename)
else:
message.add_attachment(content,
maintype,
subtype,
filename=filename)
return message
import email.message, email.utils, email.policy, sys
from pprint import pprint
import socket
info = socket.getaddrinfo('www.google.com', 'telnet', 0, socket.SOCK_STREAM, 0,
socket.AI_PASSIVE)
pprint(info)
respons = str(info)
message = email.message.EmailMessage(email.policy.SMTP)
message['To'] = "*****@*****.**"
message['From'] = 'Test message <*****@*****.**>'
message['Subject'] = 'this is test using python'
message['Date'] = email.utils.formatdate(localtime=True)
message['message-id'] = email.utils.make_msgid()
message.set_content(respons)
sys.stdout.buffer.write(message.as_bytes())
