Python client library for Postmark API

Follow up for this comment:

@Stranger6667 Is this working for you? I am getting the same exception with Python 2.7, Django 1.11 as well as Python 3.6, Django 1.11.

I get

TypeError: Object of type 'SafeMIMEText' is not JSON serializable and I am unable to debug the issue.

Hi @suriya ! Could you, please, add some code to reproduce the issue?

I can't figure out a way to send Tag information to Postmark when using the Django EmailBackend. I did dive deep into the code but unfortunately had difficulty figuring out where the right place even to patch it would be.

I know I could use the regular PostmarkClient, but it's important for us to continue using the built-in Django mechanism so that we can stay vendor agnostic.

Can you point me in the right direction on where a patch would go?

Postmarker has a dependency on mock, used here: https://github.com/Stranger6667/postmarker/blob/c0c0f7af623dc7b3fc0c030867773755dca31f67/postmarker/_compat.py#L13

I notice that mock.patch is used only in tests. Does this make sense to move the line to a separate file _compat_tests.py so that normal usage of postmarker does not need the mock package?

Thank you so much for your work here!

Just wanted to confirm if this package will be affected by the Postmark upcoming TLS configuration changes?

The email below was received just a few hours ago:

Hi there, To ensure the continued security of our systems, we wanted to let you know about some upcoming changes to our TLS (Transport Layer Security) configurations for API access.These changes may affect your application’s ability to continue to send mail through Postmark, so please read through this email in detail. You can also read through these changes on our website.These changes do not affect sending via SMTP.

What’s changingOn April 13, 2021, we are going to (1) disable TLSv1 access, (2) disable all RC4 and low-strength ciphers, and (3) add HSTS headers.Here’s the full timeline of the changes:February 2021: Announcement of the changes, and testing endpoints are made available.March 23, 2021: Perform “blackout” test, where we cut over to the new configuration for one hour in production.March 30, 2021: Perform another “blackout” test, where we cut over to the new configuration for 12 hours in production.April 13, 2021: Cut over production to new configuration permanently.April 20, 2021: Decommission temporary testing SSL endpoint.We’ll discuss each change below, as well as your next steps to make sure sending isn’t interrupted. Changes and impact(1) Disabling TLSv1 accessTLSv1 has been deprecated, and we are following suit.Impact: Connections that only support TLSv1 would not be able to connect anymore after this change.(2) Disabling all RC4 and low-strength ciphersRC4 ciphers are considered weak and they are deprecated as well. Along with this, we are getting rid of any low-strength ciphers that are vulnerable to breaks as well.Impact: Connections that only support these old/weak ciphers would not be able to connect anymore after this change.(3) Adding HSTS headersHSTS (HTTP Strict Transport Security) headers tell web clients to only ever connect to a URL over HTTPS for a period of time (usually 6 months to 1 year). This prevents something called a “downgrade attack”, where users are tricked into visiting a version of a URL that is not secured or validated with TLS.Impact: We are adding these headers in accordance with industry standards. There is no API connectivity impact. ----- | -----

What you need to doIf you send with Postmark via our API, please make sure that your sending infrastructure is able to deal with these changes prior to the April 13 cutover date.We’ve set up a temporary endpoint at api-ssl-temp.postmarkapp.com that has these changes already applied. You can use this as an endpoint to test/validate against. Please be aware that there is no expectation of uptime on this endpoint, and that it will be shut down on April 20, 2021 with no further notice. It should only be used for temporary testing of non-production traffic.If any of your tests with the temporary endpoint fail, updating your OpenSSL library should resolve the issue. If you are having trouble getting your API integration to work with this temporary endpoint, please contact our support team and let us know the exact error message encountered when attempting to connect, and a log of the connection attempt. We may be able to provide specific instructions for using newer TLS configurations.If you have any questions, just reply to this email. We’re here to help!

Unfortunately the docs at https://postmarker.readthedocs.io/en/stable/ are stuck on 1.3.0.

