Merge commit '6d1f731ff76e21de2ab3c328bad52b6fea435dd5' as 'utils_v2'
This commit is contained in:
@@ -0,0 +1,443 @@
|
||||
"""
|
||||
|
||||
AUTHOR:
|
||||
|
||||
Khushal P Soonderji
|
||||
|
||||
DATE:
|
||||
|
||||
Tuesday, 16th Jul, 2024
|
||||
|
||||
OBJECTIVE:
|
||||
|
||||
To be able to send out mails from code.
|
||||
|
||||
REFERENCES:
|
||||
|
||||
N/A
|
||||
|
||||
DOWNLOADS:
|
||||
|
||||
N/A
|
||||
|
||||
"""
|
||||
|
||||
|
||||
# *****************************************************************************************************************
|
||||
# ***** ****
|
||||
# *** IMPORT ***
|
||||
# ***** ****
|
||||
# *****************************************************************************************************************
|
||||
|
||||
|
||||
# To make sibling directories accessible for imports:
|
||||
import sys
|
||||
sys.path.append(".")
|
||||
sys.path.append("..")
|
||||
|
||||
# For working with mails:
|
||||
import aiosmtplib
|
||||
from email.mime.multipart import MIMEMultipart
|
||||
from email.mime.image import MIMEImage
|
||||
from email.mime.text import MIMEText
|
||||
from email.mime.base import MIMEBase
|
||||
from email import encoders
|
||||
|
||||
# For random strings:
|
||||
import string
|
||||
import random
|
||||
|
||||
# For system-level activities:
|
||||
import os
|
||||
|
||||
# For working with files in RAM:
|
||||
import io
|
||||
|
||||
# For debugging:
|
||||
from icecream import IceCreamDebugger
|
||||
|
||||
# To work with datatypes:
|
||||
from typing import List
|
||||
|
||||
|
||||
# *****************************************************************************************************************
|
||||
# ***** ****
|
||||
# *** MACROS / ONE-TIME INIT ***
|
||||
# ***** ****
|
||||
# *****************************************************************************************************************
|
||||
|
||||
|
||||
# --- Nothing Yet
|
||||
|
||||
|
||||
# *****************************************************************************************************************
|
||||
# ***** ****
|
||||
# *** VARIABLES ***
|
||||
# ***** ****
|
||||
# *****************************************************************************************************************
|
||||
|
||||
|
||||
# --- Nothing Yet
|
||||
|
||||
|
||||
# *****************************************************************************************************************
|
||||
# ***** ****
|
||||
# *** FUNCTIONS ***
|
||||
# ***** ****
|
||||
# *****************************************************************************************************************
|
||||
|
||||
|
||||
# --- Nothing Yet
|
||||
|
||||
|
||||
# *****************************************************************************************************************
|
||||
# ***** ****
|
||||
# *** CLASSES ***
|
||||
# ***** ****
|
||||
# *****************************************************************************************************************
|
||||
|
||||
|
||||
class SMTPMessage:
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
to_email: str,
|
||||
subject: str,
|
||||
cc_emails: List[str] = None,
|
||||
bcc_emails: List[str] = None
|
||||
):
|
||||
|
||||
"""
|
||||
Create an instance of the message that you would like to send.
|
||||
:param to_email: The EMail ID of th recipient.
|
||||
:param subject: The subject of the mail.
|
||||
:param cc_emails: A list of recipients to add to the CC section.
|
||||
:param bcc_emails: A list of recipients to add to the BCC section.
|
||||
"""
|
||||
|
||||
self.message = MIMEMultipart()
|
||||
self.message["To"] = to_email
|
||||
self.message["Subject"] = subject
|
||||
if cc_emails: self.message["CC"] = ",".join(cc_emails)
|
||||
if bcc_emails: self.message["BCC"] = ",".join(bcc_emails)
|
||||
|
||||
def add_text(self, text):
|
||||
|
||||
"""
|
||||
Add plain-text to the mail body.
|
||||
:param text: The text to add to the mail body.
|
||||
:return: None.
|
||||
"""
|
||||
|
||||
self.message.attach(MIMEText(text, "plain"))
|
||||
|
||||
def add_html(self, html_text):
|
||||
|
||||
"""
|
||||
Add HTML text to the mail body.
|
||||
:param html_text: The HTML text to add to the mail body.
|
||||
:return: None.
|
||||
"""
|
||||
|
||||
self.message.attach(MIMEText(html_text, "html"))
|
||||
|
||||
def add_inline_image(self, image_file, content_id = None):
|
||||
|
||||
"""
|
||||
Add an inline image to the body of the mail.
|
||||
NOTE: This is NOT the same as sending an image as an attachment.
|
||||
:param image_file: The image data to attach to the mail body.
|
||||
:param content_id: Inline images are inserted via HTML bocks. This field identifies the image resource. If not
|
||||
specified, I will generate a random string. You may write a custom value here if you know what you are
|
||||
doing. For most use cases, please ignore this field.
|
||||
:return: None.
|
||||
"""
|
||||
|
||||
# Read the image as bytes:
|
||||
image_bytes = None
|
||||
if type(image_file) is str:
|
||||
with open(image_file, "rb") as opened_image_file:
|
||||
image_bytes = opened_image_file.read()
|
||||
if type(image_file) is io.BytesIO:
|
||||
image_file.seek(0)
|
||||
image_bytes = image_file.getvalue()
|
||||
|
||||
# Declare the part to be attached to the multipart message:
|
||||
if image_bytes is not None:
|
||||
|
||||
# Create the HTML block if the image pointer is blank:
|
||||
if content_id is None:
|
||||
content_id = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(8))
|
||||
self.add_html(f"""
|
||||
<html>
|
||||
<body>
|
||||
<p><img src="cid:{content_id}"></p>
|
||||
</body>
|
||||
</html>
|
||||
""")
|
||||
|
||||
# Then add the image:
|
||||
image_part = MIMEImage(image_bytes)
|
||||
image_part.add_header("Content-ID", f"<{content_id}>")
|
||||
self.message.attach(image_part)
|
||||
|
||||
def add_attachment(self, attachment_file, file_name = None):
|
||||
|
||||
# Declare the part to be attached to the multipart message:
|
||||
part = MIMEBase("application", "octet-stream")
|
||||
|
||||
# If the attachment is a file stored in the local disk:
|
||||
if isinstance(attachment_file, str):
|
||||
file_name = file_name or os.path.split(attachment_file)[-1]
|
||||
with open(attachment_file, "rb") as attachment:
|
||||
part.set_payload(attachment.read())
|
||||
|
||||
# If the file is held in RAM:
|
||||
elif isinstance(attachment_file, io.BytesIO):
|
||||
attachment_file.seek(0)
|
||||
part.set_payload(attachment_file.read())
|
||||
|
||||
# Encode and attach the file:
|
||||
encoders.encode_base64(part)
|
||||
part.add_header(
|
||||
"Content-Disposition",
|
||||
f"attachment; filename= {file_name}",
|
||||
)
|
||||
self.message.attach(part)
|
||||
|
||||
def get_message(self):
|
||||
return self.message
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
class AsyncSMTPClient:
|
||||
|
||||
# Constants:
|
||||
SMTP_TLS_PORT = 587
|
||||
SMTP_SSL_PORT = 465
|
||||
|
||||
# variables:
|
||||
__smtp = None
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
email,
|
||||
password,
|
||||
server,
|
||||
port = 587,
|
||||
rate_limiters = None,
|
||||
wait_for_turn = True,
|
||||
debug = True,
|
||||
debug_prefix = "Mail (C) | "
|
||||
):
|
||||
|
||||
"""
|
||||
Set up the mail client.
|
||||
:param email: The Email ID to use when sending out mails.
|
||||
:param password: The password of the EMail ID that is being used.
|
||||
:param server: The EMail server.
|
||||
:param port: The port number to connect to the host.
|
||||
:param rate_limiters: The rate limiters to use. Must have "get_turn" and "has_turn" methods. "get_turn" method
|
||||
must wait for the turn, and "has_turn" method must only check if a turn is available.
|
||||
:param wait_for_turn: To wait for turn if the rate limit has been exceeded, or to return with failure.
|
||||
:param debug: Whether, or not, you want to print debugging messages.
|
||||
:param debug_prefix: The prefix to identify the debugging messages.
|
||||
"""
|
||||
|
||||
# Initialize the debugger:
|
||||
self.__printer = IceCreamDebugger(prefix = debug_prefix, includeContext = True)
|
||||
if not debug: self.__printer.disable()
|
||||
|
||||
# Note down the credentials and other details:
|
||||
self.__email = email
|
||||
self.__password = password
|
||||
self.__server = server
|
||||
self.__port = port
|
||||
self.__rate_limiters = rate_limiters if type(rate_limiters) is list else ([rate_limiters] if rate_limiters is not None else [])
|
||||
self.__wait_for_turn = wait_for_turn
|
||||
|
||||
def enable_debug(self):
|
||||
self.__printer.enable()
|
||||
|
||||
def disable_debug(self):
|
||||
self.__printer.disable()
|
||||
|
||||
async def login(self):
|
||||
|
||||
"""
|
||||
To connect to the mail server and authenticate the user.
|
||||
:return: True if authenticated, else False.
|
||||
"""
|
||||
|
||||
# Initialize the SMTP connection,
|
||||
# and return with success if all goes well:
|
||||
try:
|
||||
self.__smtp = aiosmtplib.SMTP(
|
||||
hostname = self.__server,
|
||||
port = self.__port,
|
||||
use_tls = False,
|
||||
start_tls = False
|
||||
)
|
||||
await self.__smtp.connect()
|
||||
await self.__smtp.starttls()
|
||||
await self.__smtp.login(self.__email, self.__password)
|
||||
return True
|
||||
|
||||
# Return with failure if something goes wrong:
|
||||
except Exception as exception:
|
||||
self.__printer(exception)
|
||||
try: await self.__smtp.quit()
|
||||
except Exception as exception: self.__printer(exception)
|
||||
self.__smtp = None
|
||||
return False
|
||||
|
||||
async def ensure_connection(self):
|
||||
|
||||
"""
|
||||
Can be run before the sending operation to confirm that we are yet connected to the server.
|
||||
If not connected, this code will reattempt to connect and log-in.
|
||||
:return: True if connected, else False.
|
||||
"""
|
||||
|
||||
# If the login had failed initially, the object will be set to null.
|
||||
# In such a case, we make an attempt to login:
|
||||
if self.__smtp is None:
|
||||
return await self.login()
|
||||
|
||||
# If the login was successful, we check if the connection is active.
|
||||
# If not, we try to re-login:
|
||||
if self.__smtp.is_connected:
|
||||
return True
|
||||
else:
|
||||
try:
|
||||
await self.__smtp.connect()
|
||||
await self.__smtp.starttls()
|
||||
await self.__smtp.login(self.__email, self.__password)
|
||||
return True
|
||||
except Exception as exception:
|
||||
self.__printer(exception)
|
||||
try: await self.__smtp.quit()
|
||||
except Exception as exception: self.__printer(exception)
|
||||
self.__smtp = None
|
||||
return False
|
||||
|
||||
async def logout(self):
|
||||
|
||||
"""
|
||||
Closes the connection to the SMTP client.
|
||||
:return: True by default.
|
||||
"""
|
||||
|
||||
if self.__smtp is not None:
|
||||
try: await self.__smtp.quit()
|
||||
except Exception as exception: self.__printer(exception)
|
||||
self.__smtp = None
|
||||
return True
|
||||
|
||||
async def send(self, mail: SMTPMessage):
|
||||
|
||||
"""
|
||||
Send out the mail.
|
||||
:param mail: The instance of 'MailMessage' with all the content populated.
|
||||
:return: A dict with 'success' and 'message'.
|
||||
"""
|
||||
|
||||
# Return with failure if we aren't connected,
|
||||
# and our attempt to (re)connect fails:
|
||||
if not await self.ensure_connection():
|
||||
return {
|
||||
"success": False,
|
||||
"message": "login failed"
|
||||
}
|
||||
|
||||
# Comply with the rate-limit:
|
||||
for rate_limiter in self.__rate_limiters:
|
||||
if not self.__wait_for_turn:
|
||||
if not await rate_limiter.has_turn(): return False
|
||||
got_turn = await rate_limiter.get_turn()
|
||||
if not got_turn:
|
||||
return {
|
||||
"success": False,
|
||||
"message": "rate-limit wait timeout"
|
||||
}
|
||||
|
||||
# Try to send the message:
|
||||
try:
|
||||
mail.message["From"] = self.__email
|
||||
response = await self.__smtp.send_message(mail.message)
|
||||
return {
|
||||
"success": True,
|
||||
"message": f"mail accepted - {response[-1]}"
|
||||
}
|
||||
|
||||
# If something goes wrong:
|
||||
except Exception as exception:
|
||||
self.__printer(exception)
|
||||
return {
|
||||
"success": False,
|
||||
"message": str(exception)
|
||||
}
|
||||
|
||||
|
||||
# *****************************************************************************************************************
|
||||
# ***** ****
|
||||
# *** MAIN PROGRAM ***
|
||||
# ***** ****
|
||||
# *****************************************************************************************************************
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
import asyncio
|
||||
from utils_v2.string import json
|
||||
|
||||
async def test():
|
||||
|
||||
mail_client = AsyncSMTPClient(
|
||||
email = "sender@gmail.com",
|
||||
password = "zcaf nmqy ncfz fave",
|
||||
server = "smtp.gmail.com",
|
||||
rate_limiters = None
|
||||
)
|
||||
|
||||
my_mail = SMTPMessage(
|
||||
to_email = "orangebhopli@gmail.coms",
|
||||
subject = "Bhopli is the best!",
|
||||
cc_emails = None,
|
||||
bcc_emails = None
|
||||
)
|
||||
my_mail.add_html(
|
||||
"""
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<title>Sample HTML String</title>
|
||||
<style>
|
||||
.heading {
|
||||
color: #ff9025;
|
||||
}
|
||||
.sub-heading {
|
||||
color: #000000;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<h1 class="heading">Hello, Bhopli!</h1>
|
||||
<h2 class="sub-heading">Bhopli is the best, most well-behaved cat in the known universe.</h2>
|
||||
</body>
|
||||
</html>
|
||||
"""
|
||||
)
|
||||
my_mail.add_text("This is how you should pet her 👇")
|
||||
my_mail.add_inline_image(r"/path/to/image/cat_petting.png")
|
||||
my_mail.add_attachment(r"/path/to/file/sample_label.pdf")
|
||||
|
||||
await mail_client.login()
|
||||
result = await mail_client.send(my_mail)
|
||||
print("MAIL RESULT:", json.to_string(result))
|
||||
await mail_client.logout()
|
||||
|
||||
asyncio.run(test())
|
||||
@@ -0,0 +1,266 @@
|
||||
"""
|
||||
|
||||
AUTHOR:
|
||||
|
||||
Khushal P Soonderji
|
||||
|
||||
DATE:
|
||||
|
||||
Tuesday, 10th Dec., 2024
|
||||
|
||||
OBJECTIVE:
|
||||
|
||||
To parse raw mail bodies and give a structure that is suitable for storing in No-SQL databases like MongoDB. The
|
||||
raw mail's text is expected to be compliant with standard defined in RFC 5322, RFC 2045, and maybe a few more.
|
||||
|
||||
REFERENCES:
|
||||
|
||||
1. GitHub: https://github.com/SpamScope/mail-parser
|
||||
2. RFC 5322: https://datatracker.ietf.org/doc/html/rfc5322
|
||||
3. RFC 2045: https://datatracker.ietf.org/doc/html/rfc2045
|
||||
4. StackOverflow: https://stackoverflow.com/questions/17874360/python-how-to-parse-the-body-from-a-raw-email-given-that-raw-email-does-not
|
||||
|
||||
DOWNLOADS:
|
||||
|
||||
N/A
|
||||
|
||||
"""
|
||||
|
||||
|
||||
# *****************************************************************************************************************
|
||||
# ***** ****
|
||||
# *** IMPORT ***
|
||||
# ***** ****
|
||||
# *****************************************************************************************************************
|
||||
|
||||
|
||||
# To make sibling directories accessible for imports:
|
||||
import sys
|
||||
sys.path.append(".")
|
||||
sys.path.append("..")
|
||||
|
||||
# System-level activities:
|
||||
import io
|
||||
|
||||
# My utils:
|
||||
from utils_v2.string import json
|
||||
from utils_v2.string import regex
|
||||
from utils_v2.date_time import date_time
|
||||
|
||||
# To work with mails:
|
||||
import email
|
||||
from email.message import Message
|
||||
from email.utils import parsedate_tz
|
||||
from email.utils import parseaddr
|
||||
|
||||
# To parse the HTML content in the mail:
|
||||
from bs4 import BeautifulSoup
|
||||
|
||||
# To work with datatypes:
|
||||
from typing import Any, Dict, List, Literal
|
||||
|
||||
# To work with various encodings:
|
||||
import base64
|
||||
import quopri
|
||||
|
||||
# To work with date and time:
|
||||
import datetime
|
||||
import pytz
|
||||
import time
|
||||
|
||||
|
||||
# *****************************************************************************************************************
|
||||
# ***** ****
|
||||
# *** MACROS / ONE-TIME INIT ***
|
||||
# ***** ****
|
||||
# *****************************************************************************************************************
|
||||
|
||||
|
||||
# --- Nothing Yet
|
||||
|
||||
|
||||
# *****************************************************************************************************************
|
||||
# ***** ****
|
||||
# *** VARIABLES ***
|
||||
# ***** ****
|
||||
# *****************************************************************************************************************
|
||||
|
||||
|
||||
# --- Nothing Yet
|
||||
|
||||
|
||||
# *****************************************************************************************************************
|
||||
# ***** ****
|
||||
# *** FUNCTIONS ***
|
||||
# ***** ****
|
||||
# *****************************************************************************************************************
|
||||
|
||||
|
||||
def parse_addr(addr_header: str) -> List[Dict[str, str]]:
|
||||
|
||||
# If the field is null, we return null:
|
||||
if addr_header is None: return []
|
||||
|
||||
# Create an empty variable that will hold the results:
|
||||
addrs = []
|
||||
|
||||
# Iterate through the addresses and parse them:
|
||||
for a in addr_header.split(","):
|
||||
n, e = parseaddr(a.strip())
|
||||
addrs.append({
|
||||
"name": n.strip() or e.strip(),
|
||||
"email": e.strip()
|
||||
})
|
||||
|
||||
# Done here:
|
||||
return addrs
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
def parse_date(date_header: str) -> datetime.datetime | None:
|
||||
|
||||
# Try to parse the date header:
|
||||
date_tuple = parsedate_tz(date_header)
|
||||
|
||||
# If the date header was parsed successfully, we assemble
|
||||
# the parts to get an aware object in UTC timezone:
|
||||
if date_tuple:
|
||||
dt = datetime.datetime(*date_tuple[:6], tzinfo = pytz.FixedOffset(int(date_tuple[-1] / 60)))
|
||||
dt = date_time.to_timezone(dt, date_time.TIMEZONE_UTC)
|
||||
return dt
|
||||
|
||||
# In case of an invalid date header:
|
||||
else: return None
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
def decode_payload(
|
||||
raw_payload: str | bytes,
|
||||
content_main_type: str,
|
||||
content_charset: str | None,
|
||||
content_transfer_encoding: Literal[None, "base64", "quoted-printable"]
|
||||
) -> str | bytes:
|
||||
|
||||
# Start by assuming nothing needs to be done:
|
||||
payload = raw_payload
|
||||
|
||||
# We decode various kinds of parts:
|
||||
match content_transfer_encoding:
|
||||
|
||||
# This is just unencoded plaintext:
|
||||
case None:
|
||||
pass
|
||||
|
||||
# Typically see with attachments:
|
||||
case "base64":
|
||||
charset = content_charset or "utf-8"
|
||||
payload = raw_payload
|
||||
payload = base64.b64decode(payload)
|
||||
if content_main_type == "text": payload = payload.decode(charset)
|
||||
|
||||
# Typically seen with HTML parts:
|
||||
case "quoted-printable":
|
||||
charset = content_charset or "utf-8"
|
||||
payload = raw_payload.encode(charset)
|
||||
payload = quopri.decodestring(payload)
|
||||
if content_main_type == "text": payload = payload.decode(charset)
|
||||
|
||||
# Done here:
|
||||
return payload
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
def parse_part(
|
||||
part: Message | List[Message]
|
||||
) -> Dict[str, Any]:
|
||||
|
||||
# Start by extracting basic details:
|
||||
part_json = {
|
||||
"boundary": part.get_boundary(),
|
||||
"contentType": part.get_content_type(),
|
||||
"contentMainType": part.get_content_maintype(),
|
||||
"contentSubType": part.get_content_subtype(),
|
||||
"contentCharset": part.get_content_charset(),
|
||||
"contentTransferEncoding": part.get("Content-Transfer-Encoding"),
|
||||
"contentDisposition": part.get_content_disposition(),
|
||||
"filename": part.get_filename(),
|
||||
"contentId": part.get("Content-ID")
|
||||
}
|
||||
|
||||
# Process the payload of this part:
|
||||
if part_json["contentMainType"] == "multipart":
|
||||
part_json["payload"] = [parse_part(sub_part) for sub_part in part.get_payload(decode = False)]
|
||||
else:
|
||||
part_json["payload"] = decode_payload(
|
||||
raw_payload = part.get_payload(decode = False),
|
||||
content_main_type = part_json["contentMainType"],
|
||||
content_charset = part_json["contentCharset"],
|
||||
content_transfer_encoding = part_json["contentTransferEncoding"]
|
||||
)
|
||||
|
||||
# Done here;
|
||||
return part_json
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
def parse(raw_mail: str | bytes) -> Dict[str, Any]:
|
||||
|
||||
"""
|
||||
To parse the raw mail text to a usable JSON that can even be stored on a No-SQL database like MongoDB.
|
||||
DOCUMENTATION:
|
||||
1. GitHub: https://github.com/SpamScope/mail-parser
|
||||
2. RFC 5322: https://datatracker.ietf.org/doc/html/rfc5322
|
||||
3. RFC 2045: https://datatracker.ietf.org/doc/html/rfc2045
|
||||
:param raw_mail: The raw mail body that adheres to RFC 5322 and RFC 2045 (among others).
|
||||
:return: The parsed JSON format (dict) of the mail.
|
||||
"""
|
||||
|
||||
# Parse the raw format:
|
||||
if isinstance(raw_mail, str): parsed_mail = email.message_from_string(raw_mail)
|
||||
else: parsed_mail = email.message_from_bytes(raw_mail)
|
||||
|
||||
# Extract the most basic details:
|
||||
mail_json = {
|
||||
"ts": parse_date(parsed_mail["Date"]),
|
||||
"headers": {k: v for k, v in parsed_mail.items()},
|
||||
"from": parse_addr(parsed_mail["From"]),
|
||||
"to": parse_addr(parsed_mail["To"]),
|
||||
"cc": parse_addr(parsed_mail["Cc"]),
|
||||
"bcc": parse_addr(parsed_mail["Bcc"]),
|
||||
"subject": parsed_mail["Subject"],
|
||||
"payload": None
|
||||
}
|
||||
|
||||
# Iterate through each part of the mail for multipart mails:
|
||||
if parsed_mail.is_multipart(): mail_json["payload"] = parse_part(parsed_mail)
|
||||
|
||||
# When the mails are not multipart, just plaintext:
|
||||
else: mail_json["payload"] = parsed_mail.get_payload()
|
||||
|
||||
# Done here:
|
||||
return mail_json
|
||||
|
||||
|
||||
# *****************************************************************************************************************
|
||||
# ***** ****
|
||||
# *** MAIN PROGRAM ***
|
||||
# ***** ****
|
||||
# *****************************************************************************************************************
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
from utils_v2.system import files
|
||||
|
||||
mail_string_raw = files.read_file(r"/home/developer/Downloads/raw_mail_test.txt")
|
||||
parse_results = parse(mail_string_raw)
|
||||
|
||||
print(json.to_string(parse_results, default = str))
|
||||
Reference in New Issue
Block a user