def mail(self, **kwargs):
    '''Sends an email.

    Examples:
        >>> mailer = SMTPMailer(type='gmail', email='gramex.guide@gmail.com', password='...')
        >>> mailer.mail(
        ... to='person@example.com',
        ... subject='Subject',
        ... html='<strong>Bold text</strong>. <img src="cid:logo">'
        ... body='This plain text is shown if the client cannot render HTML',
        ... attachments=['1.pdf', '2.txt'],
        ... images={'logo': '/path/to/logo.png'})
        >>> message(to='b@example.org', subject=sub, body=text, html=html)
        >>> message(to='b@example.org', subject=sub, body=text, attachments=['file.pdf'])
        >>> message(to='b@example.org', subject=sub, body=text, attachments=[
                {'filename': 'test.txt', 'body': 'File contents'}
            ])
        >>> message(to='b@example.org', subject=sub, html='<img src="cid:logo">',
                    images={'logo': 'd:/images/logo.png'})

    Parameters may be any email parameter in [RFC 2822](https://www.rfc-wiki.org/wiki/RFC2822).
    Parameters are case insensitive. Most commonly used are:

    - `to`: The recipient email address
    - `cc`: The carbon copy recipient email address
    - `bcc`: The blind carbon copy recipient email address
    - `reply_to`: The reply-to email address
    - `on_behalf_of`: The sender email address
    - `subject`: The email subject
    - `body`: text content of the email
    - `html`: HTML content of the email. If both `html` and `body`
        are specified, the email contains both parts. Email clients may decide to
        show one or the other.
    - `attachments`: an list of file names or dict with:
        - `body`: a byte array of the content
        - `content_type`: MIME type or `filename` indicating the file name
    - `images`: dict of `{key: path}`.
        - `key` may be anything. The HTML should include the image via `<img src="cid:key">`
        - `path` is the absolute path to the image

    In addition, any keyword arguments passed are treated as message headers.

    `To`, `Cc` and `Bcc` may be:

    - a string with comma-separated emails, e.g. `'a@x.com, b@x.com'`
    - a list of strings with emails, e.g. `['a@x.com', 'b@x.com']`
    - a list of strings with comma-separated emails, e.g. `['a@x.com', 'b@x.com, c@x.com']`
    '''
    sender = kwargs.get('sender', self.email)
    # SES allows restricting the From: address. https://amzn.to/2Kqwh2y
    # SES uses an IAM ID for login (self.email), but restricts sender -- so from= is required
    # Mailgun suggests From: be the same as Sender: http://bit.ly/2tGS5wt
    # If mail(from=) is specified, use that as the sender. Else use email: from the service
    if kwargs.get('from', None):
        sender = kwargs['from']
    else:
        kwargs['from'] = sender
    # Identify recipients from to/cc/bcc fields.
    # Note: We MUST explicitly add EVERY recipient (to/cc/bcc) in sendmail(recipients=)
    to = recipients(**kwargs)
    msg = message(**kwargs)
    tls = self.client.get('tls', True)
    # Test cases specify stub: true. This uses a stub that logs emails
    if self.stub:
        server = SMTPStub(
            self.client['host'], self.client.get('port', self.ports[tls]), self.stub
        )
    else:
        server = smtplib.SMTP(self.client['host'], self.client.get('port', self.ports[tls]))
    if tls:
        server.starttls()
    if self.email is not None and self.password is not None:
        server.login(self.email, self.password)
    server.sendmail(sender, to, msg.as_string())
    server.quit()
    app_log.info(f'Email sent via {self.client["host"]} ({self.email}) to {", ".join(to)}')

def mail_log(self, **kwargs):
    '''Same as mail() but logs the exception. Useful with running in a thread'''
    try:
        self.mail(**kwargs)
    except Exception:
        app_log.exception(f'SMTP failed: {kwargs}')
        raise