def send_email(request):
    try:
        recipients = request.GET["to"].split(",")
        url = request.GET["url"]
        proto, server, path, query, frag = urlsplit(url)
        if query:
            path += "?" + query
        conn = HTTPConnection(server)
        conn.request("GET", path)
        try:  # Python 2.7+, use buffering of HTTP responses
            resp = conn.getresponse(buffering=True)
        except TypeError:  # Python 2.6 and older
            resp = conn.getresponse()
        assert resp.status == 200, "Failed HTTP response %s %s" % (resp.status, resp.reason)
        rawData = resp.read()
        conn.close()
        message = MIMEMultipart()
        message["Subject"] = "Graphite Image"
        message["To"] = ", ".join(recipients)
        message["From"] = "[email protected]%s" % gethostname()
        text = MIMEText("Image generated by the following graphite URL at %s\r\n\r\n%s" % (ctime(), url))
        image = MIMEImage(rawData)
        image.add_header("Content-Disposition", "attachment", filename="composer_" + strftime("%b%d_%I%M%p.png"))
        message.attach(text)
        message.attach(image)
        s = SMTP(settings.SMTP_SERVER)
        s.sendmail("[email protected]%s" % gethostname(), recipients, message.as_string())
        s.quit()
        return HttpResponse("OK")
    except:
        return HttpResponse(format_exc())

def send_email(subject, message, addr):
    try:
        if (Config.get("smtp", "port") == "0"):
            smtp = SMTP("localhost")
        else:
            smtp = SMTP(Config.get("smtp", "host"), Config.get("smtp", "port"))

        if not ((Config.get("smtp", "host") == "localhost") or (Config.get("smtp", "host") == "127.0.0.1")):
            try:
                smtp.starttls()
            except SMTPException as e:
                raise SMSError("unable to shift connection into TLS: %s" % (str(e),))

            try:
                smtp.login(Config.get("smtp", "user"), Config.get("smtp", "pass"))
            except SMTPException as e:
                raise SMSError("unable to authenticate: %s" % (str(e),))

        try:
             smtp.sendmail(Config.get("smtp", "frommail"), addr, "To:%s\nFrom:%s\nSubject:%s\n%s\n" % (addr, "\"%s\" <%s>" % (
                                                           Config.get("Connection", "nick"), Config.get("smtp", "frommail")), subject, message))
        except SMTPSenderRefused as e:
            raise SMSError("sender refused: %s" % (str(e),))
        except SMTPRecipientsRefused as e:
            raise SMSError("unable to send: %s" % (str(e),))

        smtp.quit()

    except (socket.error, SSLError, SMTPException, SMSError) as e:
        return "Error sending message: %s" % (str(e),)

def sendmail(content=None):

    "Send email to my 163mail"

    if content is None:
        print 'content is None'
        return False
    try:
        from smtplib import SMTP
        from email.mime.text import MIMEText

        from_addr = "[email protected]"
        password = "hanks0722"
        to_addr = "[email protected]"
        email_client = SMTP(host='smtp.163.com')
        email_client.login(from_addr, password)

        #create message
        msg = MIMEText(content, _charset='utf-8')
        msg['Subject'] = "Interview Status Changed!"
        email_client.sendmail(from_addr, to_addr, msg.as_string())
        return True
    except Exception, e:
        print e
        return False

    def deliver(self, subject, body, recipients=False):
        """
        sends an email using the [email protected] account
        """

        if not recipients:
            recipients = self.recipients

        recipients = recipients.split(';')

        message = MIMEText(body)
        message['Subject'] = subject
        message['From'] = self.sender
        message['To'] = ','.join(recipients)

        if self.testing:
            print('***Begin Test Email Message***')
            print(message)
            print('***End Test Email Message***')

            return

        s = SMTP(self.server, self.port)

        s.sendmail(self.sender, recipients, message.as_string())
        s.quit()

        print('email sent')