Looking at the changes since then (see https://github.com/Stranger6667/postmarker/compare/0.13.0...v0.17.1), I'm not too sure what could have caused this, but I know RTD to be quite picky about docs dependencies, so maybe the move to pyproject.toml?

Referring to #150

When I try to send an email using a template alias, postmark.emails.send_with_template(TemplateAlias=alias, TemplateModel=model, To=sendto, From=efrom)

I get the following response: TypeError: send_with_template() missing 1 required positional argument: 'TemplateId'

Thanks.

Postmarker's Django backend crashes when sending a message with attachments. The crash happens when therequests library tries to convert a dictionary containing email message information into a JSON string. The conversion fails for attachments.

Here's a stack trace.

  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/django/core/mail/message.py", line 303, in send
    return self.get_connection(fail_silently).send_messages([self])
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/postmarker/django.py", line 57, in send_messages
    response = self.client.emails.send_batch(*prepared_messages, TrackOpens=self.get_option('TRACK_OPENS'))
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/postmarker/models/emails.py", line 324, in send_batch
    return self.EmailBatch(*emails).send(**extra)
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/postmarker/models/emails.py", line 245, in send
    responses = [self._manager._send_batch(*batch) for batch in chunks(emails, self.MAX_SIZE)]
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/postmarker/models/emails.py", line 268, in _send_batch
    return self.call('POST', '/email/batch', data=emails)
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/postmarker/models/base.py", line 63, in call
    return self.client.call(*args, **kwargs)
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/postmarker/core.py", line 84, in call
    **kwargs
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/postmarker/core.py", line 106, in _call
    response = self.session.request(method, url, json=data, params=kwargs, headers=default_headers)
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/requests/sessions.py", line 474, in request
    prep = self.prepare_request(req)
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/requests/sessions.py", line 407, in prepare_request
    hooks=merge_hooks(request.hooks, self.hooks),
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/requests/models.py", line 305, in prepare
    self.prepare_body(data, files, json)
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/requests/models.py", line 462, in prepare_body
    body = complexjson.dumps(json)
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/simplejson/__init__.py", line 280, in dumps
    def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/simplejson/encoder.py", line 291, in encode
    chunks = self.iterencode(o, _one_shot=True)
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/simplejson/encoder.py", line 373, in iterencode
    return _iterencode(o, 0)
  File "/home/vagrant/bookshelf.git/my-env/local/lib/python2.7/site-packages/simplejson/encoder.py", line 268, in default
    raise TypeError(repr(o) + " is not JSON serializable")
TypeError: <django.core.mail.message.SafeMIMEText instance at 0x7f15eacc8e18> is not JSON serializable

Sorry to be leaving you so many issues!

Looks like there's now an issue when sending messages at least with unicode characters in the body. The message I am sending usings django.template.Template to render a template to a string and then submit it as the message HTML body.

This problem goes away if you temporarily set sys.setdefaultencoding('utf8') (which you obviously shouldn't be doing).

Here is the traceback:

/Users/../utils/emails.pyc in send_html_email(subject, from_email, to_emails, reply_to, text_body, html_body, headers, tag, metadata, subaccount, attachments, send_in, extra_params, bcc)
    128             setattr(msg, key, value)
    129
--> 130     msg.send()
    131
    132

/Users/../.virtualenvs/TCJ/lib/python2.7/site-packages/django/core/mail/message.pyc in send(self, fail_silently)
    340             # send to.
    341             return 0
--> 342         return self.get_connection(fail_silently).send_messages([self])
    343
    344     def attach(self, filename=None, content=None, mimetype=None):

/Users/../.virtualenvs/TCJ/lib/python2.7/site-packages/postmarker/django.pyc in send_messages(self, email_messages)
     55             client_created = self.open()
     56             prepared_messages = [self.prepare_message(message) for message in email_messages]
---> 57             response = self.client.emails.send_batch(*prepared_messages, TrackOpens=self.get_option('TRACK_OPENS'))
     58             msg_count = len(response)
     59             if client_created:

/Users/../.virtualenvs/TCJ/lib/python2.7/site-packages/postmarker/models/emails.pyc in send_batch(self, *emails, **extra)
    322         :param extra: dictionary with extra arguments for every message in the batch.
    323         """
--> 324         return self.EmailBatch(*emails).send(**extra)
    325
    326     # NOTE. The following methods are included here to expose better interface without need to import relevant classes.

/Users/../.virtualenvs/TCJ/lib/python2.7/site-packages/postmarker/models/emails.pyc in send(self, **extra)
    242         :rtype: `list`
    243         """
--> 244         emails = self.as_dict(**extra)
    245         responses = [self._manager._send_batch(*batch) for batch in chunks(emails, self.MAX_SIZE)]
    246         return sum(responses, [])

/Users/../.virtualenvs/TCJ/lib/python2.7/site-packages/postmarker/models/emails.pyc in as_dict(self, **extra)
    220         :return: List of dictionaries.
    221         """
--> 222         return [self._construct_email(email, **extra) for email in self.emails]
    223
    224     def _construct_email(self, email, **extra):

/Users/../.virtualenvs/TCJ/lib/python2.7/site-packages/postmarker/models/emails.pyc in _construct_email(self, email, **extra)
    229             email = Email(manager=self._manager, **email)
    230         elif isinstance(email, (MIMEText, MIMEMultipart)):
--> 231             email = Email.from_mime(email, self._manager)
    232         elif not isinstance(email, Email):
    233             raise ValueError

/Users/../.virtualenvs/TCJ/lib/python2.7/site-packages/postmarker/models/emails.pyc in from_mime(cls, message, manager)
    178         """
    179         if isinstance(message, MIMEMultipart):
--> 180             text, html, attachments = deconstruct_multipart(message)
    181         else:
    182             text, html, attachments = message.get_payload(decode=True).decode(), None, []

/Users/../.virtualenvs/TCJ/lib/python2.7/site-packages/postmarker/models/emails.pyc in deconstruct_multipart(message)
     85             text = part.get_payload(decode=True).decode()
     86         elif content_type == 'text/html':
---> 87             html = part.get_payload(decode=True).decode()
     88         elif content_type != 'multipart/alternative':
     89             attachments.append(part)

UnicodeDecodeError: 'ascii' codec can't decode byte 0xc2 in position 3495: ordinal not in range(128)

I'm currently getting around this with the following context manager, but obviously this cannot be the case long-term:

@contextlib.contextmanager
def set_default_encoding(encoding='ascii'):
    """\
    Temporarily set the default encoding within the span of the context.

    NOTE: Using `sys.setdefaultencoding()` is HIGHLY DISCOURAGED and this context
    manager should only be used when working with third party libraries that incorrectly
    handle unicode/strings/bytestrings and cannot easily be patched, updated, or worked around.
    """
    import sys
    reload(sys)
    original_encoding = sys.getdefaultencoding()
    sys.setdefaultencoding(encoding)
    yield
    sys.setdefaultencoding(original_encoding)

If large HTML files (particularly those with large lines, for example anything produced using MJML with the --min minification flag enabled) are sent using Postmarker, the HTML is escaped using quoted-printable and sent to Postmark's API that way, when it should actually be sent unquoted.

The reason this happens is under the hood, Postmarker calls the Django email backend's message.message() within EmailBackend.prepare_message(). This has the message turn itself into MIME, which then is later deconstructed back to a dict using Email.from_mime(). Since Django thinks it's serializing the email for an SMTP send, it automatically quotes the email or alternative attachment under certain circumstances (utf-8 + long lines, see django.core.mail.message.py:220) and sets the Content-Transfer-Encoding to quoted-printable. When Postmarker turns that back into a dict, it loses the Content-Transfer-Encoding header and does not unquote, leading to the quoted version being sent directly via Postmark's API and completely incorrect emails being sent, particularly if they include any Outlook-specific markup that uses XML namespaces and colons.

One way to fix this is when converting the MIME email back to a dictionary, to detect if it has been quoted and then to unquote using email.quoprimime.body_decode(...). Alternatively, the better way to fix this is to refactor simply not to let Django's mailing backend create the MIME email at all, and simply send the body and headers to Postmark via the API without doing any unnecessary processing. This is how djrill for Mandrill works, and emails I sent with Postmarker that got mangled were not mangled with djrill.

Django release 4.0 has introduced some incompatibilities but they are all quite benign.

1. django/utils/encoding#force_text has been removed. It was previously deprecated.

force_str can be used as a direct replacement and was aliased. Available since Feb 2019 https://github.com/django/django/commit/3bb6a4390c0a57da991fcb1c0642b9b3fccff751

force_text was deprecated shortly after in https://github.com/django/django/commit/d55e88292723764a16f0689c73bc7e739dfa6047

force_text was then removed in the v4 release cycle as per the deprecation notice https://github.com/django/django/commit/810f037b29402f848a766f6900b4ebfbaf64cc88

2. Signal has lost the provided_args initialiser argument

This argument was deprecated in Mar 2020 at https://github.com/django/django/commit/769cee525222bb155735aba31d6174d73c271f3c

And subsequently removed in Jan 2021 at https://github.com/django/django/commit/1adcf20385c2856d3655089ff7a0b55b32e5587a

I don't know which previous versions of Django this affects or how backwards compatible you want to be, but I'll post a RP with these changes to run through Django v4.0

Postmark deprecated verifyspf (see https://postmarkapp.com/blog/why-we-no-longer-ask-for-spf-records).

This PR:

• Updates the test case for verifyspf to reflect this (ie. SPFVerified is always True)
• Introduces 2 new methods for verifyDkim and verifyReturnPath API endpoints

on_exception is missing from src/postmarker/django/__init__.py, making it impossible to do

from postmarker.django import on_exception

even though the pre_send and post_send signals are exposed in this way.

Thanks

The documentation for send_batch and send_template_batch both mention:

Parameters emails – Email instances or dictionaries

However, emails is actually equivalent to *args, i.e. emails internally captures (within send_batch and send_template_batch) all arguments passed to the function. The variable name emails is not actually exposed to the caller, and so isn't properly a "parameter".

Calling:

postmark.emails.send_batch(emails=[email, another_email])

will not work -- the function will instead confusingly return an empty array.

Just in case anybody comes here to troubleshoot this, the correct way to call the functon is rather:

postmark.emails.send_batch(email, another_email)
# ... or alternatively ...
my_emails = [email, another_email]
postmark.emails.send_batch(*my_emails)

Thanks!

After creating an Email object, converting it to a string representation leads to a confusing output.

Example:

e = postmark_client.emails.Email(From="[email protected]", To="[email protected]", TextBody="text")
print(e)

This outputs <Email: None>

Cheers

Hi there,

Thanks for a great library. I'm running into an edge case. If you have more than 10,000 outbound messages, this library will break as the count=None loop will eventually send a request like so:

https://api.postmarkapp.com/messages/outbound?count=500&offset=10000

And per Postmark's docs, the max of count + offset = 10,000.

So you'll get a 500 error from them.

This isn't an issue if the TotalCount in base.py returns less 10,000 because you'll break out of the loop.

I'm not sure how best to handle this. It seems like, no matter what we do, we can't get to message 10,001+ on postmark. So maybe the loop should also just break at 10,000.

Hope that helps. Thanks again for your work!

Hello, I attach csv file with unicode string and send to email with postmark. When I download csv file and open with ms excel the file show wrong string. Not sure what I do wrong ?

        files = []
        csvfile = StringIO()
        writer = csv.writer(csvfile)
        writer.writerow(['some unicode string'])

        data = csvfile.getvalue()
        attachment = MIMEBase('text', 'csv')
        attachment.set_payload(data.encode('utf-8'))
        encoders.encode_base64(attachment)
        attachment.add_header('Content-Disposition', 'attachment', filename='readme.csv')
        files.append(attachment)
        
        email = postmark.emails.send_with_template(
            TemplateId=xxx,
            TemplateModel={},
            From='[email protected]',
            To=['[email protected]'],
            Attachments=files
        )