sep-python-sdk 0.1.0__py3-none-any.whl

sep_sdk/client.py

@@ -0,0 +1,155 @@
+"""The synchronous client."""
+
+from __future__ import annotations
+
+import logging
+import time
+from types import TracebackType
+from typing import Any
+
+import httpx
+
+from sep_sdk._base import DEFAULT_TIMEOUT, ClientBase
+from sep_sdk.endpoints import Endpoints
+from sep_sdk.errors import SepError
+from sep_sdk.requests import TokenRequest
+from sep_sdk.responses import CallbackData, Token, TransactionResult
+from sep_sdk.retry import RetryPolicy
+
+logger = logging.getLogger("sep_sdk")
+
+
+class SepClient(ClientBase):
+    """Talk to the Saman online gateway from synchronous code.
+
+    ::
+
+        with SepClient(terminal_id="12345678") as sep:
+            token = sep.create_token(TokenRequest(amount=100_000, res_num="order-1", ...))
+
+    The client owns a connection pool; use it as a context manager or call
+    :meth:`close`. Pass ``http_client`` to supply your own :class:`httpx.Client`
+    (proxies, mTLS, instrumentation); it is then yours to close.
+    """
+
+    def __init__(
+        self,
+        terminal_id: str | int,
+        *,
+        endpoints: Endpoints | None = None,
+        timeout: float | httpx.Timeout = DEFAULT_TIMEOUT,
+        retry: RetryPolicy | None = None,
+        endpoint_fallback: bool = True,
+        transport: httpx.BaseTransport | None = None,
+        http_client: httpx.Client | None = None,
+    ) -> None:
+        super().__init__(
+            terminal_id, endpoints=endpoints, retry=retry, endpoint_fallback=endpoint_fallback
+        )
+        self._owns_client = http_client is None
+        self._http = http_client or httpx.Client(timeout=timeout, transport=transport)
+
+    def __enter__(self) -> SepClient:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.close()
+
+    def close(self) -> None:
+        """Release the connection pool (a client you passed in is left open)."""
+        if self._owns_client:
+            self._http.close()
+
+    # --- the four calls of the guide -------------------------------------
+
+    def create_token(self, request: TokenRequest) -> Token:
+        """Ask for a payment token for one order (guide step 1)."""
+        response = self._post("token", self._token_payload(request))
+        return self._finish_token(request, response)
+
+    def verify_transaction(
+        self, ref_num: str, *, session_key: str | None = None
+    ) -> TransactionResult:
+        """Confirm a receipt with the gateway (guide step 9). Do this within 30 minutes."""
+        response = self._post("verify", self._reference_payload(ref_num, session_key))
+        return self._finish_transaction(response, "verify")
+
+    def reverse_transaction(
+        self, ref_num: str, *, session_key: str | None = None
+    ) -> TransactionResult:
+        """Ask for the money back, up to 50 minutes after a verified payment (guide step 10)."""
+        response = self._post("reverse", self._reference_payload(ref_num, session_key))
+        return self._finish_transaction(response, "reverse")
+
+    def verify_callback(
+        self,
+        callback: CallbackData,
+        *,
+        expected_amount: int,
+        session_key: str | None = None,
+        reverse_on_mismatch: bool = False,
+    ) -> TransactionResult:
+        """The whole safe check in one call; returns only if the money is really there.
+
+        1. refuses a callback whose ``State`` is not ``OK`` (``PaymentNotCompletedError``);
+        2. verifies the receipt with the gateway;
+        3. checks the receipt, the terminal and that the gateway took ``expected_amount``
+           rials (``AmountMismatchError`` otherwise, after an optional reversal).
+
+        ``expected_amount`` must come from *your* order record, never from the request.
+        Marking the order paid, and refusing a receipt you have already used, is up to
+        you: record ``result.ref_num`` under a unique constraint.
+        """
+        self._ready_to_verify(callback, expected_amount)
+        result = self.verify_transaction(callback.ref_num, session_key=session_key)
+        self._check_result(callback, result)
+        if result.amount != expected_amount:
+            reversed_ = False
+            if reverse_on_mismatch:
+                try:
+                    self.reverse_transaction(callback.ref_num, session_key=session_key)
+                    reversed_ = True
+                except SepError:
+                    logger.exception("sep_sdk: could not reverse a mismatched payment")
+            raise self._amount_mismatch(expected_amount, result.amount, was_reversed=reversed_)
+        return result
+
+    # --- transport --------------------------------------------------------
+
+    def _post(self, operation: str, payload: dict[str, Any]) -> httpx.Response:
+        attempt = 0
+        while True:
+            attempt += 1
+            url = self._url(operation)
+            logger.debug("sep_sdk: %s attempt %d", operation, attempt)
+            try:
+                response = self._http.post(url, json=payload, headers=self._headers)
+            except httpx.TransportError as error:
+                if attempt < self.retry.max_attempts and self._may_retry_exception(
+                    error, operation
+                ):
+                    self._pause(attempt, operation)
+                    continue
+                raise self._transport_error(error, operation) from error
+            if response.status_code == 404 and self._switch_to_fallback(operation):
+                attempt -= 1
+                continue
+            if attempt < self.retry.max_attempts and self._may_retry_status(
+                response.status_code, operation
+            ):
+                self._pause(attempt, operation)
+                continue
+            return response
+
+    def _pause(self, attempt: int, operation: str) -> None:
+        delay = self.retry.delay(attempt)
+        logger.warning(
+            "sep_sdk: %s failed (attempt %d); retrying in %.1fs", operation, attempt, delay
+        )
+        if delay:
+            time.sleep(delay)