def send_email(request):
  try:
    recipients = request.GET['to'].split(',')
    url = request.GET['url']
    proto, server, path, query, frag = urlsplit(url)
    if query: path += '?' + query
    conn = HTTPConnection(server)
    conn.request('GET',path)
    resp = conn.getresponse()
    assert resp.status == 200, "Failed HTTP response %s %s" % (resp.status, resp.reason)
    rawData = resp.read()
    conn.close()
    message = MIMEMultipart()
    message['Subject'] = "Graphite Image"
    message['To'] = ', '.join(recipients)
    message['From'] = '[email protected]%s' % gethostname()
    text = MIMEText( "Image generated by the following graphite URL at %s\r\n\r\n%s" % (ctime(),url) )
    image = MIMEImage( rawData )
    image.add_header('Content-Disposition', 'attachment', filename="composer_" + strftime("%b%d_%I%M%p.png"))
    message.attach(text)
    message.attach(image)
    s = SMTP(settings.SMTP_SERVER)
    s.sendmail('[email protected]%s' % gethostname(),recipients,message.as_string())
    s.quit()
    return HttpResponse( "OK" )
  except:
    return HttpResponse( format_exc() )

    def sendEmail(self, subject, body, toAddress=False):
        """
        sends an email using the [email protected] account
        """

        if not toAddress:
            toAddress = self.toAddress
        toAddress = toAddress.split(";")

        message = MIMEText(body)
        message["Subject"] = subject
        message["From"] = self.fromAddress
        message["To"] = ",".join(toAddress)

        if not self.testing:
            s = SMTP(self.server, self.port)

            s.sendmail(self.fromAddress, toAddress, message.as_string())
            s.quit()

            print("email sent")
        else:
            print("***Begin Test Email Message***")
            print(message)
            print("***End Test Email Message***")

def send_email(prefs, report_str):
    recipients = prefs['ADMIN_EMAIL'].split(',')

    msg = dedent("""
        From: %s
        To: %s
        Subject: %s
        Date: %s

        """).lstrip() % (prefs.get('SMTP_FROM'),
       prefs.get('ADMIN_EMAIL'),
       prefs.get('SMTP_SUBJECT'),
       time.strftime(prefs.get('SMTP_DATE_FORMAT')))

    msg += report_str
    try:
        smtp = SMTP(prefs.get('SMTP_HOST'),
                    prefs.get('SMTP_PORT'))

        username = prefs.get('SMTP_USERNAME')
        password = prefs.get('SMTP_PASSWORD')

        if username and password:
            smtp.login(username, password)

        smtp.sendmail(prefs.get('SMTP_FROM'),
                      recipients,
                      msg)
        debug("sent email to: %s" % prefs.get("ADMIN_EMAIL"))
    except Exception, e:
        print "Error sending email"
        print e
        print "Email message follows:"
        print msg

    def process_message(self, message):
        """Send emails.

        Args:
            message: dict instance containing email info.
                     Fields:
                         type [REQUIRED]: HR_ASC / HR_DESC
                         attachments [OPTIONAL]: recorded images base64 encoded
        """
        self.logger.info("Sending email to %s" % RECEIVER)
        if not message.get('type'):
            self.logger.error('Received message has no type (it should have '
                              'been one of the following: HR_ASC/HR_DESC): %r')
            return

        if not message.get('attachments'):
            message = self.compose_message_without_attachments(message)
        else:
            message = self.compose_message_with_attachments(message)

        try:
            smtpObj = SMTP('localhost')
            smtpObj.sendmail(SENDER, RECEIVER, message)      
            self.logger.info("Successfully sent email to %s", RECEIVER)
        except SMTPException as e:
            self.logger.error("Unable to send email to %s: %r", RECEIVER, e)

    def monitor_score_rank(self):
        """
        监控博客积分及排名的变化
        :return:
        """
        while True:
            self.get_blog_ranks()
            if self.score != self.his_score or self.rank != self.his_rank:
                email_client = SMTP(host = 'smtp.126.com')
                email_client.login('[email protected]','******')
                mail_title = '[e-notice]:blog-rank-changes'
                # mail_body = "[%s]time-(score,rank):old-(%s,%s),now-(%s,%s)" \
                #             % (
                #                 self.id,
                #                 self.his_score, self.his_rank,
                #                 self.score, self.rank
                #             )
                msg_body = "%s, at %s, you score: %s, rank: %s" %(self.id, time.ctime(), self.score, self.rank)
                msg = MIMEText(msg_body,_charset='utf-8')
                msg['Subject'] = mail_title
                email_client.sendmail('[email protected]','[email protected]',msg.as_string())
                self.his_score = self.score
                self.his_rank = self.rank
 
            sleep(self.gap_seconds)

