Python quopri.encodestring函数代码示例

def prepare_message(email, recipient, recipients_list):
	message = email.message
	if email.reference_doctype: # is missing the check for unsubscribe message but will not add as there will be no unsubscribe url
		unsubscribe_url = get_unsubcribed_url(email.reference_doctype, email.reference_name, recipient,
		email.unsubscribe_method, email.unsubscribe_params)
		message = message.replace("<!--unsubscribe url-->", quopri.encodestring(unsubscribe_url))

	if email.expose_recipients == "header":
		pass
	else:
		if email.expose_recipients == "footer":
			if isinstance(email.show_as_cc, basestring):
				email.show_as_cc = email.show_as_cc.split(",")
			email_sent_to = [r.recipient for r in recipients_list]
			email_sent_cc = ", ".join([e for e in email_sent_to if e in email.show_as_cc])
			email_sent_to = ", ".join([e for e in email_sent_to if e not in email.show_as_cc])

			if email_sent_cc:
				email_sent_message = _("This email was sent to {0} and copied to {1}").format(email_sent_to,email_sent_cc)
			else:
				email_sent_message = _("This email was sent to {0}").format(email_sent_to)
			message = message.replace("<!--cc message-->", quopri.encodestring(email_sent_message))

		message = message.replace("<!--recipient-->", recipient)
	return message

    def body(self, n):
        if n not in self.cache['body']:
            pid, uid, i, _from = self.coda[n]

            url = "/cp/ps/Mail/commands/LoadMessage?"
            full_url = url + self.params +'&'+ urllib.urlencode( {
              'pid':pid,
              'uid':uid,
              'an':'DefaultMailAccount',
              'fp':'inbox',
            } )
            self.get ( self.baseurl, full_url)

            url = "/cp/MailMessageBody.jsp?"
            full_url = url + urllib.urlencode( {
              'pid' : pid,
              'th'  : self.token_hash,
            } )
            _body = self.filter_message( self.get ( self.baseurl, full_url) )
            _top = self.top(n)
            boundary = self.boundary(_top)
            if boundary:
                _body = "\r\n\r\n\r\n--" + boundary + "\r\nContent-Type: text/html; charset=UTF-8\r\n"+\
                        "Content-Transfer-Encoding: quoted-printable\r\n\r\n" + quopri.encodestring(_body.strip(' \r\n')) + \
                        "\r\n\r\n--" + boundary + "--\r\n"
            else:
                _body = "\r\n\r\n" +  quopri.encodestring( _body.strip(' \r\n') ) + "\r\n\r\n"

            self.cache['body'][n] = _body
        return self.cache['body'][n]

