def __init__(self, team): MIMEMultipart.__init__(self, "alternative") self.team = team self.initHeaders() self.initText() self.initHTML() self.join()
def __init__(self, subject, textcontent, htmlcontent, sendermail=None, sendername=None, recipients=None, ccrecipients=None): MIMEMultipart.__init__(self, 'related') self['Subject'] = header(subject) self.preamble = 'This is a multi-part message in MIME format.' # Attach alternative text message alternative = MIMEMultipart('alternative') self.attach(alternative) msgtext = MIMEText(textcontent.encode('UTF-8'), 'plain', 'UTF-8') alternative.attach(msgtext) # Attach html message msghtml = MIMEText(htmlcontent.encode('UTF-8'), 'html', 'UTF-8') alternative.attach(msghtml) if sendermail or sendername: self['From'] = addrheader(sendermail, sendername) if recipients: self['To'] = ', '.join( addrheader(addr) for addr in recipients if addr is not None) if ccrecipients: self['Cc'] = ', '.join( addrheader(addr) for addr in ccrecipients if addr is not None)
def __init__(self, message, attachments, gpgbinary='gpg', gnupghome=None, use_agent=True, keyring=None, keyid=None): # Hack around the fact that the Pyton 2.x MIMEMultipart is not # a new-style class. try: unicode # Doesn't exist in Python 3 MIMEMultipart.__init__(self, 'signed') except NameError: super(SignedMessage, self).__init__('signed') payload = self.__payload(message, attachments) signature = self.__signature(payload, gpgbinary, gnupghome, use_agent, keyring, keyid) self.set_param('protocol', 'application/pgp-signature') self.set_param('micalg', 'pgp-sha512') ####!!! GET THIS FROM KEY! self.preamble = 'This is an OpenPGP/MIME signed message.' self.attach(payload) self.attach(signature)
def __init__(self, _data=None, _subtype='encrypted', boundary=None, **_params): """Creates a multipart/encrypted type message. By default, creates a multipart/encrypted message, with proper Content-Type and MIME-Version headers. _subtype is the subtype of the multipart content type, defaulting to `encrypted'. boundary is the multipart boundary string. By default it is calculated as needed. _data is a string containing the raw payload data (encrypted). Additional parameters for the Content-Type header are taken from the keyword arguments (or passed into the _params argument). It will create the Email structure: └┬╴multipart/encrypted ├─╴application/pgp-encrypted └─╴application/octet-stream inline [encrypted.asc] """ _params['protocol'] = "application/pgp-encrypted" description = MIMEApplicationPGPDescription() payload = MIMEApplicationPGPPayload(_data) _subparts = [description, payload] MIMEMultipart.__init__(self, _subtype=_subtype, boundary=boundary, _subparts=_subparts, **_params)
def __init__(self, _data=None, _subtype='mixed', boundary=None, **_params): """Creates a multipart/mixed type message containing application/autocrypt-setup. By default, creates a multipart/mixed message, with proper Content-Type and MIME-Version headers. _subtype is the subtype of the multipart content type, defaulting to `mixed'. boundary is the multipart boundary string. By default it is calculated as needed. _data is a string containing the raw payload data (encrypted). Additional parameters for the Content-Type header are taken from the keyword arguments (or passed into the _params argument). It will create the Email structure: └┬╴multipart/mixed ├─╴text/plain └─╴application/autocrypt-setup attachment [autocrypt-setup-message.html] """ # _params['protocol'] = "?" description = MIMETextACSetupDescription() payload = MIMEApplicationACSetupPayload(_data) payload.add_header("Content-Disposition", 'attachment', filename=AC_CT_SETUP_FN) _subparts = [description, payload] # policy is only introduced in Python3.6 (policy=policy) MIMEMultipart.__init__(self, _subtype, boundary, _subparts, **_params)
def __init__(self): MIMEMultipart.__init__(self) self['To'] = '' self.text = '' self.html = '' self.recipients = [] self.attachments = []
def __init__(self, fingerprint=None, **kwargs): MIMEMultipart.__init__(self, **kwargs) self.fingerprint = fingerprint self.crypto = getgpg() self['From'] = app.config['SMTP_FROM'] self['Date'] = formatdate()
def __init__(self, to_addr, subj, cc_addr=None): MIMEMultipart.__init__(self) self['From'] = '"' + smtp_from_name + '" <' + smtp_from_addr + '>' self['To'] = to_addr if not cc_addr == None: self['Cc'] = cc_addr self['Date'] = formatdate(localtime=True) self['Subject'] = subj
def __init__(self, _subtype='mixed', boundary=None, _subparts=None, encoding=None, **_params): self.encoding = encoding MIMEMultipart.__init__(self, _subtype, boundary, _subparts, **_params)
def __init__(self, _subtype='mixed', boundary=None, _subparts=None, encoding=None, **_params): self.encoding = encoding MIMEMultipart.__init__(self, _subtype, boundary, _subparts, **_params) try: import email.policy # https://docs.python.org/3/library/email.policy.html self.policy = email.policy.default except ImportError: pass
def __init__(self, from_address, to_address, subject, body): MIMEMultipart.__init__(self, 'encrypted', boundary=_boundary, protocol='application/pgp-encrypted') self.from_address = self['From'] = from_address self.to_address = self['To'] = to_address self['Subject'] = subject self.attach(MIMEApplication('Version: 1', 'pgp-encrypted', encode_7or8bit)) encrypted = MIMEApplication(body, 'octet-stream; name="encrypted.asc"', encode_noop) encrypted['Content-Description'] = 'OpenPGP encrypted message' encrypted['Content-Disposition'] = 'inline; filename="encrypted.asc"' self.attach(encrypted)
def __init__(self, from_address, to_address, subject, body, signature): MIMEMultipart.__init__(self, 'signed', micalg='pgp-sha1', boundary=_boundary, protocol='application/pgp-signature') self.from_address = self['From'] = from_address self.to_address = self['To'] = to_address self['Subject'] = subject signed_data = EmptyHeaderMessage(body) self.attach(signed_data) signature = MIMEApplication(signature, 'pgp-signature; name="signature.asc"', encode_7or8bit) signature['Content-Description'] = 'OpenPGP digital signature' signature['Content-Disposition'] = 'attachment; filename="signature.asc"' self.attach(signature)
def from_parts(cls, msg, sig): """Assemble a PGP/MIME signed message from its two parts: the message and the signature, both of which already properly encoded. :param msg: a MIME encoded message :param sig: a PGP/MIME signature """ self = PGPMIMEsigned() MIMEMultipart.__init__(self, 'signed', micalg='pgp-sha1', protocol='application/pgp-signature') self.attach(msg) self.attach(sig) return self
def __init__(self, protocol, micalg, boundary=None, _subparts=None): """ Initialize the multipart/signed message. :param boundary: the multipart boundary string. By default it is calculated as needed. :type boundary: str :param _subparts: a sequence of initial subparts for the payload. It must be an iterable object, such as a list. You can always attach new subparts to the message by using the attach() method. :type _subparts: iterable """ MIMEMultipart.__init__( self, _subtype='signed', boundary=boundary, _subparts=_subparts) self.set_param('protocol', protocol) self.set_param('micalg', micalg)
def __init__(self, protocol, boundary=None, _subparts=None): """ :param protocol: The encryption protocol to be added as a parameter to the Content-Type header. :type protocol: str :param boundary: the multipart boundary string. By default it is calculated as needed. :type boundary: str :param _subparts: a sequence of initial subparts for the payload. It must be an iterable object, such as a list. You can always attach new subparts to the message by using the attach() method. :type _subparts: iterable """ MIMEMultipart.__init__( self, _subtype='encrypted', boundary=boundary, _subparts=_subparts) self.set_param('protocol', protocol)
def __init__(self, to_addrs, subject=None, text_body=None, html_body=None, from_addr=DefaultFrom, cc_addrs=DefaultCc): """Construct an instance. Parameters ---------- to_addrs : array of str An array of string objects, each of which is an email address to which this message should be sent. subject : str The subject of this email message. text_body : str The plain-text version of the email body. html_body : str The HTML version of the email body. from_addr : str The email address from which this message is to be sent. cc_addrs : array of str An array of string objects, each of which is a CC email address to which this message should be sent. """ MIMEMultipart.__init__(self, 'mixed') self['From'] = from_addr logging.debug('Message to be sent from: %s', self['From']) self['To'] = ','.join(to_addrs) logging.debug('Message to be sent to: %s', self['To']) if cc_addrs: self['CC'] = ','.join(cc_addrs) logging.debug('Message to be sent as CC to: %s', self['CC']) if subject: self['Subject'] = subject logging.debug('Message subject: %s', subject) if html_body or text_body: self.attach_text_and_html_bodies(html_body, text_body)
def __init__(self, tweet, to): MIMEMultipart.__init__(self, 'alternative', _charset='utf-8') tweet['html_text'] = Parser().parse(tweet['text']).html self['Subject'] = Header(tweet['text'].encode('utf-8'), 'utf-8') f = Header(tweet['user']['name'].encode('utf-8'), 'utf-8') f.append('<{0}@{1}>'.format(tweet['user']['screen_name'], domain), 'ascii') self['From'] = f self['To'] = to+'@'+domain self['Date'] = tweet['created_at'] self['Message-ID'] = "<{0}@{1}>".format(tweet['id'], domain) self.attach(MIMEText(tweet['text'].encode('utf-8'), 'plain', _charset='utf-8')) with codecs.open('mail.html', 'r', 'utf-8') as f: template = f.read() template = template.format(**tweet) template = template.encode('utf-8') self.attach(MIMEText(template, 'html', _charset='utf-8'))
def __init__(self, message, attachments, gpgbinary='gpg', gnupghome=None, use_agent=True, keyring=None, keyid=None): # Hack around the fact that the Pyton 2.x MIMEMultipart is not # a new-style class. try: unicode # Doesn't exist in Python 3 MIMEMultipart.__init__(self, 'signed') except NameError: super(SignedMessage, self).__init__('signed') payload = self.__payload(message, attachments) signature = self.__signature( payload, gpgbinary, gnupghome, use_agent, keyring, keyid) self.set_param('protocol', 'application/pgp-signature') self.set_param('micalg', 'pgp-sha512') ####!!! GET THIS FROM KEY! self.preamble = 'This is an OpenPGP/MIME signed message.' self.attach(payload) self.attach(signature)
def __init__( self, report_type="message/delivery-status", boundary=None, _subparts=None): """ Initialize the message. As per RFC 6522, boundary and report_type are required parameters. :param report_type: The type of report. This is set as a "Content-Type" parameter, and should match the MIME subtype of the second body part. :type report_type: str """ MIMEMultipart.__init__( self, # set mime type to "multipart/report" _subtype="report", boundary=boundary, _subparts=_subparts, # add "report-type" as a "Content-Type" parameter report_type=report_type) self._report_type = report_type
def __init__(self, msg=None, signer=None): if msg is None: return if msg.is_multipart(): # we need these to get our message correctly parsed by KMail and Thunderbird msg.preamble = 'This is a multi-part message in MIME format.' msg.epilogue = '' if signer is not None: msg_str = flatten(msg) sig = session.gnupg.msg_sign(msg_str, signer.kid) sig = MIMEApplication( _data=sig, _subtype='pgp-signature; name="signature.asc"', _encoder=encode_7or8bit) sig['Content-Description'] = 'This is a digital signature.' sig.set_charset('us-ascii') MIMEMultipart.__init__(self, 'signed', micalg='pgp-sha1', protocol='application/pgp-signature') self.attach(msg) self.attach(sig)
def __init__(self, msg, recipients): MIMEMultipart.__init__(self, 'encrypted', micalg='pgp-sha1', protocol='application/pgp-encrypted') body = flatten(msg) encrypted = session.gnupg.msg_encrypt(body, [r.kid for r in recipients]) payload = MIMEApplication(_data=encrypted, _subtype='octet-stream', _encoder=encode_7or8bit) payload['Content-Disposition'] = 'inline; name="encrypted.asc"' payload.set_charset('us-ascii') control = MIMEApplication(_data='Version: 1\n', _subtype='pgp-encrypted', _encoder=encode_7or8bit) control.set_charset('us-ascii') self.attach(control) self.attach(payload) self['Content-Disposition'] = 'attachment'
def __init__(self, report_type="message/delivery-status", boundary=None, _subparts=None): """ Initialize the message. As per RFC 6522, boundary and report_type are required parameters. :param report_type: The type of report. This is set as a "Content-Type" parameter, and should match the MIME subtype of the second body part. :type report_type: str """ MIMEMultipart.__init__( self, # set mime type to "multipart/report" _subtype="report", boundary=boundary, _subparts=_subparts, # add "report-type" as a "Content-Type" parameter report_type=report_type) self._report_type = report_type
from __future__ import unicode_literals
def __init__(self): MIMEMultipart.__init__(self, _subtype='form-data')
def __init__(self, to_addrs, cyhy_pdf_filename, agency_acronym, financial_year, fy_quarter, tmail_pdf_filename=None, https_pdf_filename=None, from_addr=DefaultFrom, cc_addrs=DefaultCc): """Construct an instance. Parameters ---------- to_addrs : array of str An array of string objects, each of which is an email address to which this message should be sent. cyhy_pdf_filename : str The filename of the PDF file that is the CYHY report corresponding to this message. agency_acronym : str The acronym ised by the agency corresponding to the CYHY report attachment. financial_year : str The two-digit financial year to corresponding to the CYHY report attachment. fy_quarter : str The quarter of the financial year corresponding to the CYHY report attachment. tmail_pdf_filename : str The filename of the PDF file that is the trustymail report corresponding to this message. https_pdf_filename : str The filename of the PDF file that is the https-scan report corresponding to this message. from_addr : str The email address from which this message is to be sent. cc_addrs : array of str An array of string objects, each of which is a CC email address to which this message should be sent. """ MIMEMultipart.__init__(self) self['From'] = from_addr logging.debug('Message to be sent from: %s', self['From']) self['To'] = ','.join(to_addrs) logging.debug('Message to be sent to: %s', self['To']) if cc_addrs: self['CC'] = ','.join(cc_addrs) logging.debug('Message to be sent as CC to: %s', self['CC']) # This is the data mustache will use to render the templates mustache_data = { 'acronym': agency_acronym, 'financial_year': financial_year, 'quarter': fy_quarter } self['Subject'] = pystache.render(CyhyMessage.Subject, mustache_data) logging.debug('Message subject: %s', self['Subject']) text_body = pystache.render(CyhyMessage.TextBody, mustache_data) self.attach(MIMEText(text_body, 'plain')) logging.debug('Message plain-text body: %s', text_body) html_body = pystache.render(CyhyMessage.HtmlBody, mustache_data) html_part = MIMEText(html_body, 'html') html_part.add_header('Content-Disposition', 'inline') self.attach(html_part) logging.debug('Message HTML body: %s', html_body) self.attach_pdf(cyhy_pdf_filename) logging.debug('Message PDF CYHY attachment: %s', cyhy_pdf_filename) if tmail_pdf_filename: self.attach_pdf(tmail_pdf_filename) logging.debug('Message PDF trustymail attachment: %s', tmail_pdf_filename) if https_pdf_filename: self.attach_pdf(https_pdf_filename) logging.debug('Message PDF https-scan attachment: %s', https_pdf_filename)
def __init__(self, subtype, **headers): MIMEMultipart.__init__(self, subtype) for header in headers: dest = header.lstrip('_').replace('_','-') self[dest] = headers[header]