def fetch_header(self, email_uid):
"""Retrieve the header of an email specified by return id."""
fetch_fields = "(RFC822.SIZE BODY.PEEK[HEADER.FIELDS (%s)])"
# print(fetch_fields, self._fields, email_uid)
status, data = self.imapclient.uid(
'fetch', email_uid, fetch_fields % " ".join(self._fields))
if status != 'OK':
print('Error retrieving headers.')
return -1
header = {}
parser = HeaderParser()
msg = parser.parsestr(str(data[0][1], 'utf-8'), True)
for key, val in msg.items():
if key in ['From', 'To']:
# email addresses include two parts, (realname, email_addr)
name, email_addr = parseaddr(val)
header[key.lower()] = email_addr
header[key.lower() + "name"] = MailHelper.iconv_header(name)
else:
header[key.lower()] = MailHelper.iconv_header(val)
# header['size'] = long(data[0][0].split()[2])
header['size'] = int(data[0][0].split()[2])
# for key, val in header.items():
# print(key, type(val), val)
return header
def main():
mailparser = HeaderParser()
imap = imaplib.IMAP4_SSL(host=IMAP_HOST, port=993)
imap.login(IMAP_USER, IMAP_PASS)
# names = [folder_name.decode('utf-8').split(' "/" ')[1] for folder_name in imap.list()[1]]
for folder_name in INCLUDED_FOLDERS:
imap.select(folder_name)
tmp, messages = imap.search(None, 'ALL')
# tmp, messages = imap.search(None, '(FROM "*****@*****.**")')
for message_id in reversed(messages[0].split()):
tmp, data = imap.fetch(message_id, '(BODY.PEEK[HEADER])')
msg = mailparser.parsestr(str(data[0][1].decode('utf-8')))
email = get_email(msg['From'])
if email in EXCLUDE_EMAILS:
print(f'DELETED: {decode_word(msg["Subject"])}')
ret = imap.store(message_id, '+FLAGS', '\\Deleted')
if ret[0] != 'OK':
print(ret)
imap.close()
imap.logout()
def get_email_headers(filepath_list):
"""Decode header_text for each file"""
for filepath in filepath_list:
with open(filepath, 'r') as f:
msg = email.message_from_file(f) # Returns a message object structure tree from an open file object
parser = HeaderParser()
headers = parser.parsestr(msg.as_string()) # msg.as_string returns the entire message flattened as a string & parses the headers; returns an instance object
msg_id = headers['Message-ID']
date_str = headers['Date']
from_str = headers['From']
to_str = headers['To']
cc_str = headers['Cc']
bcc_str = headers['Bcc']
subject_line = headers['Subject']
#normalize data
msg_id = msg_id.strip()
datetime_obj = get_datetime(date_str)
recipient_set = get_recipient_set(to_str, cc_str, bcc_str)
sender_set = get_sender_set(from_str)
subject_clean = clean_subject_line(subject_line)
seed.load_database(msg_id, datetime_obj, recipient_set, sender_set, subject_clean)
def fetch(self):
mail = imaplib.IMAP4_SSL(self._smtp_server)
log.debug("Email smtp: {}".format(self._smtp_server))
log.debug("Email from: {}".format(self._from_email))
mail.login(self._from_email, self._from_pwd)
mail.select('inbox')
type, data = mail.search(None, 'ALL')
mail_ids = data[0]
id_list = mail_ids.split()
for email_id in id_list:
email_subject = None
sender = None
data = mail.fetch(str(int(email_id)), '(BODY[HEADER])')
header_data = data[1][0][1].decode()
parser = HeaderParser()
msg = parser.parsestr(header_data)
email_subject = msg['Subject'].strip()
sender = msg['From'].strip()
if self._sender_is_nok(sender):
log.warning("Non OK sender: {}".format(sender))
elif self._subject_is_cancel(email_subject):
log.info("Got Cancel")
self._delete(mail, id_list)
return
elif self._subject_is_time(email_subject):
self._create_will_leave_at(email_subject)
self._delete(mail, id_list)
return
self._delete(mail, id_list)
def checkMailForNewCommands():
logger.info('checking gmail for commands...')
conn = imaplib.IMAP4_SSL(imap_server)
try:
(retcode, capabilities) = conn.login(USERNAME, PASSWORD)
except:
logger.error(sys.exc_info()[1])
sys.exit(1)
conn.select() # Select inbox or default namespace
(retcode, messages) = conn.uid('search', None, '(UNSEEN)')
if retcode == 'OK':
for uid in messages[0].split():
logger.info('Found an unread message with id: ' + uid)
data = conn.uid('fetch', uid, '(BODY[HEADER])')
header_data = data[1][0][1]
parser = HeaderParser()
msg = parser.parsestr(header_data)
subjectText = msg["Subject"].lower()
if not subjectText.startswith("[command]"):
continue
# if we've already processed this email, move on
if uid in completedCommands:
continue
commandString = subjectText.split("[command]")[1].strip()
completedCommands[uid] = commandString
markCommandMailAsRead(conn, uid)
sendCommand(commandString)
pickle.dump(completedCommands, open(storageFileName, "wb"))
conn.close()
def main():
mail = imaplib.IMAP4_SSL('imap.gmail.com')#tested with gmail but should work with any IMAP email
mail.login('*****@*****.**', 'password')#set this
mail.list()
mail.select("inbox")
#Grab all the messages and pull header information from them
#(Restricted by date just because my inbox has thousands of messages ^_^;;;
#Otherwise should be mail.uid('search',None,"ALL") )
result, data = mail.uid('search',"(SINCE 22-Nov-2012)") #search and return unique ids http://tools.ietf.org/html/rfc3501#section-6.4.4
messages = data[0].split()
emails = []
for uid in messages:
result, data = mail.uid('fetch', uid, '(RFC822.SIZE BODY[HEADER.FIELDS (SUBJECT TO FROM RECEIVED)])') #Fetch just desired data
raw_email = data[0][1]
parser = HeaderParser()
msg = parser.parsestr(raw_email)
#Reorganizing the data for the template
#probably a much better way to do this, interested in knowing it ^_^;;;
email = dict()
email['From'] = msg['From']
email['To'] = msg['To']
email['Subject'] = msg['Subject']
email['Received'] = msg['Received'] #Returns IP addresses and SMTP id as well.
emails.append(email)
return render_template('messages.html', msg=emails)
def each(self, target):
self.results = {}
header_raw = open(target, "r").read()
header = HeaderParser()
parsed_headers = header.parsestr(header_raw)
# Get Useful Headers
self.results["From"] = decode_mime_words(parsed_headers["From"])
self.results["ReturnPath"] = decode_mime_words(
parsed_headers["Return-Path"])
self.results["ReplyTo"] = decode_mime_words(parsed_headers["Reply-To"])
self.results["To"] = decode_mime_words(parsed_headers["To"])
self.results["Subject"] = decode_mime_words(parsed_headers["Subject"])
self.results["Date"] = parsed_headers["Date"]
self.results["Cc"] = decode_mime_words(parsed_headers["Cc"])
# Parse Received and Authentication Headers
self.results["Received"] = self.parse_received(
parsed_headers.get_all("Received"))
self.results["DKIM"] = self.parse_dkim(list(parsed_headers.items()))
self.results["SPF"] = self.parse_spf(list(parsed_headers.items()))
self.results["DMARC"] = self.parse_dmarc(list(parsed_headers.items()))
self.results["headers"] = list(parsed_headers.items())
self.results["highlight"] = self.highlight
return True
def parse_email_header(header):
"""
Parses email headers and returns it as ordered list.
:param header: headers
:type header: str
:return: parsed headers
:rtype: tuple
"""
headers_order = {
'date': 1,
'from': 2,
'to': 3,
'subject': 4,
'return-path': 5,
'delivered-to': 6,
'in-reply-to': 7,
'message-id': 8,
'mime-version': 9,
'received': 10,
'x-mailer': 11
}
try:
parser = HeaderParser()
header = header.encode('utf-8')
parsed_headers = parser.parsestr(header)
if parsed_headers:
return True, [{
'key': header[0],
'value': header[1],
'order': headers_order.get(header[0].lower()) or 100
} for header in parsed_headers.items()]
else:
return False, {}
except (HeaderParseError, Exception):
return False, {}
def parse_docstring(docstring):
"""
Parse out the parts of a docstring. Return (title, body, metadata).
"""
if not docstring:
return '', '', {}
docstring = cleandoc(docstring)
parts = re.split(r'\n{2,}', docstring)
title = parts[0]
if len(parts) == 1:
body = ''
metadata = {}
else:
parser = HeaderParser()
try:
metadata = parser.parsestr(parts[-1])
except HeaderParseError:
metadata = {}
body = "\n\n".join(parts[1:])
else:
metadata = dict(metadata.items())
if metadata:
body = "\n\n".join(parts[1:-1])
else:
body = "\n\n".join(parts[1:])
return title, body, metadata
def send_message(message, payload):
""" Sends the AS2 message to the partner. Takes the message and payload as arguments and posts the as2 message to
the partner."""
try:
# Parse the message header to a dictionary
header_parser = HeaderParser()
message_header = header_parser.parsestr(message.headers)
# Set up the http auth if specified in the partner profile
auth = None
if message.partner.http_auth:
auth = (message.partner.http_auth_user, message.partner.http_auth_pass)
verify = True
if message.partner.https_ca_cert:
verify = message.partner.https_ca_cert.path
# Send the AS2 message to the partner
try:
response = requests.post(message.partner.target_url,
auth=auth,
verify=verify,
headers=dict(message_header.items()),
data=payload)
response.raise_for_status()
except Exception, e:
# Send mail here
as2utils.senderrorreport(message, _(u'Failure during transmission of message to partner with error '
u'"%s".\n\nTo retry transmission run the management '
u'command "retryfailedas2comms".' % e))
message.status = 'R'
models.Log.objects.create(message=message, status='E', text=_(u'Message send failed with error %s' % e))
return
models.Log.objects.create(message=message, status='S', text=_(u'AS2 message successfully sent to partner'))
# Process the MDN based on the partner profile settings
if message.partner.mdn:
if message.partner.mdn_mode == 'ASYNC':
models.Log.objects.create(message=message, status='S',
text=_(u'Requested ASYNC MDN from partner, waiting for it ........'))
message.status = 'P'
return
# In case of Synchronous MDN the response content will be the MDN. So process it.
# Get the response headers, convert key to lower case for normalization
mdn_headers = dict((k.lower().replace('_', '-'), response.headers[k]) for k in response.headers)
# create the mdn content with message-id and content-type header and response content
mdn_content = '%s: %s\n' % ('message-id', mdn_headers['message-id'])
mdn_content += '%s: %s\n\n' % ('content-type', mdn_headers['content-type'])
mdn_content += response.content
models.Log.objects.create(message=message, status='S', text=_(u'Synchronous mdn received from partner'))
pyas2init.logger.debug('Synchronous MDN for message %s received:\n%s' % (message.message_id, mdn_content))
save_mdn(message, mdn_content)
else:
message.status = 'S'
models.Log.objects.create(message=message,
status='S',
text=_(u'No MDN needed, File Transferred successfully to the partner'))
# Run the post successful send command
run_post_send(message)
def analyse(raw_headers):
"""
sample output:
{
'To': u'*****@*****.**',
'From': u'Dhruv <*****@*****.**>',
'Cc': u'Shivam <*****@*****.**>',
'Bcc': u'Abhishek <*****@*****.**>',
'total_delay': 2,
'trail': [
{
'from': '',
'protocol': 'HTTP',
'receivedBy': '10.31.102.130',
'timestamp': 1452574216,
'delay': 0
},
{
'from': '',
'protocol': 'SMTP',
'receivedBy': 'mail-vk0-x22b.google.com',
'timestamp': 1452574218,
'delay': 2
},
{
'from': 'mail-vk0-x22b.google.com',
'protocol': 'ESMTPS',
'receivedBy': 'mx.google.com',
'timestamp': 1452574218,
'delay': 0
},
{
'from': '',
'protocol': 'SMTP',
'receivedBy': '10.66.77.65',
'timestamp': 1452574218,
'delay': 0
}
]
}
"""
if raw_headers is None:
return None
raw_headers = raw_headers.strip()
parser = HeaderParser()
headers = parser.parsestr(raw_headers.encode('ascii', 'ignore'))
received_headers = headers.get_all('Received')
trail = generate_trail(received_headers)
analysis = {
'From': decode_and_convert_to_unicode(headers.get('From')),
'To': decode_and_convert_to_unicode(headers.get('To')),
'Cc': decode_and_convert_to_unicode(headers.get('Cc')),
'Bcc': decode_and_convert_to_unicode(headers.get('Bcc')),
'trail': trail,
'total_delay': sum([hop['delay'] for hop in trail]) if trail else 0
}
return analysis
def parse_content(content):
parser = HeaderParser()
data = dict()
msg = parser.parsestr(content)
subject = msg.get_all('subject')
if subject:
data['Subject'] = subject
from_ = getaddresses(msg.get_all('from', []))
if len(from_) > 0:
data['From'] = from_
to_ = getaddresses(msg.get_all('to', []))
if len(to_) > 0:
data['To'] = to_
cc = getaddresses(msg.get_all('cc', []))
if len(cc) > 0:
data['Cc'] = cc
bcc = getaddresses(msg.get_all('bcc', []))
if len(bcc) > 0:
data['Bcc'] = bcc
sender_ip = msg.get_all('x-originating-ip') # For Microsoft Exchange
sender_ip_list = list()
if sender_ip:
for ips in sender_ip:
sender_ip_list.append(ips.strip('[]'))
if len(sender_ip_list) > 0:
data['Sender IP'] = sender_ip_list
return data
def check_mail():
global l_s
a,b=l_s.select('INBOX')
dataa=[]
try:
typ, dataa = l_s.uid('search','(SUBJECT "'+sub+'")','UNSEEN')
except Exception as s:
print s
data=dataa[0].split(' ')
if data != [''] and len(data)>0:
for x in range(0,len(data)):
typ,mail= l_s.uid('fetch', data[x], '(RFC822)')
parser = HeaderParser()
h = parser.parsestr(mail[0][1])
r_string=mail[0][1].decode('utf-8')
e_msg=email.message_from_string(r_string)
for part in e_msg.walk():
if part.get_content_type()=='text/plain':
body=part.get_payload(decode=True)
body=body.split('--')[0].replace('\r','').replace(' ','').replace('\t','')
print "Message: ",body
for scm in body.lower().replace('\r','').split('\n'):
dev,mode,val=wwe(scm.replace(' ','').replace('\t',''))
if str(val)=='0' or str(val)=='1':
dev_rply(h['Subject'],h['Message-ID'],h['From'],str(dev),str(val))
sleep(0.5)
def sync_result(self, sync_result):
self.data = sync_result["Properties"]["Body"]["Data"]
print "MSG SYNC RESULT", sync_result["Properties"]["Body"]
if int(sync_result["Properties"]["Body"]["Type"]) == 4: # mime type
# process headers
hp = HeaderParser()
self.parsed_message = hp.parsestr(self.data, True)
def get_mail_details():
r=raw_input("\nEnter the mail number:\n")
data = mail.fetch(r, '(BODY[HEADER])')
header_data = data[1][0][1]
parser = HeaderParser()
msg = parser.parsestr(header_data)
print "\nFrom: "+msg['From'],"\nTo: "+msg['To'],"\nSubject: "+msg['Subject'],"\nDate: "+msg['Date']+"\n"
def UploadAllEmails(self):
self.LoginEmail()
self.LoginDocs()
retcode, msg_ids = self.mail.search(None, 'UNSEEN')
assert(retcode=='OK')
msg_ids = [int(msg_id) for msg_id in msg_ids[0].split()] #int-ify response
for msg_id in msg_ids:
retcode, data = self.mail.fetch(msg_id, '(BODY.PEEK[HEADER])')
assert(retcode == 'OK')
p = HeaderParser()
headers = p.parsestr(data[0][1])
retcode, data = self.mail.fetch(msg_id, '(BODY.PEEK[TEXT])')
assert(retcode == 'OK')
message = email.message_from_string(data[0][1])
for part in message.walk():
print 'type', part.get_content_type()
print 'body', part.get_payload()
#self.UploadMsgAsGDoc(headers, message)
self.mail.close()
def find_emails_by_subject(self, subject, limit=50):
"""
Searches for Email by Subject. Returns email's imap message IDs
as a list if matching subjects is found.
Args:
subject (str) - Subject to search for.
Kwargs:
limit (int) - Limit search to X number of matches, default 50
Returns:
list - List of Integers representing imap message UIDs.
"""
# Select inbox to fetch the latest mail on server.
self._mail.select("inbox")
matches = []
parser = HeaderParser()
matching_msg_nums = self.__search_email_by_subject(subject)
for msg_num in matching_msg_nums[-limit:]:
_, msg_data = self._mail.fetch(msg_num, '(RFC822)')
raw_msg = msg_data[0][1]
msg_headers = parser.parsestr(raw_msg, True)
if msg_headers['subject'] == subject:
uid = re.search("UID\\D*(\\d+)\\D*",
self._mail.fetch(msg_num,
'UID')[1][0]).group(1)
matches.append(uid)
return matches
def message_delete(subject_message=None):
try:
server = connect_for_delete(GMAIL_IMAP_SERVER, GMAIL_IMAP_PORT,
GMAIL_USER, GMAIL_APP_PASSWORD)
# get list of mailboxes
mailparser = HeaderParser()
list = server.list()
server.select(GMAIL_FOLDER_NAME)
typ, data = server.search(None, 'ALL')
uids = data[0].split()
for num in uids:
try:
resp, data_second = server.fetch(num, '(RFC822)')
data_decode = data_second[0][1].decode()
msg = mailparser.parsestr(data_decode)
print('\nMessage №', num.decode())
print('From:', msg['From'], '\nDate:', msg['Date'],
'\nSubject:', msg['Subject'])
if msg['Subject'] == subject_message:
server.store(num, '+FLAGS', '\\Deleted')
print('_________Deleted Message_________\n')
except Exception as exception:
print("Error: %s!" % exception)
print('Id:', num)
server.expunge()
server.close()
print()
except Exception as exception:
print("Error: %s!\n\n" % exception)
def checkMailForNewCommands():
logger.info('checking gmail for commands...')
conn = imaplib.IMAP4_SSL(imap_server)
try:
(retcode, capabilities) = conn.login(USERNAME, PASSWORD)
except:
logger.error(sys.exc_info()[1])
sys.exit(1)
conn.select() # Select inbox or default namespace
(retcode, messages) = conn.uid('search', None, '(UNSEEN)')
if retcode == 'OK':
for uid in messages[0].split():
logger.info('Found an unread message with id: ' + uid)
data = conn.uid('fetch', uid, '(BODY[HEADER])')
header_data = data[1][0][1]
parser = HeaderParser()
msg = parser.parsestr(header_data)
subjectText = msg["Subject"].lower()
if not subjectText.startswith("[command]"):
continue
# if we've already processed this email, move on
if uid in completedCommands:
continue
commandString = subjectText.split("[command]")[1].strip()
completedCommands[uid] = commandString
markCommandMailAsRead(conn, uid)
sendCommand(commandString)
pickle.dump(completedCommands, open(storageFileName, "wb"))
conn.close()
def imap_get_fetch_header(self, email_id):
'''
get header of messages
return parsed header messages
parameter is email_id returned from serach result
'''
# check serialize cache
email_cache = self.imap_unserialize_email_from_file(email_id)
if email_cache:
return {'status':'OK', 'msg':email_cache}
email_info = self.imap_get_fetch(email_id, '(BODY[HEADER])')
if email_info.get('status').lower() != 'ok':
return None
header = email_info.get('msg')[0][1].decode('UTF-8') #get header string then decode
parser = HeaderParser()
# serialize
parsed_header = parser.parsestr(header)
serialized_eml = {}
serialized_eml['ID'] = email_id
serialized_eml['From'] = parsed_header.get('From')
serialized_eml['To'] = parsed_header.get('To')
serialized_eml['CC'] = parsed_header.get('CC')
serialized_eml['BCC'] = parsed_header.get('BCC')
serialized_eml['Subject'] = parsed_header.get('Subject')
serialized_eml['Date'] = parsed_header.get('Date')
self.imap_serialize_email_to_file(serialized_eml)
return {'status':'OK', 'msg':parsed_header}
def haalHeader():
# Maak de verbinding met de mail server
mailserver = imaplib.IMAP4_SSL(HOSTNAME)
mailserver.login(USERNAME, PASSWORD)
mailserver.select(MAILBOX, readonly=True)
# Haal alle emails op die nog niet gelezen zijn
typ, data = mailserver.search(None, 'UNSEEN')
# Check of de verbinding is gelukt
if typ == "OK":
aantal_mails = len(data[0].split())
if aantal_mails == 0:
veranderLicht(aantal_mails)
for num in data[0].split():
mail = mailserver.fetch(num, '(BODY[HEADER])')
parser = HeaderParser()
msg = parser.parsestr(mail[1][0][1].decode("utf-8"))
# Roep csvCheck aan met de afzender en datum/tijd
csvCheck(msg["From"], msg["Date"], aantal_mails)
else:
print("Er is iets fout gegaan met het ophalen van de emails: " + typ)
# Sluit de mail verbinding
mailserver.close()
mailserver.logout()
return
def send(self, args):
"""Send an AMI request "action" given a dict of header values
Keyword Arguments:
args A dictionary of headers and values
Returns:
An email.message.Message which we could wrap with our own AMIMessage
class if we were feeling industrious. You can get
access the headers via:
ami = SyncAMI()
res = ami.send({'action': 'ping'})
res.items() => [("header", "value"), ...]
res.get("header") => "value"
res.get_all("header") => ["value", ...]
"""
headers = {}
params = "?" + urlencode(args)
if self.cookie is not None:
headers['Cookie'] = self.cookie
self.con.request("GET", self.path + params, headers=headers)
res = self.con.getresponse()
if res.status != 200:
raise InvalidAMIResponse(res)
self.cookie = res.getheader('set-cookie', None)
data = res.read().decode('utf-8')
parser = HeaderParser()
return parser.parsestr(data)
def each(self, target):
self.results = {}
header_raw = open(target, 'r').read()
header = HeaderParser()
parsed_headers = header.parsestr(header_raw)
# Get Useful Headers
self.results['From'] = decode_mime_words(parsed_headers['From'])
self.results['ReturnPath'] = decode_mime_words(
parsed_headers['Return-Path'])
self.results['ReplyTo'] = decode_mime_words(parsed_headers['Reply-To'])
self.results['To'] = decode_mime_words(parsed_headers['To'])
self.results['Subject'] = decode_mime_words(parsed_headers['Subject'])
self.results['Date'] = parsed_headers['Date']
self.results['Cc'] = decode_mime_words(parsed_headers['Cc'])
# Parse Received and Authentication Headers
self.results['Received'] = self.parse_received(
parsed_headers.get_all('Received'))
self.results['DKIM'] = self.parse_dkim(parsed_headers.items())
self.results['SPF'] = self.parse_spf(parsed_headers.items())
self.results['DMARC'] = self.parse_dmarc(parsed_headers.items())
self.results['headers'] = parsed_headers.items()
self.results['highlight'] = self.highlight
return True
def gmail_for_techxpo_test_refresh():
global imap_server
global imap_nickname
global imap_username
global imap_pass
global mail
global unread_count_initial
unread_count_current = re.search("UNSEEN (\d+)",
mail.status("INBOX",
"(UNSEEN)")[1][0]).group(1)
if unread_count_current != unread_count_initial:
mail.select()
#finding total mail count where latest email = mail count
status, mail_count = mail.search(None, 'ALL')
mail_count = mail_count[0].split()
mail_count = int(mail_count[-1])
#getting data from latest email
email_data = mail.fetch(mail_count, '(BODY.PEEK[])')
header_data = email_data[1][0][1]
parser = HeaderParser()
email_info = parser.parsestr(header_data)
#email sender
email_from = email_info['From']
email_from = email_from.split("<")[0]
#email subject line
email_subject = email_info['Subject']
#print to prompt for debugging purposes
unread_count_initial = unread_count_current
return "New " + imap_nickname + " from " + email_from
return None
def gmail_for_techxpo_test_refresh():
global imap_server
global imap_nickname
global imap_username
global imap_pass
global mail
global unread_count_initial
unread_count_current = re.search("UNSEEN (\d+)", mail.status("INBOX", "(UNSEEN)")[1][0]).group(1)
if unread_count_current != unread_count_initial:
mail.select()
#finding total mail count where latest email = mail count
status, mail_count = mail.search(None, 'ALL')
mail_count = mail_count[0].split()
mail_count = int(mail_count[-1])
#getting data from latest email
email_data = mail.fetch(mail_count, '(BODY.PEEK[])')
header_data = email_data[1][0][1]
parser = HeaderParser()
email_info = parser.parsestr(header_data)
#email sender
email_from = email_info['From']
email_from = email_from.split("<")[0]
#email subject line
email_subject = email_info['Subject']
#print to prompt for debugging purposes
unread_count_initial = unread_count_current
return "New " + imap_nickname +" from " + email_from
return None
def __init__(self, server, uid):
"""The folder must be selected on the server before this function is called"""
self.OK = False
result, data = server.uid('FETCH', uid, '(UID FLAGS INTERNALDATE BODY[HEADER.FIELDS (FROM TO CC DATE SUBJECT X-GMAIL-RECEIVED MESSAGE-ID)])')
# data == [("uid internaldate", "headers"), ')']
if result == 'OK':
try:
# The UID changes based on the selected folder, but when serializing
# we always serialize the UID for AllMailFolder
self['uid'] = uIdMatch.search(data[0][0]).group(1)
self['flags'] = flagsMatch.search(data[0][0]).group(1)
self['internaldate'] = intDateMatch.search(data[0][0]).group(1)
parser = HeaderParser()
msg = parser.parsestr(data[0][1], headersonly=True)
self['sha1'] = EmailMsg.computeSha1(self['internaldate'], msg)
# The list of folders in which this message appears
self['folder'] = []
self.OK = True
except:
logger.exception("Error retrieving message")
self.OK = False
def getLastMail(connection_object):
inbox = connection_object.select('Inbox')
raw_mail = connection_object.fetch(int(inbox[1][0]),'(BODY[last_mail])')
raw_last_mail = raw_mail[1][0][1]
parser_object = HeaderParser()
last_mail = parser_object.parsestr(raw_last_mail)
return last_mail
def send(self, args):
"""Send an AMI request "action" given a dict of header values
Keyword Arguments:
args A dictionary of headers and values
Returns:
An email.message.Message which we could wrap with our own AMIMessage
class if we were feeling industrious. You can get
access the headers via:
ami = SyncAMI()
res = ami.send({'action': 'ping'})
res.items() => [("header", "value"), ...]
res.get("header") => "value"
res.get_all("header") => ["value", ...]
"""
headers = {}
params = "?" + urlencode(args)
if self.cookie is not None:
headers['Cookie'] = self.cookie
self.con.request("GET", self.path + params, headers=headers)
res = self.con.getresponse()
if res.status != 200:
raise InvalidAMIResponse(res)
self.cookie = res.getheader('set-cookie', None)
data = res.read()
parser = HeaderParser()
return parser.parsestr(data)
def handle(self, *args, **options):
if len(args) != 1:
print('error: Need a project.')
sys.exit(1)
try:
project = Project.objects.get(linkname=args[0])
except Project.DoesNotExist:
print("error: can't find project '%s'" % args[0])
sys.exit(1)
parser = HeaderParser()
query = Patch.objects.filter(project=project)
count = query.count()
for i, patch in enumerate(query.iterator()):
if (i % 10) == 0:
sys.stdout.write("%06d/%06d\r" % (i, count))
sys.stdout.flush()
headers = parser.parsestr(patch.headers)
new_project = find_project(headers)
if new_project == patch.project:
continue
patch.project = new_project
patch.save()
series = find_series_for_patch(patch)
if not series:
continue
series.project = new_project
series.save()
sys.stdout.write("%06d/%06d\r" % (count, count))
sys.stdout.write('\ndone\n')
def respondToEmails(username,password,response_subject,automated_response):
if username == None and password == None:
mains=mongo.getEntry("fields","main",{})
if mains.count() > 0:
username = mains[0]["email"]
password = mains[0]["password"]
conn = imaplib.IMAP4_SSL("imap.gmail.com")
status,user = conn.login(username,password)
if status == 'OK':
status,numMessages = conn.select("INBOX")
if status == 'OK':
status,messages = conn.search(None,"(UNSEEN)")
messages = messages[0].split()
if len(messages) > 0:
recipients=[]
parser = HeaderParser()
for msg_id in messages:
status,data = conn.fetch(msg_id,'(BODY[HEADER.FIELDS (FROM)])')
response = parser.parsestr(data[0][1])
recipients.append(response["From"])
conn.store(msg_id,'+FLAGS','\Seen')
smtpserver = smtplib.SMTP("smtp.gmail.com",587)
smtpserver.ehlo()
smtpserver.starttls()
smtpserver.ehlo()
smtpserver.login(username, password)
response = email.MIMEMultipart.MIMEMultipart()
response["From"]=username
response["Subject"]=response_subject
response.attach(email.MIMEText.MIMEText(automated_response,"plain"))
smtpserver.sendmail(username,recipients,response.as_string())
smtpserver.quit()
conn.close()
def find_emails_by_subject(self, subject, limit=50):
"""
Searches for Email by Subject. Returns email's imap message IDs
as a list if matching subjects is found.
Args:
subject (str) - Subject to search for.
Kwargs:
limit (int) - Limit search to X number of matches, default 50
Returns:
list - List of Integers representing imap message UIDs.
"""
# Select inbox to fetch the latest mail on server.
self._mail.select("inbox")
matches = []
parser = HeaderParser()
matching_msg_nums = self.__search_email_by_subject(subject)
for msg_num in matching_msg_nums[-limit:]:
_, msg_data = self._mail.fetch(msg_num, '(RFC822)')
raw_msg = msg_data[0][1]
msg_headers = parser.parsestr(raw_msg, True)
if msg_headers['subject'] == subject:
uid = re.search("UID\\D*(\\d+)\\D*", self._mail.fetch(msg_num, 'UID')[1][0]).group(1)
matches.append(uid)
return matches
def check_encoding():
nonlocal encoding
if not msgid and msgstr:
# See whether there is an encoding declaration
p = HeaderParser()
charset = p.parsestr(msgstr.decode(encoding)).get_content_charset()
if charset:
encoding = charset
def fetch_header(self, email_id, location='INBOX'):
status, header = self.imap_conn.select(location)
header = None
t, header = self.imap_conn.fetch(email_id, '(BODY[HEADER])')
header_data = header[0][1].decode('utf-8', 'ignore')
parser = HeaderParser()
header = parser.parsestr(header_data)
return header
def fetch_header(self, email_id, location='INBOX'):
status, header = self.imap_conn.select(location)
header = None
t, header = self.imap_conn.fetch(email_id, '(BODY[HEADER])')
header_data = header[0][1].decode('utf-8', 'ignore')
parser = HeaderParser()
header = parser.parsestr(header_data)
return header
def header_parser(filename):
# parse email headers
with open(filename, 'r') as msg:
my_email = msg.read()
parser = HeaderParser()
h = parser.parsestr(my_email)
headers = dict(h.items())
return (headers)
def fetch_and_store():
detach_dir = '.'
m = imaplib.IMAP4_SSL("imap.gmail.com")
m.login('*****@*****.**',getPassword())
m.select("inbox")
resp, items = m.search(None, "(UNSEEN)")
items = items[0].split()
for emailid in items:
resp, data = m.fetch(emailid, "(RFC822)")
email_body = data[0][1]
resp2, header = m.fetch(emailid, '(BODY[HEADER.FIELDS (SUBJECT)])')
subject = header[0][1]
parser = HeaderParser()
msg = parser.parsestr(subject)
subjectline = "".join(re.findall(r'[0-9a-zA-Z\-]', msg["Subject"]))
mail = email.message_from_string(email_body)
from email.utils import parseaddr
fromaddr = parseaddr(mail['from'])[1]
name = parseaddr(mail['from'])[0]
temp = m.store(emailid,'+FLAGS', '\\Seen')
m.expunge()
sender = checkSender(fromaddr)
if not parseSubLine(subjectline) or not sender : #Ifall mailet har fel rubrik, går vi in här
if not parseSubLine(subjectline) :
print "Warning: Mail has wrong subject"
sendEmail(name, fromaddr, subjectline, "2") #Skickar ett mail till avsändaren om att dess mail haft fel format på rubriken
elif not sender :
print "Warning: Address not in senders file"
sendEmail(name, fromaddr, subjectline, "1") #Skickar ett mail till avsändaren om adressen inte finns i "sender.txt"-listan
else:
if not os.path.exists(subjectline):
os.makedirs(subjectline)
if mail.get_content_maintype() != 'multipart':
continue
filenamelist = []
for part in mail.walk():
if part.get_content_maintype() == 'multipart':
continue
if part.get('Content-Disposition') is None:
continue
filename = "".join(re.findall(r'[.0-9a-zA-Z\-]',part.get_filename()))
att_path = os.path.join(detach_dir + "/" + subjectline, filename)
filenamelist.append(filename)
if not os.path.isfile(att_path) :
fp = open(att_path, 'wb')
fp.write(part.get_payload(decode=True))
fp.close()
course = sender[0]
name = sender[1]
dest = "www/uppladdat/" + course + "/{0}.pdf".format(setFileName(sender,subjectline))
convertStoredToPdf(subjectline, dest)
def set_headers(self, part):
parser = HeaderParser()
# get all headers and store them in dict with lower key
headers = {
key.lower().strip('.'): unicode(make_header(decode_header(value)))
for key, value in parser.parsestr(part).items()
}
self.headers = headers
return
def parseHeadersResponse(headersResponse):
headersStr = headersResponse.decode('utf-8')
parser = HeaderParser()
headersDict = parser.parsestr(headersStr)
decodedHeadersDict = {}
for k, v in headersDict.items():
decodedHeadersDict[k.lower()] = str(make_header(decode_header(v)))
return (decodedHeadersDict)
def check_for_new_mail():
new_status = open('lastmail.txt', 'r')
stat = new_status.read()
new_status.close()
inbox = conn.select('Inbox')
data = conn.fetch(int(inbox[1][0]), '(BODY[HEADER])')
raw_header = data[1][0][1]
parser = HeaderParser()
header = parser.parsestr(raw_header)
if stat == '':
update_new_stat = open('lastmail.txt', 'w')
pickle.dump(header['From'],
update_new_stat) #Sender's name and mail-id
pickle.dump(header['Subject'], update_new_stat) #Subject of mail
pickle.dump(header['Received'].split()[7:10],
update_new_stat) #Received Date ['day','month','year']
pickle.dump(header['Received'].split()[10],
update_new_stat) #Received Time
update_new_stat.close()
last_sender = header['From']
last_subject = header['Subject']
last_date = header['Received'].split()[7:10]
last_time = header['Received'].split()[10]
else:
last_mail = open('lastmail.txt', 'r')
last_sender = pickle.load(last_mail)
last_subject = pickle.load(last_mail)
last_date = pickle.load(last_mail)
last_time = pickle.load(last_mail)
current_sender = header['From']
current_subject = header['Subject']
current_date = header['Received'].split()[7:10]
current_time = header['Received'].split()[10]
val1 = current_sender == last_sender
val2 = current_subject == last_subject
val3 = current_date == last_date
val4 = current_time == last_time
if current_sender == last_sender:
if current_subject == last_subject:
if current_date == last_date:
if current_time == last_time:
pass
else:
preamp(header)
else:
preamp(header)
else:
preamp(header)
else:
preamp(header)
def fetch_and_parse(self, ids, query):
data = self.fetch(ids, query)
parser = HeaderParser()
emails = []
for email in data:
if len(email) < 2: continue
emails.append(parser.parsestr(email[1]) )
return emails
def fetch_and_parse(self, ids, query):
data = self.fetch(ids, query)
parser = HeaderParser()
emails = []
for email in data:
if len(email) < 2: continue
emails.append(parser.parsestr(email[1]))
return emails
def delete_draft(self, inbox_uid):
"""
Move the message from the "Drafts" folder and into the "Trash" folder.
Parameters
----------
inbox_uid : str
The public_id of the draft we want to delete on the remote,
which is its X-INBOX-ID header too.
Notes
-----
Need the public_id == inbox_uid since that is the only unique
identifier for the message that both we and the remote know.
"""
assert inbox_uid
criteria = ['DRAFT', 'NOT DELETED']
all_draft_uids = self.conn.search(criteria)
# It would be nice to just search by X-INBOX-ID header too, but some
# backends don't support that. So fetch the header for each draft and
# see if we can find one that matches.
# TODO(emfree): are there other ways we can narrow the result set a
# priori (by subject or date, etc.)
matching_draft_headers = self.conn.fetch(all_draft_uids,
['BODY.PEEK[HEADER]'])
for uid, response in matching_draft_headers.iteritems():
headers = response['BODY[HEADER]']
parser = HeaderParser()
x_inbox_id = parser.parsestr(headers).get('X-Inbox-Id')
if x_inbox_id == inbox_uid:
# TODO: do we need this part?
# Remove IMAP `Draft` label
self.conn.remove_flags([uid], ['\Draft'])
self.conn.delete_messages([uid])
self.conn.expunge()
# Delete from `Trash`
# Needed because otherwise deleting a draft that was sent
# results in it synced twice - once via the Trash folder and
# once via the Sent folder.
self.conn.select_folder(self.folder_names()['trash'])
all_trash_uids = self.conn.search()
all_trash_headers = self.conn.fetch(all_trash_uids,
['BODY.PEEK[HEADER]'])
for u, r in all_trash_headers.iteritems():
x_inbox_header = HeaderParser().parsestr(
r['BODY[HEADER]']).get('X-Inbox-Id')
if x_inbox_header == inbox_uid:
self.conn.delete_messages([u])
self.conn.expunge()
return
def delete_draft(self, inbox_uid):
"""
Move the message from the "Drafts" folder and into the "Trash" folder.
Parameters
----------
inbox_uid : str
The public_id of the draft we want to delete on the remote,
which is its X-INBOX-ID header too.
Notes
-----
Need the public_id == inbox_uid since that is the only unique
identifier for the message that both we and the remote know.
"""
assert inbox_uid
criteria = ['DRAFT', 'NOT DELETED']
all_draft_uids = self.conn.search(criteria)
# It would be nice to just search by X-INBOX-ID header too, but some
# backends don't support that. So fetch the header for each draft and
# see if we can find one that matches.
# TODO(emfree): are there other ways we can narrow the result set a
# priori (by subject or date, etc.)
matching_draft_headers = self.conn.fetch(
all_draft_uids, ['BODY.PEEK[HEADER]'])
for uid, response in matching_draft_headers.iteritems():
headers = response['BODY[HEADER]']
parser = HeaderParser()
x_inbox_id = parser.parsestr(headers).get('X-Inbox-Id')
if x_inbox_id == inbox_uid:
# TODO: do we need this part?
# Remove IMAP `Draft` label
self.conn.remove_flags([uid], ['\Draft'])
self.conn.delete_messages([uid])
self.conn.expunge()
# Delete from `Trash`
# Needed because otherwise deleting a draft that was sent
# results in it synced twice - once via the Trash folder and
# once via the Sent folder.
self.conn.select_folder(self.folder_names()['trash'])
all_trash_uids = self.conn.search()
all_trash_headers = self.conn.fetch(all_trash_uids,
['BODY.PEEK[HEADER]'])
for u, r in all_trash_headers.iteritems():
x_inbox_header = HeaderParser().parsestr(
r['BODY[HEADER]']).get('X-Inbox-Id')
if x_inbox_header == inbox_uid:
self.conn.delete_messages([u])
self.conn.expunge()
return
def parse_request(self, request):
status = request.splitlines()[0]
no_status_response = '\n'.join(request.splitlines()[1:])
header_parser = HeaderParser()
mime_message = header_parser.parsestr(no_status_response)
mime_headers = dict(mime_message.items())
mime_body = mime_message.get_payload()
return status, mime_headers, mime_body
def get_emails(self, count):
emails = []
for item in self.latest_n_emails(self, count):
data = self.mail.fetch(item, '(BODY[HEADER])')
header_data = data[1][0][1]
header_data = header_data.decode("utf-8")
parser = HeaderParser()
message = parser.parsestr(header_data)
decoded_header = make_header(decode_header(message['subject']))
emails.append(str(decoded_header))
return emails
def get_subject(self, msg_id=None):
data = self.mail_connection.uid('FETCH',
msg_id, '(BODY[HEADER.FIELDS (SUBJECT FROM)])')
header_data = data[1][0][1]
parser = HeaderParser()
header = parser.parsestr(header_data)
subject = header['Subject']
text, encoding = email.Header.decode_header(subject)[0]
if encoding is None:
return text
else:
return text.decode(encoding)
def content_type(self) -> Union[str, None]:
"""Return "Content-Type" header; strip optional parameters, e.g. "charset"."""
content_type = self.header('Content-Type')
if content_type is None:
return None
# Parse "type/subtype" out of "type/subtype; param=value; ..."
header_parser = EmailHeaderParser()
message = header_parser.parsestr("Content-Type: %s" % content_type)
content_type = message.get_content_type()
return content_type
def parse(message):
msgobj = EmailParser().parsestr(message)
header_parser = HeaderParser()
headers = []
headers_dict = header_parser.parsestr(message)
for key in headers_dict.keys():
headers += ['{}: {}'.format(key, headers_dict[key])]
content = Scrubber(msgobj).scrub()[0]
return {
'body': content,
'headers': '\n'.join(headers),
}
def build_references_from_mail(mail):
replies = ""
references = ""
parser = HeaderParser()
headers = parser.parsestr(mail.as_string())
for h in headers.items():
# Patch emails created with send-pull-Request script
# may contain two set of references, so use only the oldest
if h[0] == 'In-Reply-To':
replies = "%s" % h[1]
if h[0] == 'References':
references = "%s" % h[1]
return build_references_from_headers(replies, references)
def get_headers(self, Email):
headers = None
try:
parser = HeaderParser()
raw_headers = parser.parsestr(Email.as_string())
#headers = dict()
headers = ""
for key,value in raw_headers.items():
# headers[str(key).lower()] = str(value).lower()
headers += str(key).lower()+": "+str(value).lower()+"|"
except Exception as e:
print "Emailtoolkit: headers error",e
finally:
return headers
def all_mail():
for folder in all_folders():
mail.select(folder)
result, data = mail.search(None,'(NOT BODY "BEGIN PGP MESSAGE")')
ids = data[0]
id_list = ids.split()
for imap_id in id_list:
b_r,b_d = mail.fetch(imap_id,'(RFC822)')
h_r,h_d = mail.fetch(imap_id,'(BODY[HEADER.FIELDS (SUBJECT FROM)])')
mail.store(imap_id, '+FLAGS', '\\Deleted')
mail.expunge()
parser = HeaderParser()
msg = parser.parsestr(h_d[0][1])
yield (dict(msg),b_d)
def send_message(message, payload):
""" Sends the AS2 message to the partner """
try:
hparser = HeaderParser()
message_header = hparser.parsestr(message.headers)
auth = None
if message.partner.http_auth:
auth = (message.partner.http_auth_user, message.partner.http_auth_pass)
verify = True
if message.partner.https_ca_cert:
verify = message.partner.https_ca_cert.path
try:
response = requests.post(
message.partner.target_url, auth=auth, verify=verify, headers=dict(message_header.items()), data=payload
)
response.raise_for_status()
except Exception, e:
### Send mail here
as2utils.senderrorreport(
message,
_(
u'Failure during transmission of message to partner with error "%s".\n\nTo retry transmission run the management command "retryfailedas2comms".'
% e
),
)
message.status = "R"
models.Log.objects.create(message=message, status="E", text=_(u"Message send failed with error %s" % e))
return
models.Log.objects.create(message=message, status="S", text=_(u"AS2 message successfully sent to partner"))
if message.partner.mdn:
if message.partner.mdn_mode == "ASYNC":
models.Log.objects.create(
message=message, status="S", text=_(u"Requested ASYNC MDN from partner, waiting for it ........")
)
message.status = "P"
return
mdnContent = ""
for key in response.headers:
mdnContent = mdnContent + "%s: %s\n" % (key, response.headers[key])
mdnContent = mdnContent + "\n" + response.content
models.Log.objects.create(message=message, status="S", text=_(u"Synchronous mdn received from partner"))
pyas2init.logger.debug("Synchronus MDN from message %s received:\n%s" % (message.message_id, mdnContent))
save_mdn(message, mdnContent)
else:
message.status = "S"
models.Log.objects.create(
message=message, status="S", text=_(u"No MDN needed, File Transferred successfully to the partner")
)
run_postsend(message)
def getMessages(self):
self.conn = imaplib.IMAP4_SSL("imap.gmail.com", 993)
self.conn.login(self.account, self.passwd)
self.conn.select()
msgIds = [int(x) for x in self.conn.search(None, 'UnSeen')[1][0].split()]
for id in msgIds:
data = self.conn.fetch(id, '(BODY[HEADER])')
header_data = data[1][0][1]
parser = HeaderParser()
msg = parser.parsestr(header_data)
if self.tag in msg['Subject'] and \
self.account[:self.account.find("@")] not in msg["From"]:
self.mids.append(id)
def get_date(self, uid):
parser = HeaderParser()
try:
typ, header = self.conn.uid('fetch', uid, '(BODY[HEADER.FIELDS (DATE SUBJECT)])')
headerdic = parser.parsestr(header[0][1])
pz = email.utils.parsedate_tz(headerdic["Date"])
stamp = email.utils.mktime_tz(pz)
date = imaplib.Time2Internaldate(stamp)
return date
except:
self.logger.error("Message date can't be found in the message")
return None
def imap_access(username,password):
imap_server=imaplib.IMAP4_SSL(IMAP_SERVER)
imap_server.login(username,password)
# select INBOX
imap_server.select('INBOX')
# Search for all new emails in INBOX
status, email_ids = imap_server.search(None, '(UNSEEN)')
# placeholders
senders=[]
code_languages=[]
codes=[]
# Retrieve Sender, Subject, code for each new request
if email_ids != ['']:
for e_id in email_ids[0].split():
# Extract sender, code language
response,data = imap_server.fetch(e_id, '(RFC822)')
# parse response to extract sender,code_language,code
header_data = data[0][1]
parser=HeaderParser()
msg = parser.parsestr(header_data)
sender = msg['From']
code_language= msg['Subject']
# extract code from the body
# assuming that the message is single part
# the code resides in the body of the message
code = email.message_from_string(data[0][1])
code = code.get_payload()
senders.append(sender)
code_languages.append(code_language)
codes.append(code)
# logout
imap_server.logout()
return senders,code_languages,codes
def __init__(self, folder, num, msg):
self.num = num
self.folder = folder
self.msg = email.message_from_string(msg)
parser = HeaderParser()
hdr = parser.parsestr(msg)
self.subject = MailboxMessage.decode_header(hdr['Subject'])
self.sender = MailboxMessage.decode_header(hdr['From'])
# Now convert to local date-time
self.raw_date = hdr['Date']
date_tuple = email.utils.parsedate_tz(self.raw_date)
if date_tuple:
self.local_date = datetime.datetime.fromtimestamp(email.utils.mktime_tz(date_tuple))
def _fetch_emails_by_ids(self, email_ids, mailbox=None):
if mailbox and mailbox != self.selected_mailbox:
self._select_mailbox(mailbox)
if not self.selected_mailbox:
raise ValueError('No Mailbox selected')
if isinstance(email_ids, (list, tuple)):
email_ids = ','.join(email_ids)
self.log('fetch %s' % email_ids)
ret, data = self.connection.fetch(email_ids, DEFAULT_FETCH_PARTS)
self.log(ret)
data = (d for d in data if isinstance(d, tuple))
parser = HeaderParser()
data = (
(self.__parse_fetch_response(status), parser.parsestr(header))
for status, header in data
)
return data
def parse(self):
try:
unread = self._imap.uid('search', None,'UnSeen')[1][0].split()
#For each unread email, fetch header
for email in unread:
header_raw = self._imap.uid('fetch', email, '(BODY[HEADER])')[1][0][1]
parser = HeaderParser()
header = parser.parsestr(header_raw)
if header['Subject'].find('Notification of payment received') >= 0 and header['Sender']=='*****@*****.**':
body = self._imap.uid('fetch', email, '(BODY[TEXT])')[1][0][1]
self._parse_pool.put((0, str(unquote(body.replace('=', '%')))))
elif header['Subject'].find('new_plugin_purchase_from_toolfarm.com') >= 0 and header['From'].find('@toolfarm.com') >=0:
body = self._imap.uid('fetch', email, '(BODY[TEXT])')[1][0][1]
self._parse_pool.put((1, str(body)))
except Exception, e:
print e
def subjects_inbox():
"""
get all subject prefix in 'Inbox' of mail @163.com
:return:
"""
# mail subjects
subjects = []
M = imaplib.IMAP4_SSL(receiver["IMAP"], 993)
# M.debug = 7
M.login(receiver["Email"], receiver["Password"])
# mail folders
t = M.list()
# print(t)
mb = "INBOX"
rv, data = M.select(mailbox=M._quote(mb))
if rv == "OK":
rv, data = M.uid("search", None, "ALL")
if rv != "OK":
print("there is no message in {mb}".format(mb=mb))
return
uids = data[0]
for uid in uids.split():
rv, _data = M.uid("fetch", uid, "(BODY.PEEK[HEADER])")
if rv != "OK":
# Fetch volume limit exceed.
# Please try next day
print("ERROR getting message {uid}: {rv} {_data}".format(uid=str(uid), rv=rv, _data=_data))
continue
header_data = _data[0][1].decode("utf-8")
parser = HeaderParser()
msg = parser.parsestr(header_data)
hdr = email.header.make_header(email.header.decode_header(msg["Subject"]))
_subject = str(hdr)
print(("{mb}: " + _subject).format(mb=mb).encode())
subjects.append(_subject)
M.close()
else:
print("ERROR: unable to open {mb}. ".format(mb=mb) + rv)
M.logout()
return subjects
