mail.py
520 lines
| 16.5 KiB
| text/x-python
|
PythonLexer
/ mercurial / mail.py
|
r2889 | # mail.py - mail sending bits for mercurial | ||
# | ||||
|
r47575 | # Copyright 2006 Olivia Mackall <olivia@selenic.com> | ||
|
r2889 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r2889 | |||
|
r30325 | from __future__ import absolute_import | ||
|
r25957 | |||
|
r19790 | import email | ||
|
r30089 | import email.charset | ||
|
r43426 | import email.generator | ||
|
r30072 | import email.header | ||
|
r34311 | import email.message | ||
|
r38354 | import email.parser | ||
import io | ||||
|
r25957 | import os | ||
import smtplib | ||||
import socket | ||||
import time | ||||
from .i18n import _ | ||||
|
r43359 | from .pycompat import ( | ||
getattr, | ||||
open, | ||||
) | ||||
|
r25957 | from . import ( | ||
encoding, | ||||
|
r26587 | error, | ||
|
r36064 | pycompat, | ||
|
r25957 | sslutil, | ||
util, | ||||
) | ||||
|
r37102 | from .utils import ( | ||
|
r37138 | procutil, | ||
|
r37102 | stringutil, | ||
r47669 | urlutil, | |||
|
r37102 | ) | ||
|
r2889 | |||
|
r44212 | if pycompat.TYPE_CHECKING: | ||
|
r44024 | from typing import Any, List, Tuple, Union | ||
# keep pyflakes happy | ||||
assert all((Any, List, Tuple, Union)) | ||||
|
r43346 | |||
|
r18885 | class STARTTLS(smtplib.SMTP): | ||
|
r46554 | """Derived class to verify the peer certificate for STARTTLS. | ||
|
r18885 | |||
This class allows to pass any keyword arguments to SSL socket creation. | ||||
|
r46554 | """ | ||
|
r43346 | |||
|
r29251 | def __init__(self, ui, host=None, **kwargs): | ||
|
r18885 | smtplib.SMTP.__init__(self, **kwargs) | ||
|
r29248 | self._ui = ui | ||
|
r28935 | self._host = host | ||
|
r18885 | |||
def starttls(self, keyfile=None, certfile=None): | ||||
|
r43439 | if not self.has_extn("starttls"): | ||
|
r43347 | msg = b"STARTTLS extension not supported by server" | ||
|
r18885 | raise smtplib.SMTPException(msg) | ||
|
r43440 | (resp, reply) = self.docmd("STARTTLS") | ||
|
r18885 | if resp == 220: | ||
|
r43346 | self.sock = sslutil.wrapsocket( | ||
self.sock, | ||||
keyfile, | ||||
certfile, | ||||
ui=self._ui, | ||||
serverhostname=self._host, | ||||
) | ||||
|
r43441 | self.file = self.sock.makefile("rb") | ||
|
r18885 | self.helo_resp = None | ||
self.ehlo_resp = None | ||||
self.esmtp_features = {} | ||||
self.does_esmtp = 0 | ||||
return (resp, reply) | ||||
|
r43346 | |||
|
r26673 | class SMTPS(smtplib.SMTP): | ||
|
r46554 | """Derived class to verify the peer certificate for SMTPS. | ||
|
r18886 | |||
|
r26673 | This class allows to pass any keyword arguments to SSL socket creation. | ||
|
r46554 | """ | ||
|
r43346 | |||
def __init__(self, ui, keyfile=None, certfile=None, host=None, **kwargs): | ||||
|
r26673 | self.keyfile = keyfile | ||
self.certfile = certfile | ||||
smtplib.SMTP.__init__(self, **kwargs) | ||||
|
r28935 | self._host = host | ||
|
r26673 | self.default_port = smtplib.SMTP_SSL_PORT | ||
|
r29248 | self._ui = ui | ||
|
r26673 | |||
def _get_socket(self, host, port, timeout): | ||||
if self.debuglevel > 0: | ||||
|
r43347 | self._ui.debug(b'connect: %r\n' % ((host, port),)) | ||
|
r26673 | new_socket = socket.create_connection((host, port), timeout) | ||
|
r43346 | new_socket = sslutil.wrapsocket( | ||
new_socket, | ||||
self.keyfile, | ||||
self.certfile, | ||||
ui=self._ui, | ||||
serverhostname=self._host, | ||||
) | ||||
|
r43906 | self.file = new_socket.makefile('rb') | ||
|
r26673 | return new_socket | ||
|
r18886 | |||
|
r43346 | |||
|
r39060 | def _pyhastls(): | ||
|
r44024 | # type: () -> bool | ||
|
r39060 | """Returns true iff Python has TLS support, false otherwise.""" | ||
try: | ||||
import ssl | ||||
|
r43346 | |||
|
r39060 | getattr(ssl, 'HAS_TLS', False) | ||
return True | ||||
except ImportError: | ||||
return False | ||||
|
r43346 | |||
|
r2889 | def _smtp(ui): | ||
|
r5973 | '''build an smtp connection and return a function to send mail''' | ||
|
r43347 | local_hostname = ui.config(b'smtp', b'local_hostname') | ||
tls = ui.config(b'smtp', b'tls') | ||||
|
r13201 | # backward compatible: when tls = true, we use starttls. | ||
|
r43347 | starttls = tls == b'starttls' or stringutil.parsebool(tls) | ||
smtps = tls == b'smtps' | ||||
|
r39060 | if (starttls or smtps) and not _pyhastls(): | ||
|
r43347 | raise error.Abort(_(b"can't use TLS: Python SSL support not installed")) | ||
mailhost = ui.config(b'smtp', b'host') | ||||
|
r2889 | if not mailhost: | ||
|
r43347 | raise error.Abort(_(b'smtp.host not configured - cannot send mail')) | ||
|
r18888 | if smtps: | ||
|
r43347 | ui.note(_(b'(using smtps)\n')) | ||
|
r29251 | s = SMTPS(ui, local_hostname=local_hostname, host=mailhost) | ||
|
r18888 | elif starttls: | ||
|
r29251 | s = STARTTLS(ui, local_hostname=local_hostname, host=mailhost) | ||
|
r18888 | else: | ||
s = smtplib.SMTP(local_hostname=local_hostname) | ||||
|
r19050 | if smtps: | ||
defaultport = 465 | ||||
else: | ||||
defaultport = 25 | ||||
r47669 | mailport = urlutil.getport(ui.config(b'smtp', b'port', defaultport)) | |||
|
r43347 | ui.note(_(b'sending mail: smtp host %s, port %d\n') % (mailhost, mailport)) | ||
|
r2889 | s.connect(host=mailhost, port=mailport) | ||
|
r13201 | if starttls: | ||
|
r43347 | ui.note(_(b'(using starttls)\n')) | ||
|
r2889 | s.ehlo() | ||
s.starttls() | ||||
s.ehlo() | ||||
|
r29285 | if starttls or smtps: | ||
|
r43347 | ui.note(_(b'(verifying remote certificate)\n')) | ||
|
r29285 | sslutil.validatesocket(s.sock) | ||
|
r43347 | username = ui.config(b'smtp', b'username') | ||
password = ui.config(b'smtp', b'password') | ||||
|
r43442 | if username: | ||
if password: | ||||
password = encoding.strfromlocal(password) | ||||
else: | ||||
password = ui.getpass() | ||||
|
r46541 | if password is not None: | ||
password = encoding.strfromlocal(password) | ||||
|
r2889 | if username and password: | ||
|
r43347 | ui.note(_(b'(authenticating to mail server as %s)\n') % username) | ||
|
r43442 | username = encoding.strfromlocal(username) | ||
|
r9246 | try: | ||
s.login(username, password) | ||||
|
r25660 | except smtplib.SMTPException as inst: | ||
|
r47510 | raise error.Abort(stringutil.forcebytestr(inst)) | ||
|
r2889 | |||
|
r5973 | def send(sender, recipients, msg): | ||
try: | ||||
return s.sendmail(sender, recipients, msg) | ||||
|
r25660 | except smtplib.SMTPRecipientsRefused as inst: | ||
|
r5973 | recipients = [r[1] for r in inst.recipients.values()] | ||
|
r43347 | raise error.Abort(b'\n' + b'\n'.join(recipients)) | ||
|
r25660 | except smtplib.SMTPException as inst: | ||
|
r26587 | raise error.Abort(inst) | ||
|
r5947 | |||
|
r5973 | return send | ||
|
r5947 | |||
|
r43346 | |||
|
r5973 | def _sendmail(ui, sender, recipients, msg): | ||
'''send mail using sendmail.''' | ||||
|
r43347 | program = ui.config(b'email', b'method') | ||
|
r43366 | |||
def stremail(x): | ||||
return procutil.shellquote(stringutil.email(encoding.strtolocal(x))) | ||||
|
r43347 | cmdline = b'%s -f %s %s' % ( | ||
|
r43346 | program, | ||
stremail(sender), | ||||
|
r43347 | b' '.join(map(stremail, recipients)), | ||
|
r43346 | ) | ||
|
r43347 | ui.note(_(b'sending mail: %s\n') % cmdline) | ||
fp = procutil.popen(cmdline, b'wb') | ||||
|
r37476 | fp.write(util.tonativeeol(msg)) | ||
|
r5973 | ret = fp.close() | ||
if ret: | ||||
|
r43346 | raise error.Abort( | ||
|
r43347 | b'%s %s' | ||
|
r43346 | % ( | ||
|
r44277 | os.path.basename(procutil.shellsplit(program)[0]), | ||
|
r43346 | procutil.explainexit(ret), | ||
) | ||||
) | ||||
|
r2889 | |||
|
r15560 | def _mbox(mbox, sender, recipients, msg): | ||
'''write mails to mbox''' | ||||
|
r43347 | fp = open(mbox, b'ab+') | ||
|
r15560 | # Should be time.asctime(), but Windows prints 2-characters day | ||
# of month instead of one. Make them print the same thing. | ||||
|
r43906 | date = time.strftime('%a %b %d %H:%M:%S %Y', time.localtime()) | ||
|
r43346 | fp.write( | ||
|
r43347 | b'From %s %s\n' | ||
|
r43346 | % (encoding.strtolocal(sender), encoding.strtolocal(date)) | ||
) | ||||
|
r15560 | fp.write(msg) | ||
|
r43347 | fp.write(b'\n\n') | ||
|
r15560 | fp.close() | ||
|
r43346 | |||
|
r15560 | def connect(ui, mbox=None): | ||
|
r46554 | """make a mail connection. return a function to send mail. | ||
call as sendmail(sender, list-of-recipients, msg).""" | ||||
|
r15560 | if mbox: | ||
|
r43347 | open(mbox, b'wb').close() | ||
|
r15560 | return lambda s, r, m: _mbox(mbox, s, r, m) | ||
|
r43347 | if ui.config(b'email', b'method') == b'smtp': | ||
|
r5947 | return _smtp(ui) | ||
|
r5973 | return lambda s, r, m: _sendmail(ui, s, r, m) | ||
|
r2889 | |||
|
r43346 | |||
|
r15561 | def sendmail(ui, sender, recipients, msg, mbox=None): | ||
send = connect(ui, mbox=mbox) | ||||
|
r5973 | return send(sender, recipients, msg) | ||
|
r4489 | |||
|
r43346 | |||
|
r4489 | def validateconfig(ui): | ||
'''determine if we have enough config data to try sending email.''' | ||||
|
r43347 | method = ui.config(b'email', b'method') | ||
if method == b'smtp': | ||||
if not ui.config(b'smtp', b'host'): | ||||
|
r43346 | raise error.Abort( | ||
_( | ||||
|
r43347 | b'smtp specified as email transport, ' | ||
b'but no smtp host configured' | ||||
|
r43346 | ) | ||
) | ||||
|
r4489 | else: | ||
|
r37138 | if not procutil.findexe(method): | ||
|
r43346 | raise error.Abort( | ||
|
r43387 | _(b'%r specified as email transport, but not in PATH') % method | ||
|
r43346 | ) | ||
|
r7114 | |||
|
r30089 | def codec2iana(cs): | ||
|
r44025 | # type: (str) -> str | ||
|
r30089 | '''''' | ||
|
r44025 | cs = email.charset.Charset(cs).input_charset.lower() | ||
|
r30089 | |||
# "latin1" normalizes to "iso8859-1", standard calls for "iso-8859-1" | ||||
|
r44025 | if cs.startswith("iso") and not cs.startswith("iso-"): | ||
return "iso-" + cs[3:] | ||||
|
r30089 | return cs | ||
|
r43346 | |||
|
r44026 | def mimetextpatch(s, subtype='plain', display=False): | ||
# type: (bytes, str, bool) -> email.message.Message | ||||
|
r46554 | """Return MIME message suitable for a patch. | ||
|
r30089 | Charset will be detected by first trying to decode as us-ascii, then utf-8, | ||
and finally the global encodings. If all those fail, fall back to | ||||
ISO-8859-1, an encoding with that allows all byte sequences. | ||||
|
r46554 | Transfer encodings will be used if necessary.""" | ||
|
r8332 | |||
|
r44025 | cs = [ | ||
'us-ascii', | ||||
'utf-8', | ||||
pycompat.sysstr(encoding.encoding), | ||||
pycompat.sysstr(encoding.fallbackencoding), | ||||
] | ||||
|
r30089 | if display: | ||
|
r44025 | cs = ['us-ascii'] | ||
|
r30089 | for charset in cs: | ||
|
r8332 | try: | ||
|
r44025 | s.decode(charset) | ||
|
r30089 | return mimetextqp(s, subtype, codec2iana(charset)) | ||
|
r8332 | except UnicodeDecodeError: | ||
|
r30089 | pass | ||
|
r8332 | |||
|
r44025 | return mimetextqp(s, subtype, "iso-8859-1") | ||
|
r15562 | |||
|
r43346 | |||
|
r15562 | def mimetextqp(body, subtype, charset): | ||
|
r44026 | # type: (bytes, str, str) -> email.message.Message | ||
|
r46554 | """Return MIME message. | ||
|
r17424 | Quoted-printable transfer encoding will be used if necessary. | ||
|
r46554 | """ | ||
|
r44025 | cs = email.charset.Charset(charset) | ||
|
r34311 | msg = email.message.Message() | ||
|
r44026 | msg.set_type('text/' + subtype) | ||
|
r34311 | |||
|
r15562 | for line in body.splitlines(): | ||
if len(line) > 950: | ||||
|
r34311 | cs.body_encoding = email.charset.QP | ||
|
r15562 | break | ||
|
r41450 | # On Python 2, this simply assigns a value. Python 3 inspects | ||
# body and does different things depending on whether it has | ||||
# encode() or decode() attributes. We can get the old behavior | ||||
# if we pass a str and charset is None and we call set_charset(). | ||||
# But we may get into trouble later due to Python attempting to | ||||
# encode/decode using the registered charset (or attempting to | ||||
# use ascii in the absence of a charset). | ||||
|
r34311 | msg.set_payload(body, cs) | ||
|
r8332 | return msg | ||
|
r7191 | |||
|
r43346 | |||
|
r7114 | def _charsets(ui): | ||
|
r44025 | # type: (Any) -> List[str] | ||
|
r7114 | '''Obtains charsets to send mail parts not containing patches.''' | ||
|
r44024 | charsets = [ | ||
|
r44025 | pycompat.sysstr(cs.lower()) | ||
for cs in ui.configlist(b'email', b'charsets') | ||||
] | ||||
|
r43346 | fallbacks = [ | ||
|
r44025 | pycompat.sysstr(encoding.fallbackencoding.lower()), | ||
pycompat.sysstr(encoding.encoding.lower()), | ||||
'utf-8', | ||||
] | ||||
|
r43346 | for cs in fallbacks: # find unique charsets while keeping order | ||
|
r7114 | if cs not in charsets: | ||
charsets.append(cs) | ||||
|
r44025 | return [cs for cs in charsets if not cs.endswith('ascii')] | ||
|
r7114 | |||
|
r43346 | |||
|
r7114 | def _encode(ui, s, charsets): | ||
|
r44025 | # type: (Any, bytes, List[str]) -> Tuple[bytes, str] | ||
|
r46554 | """Returns (converted) string, charset tuple. | ||
|
r7114 | Finds out best charset by cycling through sendcharsets in descending | ||
|
r7948 | order. Tries both encoding and fallbackencoding for input. Only as | ||
|
r7114 | last resort send as is in fake ascii. | ||
|
r46554 | Caveat: Do not use for mail parts containing patches!""" | ||
|
r39058 | sendcharsets = charsets or _charsets(ui) | ||
if not isinstance(s, bytes): | ||||
# We have unicode data, which we need to try and encode to | ||||
# some reasonable-ish encoding. Try the encodings the user | ||||
# wants, and fall back to garbage-in-ascii. | ||||
for ocs in sendcharsets: | ||||
try: | ||||
|
r44025 | return s.encode(ocs), ocs | ||
|
r39058 | except UnicodeEncodeError: | ||
pass | ||||
except LookupError: | ||||
|
r44025 | ui.warn( | ||
_(b'ignoring invalid sendcharset: %s\n') | ||||
% pycompat.sysbytes(ocs) | ||||
) | ||||
|
r39058 | else: | ||
# Everything failed, ascii-armor what we've got and send it. | ||||
|
r44025 | return s.encode('ascii', 'backslashreplace'), 'us-ascii' | ||
|
r39058 | # We have a bytes of unknown encoding. We'll try and guess a valid | ||
# encoding, falling back to pretending we had ascii even though we | ||||
# know that's wrong. | ||||
|
r7114 | try: | ||
s.decode('ascii') | ||||
except UnicodeDecodeError: | ||||
|
r7948 | for ics in (encoding.encoding, encoding.fallbackencoding): | ||
|
r43638 | ics = pycompat.sysstr(ics) | ||
|
r7114 | try: | ||
u = s.decode(ics) | ||||
except UnicodeDecodeError: | ||||
continue | ||||
for ocs in sendcharsets: | ||||
try: | ||||
|
r44025 | return u.encode(ocs), ocs | ||
|
r7114 | except UnicodeEncodeError: | ||
pass | ||||
except LookupError: | ||||
|
r44025 | ui.warn( | ||
_(b'ignoring invalid sendcharset: %s\n') | ||||
% pycompat.sysbytes(ocs) | ||||
) | ||||
|
r7114 | # if ascii, or all conversion attempts fail, send (broken) ascii | ||
|
r44025 | return s, 'us-ascii' | ||
|
r7114 | |||
|
r43346 | |||
|
r7114 | def headencode(ui, s, charsets=None, display=False): | ||
|
r44025 | # type: (Any, Union[bytes, str], List[str], bool) -> str | ||
|
r7114 | '''Returns RFC-2047 compliant header from given string.''' | ||
if not display: | ||||
# split into words? | ||||
s, cs = _encode(ui, s, charsets) | ||||
|
r44025 | return email.header.Header(s, cs).encode() | ||
|
r43975 | return encoding.strfromlocal(s) | ||
|
r7114 | |||
|
r43346 | |||
|
r9948 | def _addressencode(ui, name, addr, charsets=None): | ||
|
r44027 | # type: (Any, str, str, List[str]) -> str | ||
addr = encoding.strtolocal(addr) | ||||
|
r43975 | name = headencode(ui, name, charsets) | ||
|
r7114 | try: | ||
|
r43347 | acc, dom = addr.split(b'@') | ||
|
r39143 | acc.decode('ascii') | ||
|
r39144 | dom = dom.decode(pycompat.sysstr(encoding.encoding)).encode('idna') | ||
|
r43347 | addr = b'%s@%s' % (acc, dom) | ||
|
r7114 | except UnicodeDecodeError: | ||
|
r43347 | raise error.Abort(_(b'invalid email address: %s') % addr) | ||
|
r7114 | except ValueError: | ||
try: | ||||
# too strict? | ||||
|
r39143 | addr.decode('ascii') | ||
|
r7114 | except UnicodeDecodeError: | ||
|
r43347 | raise error.Abort(_(b'invalid local address: %s') % addr) | ||
|
r43976 | return email.utils.formataddr((name, encoding.strfromlocal(addr))) | ||
|
r43346 | |||
|
r7114 | |||
|
r9948 | def addressencode(ui, address, charsets=None, display=False): | ||
|
r44025 | # type: (Any, bytes, List[str], bool) -> str | ||
|
r9948 | '''Turns address into RFC-2047 compliant header.''' | ||
if display or not address: | ||||
|
r43976 | return encoding.strfromlocal(address or b'') | ||
|
r39059 | name, addr = email.utils.parseaddr(encoding.strfromlocal(address)) | ||
|
r44027 | return _addressencode(ui, name, addr, charsets) | ||
|
r9948 | |||
|
r43346 | |||
|
r9948 | def addrlistencode(ui, addrs, charsets=None, display=False): | ||
|
r44025 | # type: (Any, List[bytes], List[str], bool) -> List[str] | ||
|
r46554 | """Turns a list of addresses into a list of RFC-2047 compliant headers. | ||
|
r9948 | A single element of input list may contain multiple addresses, but output | ||
|
r46554 | always has one address per item""" | ||
|
r43977 | straddrs = [] | ||
|
r39059 | for a in addrs: | ||
|
r43906 | assert isinstance(a, bytes), '%r unexpectedly not a bytestr' % a | ||
|
r43977 | straddrs.append(encoding.strfromlocal(a)) | ||
|
r9948 | if display: | ||
|
r43977 | return [a.strip() for a in straddrs if a.strip()] | ||
|
r9948 | |||
result = [] | ||||
|
r43977 | for name, addr in email.utils.getaddresses(straddrs): | ||
|
r9948 | if name or addr: | ||
|
r44027 | r = _addressencode(ui, name, addr, charsets) | ||
|
r39142 | result.append(r) | ||
|
r39141 | return result | ||
|
r9948 | |||
|
r43346 | |||
|
r7114 | def mimeencode(ui, s, charsets=None, display=False): | ||
|
r44025 | # type: (Any, bytes, List[str], bool) -> email.message.Message | ||
|
r46554 | """creates mime text object, encodes it if needed, and sets | ||
charset and transfer-encoding accordingly.""" | ||||
|
r44025 | cs = 'us-ascii' | ||
|
r7114 | if not display: | ||
s, cs = _encode(ui, s, charsets) | ||||
|
r44026 | return mimetextqp(s, 'plain', cs) | ||
|
r28341 | |||
|
r43346 | |||
|
r38354 | if pycompat.ispy3: | ||
|
r43346 | |||
|
r43426 | Generator = email.generator.BytesGenerator | ||
|
r38354 | def parse(fp): | ||
|
r44024 | # type: (Any) -> email.message.Message | ||
|
r38354 | ep = email.parser.Parser() | ||
# disable the "universal newlines" mode, which isn't binary safe. | ||||
# I have no idea if ascii/surrogateescape is correct, but that's | ||||
# what the standard Python email parser does. | ||||
|
r43346 | fp = io.TextIOWrapper( | ||
|
r43906 | fp, encoding='ascii', errors='surrogateescape', newline=chr(10) | ||
|
r43346 | ) | ||
|
r38354 | try: | ||
return ep.parse(fp) | ||||
finally: | ||||
fp.detach() | ||||
|
r43346 | |||
|
r43634 | def parsebytes(data): | ||
|
r44024 | # type: (bytes) -> email.message.Message | ||
|
r43634 | ep = email.parser.BytesParser() | ||
return ep.parsebytes(data) | ||||
|
r43346 | |||
|
r43670 | |||
|
r38354 | else: | ||
|
r43346 | |||
|
r43426 | Generator = email.generator.Generator | ||
|
r38354 | def parse(fp): | ||
|
r44024 | # type: (Any) -> email.message.Message | ||
|
r38354 | ep = email.parser.Parser() | ||
return ep.parse(fp) | ||||
|
r43634 | def parsebytes(data): | ||
|
r44024 | # type: (str) -> email.message.Message | ||
|
r43634 | ep = email.parser.Parser() | ||
return ep.parsestr(data) | ||||
|
r43346 | |||
|
r28341 | def headdecode(s): | ||
|
r44024 | # type: (Union[email.header.Header, bytes]) -> bytes | ||
|
r28341 | '''Decodes RFC-2047 header''' | ||
uparts = [] | ||||
|
r30072 | for part, charset in email.header.decode_header(s): | ||
|
r28341 | if charset is not None: | ||
try: | ||||
uparts.append(part.decode(charset)) | ||||
continue | ||||
|
r43632 | except (UnicodeDecodeError, LookupError): | ||
|
r28341 | pass | ||
|
r37487 | # On Python 3, decode_header() may return either bytes or unicode | ||
# depending on whether the header has =?<charset>? or not | ||||
if isinstance(part, type(u'')): | ||||
uparts.append(part) | ||||
continue | ||||
|
r28341 | try: | ||
uparts.append(part.decode('UTF-8')) | ||||
continue | ||||
except UnicodeDecodeError: | ||||
pass | ||||
uparts.append(part.decode('ISO-8859-1')) | ||||
|
r31447 | return encoding.unitolocal(u' '.join(uparts)) | ||