sep_sdk/constants.py

@@ -0,0 +1,43 @@
+"""Protocol constants taken from the SEP online gateway guide (v3.6).
+
+Nothing here is secret. Anything that may change on Saman's side (hosts, paths)
+lives in :class:`sep_sdk.Endpoints`, so it can be overridden without patching.
+"""
+
+from __future__ import annotations
+
+from typing import Final
+
+TOKEN_URL: Final = "https://sep.shaparak.ir/onlinepg/onlinepg"
+FORM_ACTION_URL: Final = "https://sep.shaparak.ir/OnlinePG/OnlinePG"
+SEND_TOKEN_URL: Final = "https://sep.shaparak.ir/OnlinePG/SendToken"
+VERIFY_URL: Final = "https://sep.shaparak.ir/verifyTxnRandomSessionkey/ipg/VerifyTransaction"
+REVERSE_URL: Final = "https://sep.shaparak.ir/verifyTxnRandomSessionkey/ipg/ReverseTransaction"
+# Saman's own Postman collections spell these "Transcation". The PDF guide does not.
+# The client tries the other spelling once if the first answers 404.
+LEGACY_VERIFY_URL: Final = "https://sep.shaparak.ir/verifyTxnRandomSessionkey/ipg/VerifyTranscation"
+LEGACY_REVERSE_URL: Final = (
+    "https://sep.shaparak.ir/verifyTxnRandomSessionkey/ipg/ReverseTranscation"
+)
+
+DEFAULT_TOKEN_EXPIRY_MINUTES: Final = 20
+MIN_TOKEN_EXPIRY_MINUTES: Final = 20
+MAX_TOKEN_EXPIRY_MINUTES: Final = 3600
+
+#: A transaction must be verified within this many minutes, or Saman reverses it.
+VERIFY_WINDOW_MINUTES: Final = 30
+#: A verified transaction can be reversed up to this many minutes after it happened.
+REVERSE_WINDOW_MINUTES: Final = 50
+
+MAX_REDIRECT_URL_LENGTH: Final = 2083
+MAX_REDIRECT_URL_LENGTH_GET: Final = 1538
+MAX_EXTRA_DATA_ITEMS: Final = 4
+MAX_EXTRA_DATA_LENGTH: Final = 50
+MAX_ALLOWED_CARDS: Final = 10
+MAX_SETTLEMENT_ITEMS: Final = 9
+PURCHASE_ID_LENGTH: Final = 30
+#: The purchase id of an ordinary (non-government) settlement line in a mixed request.
+NO_PURCHASE_ID: Final = "0" * PURCHASE_ID_LENGTH
+
+#: Header Saman sends back on token requests for terminals moved to ``neo-pg``.
+IPG_URL_HEADER: Final = "X-IPG-Url"

sep_sdk/endpoints.py