def prepare_message(email, recipient, recipients_list):
	message = email.message
	if not message:
		return ""

	if email.add_unsubscribe_link and email.reference_doctype: # is missing the check for unsubscribe message but will not add as there will be no unsubscribe url
		unsubscribe_url = get_unsubcribed_url(email.reference_doctype, email.reference_name, recipient,
		email.unsubscribe_method, email.unsubscribe_params)
		message = message.replace("<!--unsubscribe url-->", quopri.encodestring(unsubscribe_url.encode()).decode())

	if email.expose_recipients == "header":
		pass
	else:
		if email.expose_recipients == "footer":
			if isinstance(email.show_as_cc, string_types):
				email.show_as_cc = email.show_as_cc.split(",")
			email_sent_to = [r.recipient for r in recipients_list]
			email_sent_cc = ", ".join([e for e in email_sent_to if e in email.show_as_cc])
			email_sent_to = ", ".join([e for e in email_sent_to if e not in email.show_as_cc])

			if email_sent_cc:
				email_sent_message = _("This email was sent to {0} and copied to {1}").format(email_sent_to,email_sent_cc)
			else:
				email_sent_message = _("This email was sent to {0}").format(email_sent_to)
			message = message.replace("<!--cc message-->", quopri.encodestring(email_sent_message.encode()).decode())

		message = message.replace("<!--recipient-->", recipient)

	message = (message and message.encode('utf8')) or ''
	if not email.attachments:
		return message

	# On-demand attachments
	from email.parser import Parser

	msg_obj = Parser().parsestr(message)
	attachments = json.loads(email.attachments)

	for attachment in attachments:
		if attachment.get('fcontent'): continue

		fid = attachment.get("fid")
		if fid:
			fname, fcontent = get_file(fid)
			attachment.update({
				'fname': fname,
				'fcontent': fcontent,
				'parent': msg_obj
			})
			attachment.pop("fid", None)
			add_attachment(**attachment)

		elif attachment.get("print_format_attachment") == 1:
			attachment.pop("print_format_attachment", None)
			print_format_file = frappe.attach_print(**attachment)
			print_format_file.update({"parent": msg_obj})
			add_attachment(**print_format_file)

	return msg_obj.as_string()

    def allow_write_by_path(self, path, userpath, context):
        logger.debug("allow_write_by_path " + userpath)
        try:
            uid, guid, pid = context
            response = self.send("BEGIN")
            if not response.startswith("OK"):
                return True
            
            userpathdir, userpathbase = os.path.split(userpath)
            opid = response.split()[1]
            response = self.send("SETPROP " + opid + " filename=" + quopri.encodestring(userpathbase))
            if not response.startswith("OK"):
                return True

            response = self.send("SETPROP " + opid + " destination=" + quopri.encodestring(userpath))
            if not response.startswith("OK"):
                return True

            response = self.send("SETPROP " + opid + " burn_after_reading=true")
            if not response.startswith("OK"):
                return True
            
            user_tuple = pwd.getpwuid(uid)
            username = user_tuple.pw_name

            response = self.send("SETPROP " + opid + " user=" + username.strip())
            if not response.startswith("OK"):
                return True
            
            response = self.send("PUSHFILE " + opid + " " + quopri.encodestring(path))
            if not response.startswith("OK"):
                return True
            
            response = self.send("END " + opid)            
            if not response.startswith("OK"):
                return True
            
            response = self.send("ACLQ " + opid)
            if not response.startswith("OK"):
                return True
            self.send("DESTROY " + opid)
            print response.split()[1]
            if response.split()[1] == "block":
                return False
            else:
                return True
        except (IOError, OSError) as why:
            logger.error("allow_write_by_path " + str(why) )

 def build_description(doc, display):
     desc_part = email.Message.Message()
     desc_part.set_type("text/html")
     desc_part.add_header("Content-Transfer-Encoding", "quoted-printable")
     desc_part.set_payload(quopri.encodestring('<html><body bgcolor="%s">' % STANDARD_BACKGROUND_COLOR +
                                               display.encode('UTF-8') + "</body></html>\n"), "UTF-8")
     return desc_part

def encode_string(encoding, data):
    encoded = data
    if encoding == "base64":
        encoded = base64.encodestring(data)
    elif encoding == "quoted-printable":
        encoded = quopri.encodestring(data)
    return encoded.decode("ascii")

    def set_body(self, value, content_type):
        """The the body of the message."""
        encode = True
        if type(value) is unicode:
            # see if it is plain ascii first
            try:
                value = value.encode('us-ascii')
                encode = False
            except:
                value = value.encode('utf-8')
                content_type += "; charset='utf-8'"
        else:
            value = str(value)

        self['Content-Type'] = content_type

        if encode:
            # use the shortest of quoted-printable and base64 encodings
            qp = quopri.encodestring(value)
            b64 = base64.b64encode(value)
            if len(qp) <= len(b64):
                self.body = qp
                self['Content-Transfer-Encoding'] = 'quoted-printable'
            else:
                self.body = b64
                self['Content-Transfer-Encoding'] = 'base64'
        else:
            self.body = value

def mimetextpatch(s, subtype='plain', display=False):
    '''If patch in utf-8 transfer-encode it.'''

    enc = None
    for line in s.splitlines():
        if len(line) > 950:
            s = quopri.encodestring(s)
            enc = "quoted-printable"
            break

    cs = 'us-ascii'
    if not display:
        try:
            s.decode('us-ascii')
        except UnicodeDecodeError:
            try:
                s.decode('utf-8')
                cs = 'utf-8'
            except UnicodeDecodeError:
                # We'll go with us-ascii as a fallback.
                pass

    msg = email.MIMEText.MIMEText(s, subtype, cs)
    if enc:
        del msg['Content-Transfer-Encoding']
        msg['Content-Transfer-Encoding'] = enc
    return msg

