postmarker 2.0__tar.gz → 2.1__tar.gz

postmarker-2.1/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.5
+Name: postmarker
+Version: 2.1
+Summary: Python client library for Postmark API
+Project-URL: Documentation, https://postmarker.readthedocs.io/en/stable/
+Project-URL: Changelog, https://github.com/Stranger6667/postmarker/blob/master/CHANGELOG.md
+Project-URL: Bug Tracker, https://github.com/Stranger6667/postmarker/issues
+Project-URL: Funding, https://github.com/sponsors/Stranger6667
+Project-URL: Source Code, https://github.com/Stranger6667/postmarker
+Author-email: Dmitry Dygalo <dmitry@dygalo.dev>
+Maintainer-email: Dmitry Dygalo <dmitry@dygalo.dev>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api,client,django,email,email backend,postmark,postmarkapp,transactional email
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Communications :: Email
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.20.0
+Provides-Extra: css-inline
+Requires-Dist: css-inline>=0.24; extra == 'css-inline'
+Provides-Extra: docs
+Requires-Dist: mkdocstrings[python]; extra == 'docs'
+Requires-Dist: pymdown-extensions; extra == 'docs'
+Requires-Dist: ruff; extra == 'docs'
+Requires-Dist: zensical<0.2,>=0.1.1; extra == 'docs'
+Provides-Extra: tests
+Requires-Dist: coverage[toml]>=7.2; extra == 'tests'
+Requires-Dist: css-inline>=0.24; extra == 'tests'
+Requires-Dist: pytest-django; extra == 'tests'
+Requires-Dist: pytest-recording>=0.14; extra == 'tests'
+Requires-Dist: pytest>=8; extra == 'tests'
+Requires-Dist: tornado; extra == 'tests'
+Description-Content-Type: text/markdown
+
+# Postmarker
+
+[![Build](https://github.com/Stranger6667/postmarker/actions/workflows/build.yml/badge.svg)](https://github.com/Stranger6667/postmarker/actions/workflows/build.yml) [![Coverage](https://codecov.io/gh/Stranger6667/postmarker/branch/master/graph/badge.svg)](https://codecov.io/gh/Stranger6667/postmarker) [![Version](https://img.shields.io/pypi/v/postmarker.svg)](https://pypi.org/project/postmarker/) [![Python versions](https://img.shields.io/pypi/pyversions/postmarker.svg)](https://pypi.org/project/postmarker/) [![Docs](https://readthedocs.org/projects/postmarker/badge/?version=stable)](https://postmarker.readthedocs.io/en/stable/) [![License](https://img.shields.io/pypi/l/postmarker.svg)](https://opensource.org/licenses/MIT)
+
+Python client for the [Postmark](https://postmarkapp.com) email API.
+
+Postmarker covers Postmark's API beyond sending: templates, bounces, suppressions, message streams, stats, servers and domains.
+It also ships a Django email backend, Postmark webhook wrappers and a pytest fixture for your tests.
+
+> [!NOTE]
+> Postmarker keeps Postmark's field names: `From`, `HtmlBody`, `TemplateModel`, `MessageStream`.
+> Copy any field from the [Postmark API docs](https://postmarkapp.com/developer) and pass it as is. There are no snake_case aliases.
+
+## Installation
+
+```
+uv pip install postmarker
+```
+
+To inline `<style>` CSS into HTML emails, install the `css-inline` extra and create the client with `inline_css=True`:
+
+```
+uv pip install 'postmarker[css-inline]'
+```
+
+## Usage
+
+```python
+from postmarker.core import PostmarkClient
+
+postmark = PostmarkClient(server_token="POSTMARK_API_TEST")
+postmark.emails.send(
+    From="sender@example.com",
+    To="receiver@example.com",
+    Subject="Postmark test",
+    HtmlBody="<strong>Hello</strong> dear Postmark user.",
+)
+# {"ErrorCode": 0, "Message": "Test job accepted", "MessageID": "...", ...}
+```
+
+With the `POSTMARK_API_TEST` token, Postmark validates the request without delivering it.
+To send real emails, use the server token from your server's API Tokens tab in Postmark.
+`From` must be a confirmed sender signature or an address on a verified domain.
+
+Send with a template:
+
+```python
+postmark.emails.send_with_template(
+    TemplateAlias="welcome",
+    TemplateModel={"name": "Jane"},
+    From="sender@example.com",
+    To="receiver@example.com",
+)
+```
+
+Send a batch. Postmarker splits it into requests of 500 messages, Postmark's limit:
+
+```python
+messages = [
+    {"From": "sender@example.com", "To": to, "Subject": "Hi", "TextBody": "Hello"}
+    for to in ("first@example.com", "second@example.com")
+]
+responses = postmark.emails.send_batch(*messages)
+# Postmark accepts or rejects each message separately
+failed = [response for response in responses if response["ErrorCode"] != 0]
+```
+
+Add headers and attachments:
+
+```python
+email = postmark.emails.Email(
+    From="sender@example.com",
+    To="receiver@example.com",
+    Subject="Report",
+    TextBody="See the attached report.",
+)
+email["X-Accept-Language"] = "en-us, en"
+email.attach("/home/user/report.pdf")
+email.attach_binary(content=b"content", filename="readme.txt")
+email.send()
+```
+
+A rejected request raises `ClientError` with Postmark's [error code](https://postmarkapp.com/developer/api/overview#error-codes):
+
+```python
+from postmarker.exceptions import ClientError
+
+try:
+    postmark.emails.send(
+        From="sender@example.com",
+        To="receiver@example.com",
+        TextBody="Hello",
+    )
+except ClientError as exc:
+    print(exc.error_code)  # For example, 406 for an inactive recipient
+```
+
+## Django
+
+Django 6.1+:
+
+```python
+MAILERS = {
+    "default": {
+        "BACKEND": "postmarker.django.EmailBackend",
+        "OPTIONS": {"token": "<YOUR POSTMARK SERVER TOKEN>"},
+    },
+}
+```
+
+Django 5.2 and 6.0:
+
+```python
+EMAIL_BACKEND = "postmarker.django.EmailBackend"
+POSTMARK = {"TOKEN": "<YOUR POSTMARK SERVER TOKEN>"}
+```
+
+Django then sends `send_mail`, `EmailMessage` and emails from third-party apps through Postmark.
+The [Django guide](https://postmarker.readthedocs.io/en/stable/django/) covers tags, metadata, message streams and signals.
+
+## Testing
+
+Postmarker ships a `postmark_request` pytest fixture.
+It mocks requests to Postmark and records what your code sent, through `PostmarkClient` or the Django backend:
+
+```python
+def test_welcome_email(postmark_request):
+    send_welcome_email("jane@example.com")  # Your code that sends an email
+    assert postmark_request.call_args.kwargs["json"]["To"] == "jane@example.com"
+```
+
+## Features
+
+- Server APIs: Emails, Templates with layouts, Bounces, Messages (inbound, outbound, opens and clicks), Message Streams, Suppressions, Server, Stats and Triggers.
+- Account APIs: Domains, Sender signatures, Servers and pushing templates between servers.
+- Status and Spam check APIs.
+- Webhook wrappers: Inbound, Delivery, Open, Click, Bounce, Spam complaint and Subscription change.
+- Sending `email.message.Message` instances.
+- CSS inlining via [css-inline](https://github.com/Stranger6667/css-inline).
+- Django email backend and Tornado helper.
+- Type annotations, with a `py.typed` marker.
+
+## Documentation
+
+<https://postmarker.readthedocs.io/en/stable/>
+
+## Python support
+
+Postmarker supports CPython 3.10 to 3.15 and PyPy 3.11. The Django email backend supports Django 5.2, 6.0 and 6.1.

postmarker-2.1/README.md

@@ -0,0 +1,149 @@
+# Postmarker
+
+[![Build](https://github.com/Stranger6667/postmarker/actions/workflows/build.yml/badge.svg)](https://github.com/Stranger6667/postmarker/actions/workflows/build.yml) [![Coverage](https://codecov.io/gh/Stranger6667/postmarker/branch/master/graph/badge.svg)](https://codecov.io/gh/Stranger6667/postmarker) [![Version](https://img.shields.io/pypi/v/postmarker.svg)](https://pypi.org/project/postmarker/) [![Python versions](https://img.shields.io/pypi/pyversions/postmarker.svg)](https://pypi.org/project/postmarker/) [![Docs](https://readthedocs.org/projects/postmarker/badge/?version=stable)](https://postmarker.readthedocs.io/en/stable/) [![License](https://img.shields.io/pypi/l/postmarker.svg)](https://opensource.org/licenses/MIT)
+
+Python client for the [Postmark](https://postmarkapp.com) email API.
+
+Postmarker covers Postmark's API beyond sending: templates, bounces, suppressions, message streams, stats, servers and domains.
+It also ships a Django email backend, Postmark webhook wrappers and a pytest fixture for your tests.
+
+> [!NOTE]
+> Postmarker keeps Postmark's field names: `From`, `HtmlBody`, `TemplateModel`, `MessageStream`.
+> Copy any field from the [Postmark API docs](https://postmarkapp.com/developer) and pass it as is. There are no snake_case aliases.
+
+## Installation
+
+```
+uv pip install postmarker
+```
+
+To inline `<style>` CSS into HTML emails, install the `css-inline` extra and create the client with `inline_css=True`:
+
+```
+uv pip install 'postmarker[css-inline]'
+```
+
+## Usage
+
+```python
+from postmarker.core import PostmarkClient
+
+postmark = PostmarkClient(server_token="POSTMARK_API_TEST")
+postmark.emails.send(
+    From="sender@example.com",
+    To="receiver@example.com",
+    Subject="Postmark test",
+    HtmlBody="<strong>Hello</strong> dear Postmark user.",
+)
+# {"ErrorCode": 0, "Message": "Test job accepted", "MessageID": "...", ...}
+```
+
+With the `POSTMARK_API_TEST` token, Postmark validates the request without delivering it.
+To send real emails, use the server token from your server's API Tokens tab in Postmark.
+`From` must be a confirmed sender signature or an address on a verified domain.
+
+Send with a template:
+
+```python
+postmark.emails.send_with_template(
+    TemplateAlias="welcome",
+    TemplateModel={"name": "Jane"},
+    From="sender@example.com",
+    To="receiver@example.com",
+)
+```
+
+Send a batch. Postmarker splits it into requests of 500 messages, Postmark's limit:
+
+```python
+messages = [
+    {"From": "sender@example.com", "To": to, "Subject": "Hi", "TextBody": "Hello"}
+    for to in ("first@example.com", "second@example.com")
+]
+responses = postmark.emails.send_batch(*messages)
+# Postmark accepts or rejects each message separately
+failed = [response for response in responses if response["ErrorCode"] != 0]
+```
+
+Add headers and attachments:
+
+```python
+email = postmark.emails.Email(
+    From="sender@example.com",
+    To="receiver@example.com",
+    Subject="Report",
+    TextBody="See the attached report.",
+)
+email["X-Accept-Language"] = "en-us, en"
+email.attach("/home/user/report.pdf")
+email.attach_binary(content=b"content", filename="readme.txt")
+email.send()
+```
+
+A rejected request raises `ClientError` with Postmark's [error code](https://postmarkapp.com/developer/api/overview#error-codes):
+
+```python
+from postmarker.exceptions import ClientError
+
+try:
+    postmark.emails.send(
+        From="sender@example.com",
+        To="receiver@example.com",
+        TextBody="Hello",
+    )
+except ClientError as exc:
+    print(exc.error_code)  # For example, 406 for an inactive recipient
+```
+
+## Django
+
+Django 6.1+:
+
+```python
+MAILERS = {
+    "default": {
+        "BACKEND": "postmarker.django.EmailBackend",
+        "OPTIONS": {"token": "<YOUR POSTMARK SERVER TOKEN>"},
+    },
+}
+```
+
+Django 5.2 and 6.0:
+
+```python
+EMAIL_BACKEND = "postmarker.django.EmailBackend"
+POSTMARK = {"TOKEN": "<YOUR POSTMARK SERVER TOKEN>"}
+```
+
+Django then sends `send_mail`, `EmailMessage` and emails from third-party apps through Postmark.
+The [Django guide](https://postmarker.readthedocs.io/en/stable/django/) covers tags, metadata, message streams and signals.
+
+## Testing
+
+Postmarker ships a `postmark_request` pytest fixture.
+It mocks requests to Postmark and records what your code sent, through `PostmarkClient` or the Django backend:
+
+```python
+def test_welcome_email(postmark_request):
+    send_welcome_email("jane@example.com")  # Your code that sends an email
+    assert postmark_request.call_args.kwargs["json"]["To"] == "jane@example.com"
+```
+
+## Features
+
+- Server APIs: Emails, Templates with layouts, Bounces, Messages (inbound, outbound, opens and clicks), Message Streams, Suppressions, Server, Stats and Triggers.
+- Account APIs: Domains, Sender signatures, Servers and pushing templates between servers.
+- Status and Spam check APIs.
+- Webhook wrappers: Inbound, Delivery, Open, Click, Bounce, Spam complaint and Subscription change.
+- Sending `email.message.Message` instances.
+- CSS inlining via [css-inline](https://github.com/Stranger6667/css-inline).
+- Django email backend and Tornado helper.
+- Type annotations, with a `py.typed` marker.
+
+## Documentation
+
+<https://postmarker.readthedocs.io/en/stable/>
+
+## Python support
+
+Postmarker supports CPython 3.10 to 3.15 and PyPy 3.11. The Django email backend supports Django 5.2, 6.0 and 6.1.

{postmarker-2.0 → postmarker-2.1}/pyproject.toml

@@ -39,7 +39,8 @@ classifiers = [
 dependencies = ["requests>=2.20.0"]
 
 [project.optional-dependencies]
-tests = ["coverage[toml]>=7", "pytest>=8", "pytest-django", "pytest-recording>=0.14", "tornado"]
+css-inline = ["css-inline>=0.24"]
+tests = ["postmarker[css-inline]", "coverage[toml]>=7.2", "pytest>=8", "pytest-django", "pytest-recording>=0.14", "tornado"]
 docs = ["mkdocstrings[python]", "pymdown-extensions", "ruff", "zensical>=0.1.1,<0.2"]
 
 [project.entry-points.pytest11]
@@ -76,7 +77,8 @@ source = ["src", ".tox/*/site-packages", ".tox/*/lib/*/site-packages", ".tox/*/L
 [tool.coverage.report]
 show_missing = true
 precision = 2
-exclude_lines = ["raise NotImplementedError"]
+exclude_also = ["if TYPE_CHECKING:"]
+fail_under = 100
 
 [tool.ruff]
 line-length = 120

postmarker-2.1/src/postmarker/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.1"

{postmarker-2.0 → postmarker-2.1}/src/postmarker/core.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import sys
 from collections.abc import Mapping
-from typing import Any, TextIO
+from typing import TYPE_CHECKING, Any, TextIO
 from urllib.parse import urljoin
 
 import requests
@@ -26,6 +26,9 @@ from .models.templates import TemplateManager
 from .models.triggers import TriggersManager
 from .utils import get_args
 
+if TYPE_CHECKING:
+    from css_inline import CSSInliner
+
 DEFAULT_API = "https://api.postmarkapp.com/"
 STATUS_API = "https://status.postmarkapp.com/api/1.0/"
 SPAMCHECK_API = "https://spamcheck.postmarkapp.com/filter/"
@@ -33,6 +36,21 @@ USER_AGENT = f"Postmarker/{__version__}"
 TEST_TOKEN = "POSTMARK_API_TEST"
 
 
+def make_css_inliner(inline_css: bool | CSSInliner) -> CSSInliner | None:
+    if not inline_css:
+        return None
+    if inline_css is not True:
+        return inline_css
+    try:
+        import css_inline
+    except ImportError as exc:
+        raise ImportError(
+            "`inline_css` requires the `css-inline` package: pip install 'postmarker[css-inline]'"
+        ) from exc
+    # Email HTML may carry user content; never fetch `<link>` URLs from it
+    return css_inline.CSSInliner(load_remote_stylesheets=False)
+
+
 class PostmarkClient:
     """Basic class for API clients. Provides basic functionality to make requests."""
 
@@ -76,6 +94,7 @@ class PostmarkClient:
         timeout: float | tuple[float, float] | None = None,
         logs_stream: TextIO = sys.stdout,
         root_api_url: str = DEFAULT_API,
+        inline_css: bool | CSSInliner = False,
     ) -> None:
         assert server_token or account_token, "You have to provide server_token or account_token to use Postmark API"
         self.server_token = server_token
@@ -84,6 +103,7 @@ class PostmarkClient:
         self.timeout = timeout
         self.logger = get_logger("Postmarker", verbosity, logs_stream)
         self.root_api_url = root_api_url
+        self.css_inliner = make_css_inliner(inline_css)
         self._setup_managers()
 
     @classmethod

{postmarker-2.0 → postmarker-2.1}/src/postmarker/django/backend.py

@@ -10,11 +10,11 @@ from django.core.mail.backends.base import BaseEmailBackend
 from django.utils.encoding import force_str
 from django.utils.functional import partition
 
-from ..core import TEST_TOKEN, PostmarkClient
+from ..core import TEST_TOKEN, PostmarkClient, make_css_inliner
 from ..exceptions import ClientError
 from .signals import on_exception, post_send, pre_send
 
-DEFAULT_CONFIG = {"TEST_MODE": False, "TRACK_OPENS": False, "VERBOSITY": 0}
+DEFAULT_CONFIG = {"TEST_MODE": False, "TRACK_OPENS": False, "VERBOSITY": 0, "INLINE_CSS": False}
 
 
 class EmailBackend(BaseEmailBackend):
@@ -31,6 +31,8 @@ class EmailBackend(BaseEmailBackend):
             self.server_token = token or self.get_option("TOKEN")
             if self.server_token is None:
                 raise ImproperlyConfigured("You should specify TOKEN to use Postmark email backend")
+        # Outside `send_messages`, so `fail_silently` can't hide a missing `css-inline`
+        self.inline_css = make_css_inliner(self.get_option("INLINE_CSS")) or False
 
     @property
     def config(self) -> dict[str, Any]:
@@ -42,7 +44,11 @@ class EmailBackend(BaseEmailBackend):
 
     def open(self) -> bool:
         if self.client is None:
-            self.client = PostmarkClient(server_token=self.server_token, verbosity=self.get_option("VERBOSITY"))
+            self.client = PostmarkClient(
+                server_token=self.server_token,
+                verbosity=self.get_option("VERBOSITY"),
+                inline_css=self.inline_css,
+            )
             return True
         return False
 

{postmarker-2.0 → postmarker-2.1}/src/postmarker/models/emails.py

@@ -51,7 +51,7 @@ def prepare_attachments(attachment: AttachmentData) -> dict[str, Any]:
         # Postmark requires base64 content for every attachment, including `message/rfc822`.
         # A payload without `Content-Transfer-Encoding` is expected to be base64 already
         if content_type == "message/rfc822" and not isinstance(payload, str):
-            payload = b64encode(payload[0].get_payload(decode=True)).decode()
+            payload = b64encode(payload[0].as_bytes()).decode()
         elif "Content-Transfer-Encoding" in attachment:
             payload = b64encode(cast(bytes, attachment.get_payload(decode=True))).decode()
         result = {
@@ -234,6 +234,13 @@ class Email(BaseEmail):
             MessageStream=message_stream,
         )
 
+    def as_dict(self) -> dict[str, Any]:
+        data = super().as_dict()
+        inliner = self._manager and self._manager.client.css_inliner
+        if inliner and data.get("HtmlBody"):
+            data["HtmlBody"] = inliner.inline(data["HtmlBody"])
+        return data
+
     def send(self) -> Any:
         return self._manager._send(**self.as_dict())
 

{postmarker-2.0 → postmarker-2.1}/test/django/test_backend.py

@@ -1,3 +1,4 @@
+import sys
 import warnings
 from base64 import b64decode
 from contextlib import contextmanager
@@ -234,8 +235,9 @@ def test_text_html_alternative_and_pdf_attachment_failure(postmark_request, mess
 
 
 def test_message_rfc822(postmark_request, message):
-    message_content = "Fake message"
-    expected_content = "RmFrZSBtZXNzYWdl"
+    # Headers of the attached message must survive, not only its body
+    message_content = "Subject: Hi\n\nFake message"
+    expected_content = "U3ViamVjdDogSGkKCkZha2UgbWVzc2FnZQ=="
     message.attach_alternative(message_content, "message/rfc822")
     message.send(fail_silently=False)
     assert postmark_request.call_args[1]["json"][0] == {
@@ -550,3 +552,22 @@ def test_signals_on_exception(catch_signal):
     assert kwargs["signal"] == on_exception
     assert isinstance(kwargs["exception"], ConnectTimeout)
     assert len(kwargs["raw_messages"]) == 1
+
+
+def test_inline_css(settings, postmark_request):
+    settings.POSTMARK = {**settings.POSTMARK, "INLINE_CSS": True}
+    send_mail(
+        html_message="<html><head><style>h1{color:red}</style></head><body><h1>Hi</h1></body></html>", **SEND_KWARGS
+    )
+    assert (
+        postmark_request.call_args[1]["json"][0]["HtmlBody"]
+        == '<html><head></head><body><h1 style="color: red;">Hi</h1></body></html>'
+    )
+
+
+def test_inline_css_missing_package(settings, monkeypatch):
+    # Raised outside `fail_silently`, otherwise every email is dropped without a trace
+    settings.POSTMARK = {**settings.POSTMARK, "INLINE_CSS": True}
+    monkeypatch.setitem(sys.modules, "css_inline", None)
+    with pytest.raises(ImportError, match=r"postmarker\[css-inline\]"):
+        EmailBackend(fail_silently=True)

{postmarker-2.0 → postmarker-2.1}/test/models/test_emails.py

@@ -2,14 +2,19 @@ import base64
 import os
 import platform
 import re
+import sys
 from email import encoders
+from email.message import EmailMessage
 from email.mime.base import MIMEBase
 from email.mime.image import MIMEImage
+from email.mime.message import MIMEMessage
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 
+import css_inline
 import pytest
 
+from postmarker.core import PostmarkClient
 from postmarker.models.emails import Email
 
 pytestmark = pytest.mark.vcr
@@ -267,7 +272,7 @@ def test_batch_send_multiple(postmark, email, postmark_request):
 
 def test_batch_send_mime(postmark, postmark_request):
     postmark.emails.send_batch(MIME_MESSAGE)
-    email = Email.from_mime(MIME_MESSAGE, postmark)
+    email = Email.from_mime(MIME_MESSAGE, postmark.emails)
     assert postmark_request.call_args[1]["json"] == (email.as_dict(),)
 
 
@@ -364,7 +369,7 @@ def test_email_attach_binary(email, postmark_request):
 
 
 def test_email_from_mime(postmark):
-    email = Email.from_mime(MIME_MESSAGE, postmark)
+    email = Email.from_mime(MIME_MESSAGE, postmark.emails)
     assert email.TextBody == "Text"
     assert email.From == MIME_MESSAGE["From"]
     assert email.To == MIME_MESSAGE["To"]
@@ -485,3 +490,90 @@ def test_email_template_repr(email_template):
 
 def test_email_template_batch_len(email_template_batch):
     assert len(email_template_batch) == 1
+
+
+STYLED_HTML = "<html><head><style>h1{color:red}</style></head><body><h1>Hi</h1></body></html>"
+INLINED_HTML = '<html><head></head><body><h1 style="color: red;">Hi</h1></body></html>'
+STYLED_EMAIL = {"From": "sender@example.com", "To": "receiver@example.com", "HtmlBody": STYLED_HTML}
+
+
+def sent_html_body(postmark_request):
+    payload = postmark_request.call_args[1]["json"]
+    # Batches send a tuple of emails
+    if isinstance(payload, tuple):
+        payload = payload[0]
+    return payload["HtmlBody"]
+
+
+@pytest.mark.parametrize(
+    "send",
+    (
+        lambda client: client.emails.send(**STYLED_EMAIL),
+        lambda client: client.emails.send(message=get_mime_message("Text", STYLED_HTML, **DEFAULT_HEADERS)),
+        lambda client: client.emails.send_batch(STYLED_EMAIL),
+        lambda client: client.emails.send_batch(get_mime_message("Text", STYLED_HTML, **DEFAULT_HEADERS)),
+    ),
+    ids=("send", "send-mime", "batch", "batch-mime"),
+)
+def test_inline_css(postmark_request, send):
+    send(PostmarkClient(server_token="SERVER_TOKEN", inline_css=True))
+    assert sent_html_body(postmark_request) == INLINED_HTML
+
+
+def test_inline_css_from_config(postmark_request):
+    client = PostmarkClient.from_config({"postmark_server_token": "SERVER_TOKEN", "postmark_inline_css": True})
+    client.emails.send(**STYLED_EMAIL)
+    assert sent_html_body(postmark_request) == INLINED_HTML
+
+
+def test_inline_css_custom_inliner(postmark_request):
+    client = PostmarkClient(server_token="SERVER_TOKEN", inline_css=css_inline.CSSInliner(keep_style_tags=True))
+    client.emails.send(**STYLED_EMAIL)
+    assert (
+        sent_html_body(postmark_request)
+        == '<html><head><style>h1{color:red}</style></head><body><h1 style="color: red;">Hi</h1></body></html>'
+    )
+
+
+def test_inline_css_skips_remote_stylesheets(postmark_request):
+    # Email HTML may carry user content; the default inliner must not fetch `<link>` URLs
+    html = '<html><head><link rel="stylesheet" href="http://127.0.0.1:9/x.css"></head><body>Hi</body></html>'
+    PostmarkClient(server_token="SERVER_TOKEN", inline_css=True).emails.send(**{**STYLED_EMAIL, "HtmlBody": html})
+    assert sent_html_body(postmark_request) == "<html><head></head><body>Hi</body></html>"
+
+
+def test_inline_css_missing_package(monkeypatch):
+    monkeypatch.setitem(sys.modules, "css_inline", None)
+    with pytest.raises(ImportError, match=r"postmarker\[css-inline\]"):
+        PostmarkClient(server_token="SERVER_TOKEN", inline_css=True)
+
+
+@pytest.mark.parametrize(
+    "inner", (MIMEText("Forwarded"), get_mime_message("Text", "<b>HTML</b>")), ids=("simple", "multipart")
+)
+def test_email_attach_forwarded_message(email, postmark_request, inner):
+    attachment = MIMEMessage(inner)
+    attachment.add_header("Content-Disposition", "attachment", filename="forwarded.eml")
+    email.attach(attachment)
+    email.send()
+    assert postmark_request.call_args[1]["json"]["Attachments"] == [
+        {
+            "Name": "forwarded.eml",
+            "Content": base64.b64encode(inner.as_bytes()).decode(),
+            "ContentType": "message/rfc822",
+        }
+    ]
+
+
+def test_email_from_mime_encoded_headers(postmark):
+    message = MIMEText("Text")
+    # An encoded word followed by plain text decodes into parts with and without a charset
+    message["Subject"] = "=?utf-8?b?w6k=?= text"
+    assert Email.from_mime(message, postmark.emails).Subject == "\u00e9 text"
+
+
+def test_email_from_mime_set_content(postmark):
+    message = EmailMessage()
+    # `set_content` appends a newline the sender never wrote
+    message.set_content("Text")
+    assert Email.from_mime(message, postmark.emails).TextBody == "Text"