def send_mail(subject, sender, recipient, text, server, files=[]):
    """Sends email with attachment"""

    # Create the enclosing (outer) message
    outer = MIMEMultipart()
    outer['Subject'] = subject
    outer['To'] = recipient
    outer['From'] = sender
    outer.preamble = 'You will not see this in a MIME-aware mail reader.'

    msg = MIMEText(text)
    outer.attach(msg)

    for filename in files:
        ctype = 'application/octet-stream'
        maintype, subtype = ctype.split('/', 1)
        fp = open(filename, 'rb')
        msg = MIMEBase(maintype, subtype)
        msg.set_payload(fp.read())
        fp.close()
        # Encode the payload using Base64
        encoders.encode_base64(msg)
        # Set the filename parameter
        msg.add_header('Content-Disposition', 'attachment', filename=filename)
        outer.attach(msg)

    composed = outer.as_string()
    session = SMTP('localhost')
    session.sendmail(sender, recipient, composed)
    session.quit()

    def notify(self, seminar):
        """
        Notify seminar
        """
        import re 
        from datetime import datetime
        from smtplib import SMTP
        from email.mime.text import MIMEText
        from email.header import Header

        dt = datetime.combine(seminar.date, seminar.time)

        format_values = (seminar.title, '\n'.join(['  ' + c for c in seminar.contents]), seminar.place)
        datetime_formatter = lambda matches: dt.strftime(matches.group(0))
        datetime_pattern = re.compile('%-?[a-zA-Z]')

        message_body = datetime_pattern.sub(datetime_formatter, self.message.format(*format_values))

        message = MIMEText(message_body, _charset = 'UTF-8')
        message['Subject'] = Header(datetime_pattern.sub(datetime_formatter, self.subject.format(*format_values)), 'UTF-8').encode()
        message['From'] = self.from_
        message['To'] = ', '.join(self.to)

        smtp = SMTP(self.host, self.port)
        smtp.sendmail(self.from_, self.to, message.as_string())
        smtp.quit()

def mailtrn(trndir,fltid,lognum):
  from smtplib import SMTP
  from email.mime.text import MIMEText
  from socket import gethostname
  from getpass import getuser

  # Create a text/plain message from file.
  trnfile = str.format('{0:s}/{1:s}/ema-{1:s}-log-{2:04d}.trn',trndir,fltid,lognum)
  if options.verbose:
    print('compute trnfile: ', trnfile)
  fp = open(trnfile, 'rt')
  msg = MIMEText(fp.read())
  fp.close()

  # msg = MIMEText('New trnfile: ' + trnfile)


  host = gethostname()
  user =  getuser()

  From = '[email protected]'
  From = user+'@'+host
  To = '[email protected]'
  Reply_To = '[email protected]'

  msg['Subject'] = str.format('emarun.py {0:s} {1:04d}',fltid,lognum)
  msg['From'] = From
  msg['To'] = To
  msg.add_header('Reply-To', Reply_To)

  s = SMTP('localhost')
  s.sendmail(From, To, msg.as_string())
  s.quit()