@@ -0,0 +1,65 @@
+"""Where the gateway lives. Override any URL if Saman moves it."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from sep_sdk import constants
+from sep_sdk.errors import SepConfigurationError
+from sep_sdk.validation import require_http_url
+
+_MAX_URL_LENGTH = 2048
+
+
+@dataclass(frozen=True, slots=True)
+class Endpoints:
+    """The five URLs of the gateway, plus optional fallbacks for verify and reverse.
+
+    The defaults follow the v3.6 guide. Saman's Postman collections spell the
+    verify/reverse paths ``…Transcation``; the client therefore retries the
+    ``*_fallback_url`` once when the primary answers HTTP 404, and remembers the one
+    that worked. Use :meth:`legacy` to make the old spelling the primary.
+    """
+
+    token_url: str = constants.TOKEN_URL
+    form_action_url: str = constants.FORM_ACTION_URL
+    send_token_url: str = constants.SEND_TOKEN_URL
+    verify_url: str = constants.VERIFY_URL
+    reverse_url: str = constants.REVERSE_URL
+    verify_fallback_url: str | None = constants.LEGACY_VERIFY_URL
+    reverse_fallback_url: str | None = constants.LEGACY_REVERSE_URL
+
+    def __post_init__(self) -> None:
+        for name in ("token_url", "form_action_url", "send_token_url", "verify_url", "reverse_url"):
+            self._check(name, getattr(self, name))
+        for name in ("verify_fallback_url", "reverse_fallback_url"):
+            value = getattr(self, name)
+            if value is not None:
+                self._check(name, value)
+
+    @staticmethod
+    def _check(name: str, value: object) -> None:
+        try:
+            require_http_url(name, value, max_length=_MAX_URL_LENGTH)
+        except ValueError as error:
+            raise SepConfigurationError(str(error)) from None
+
+    @classmethod
+    def production(cls) -> Endpoints:
+        """The documented production endpoints (the default)."""
+        return cls()
+
+    @classmethod
+    def legacy(cls) -> Endpoints:
+        """Use the ``…Transcation`` spelling first and the documented one as fallback."""
+        return cls(
+            verify_url=constants.LEGACY_VERIFY_URL,
+            reverse_url=constants.LEGACY_REVERSE_URL,
+            verify_fallback_url=constants.VERIFY_URL,
+            reverse_fallback_url=constants.REVERSE_URL,
+        )
+
+    @classmethod
+    def without_fallback(cls) -> Endpoints:
+        """Production endpoints and never try another spelling."""
+        return cls(verify_fallback_url=None, reverse_fallback_url=None)

sep_sdk/enums.py

@@ -0,0 +1,173 @@
+"""The vocabulary of the gateway: transaction states, status codes and result codes."""
+
+from __future__ import annotations
+
+from enum import Enum, IntEnum
+from typing import Literal
+
+Language = Literal["en", "fa"]
+
+
+class TransactionState(str, Enum):
+    """The ``State`` field Saman posts back to your ``RedirectUrl`` (guide, table 1).
+
+    Only :attr:`OK` means the bank reports a completed payment, and even that is
+    a *claim made by the user's browser*: always confirm with
+    :meth:`SepClient.verify_transaction`.
+    """
+
+    OK = "OK"
+    CANCELED_BY_USER = "CanceledByUser"
+    FAILED = "Failed"
+    SESSION_IS_NULL = "SessionIsNull"
+    INVALID_PARAMETERS = "InvalidParameters"
+    MERCHANT_IP_ADDRESS_IS_INVALID = "MerchantIpAddressIsInvalid"
+    TOKEN_NOT_FOUND = "TokenNotFound"
+    TOKEN_REQUIRED = "TokenRequired"
+    TERMINAL_NOT_FOUND = "TerminalNotFound"
+    MULTISETTLE_POLICY_ERRORS = "MultisettlePolicyErrors"
+    #: A value this version of the SDK does not know. Treated as "not paid".
+    UNKNOWN = "Unknown"
+
+    @classmethod
+    def from_wire(cls, value: str | None) -> TransactionState:
+        """Parse the wire value exactly; anything unrecognised becomes :attr:`UNKNOWN`."""
+        for member in cls:
+            if member is not cls.UNKNOWN and member.value == value:
+                return member
+        return cls.UNKNOWN
+
+    @property
+    def is_ok(self) -> bool:
+        return self is TransactionState.OK
+
+    def message(self, language: Language = "en") -> str:
+        """A short, user-presentable explanation in English or Persian."""
+        return _STATE_MESSAGES[self][language]
+
+
+class TransactionStatus(IntEnum):
+    """The numeric ``Status`` field that accompanies :class:`TransactionState`."""
+
+    CANCELED_BY_USER = 1
+    OK = 2
+    FAILED = 3
+    SESSION_IS_NULL = 4
+    INVALID_PARAMETERS = 5
+    MERCHANT_IP_ADDRESS_IS_INVALID = 8
+    TOKEN_NOT_FOUND = 10
+    TOKEN_REQUIRED = 11
+    TERMINAL_NOT_FOUND = 12
+    MULTISETTLE_POLICY_ERRORS = 21
+
+    @classmethod
+    def from_wire(cls, value: object) -> TransactionStatus | None:
+        """Parse an int or numeric string; ``None`` if absent or unrecognised."""
+        try:
+            return cls(int(str(value).strip()))
+        except ValueError:
+            return None
+
+
+class ResultCode(IntEnum):
+    """``ResultCode`` of the verify and reverse services (guide, error table)."""
+
+    SUCCESS = 0
+    DUPLICATE_REQUEST = 2
+    TRANSACTION_REVERSED = 5
+    TRANSACTION_NOT_FOUND = -2
+    VERIFY_WINDOW_EXPIRED = -6
+    TERMINAL_INACTIVE = -104
+    TERMINAL_NOT_FOUND = -105
+    IP_NOT_ALLOWED = -106
+
+    @classmethod
+    def from_wire(cls, value: int) -> ResultCode | int:
+        """The enum member when known, otherwise the raw integer."""
+        try:
+            return cls(value)
+        except ValueError:
+            return value
+
+    def message(self, language: Language = "en") -> str:
+        return _RESULT_MESSAGES[self][language]
+
+
+_STATE_MESSAGES: dict[TransactionState, dict[Language, str]] = {
+    TransactionState.OK: {
+        "en": "The payment was completed.",
+        "fa": "پرداخت با موفقیت انجام شد.",
+    },
+    TransactionState.CANCELED_BY_USER: {
+        "en": "The customer cancelled the payment.",
+        "fa": "کاربر از پرداخت انصراف داد.",
+    },
+    TransactionState.FAILED: {
+        "en": "The payment was not completed.",
+        "fa": "پرداخت انجام نشد.",
+    },
+    TransactionState.SESSION_IS_NULL: {
+        "en": "The customer did not respond within the allowed time.",
+        "fa": "کاربر در بازهٔ زمانی تعیین‌شده پاسخی ارسال نکرد.",
+    },
+    TransactionState.INVALID_PARAMETERS: {
+        "en": "The parameters sent to the gateway are invalid.",
+        "fa": "پارامترهای ارسالی نامعتبر است.",
+    },
+    TransactionState.MERCHANT_IP_ADDRESS_IS_INVALID: {
+        "en": "The merchant server address is not registered with the gateway.",
+        "fa": "آدرس سرور پذیرنده نزد درگاه ثبت نشده است.",
+    },
+    TransactionState.TOKEN_NOT_FOUND: {
+        "en": "The token was not found.",
+        "fa": "توکن ارسال‌شده پیدا نشد.",
+    },
+    TransactionState.TOKEN_REQUIRED: {
+        "en": "This terminal accepts token-based payments only.",
+        "fa": "با این ترمینال فقط تراکنش‌های توکنی قابل پرداخت هستند.",
+    },
+    TransactionState.TERMINAL_NOT_FOUND: {
+        "en": "The terminal number was not found.",
+        "fa": "شمارهٔ ترمینال ارسال‌شده پیدا نشد.",
+    },
+    TransactionState.MULTISETTLE_POLICY_ERRORS: {
+        "en": "The multi-account settlement rules were not respected.",
+        "fa": "محدودیت‌های مدل چندحسابی رعایت نشده است.",
+    },
+    TransactionState.UNKNOWN: {
+        "en": "The gateway reported a state this SDK does not recognise.",
+        "fa": "درگاه وضعیتی گزارش کرد که این SDK نمی‌شناسد.",
+    },
+}
+
+_RESULT_MESSAGES: dict[ResultCode, dict[Language, str]] = {
+    ResultCode.SUCCESS: {"en": "The operation succeeded.", "fa": "عملیات با موفقیت انجام شد."},
+    ResultCode.DUPLICATE_REQUEST: {
+        "en": "This request was already processed.",
+        "fa": "این درخواست قبلاً انجام شده است.",
+    },
+    ResultCode.TRANSACTION_REVERSED: {
+        "en": "The transaction has been reversed.",
+        "fa": "تراکنش برگشت خورده است.",
+    },
+    ResultCode.TRANSACTION_NOT_FOUND: {
+        "en": "The transaction was not found.",
+        "fa": "تراکنش پیدا نشد.",
+    },
+    ResultCode.VERIFY_WINDOW_EXPIRED: {
+        "en": "More than 30 minutes have passed since the transaction.",
+        "fa": "بیش از نیم ساعت از زمان تراکنش گذشته است.",
+    },
+    ResultCode.TERMINAL_INACTIVE: {
+        "en": "The terminal is inactive.",
+        "fa": "ترمینال غیرفعال است.",
+    },
+    ResultCode.TERMINAL_NOT_FOUND: {
+        "en": "The terminal does not exist.",
+        "fa": "ترمینال در سیستم موجود نیست.",
+    },
+    ResultCode.IP_NOT_ALLOWED: {
+        "en": "The server address is not allowed to call this service.",
+        "fa": "آدرس IP درخواست‌دهنده مجاز نیست.",
+    },
+}

sep_sdk/errors.py

@@ -0,0 +1,134 @@
+"""Every exception this SDK raises, in one hierarchy rooted at :class:`SepError`.
+
+Catch :class:`SepError` to handle anything; catch the narrower classes to react
+differently to "the network is down" (retry later), "the bank refused" (tell the
+customer) and "your request was wrong" (fix your code).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from sep_sdk.enums import ResultCode, TransactionState
+
+
+class SepError(Exception):
+    """Base class of every error raised by this package."""
+
+
+class SepConfigurationError(SepError, ValueError):
+    """The client was configured with something unusable (terminal id, endpoints, retry)."""
+
+
+class SepValidationError(SepError, ValueError):
+    """A request was rejected locally, before anything was sent to the gateway."""
+
+
+class SepTransportError(SepError):
+    """The request did not complete, so the gateway's answer is unknown."""
+
+
+class SepConnectionError(SepTransportError):
+    """The gateway could not be reached (DNS, TLS, refused or reset connection)."""
+
+
+class SepTimeoutError(SepTransportError):
+    """The gateway did not answer in time."""
+
+
+class SepHTTPError(SepError):
+    """The gateway answered with an HTTP status this SDK cannot interpret further."""
+
+    def __init__(self, message: str, *, status_code: int) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class SepResponseError(SepError):
+    """The gateway answered 2xx but the body was not what the guide describes."""
+
+
+class SepAPIError(SepError):
+    """The gateway understood the request and refused it.
+
+    ``code`` is the vendor's numeric code, ``description`` its free text. The text
+    is written by the gateway: log it, but do not show it to customers verbatim.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        code: int | None = None,
+        description: str = "",
+        operation: str = "",
+    ) -> None:
+        super().__init__(message)
+        self.code = code
+        self.description = description
+        self.operation = operation
+
+
+class SepTokenError(SepAPIError):
+    """The token request was refused (``status = -1``). See ``code`` / ``description``."""
+
+
+class SepTransactionError(SepAPIError):
+    """Verify or reverse was refused. ``result_code`` is the vendor's ``ResultCode``."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        result_code: ResultCode | int,
+        description: str = "",
+        operation: str = "",
+    ) -> None:
+        super().__init__(
+            message, code=int(result_code), description=description, operation=operation
+        )
+        self.result_code = result_code
+
+
+class TransactionNotFoundError(SepTransactionError):
+    """No such receipt (``-2``): wrong ``RefNum``, or a ``TxnRandomSessionKey`` mismatch."""
+
+
+class VerifyWindowExpiredError(SepTransactionError):
+    """More than 30 minutes passed (``-6``); Saman has reversed or will reverse the payment."""
+
+
+class TransactionReversedError(SepTransactionError):
+    """The transaction was reversed (``5``): the customer has been refunded."""
+
+
+class TerminalError(SepTransactionError):
+    """The terminal is unknown (``-105``) or inactive (``-104``)."""
+
+
+class IPNotAllowedError(SepTransactionError):
+    """This server's IP address is not registered with Saman (``-106``)."""
+
+
+class PaymentNotCompletedError(SepError):
+    """The callback says the customer did not pay, so there is nothing to verify."""
+
+    def __init__(self, message: str, *, state: TransactionState) -> None:
+        super().__init__(message)
+        self.state = state
+
+
+class AmountMismatchError(SepError):
+    """The gateway took a different sum than the order was priced at.
+
+    Saman's guide: the whole amount must go back to the customer and the goods
+    must not be delivered. ``reversed`` tells you whether the SDK already did the
+    reversal (``reverse_on_mismatch=True``) and it succeeded.
+    """
+
+    def __init__(self, message: str, *, expected: int, actual: int, was_reversed: bool) -> None:
+        super().__init__(message)
+        self.expected = expected
+        self.actual = actual
+        self.reversed = was_reversed