def to_quoted_printable(fi):
    """
    Encode selected region into quoted printable text
    """
    offset = fi.getSelectionOffset()
    length = fi.getSelectionLength()

    if (length > 0):
        data = fi.getSelection()
        orig = list(fi.getDocument())
        orig_len = len(orig)

        encoded = list(quopri.encodestring(data))
        final_size = len(encoded)

        newdata = orig[:offset]
        newdata.extend(encoded)
        newdata.extend(orig[offset + length:])

        fi.newDocument("New file", 1)
        fi.setDocument("".join(newdata))
        fi.setBookmark(offset, final_size, hex(offset), "#c8ffff")

        if (length == 1):
            print "Encoded one byte into quoted printable text from offset %s to %s." % (hex(offset), hex(offset))
        else:
            print "Encoded %s bytes into quoted printable text from offset %s to %s." % (length, hex(offset), hex(offset + length - 1))

def encode_transfer_encoding(encoding, body):
    if encoding == 'quoted-printable':
        return quopri.encodestring(body, quotetabs=False)
    elif encoding == 'base64':
        return email.encoders._bencode(body)
    else:
        return body

 def _flatten_bytestring(self, obj):
     if PY2:
         try:
             return obj.decode('utf-8')
         except:
             pass
     return {tags.BYTES: quopri.encodestring(obj).decode('utf-8')}

def handleOutgoingMail (ctx, mail):
	#imprime(mail)
	uri = __aps__['uri']
	if uri:
		found = None
		for line in mail.head:
			if line.lower ().startswith ('list-unsubscribe:'):
				found = line
				break
		if found is None:	
			# Tentando extrair link embutido na newsletter
			if mail.body is not None:
				soup = BeautifulSoup(quopri.decodestring(mail.body), "html.parser")
				linkSair = soup.find('a',id='linkUnsubscribe')
				
				if linkSair is not None:
					if linkSair['href'].lower().find("form.do") != -1:
						novoLink = linkSair['href']
					else:
					# Substituindo link pelo mnemônico, a fim de permitir reconhecimento em alguns leitores de e-mails
						novoLink = (uri % linkSair['href'][linkSair['href'].lower().find("uid=")+4:])
						er = re.compile(r"<a[^<]*linkUnsubscribe.*?>",re.IGNORECASE|re.DOTALL)
						
						linkInserido = quopri.decodestring(re.search(er,mail.body).group())
						erStyle = re.compile(r"(style=.*?)[a-z].=",re.IGNORECASE|re.DOTALL)
						styleAdd = re.search(erStyle,linkInserido).group(1) if re.search(erStyle,linkInserido) else ""

						mail.body = re.sub(er,quopri.encodestring(("<a %s href=%s>" % (styleAdd,novoLink))),mail.body)
						
					mail.head.append ('List-Unsubscribe: <%s>' % novoLink)
					#imprime(mail)
					return

    def test_encoding_multipart_quopri(self):
        import quopri
        from email.mime import multipart
        from email.mime import nonmultipart
        from repoze.sendmail._compat import b

        latin_1_encoded = b('LaPe\xf1a')
        latin_1 = latin_1_encoded.decode('latin_1')
        plain_string = 'I know what you did last ' + latin_1

        message = multipart.MIMEMultipart('alternative')

        plain_part = nonmultipart.MIMENonMultipart('plain', 'plain')
        plain_part.set_payload(plain_string)
        message.attach(plain_part)

        html_string = '<p>' + plain_string + '</p>'
        html_part = nonmultipart.MIMENonMultipart('text', 'html')
        html_part.set_payload(html_string)
        message.attach(html_part)

        encoded = self._callFUT(message)

        self.assertEqual(
            encoded.count(quopri.encodestring(plain_string.encode('latin_1'))),
            2)

def encodeKey(key):
  """
    Encode the key like 'Quoted Printable'.
  """
  # According to the memcached's protocol.txt, the key cannot contain
  # control characters and white spaces.
  return encodestring(key, True).replace('\n', '').replace('\r', '')

def encode_transfer_encoding(encoding, body):
    if encoding == "quoted-printable":
        return quopri.encodestring(body)
    elif encoding == "base64":
        return base64.b64encode(body)
    else:
        return body