def sendMail(rcpt, subject, body, files=[]):

    send_from = "[email protected]"
    msg = MIMEMultipart()
    msg['From'] = send_from

    if rcpt is None: rcpt = admin_email


    msg['To'] = COMMASPACE.join(rcpt)
    msg['Date'] = formatdate(localtime=True)
    msg['Subject'] = subject
    
    msg.attach( MIMEText(body) )
    
    for f,b in files:
        logger.debug("SEND ATT "+f)
        part = MIMEBase('application', "octet-stream")
        part.set_payload(open(f).read())
        Encoders.encode_base64(part)
        part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(b))
        msg.attach(part)
    

    server = SMTP(smtphost, smtpport)
    server.sendmail(send_from, rcpt, msg.as_string())
    server.close()

    def send(self, msg):
        if len(msg['text']) > 32:
            teaser = msg['text'][:32] + '...'
        else:
            teaser = msg['text']
        msg = '''From: %s
To: %s
Subject: %s

%s''' % (self.config['mail']['from_address'], self.config['mail']['to_address'], '[foobox] %s: %s' % (msg['src'], teaser), msg['text'])

        host = self.config['mail']['smtp_server']
        if host.rfind(':') != -1:
            host, port = host.rsplit(':', 1)
        else:
            port = 25
        port = int(port)
        logging.debug('Sending mail via %s:%s' % (host, port))

        try:
            server = SMTP(host, port)
            server.sendmail(self.config['mail']['from_address'], self.config['mail']['to_address'], msg)
            server.quit()
            logging.info('Sent email to %s' % self.config['mail']['to_address'])
        except:
            logging.error('Error sending mail: %s' % format_exc())

    def response(self, nick, args, kwargs):
        try:
            sendto, reason = args
            email = self.learn.lookup(u'email', sendto)
            if email is None:
                return u"%s: I don't know the email for %s" % (nick, sendto)

            # just make all this shit ASCII, email is best that way...
            email = email.encode('ascii', 'replace')
            if reason:
                reason = reason.encode('ascii', 'replace')
            anick = nick.encode('ascii', 'replace')

            body = 'To: %s <%s>\n' % (sendto.encode('ascii', 'replace'), email)
            body += 'From: %s\n' % (self.config.smtp.sender)
            body += 'Subject: Summon from %s' % anick
            body += '\n'
            body += 'You were summoned by %s. Reason: %s' % (anick, reason)

            smtp = SMTP(self.config.smtp.server)
            if len(self.config.smtp.user):
                smtp.login(self.config.smtp.user, self.config.smtp.password)
            smtp.sendmail(self.config.smtp.sender, [email], body)

            return u"%s: summoned %s" % (nick, sendto)

        except Exception, error:
            log.warn(u'error in module %s' % self.__module__)
            log.exception(error)
            return u"%s: I couldn't make that summon: %s" % (nick, error)

    def sendmail(self, to, subject, content):
        '''Shortcut method to send a simple mail.

        Args
        ----
        - to      : A list of addresses to send this mail to. A bare string will
                    be treated as a list with 1 address.
        - subject : Mail subject
        - content : Mail body. treated as pure text

        Example
        -------
        >>> from pyrcp.gsmtplib import GSMTP
        >>> s = GSMTP('your_google_account', 'your_google_password')
        >>> s.sendmail('[email protected]',
        ...            'Hello world!',
        ...            'This is a message sent by gsmtplib'))
        >>> s.quit()

        '''
        mail = MIMEText(content)
        mail['subject'] = subject
        mail['from'] = self.account
        mail['to'] = to

        SMTP.sendmail(self, self.account, to, mail.as_string())

    def send(self, message, recipients=None):
        """Send an email.

        The email is sent to `recipient', which must be a list of
        RFC2822 compliant mailboxes and groups.

        If recipients is not specified, it is extracted from the
        'To', 'Cc' and 'Bcc' headers of the message.

        The return value is a list of failed email addresses. If
        not a single email could be sent, an exception is raised.
        """
        if not isinstance(message, Message):
            raise TypeError, 'Expecting "Message" instance.'
        if recipients is None:
            recipients = message.recipients()
            recipients += message.cc_recipients()
            recipients += message.bcc_recipients()
        message.del_header('Bcc')
        smtp = SMTP()
        try:
            smtp.connect(self.m_smtp_server, self.m_smtp_port)
            ret = smtp.sendmail(self.m_sender, recipients, message.dump())
        except SMTPException, err:
            m = 'Could not send email: %s' % str(err)
            raise SendmailError, m

 def send_email(self, user, receiver, public_text, email, message):
     try:
         if (Config.get("smtp", "port") == "0"):
             smtp = SMTP("localhost")
         else:
             smtp = SMTP(Config.get("smtp", "host"), Config.get("smtp", "port"))
         
         if not ((Config.get("smtp", "host") == "localhost") or (Config.get("smtp", "host") == "127.0.0.1")): 
             try:
                 smtp.starttls()
             except SMTPException as e:
                 raise SMSError("unable to shift connection into TLS: %s" % (str(e),))
             
             try:
                 smtp.login(Config.get("smtp", "user"), Config.get("smtp", "pass"))
             except SMTPException as e:
                 raise SMSError("unable to authenticate: %s" % (str(e),))
         
         try:
              smtp.sendmail(Config.get("smtp", "frommail"), email, 
                           "To:%s\nFrom:%s\nSubject:%s\n\n%s\n" % (email,
                                                                 Config.get("smtp", "frommail"),
                                                                 Config.get("Alliance", "name"),
                                                                 message,))
         except SMTPSenderRefused as e:
             raise SMSError("sender refused: %s" % (str(e),))
         except SMTPRecipientsRefused as e:
             raise SMSError("unable to send: %s" % (str(e),))
         
         smtp.quit()
         self.log_message(user, receiver, email, public_text, "email")
         
     except (socket.error, SSLError, SMTPException, SMSError) as e:
         return "Error sending message: %s" % (str(e),)