sep_sdk/redirect.py

@@ -0,0 +1,82 @@
+"""Sending the customer to the bank.
+
+Saman refuses a visitor whose browser does not send a ``Referer`` from the
+merchant's own site. The form below is meant to be *served by your site*. Do not
+send ``Referrer-Policy: no-referrer`` on that page; the form sets
+``<meta name="referrer" content="origin">`` itself so that ``origin`` is used.
+"""
+
+from __future__ import annotations
+
+from html import escape
+from urllib.parse import urlencode
+
+from sep_sdk.constants import SEND_TOKEN_URL
+from sep_sdk.enums import Language
+from sep_sdk.responses import Token
+
+_TEXT: dict[Language, dict[str, str]] = {
+    "en": {
+        "title": "Redirecting to the payment gateway",
+        "message": "Please wait while we take you to the bank…",
+        "button": "Continue to the bank",
+        "dir": "ltr",
+    },
+    "fa": {
+        "title": "انتقال به درگاه پرداخت",
+        "message": "لطفاً چند لحظه صبر کنید؛ در حال انتقال به درگاه بانک هستیم…",
+        "button": "ادامه به درگاه بانک",
+        "dir": "rtl",
+    },
+}
+
+
+def build_send_token_url(token: str, *, base_url: str = SEND_TOKEN_URL) -> str:
+    """The classic ``GET`` redirect link. Not available on ``neo-pg`` terminals."""
+    return f"{base_url}?{urlencode({'token': token})}"
+
+
+def redirect_form_fields(token: Token) -> dict[str, str]:
+    """The hidden inputs of the hand-off form, for use in your own template."""
+    fields = {"Token": token.token}
+    if token.get_method:
+        fields["GetMethod"] = "true"
+    return fields
+
+
+def render_redirect_form(
+    token: Token,
+    *,
+    language: Language = "en",
+    nonce: str | None = None,
+    auto_submit: bool = True,
+) -> str:
+    """A complete HTML page that POSTs the customer to the bank.
+
+    ``nonce`` is added to the inline script when your Content-Security-Policy uses
+    one. With ``auto_submit=False`` (or JavaScript disabled) the customer gets a
+    button instead. Every value is HTML-escaped.
+    """
+    text = _TEXT[language]
+    inputs = "".join(
+        f'<input type="hidden" name="{escape(name)}" value="{escape(value)}">'
+        for name, value in redirect_form_fields(token).items()
+    )
+    script = ""
+    if auto_submit:
+        nonce_attribute = f' nonce="{escape(nonce, quote=True)}"' if nonce else ""
+        script = (
+            f'<script{nonce_attribute}>document.getElementById("sep-redirect").submit();</script>'
+        )
+    return (
+        f'<!doctype html><html lang="{language}" dir="{text["dir"]}"><head>'
+        '<meta charset="utf-8">'
+        '<meta name="viewport" content="width=device-width, initial-scale=1">'
+        '<meta name="referrer" content="origin">'
+        '<meta name="robots" content="noindex, nofollow">'
+        f"<title>{escape(text['title'])}</title></head><body>"
+        f"<p>{escape(text['message'])}</p>"
+        f'<form id="sep-redirect" method="post" action="{escape(token.form_action, quote=True)}">'
+        f'{inputs}<noscript><button type="submit">{escape(text["button"])}</button></noscript>'
+        f"</form>{script}</body></html>"
+    )