def send_email(from_, to, cc, subject, content):
    """
    @param from_ (str)
    @param to (list - str)
    @param cc (list - str)
    @param content (str)
    """
    msg = MIMEText(content, _charset='utf-8')
    msg['Subject'] = subject
    msg['From'] = from_
    assert type(to) is list
    assert type(cc) is list
    msg['To'] = ",".join(to)
    msg['Cc'] = ",".join(cc)

    email_is_sent = False
    try:
        email_server = SMTP('smtp')
        try:
            email_server.sendmail(from_, to + cc, msg.as_string())
            email_is_sent = True
        except:
            logging.error("*** Failed to send the email")
        email_server.quit()
    except:
        logging.error("*** Can't connect to the SMTP server")

    return email_is_sent

def mailtest():
	from smtplib import SMTP
	from poplib import POP3
	from time import sleep

	smtpsvr = 'xxxxx'
	pop3svr = 'xxxxx'

	user = '[email protected]'
	body = '''\
	From: %(who)s
	To: %(who)s
	Subject: TEST msg
	HELLO World!
	''' % ('who':user)

	sendsvr = SMTP(smtpsvr)
	errs = sendsvr.sendmail(user,[user],origMsg)
	sendsvr.quit()

	assert len(errs) == 0,errs
	sleep(10)

	recvsvr = POP3(pop3svr)
	recvsvr.user('xxx')
	recvsvr.pass_('xxxx')
	rsp,msg,siz = recvsvr.retr(recvsvr.stat()[0]) #登录成功后通过stat()方法得到可用消息列表,通过[0]获取第一条消息

	sep = msg.index('')
	recvbody = msg[sep+1:]

	assert origbody == recvbody

#IMAP4 互联网邮件访问协议，该模块定义了三个类 IMAP4 IMAP4_SSL IMAP4_stream
	"""