smscode 1.0.0__py3-none-any.whl

smscode/resources/webhook.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import Any, Literal
+
+from smscode.errors import InvalidResponseError
+from smscode.models import WebhookConfig, WebhookTestResult
+from smscode.types import ApiResult
+
+SyncRequest = Callable[..., ApiResult[Any]]
+AsyncRequest = Callable[..., Awaitable[ApiResult[Any]]]
+ApiPrefix = Literal["/v1", "/v2"]
+
+
+def _update_body(
+    *,
+    webhook_url: str | None = None,
+    webhook_secret: str | None = None,
+) -> dict[str, str]:
+    body: dict[str, str] = {}
+    if webhook_url is not None:
+        body["webhook_url"] = webhook_url
+    if webhook_secret is not None:
+        body["webhook_secret"] = webhook_secret
+    return body
+
+
+def _decode_webhook_config(data: object) -> WebhookConfig:
+    if not isinstance(data, dict):
+        raise InvalidResponseError("The webhook config response is malformed.")
+    consecutive = data.get("webhook_consecutive_failures")
+    return WebhookConfig(
+        webhook_url=data.get("webhook_url") if isinstance(data.get("webhook_url"), str) else None,
+        webhook_secret=(
+            data.get("webhook_secret") if isinstance(data.get("webhook_secret"), str) else None
+        ),
+        webhook_disabled_at=(
+            data.get("webhook_disabled_at")
+            if isinstance(data.get("webhook_disabled_at"), str)
+            else None
+        ),
+        webhook_disabled_reason=(
+            data.get("webhook_disabled_reason")
+            if isinstance(data.get("webhook_disabled_reason"), str)
+            else None
+        ),
+        webhook_consecutive_failures=consecutive if type(consecutive) is int else 0,
+        raw=dict(data),
+    )
+
+
+def _decode_webhook_test_result(data: object) -> WebhookTestResult:
+    if not isinstance(data, dict) or type(data.get("status_code")) is not int:
+        raise InvalidResponseError("The webhook test response is malformed.")
+    return WebhookTestResult(status_code=data["status_code"], raw=dict(data))
+
+
+class WebhookResource:
+    def __init__(self, request: SyncRequest, prefix: ApiPrefix) -> None:
+        self._request = request
+        self._prefix = prefix
+
+    def get(self) -> WebhookConfig:
+        return _decode_webhook_config(self._request("GET", f"{self._prefix}/webhook").data)
+
+    def update(
+        self,
+        *,
+        webhook_url: str | None = None,
+        webhook_secret: str | None = None,
+    ) -> WebhookConfig:
+        return _decode_webhook_config(
+            self._request(
+                "PATCH",
+                f"{self._prefix}/webhook",
+                json=_update_body(webhook_url=webhook_url, webhook_secret=webhook_secret),
+                retry=0,
+            ).data
+        )
+
+    def test(self) -> WebhookTestResult:
+        return _decode_webhook_test_result(
+            self._request("POST", f"{self._prefix}/webhook/test", retry=0).data
+        )
+
+
+class V2WebhookResource(WebhookResource):
+    def __init__(self, request: SyncRequest) -> None:
+        super().__init__(request, "/v2")
+
+
+class V1WebhookResource(WebhookResource):
+    def __init__(self, request: SyncRequest) -> None:
+        super().__init__(request, "/v1")
+
+
+class AsyncWebhookResource:
+    def __init__(self, request: AsyncRequest, prefix: ApiPrefix) -> None:
+        self._request = request
+        self._prefix = prefix
+
+    async def get(self) -> WebhookConfig:
+        return _decode_webhook_config((await self._request("GET", f"{self._prefix}/webhook")).data)
+
+    async def update(
+        self,
+        *,
+        webhook_url: str | None = None,
+        webhook_secret: str | None = None,
+    ) -> WebhookConfig:
+        return _decode_webhook_config(
+            (
+                await self._request(
+                    "PATCH",
+                    f"{self._prefix}/webhook",
+                    json=_update_body(webhook_url=webhook_url, webhook_secret=webhook_secret),
+                    retry=0,
+                )
+            ).data
+        )
+
+    async def test(self) -> WebhookTestResult:
+        return _decode_webhook_test_result(
+            (await self._request("POST", f"{self._prefix}/webhook/test", retry=0)).data
+        )
+
+
+class AsyncV2WebhookResource(AsyncWebhookResource):
+    def __init__(self, request: AsyncRequest) -> None:
+        super().__init__(request, "/v2")
+
+
+class AsyncV1WebhookResource(AsyncWebhookResource):
+    def __init__(self, request: AsyncRequest) -> None:
+        super().__init__(request, "/v1")

smscode/retry.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import asyncio
+import random
+import time
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import TypeVar
+
+T = TypeVar("T")
+
+BACKOFF_BASE_SECONDS = 0.250
+BACKOFF_CAP_SECONDS = 10.0
+
+
+@dataclass(frozen=True)
+class RetryPolicy:
+    max_retries: int = 0
+    retry_on: Callable[[Exception], bool] = lambda err: False
+    retry_after: Callable[[Exception], float | None] | None = None
+    delay_seconds: Callable[[int], float] | None = None
+    sleep: Callable[[float], None] | None = None
+    async_sleep: Callable[[float], Awaitable[None]] | None = None
+
+
+def default_delay_seconds(attempt: int) -> float:
+    ceiling = min(BACKOFF_CAP_SECONDS, BACKOFF_BASE_SECONDS * 2 ** max(0, attempt - 1))
+    return float(random.random() * ceiling)
+
+
+def _retry_delay_seconds(err: Exception, attempt: int, policy: RetryPolicy) -> float:
+    retry_after = policy.retry_after(err) if policy.retry_after is not None else None
+    if retry_after is not None:
+        return max(0.0, retry_after)
+    delay = (
+        policy.delay_seconds(attempt)
+        if policy.delay_seconds is not None
+        else default_delay_seconds(attempt)
+    )
+    return max(0.0, delay)
+
+
+def with_retry(fn: Callable[[], T], policy: RetryPolicy) -> T:
+    sleep = policy.sleep or time.sleep
+    max_retries = max(0, policy.max_retries)
+    for attempt in range(max_retries + 1):
+        try:
+            return fn()
+        except Exception as err:
+            if attempt >= max_retries or not policy.retry_on(err):
+                raise
+            sleep(_retry_delay_seconds(err, attempt + 1, policy))
+    raise RuntimeError("unreachable retry loop")
+
+
+async def async_with_retry(fn: Callable[[], Awaitable[T]], policy: RetryPolicy) -> T:
+    sleep = policy.async_sleep or asyncio.sleep
+    max_retries = max(0, policy.max_retries)
+    for attempt in range(max_retries + 1):
+        try:
+            return await fn()
+        except Exception as err:
+            if attempt >= max_retries or not policy.retry_on(err):
+                raise
+            await sleep(_retry_delay_seconds(err, attempt + 1, policy))
+    raise RuntimeError("unreachable retry loop")

smscode/types.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any, Generic, Literal, TypeVar
+
+T = TypeVar("T")
+
+QueryValue = str | int | float | bool | None
+HttpMethod = Literal["GET", "POST", "PUT", "PATCH", "DELETE"]
+OrderStatus = Literal["ACTIVE", "OTP_RECEIVED", "COMPLETED", "CANCELED", "EXPIRED"]
+SortQuery = Literal[
+    "price_asc",
+    "price_desc",
+    "available_asc",
+    "available_desc",
+    "name_asc",
+    "name_desc",
+]
+
+
+@dataclass(frozen=True)
+class RequestOptions:
+    params: Mapping[str, QueryValue] | None = None
+    json: Any | None = None
+    headers: Mapping[str, str] | None = None
+    retry: int | None = None
+
+
+@dataclass(frozen=True)
+class ApiResult(Generic[T]):
+    data: T
+    meta: dict[str, Any] | None
+    request_id: str | None
+    status: int

smscode/wait.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from collections.abc import Awaitable, Callable, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from smscode.errors import OrderTerminalError, OtpTimeoutError, RateLimitError
+
+TERMINAL_STATUSES = {"COMPLETED", "CANCELED", "EXPIRED"}
+DEFAULT_POLL_INTERVAL_MS = 3000
+DEFAULT_TIMEOUT_MS = 20 * 60 * 1000
+
+
+@dataclass(frozen=True)
+class OtpResult:
+    otp_code: str
+    status: str
+    order: Any
+
+
+def wait_for_otp(
+    poll_order: Callable[[], Any],
+    *,
+    after_code: str | None = None,
+    timeout_ms: int = DEFAULT_TIMEOUT_MS,
+    poll_interval_ms: int = DEFAULT_POLL_INTERVAL_MS,
+    sleep: Callable[[float], None] | None = None,
+    now: Callable[[], float] | None = None,
+) -> OtpResult:
+    sleep_fn = sleep or time.sleep
+    now_fn = now or (lambda: time.monotonic() * 1000)
+    deadline = now_fn() + timeout_ms
+
+    while True:
+        try:
+            order = poll_order()
+        except RateLimitError as err:
+            delay_seconds = (
+                err.retry_after_seconds
+                if err.retry_after_seconds is not None
+                else poll_interval_ms / 1000
+            )
+            if now_fn() + delay_seconds * 1000 > deadline:
+                raise OtpTimeoutError("Timed out waiting for OTP.") from err
+            sleep_fn(delay_seconds)
+            continue
+
+        result = _result_or_error(order, after_code=after_code)
+        if result is not None:
+            return result
+        status = _status(order)
+        if status in TERMINAL_STATUSES:
+            raise OrderTerminalError(f"Order reached terminal status {status} before OTP arrived.")
+        if now_fn() + poll_interval_ms > deadline:
+            raise OtpTimeoutError("Timed out waiting for OTP.")
+        sleep_fn(poll_interval_ms / 1000)
+
+
+async def async_wait_for_otp(
+    poll_order: Callable[[], Awaitable[Any]],
+    *,
+    after_code: str | None = None,
+    timeout_ms: int = DEFAULT_TIMEOUT_MS,
+    poll_interval_ms: int = DEFAULT_POLL_INTERVAL_MS,
+    sleep: Callable[[float], Awaitable[None]] | None = None,
+    now: Callable[[], float] | None = None,
+) -> OtpResult:
+    sleep_fn = sleep or asyncio.sleep
+    now_fn = now or (lambda: time.monotonic() * 1000)
+    deadline = now_fn() + timeout_ms
+
+    while True:
+        try:
+            order = await poll_order()
+        except RateLimitError as err:
+            delay_seconds = (
+                err.retry_after_seconds
+                if err.retry_after_seconds is not None
+                else poll_interval_ms / 1000
+            )
+            if now_fn() + delay_seconds * 1000 > deadline:
+                raise OtpTimeoutError("Timed out waiting for OTP.") from err
+            await sleep_fn(delay_seconds)
+            continue
+
+        result = _result_or_error(order, after_code=after_code)
+        if result is not None:
+            return result
+        status = _status(order)
+        if status in TERMINAL_STATUSES:
+            raise OrderTerminalError(f"Order reached terminal status {status} before OTP arrived.")
+        if now_fn() + poll_interval_ms > deadline:
+            raise OtpTimeoutError("Timed out waiting for OTP.")
+        await sleep_fn(poll_interval_ms / 1000)
+
+
+def _result_or_error(order: Any, *, after_code: str | None) -> OtpResult | None:
+    code = _otp_code(order)
+    if code is not None and code != "" and code != after_code:
+        return OtpResult(otp_code=code, status=_status(order), order=order)
+    return None
+
+
+def _otp_code(order: Any) -> str | None:
+    value = _field(order, "otp_code")
+    return value if isinstance(value, str) else None
+
+
+def _status(order: Any) -> str:
+    value = _field(order, "status")
+    return value if isinstance(value, str) else ""
+
+
+def _field(order: Any, name: str) -> object:
+    if isinstance(order, Mapping):
+        return order.get(name)
+    value = getattr(order, name, None)
+    if value is not None:
+        return value
+    getter = getattr(order, "get", None)
+    if callable(getter):
+        return getter(name)
+    return None

smscode/webhook.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+from collections.abc import Mapping
+from typing import Any, TypeAlias
+
+WebhookEvent: TypeAlias = dict[str, Any]
+
+WEBHOOK_EVENTS = {
+    "order.otp_received",
+    "order.completed",
+    "order.expired",
+    "order.canceled",
+    "webhook.test",
+}
+SIGNATURE_PREFIX = "sha256="
+SHA256_BYTES = 32
+
+
+def verify_webhook_signature(raw_body: bytes | str, signature_header: str, secret: str) -> bool:
+    if not isinstance(signature_header, str) or not signature_header.startswith(SIGNATURE_PREFIX):
+        return False
+    digest_hex = signature_header[len(SIGNATURE_PREFIX) :]
+    try:
+        provided = bytes.fromhex(digest_hex)
+    except ValueError:
+        return False
+    if len(provided) != SHA256_BYTES:
+        return False
+
+    expected = hmac.new(_to_bytes(secret), _to_bytes(raw_body), hashlib.sha256).digest()
+    return hmac.compare_digest(expected, provided)
+
+
+def parse_webhook_event(raw_body: bytes | str | object) -> WebhookEvent:
+    value = raw_body
+    if isinstance(raw_body, bytes):
+        value = _json_loads(raw_body.decode("utf-8"))
+    elif isinstance(raw_body, str):
+        value = _json_loads(raw_body)
+
+    if not isinstance(value, Mapping):
+        raise TypeError("Webhook payload is not a JSON object.")
+    event = value.get("event")
+    if not isinstance(event, str) or event not in WEBHOOK_EVENTS:
+        raise TypeError(f"Webhook payload has an unknown event type: {event!r}.")
+    return dict(value)
+
+
+def is_webhook_event(value: object) -> bool:
+    if not isinstance(value, Mapping):
+        return False
+    event = value.get("event")
+    return isinstance(event, str) and event in WEBHOOK_EVENTS
+
+
+def _json_loads(raw: str) -> object:
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as err:
+        raise TypeError("Webhook payload is not valid JSON.") from err
+
+
+def _to_bytes(value: bytes | str) -> bytes:
+    return value if isinstance(value, bytes) else value.encode("utf-8")

smscode-1.0.0.dist-info/METADATA

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: smscode
+Version: 1.0.0
+Summary: Official Python SDK for the SMSCode virtual number API.
+Project-URL: Homepage, https://smscode.gg
+Project-URL: Documentation, https://smscode.gg/docs/ai.md
+Project-URL: Repository, https://github.com/smscode-gg/sdks
+Project-URL: Issues, https://github.com/smscode-gg/sdks/issues
+Author-email: SMSCode <dev@smscode.gg>
+License: MIT
+License-File: LICENSE
+Keywords: 2fa,api-client,online-sms,otp,phone-verification,python,receive-sms-online,sdk,sms,sms-otp,sms-verification,smscode,temporary-phone-number,virtual-number,virtual-phone-number
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx<1,>=0.27
+Description-Content-Type: text/markdown
+
+# smscode
+
+Official Python SDK for the SMSCode virtual-number API.
+
+Use it to rent temporary phone numbers, receive SMS OTP verification codes, and
+manage order lifecycle from Python services, bots, and automations.
+
+## Install
+
+```bash
+pip install smscode
+```
+
+Requires Python 3.10+.
+
+## Quick start
+
+`SmscodeClient` uses the USD-native `/v2` API by default. Money values are typed
+objects with the exact IDR ledger amount preserved as `canonical_amount`.
+
+```py
+import os
+
+from smscode import OtpTimeoutError, OrderTerminalError, SmscodeClient
+
+client = SmscodeClient(token=os.environ["SMSCODE_TOKEN"])
+
+body = {
+    "catalog_product_id": int(os.environ["SMSCODE_CATALOG_PRODUCT_ID"]),
+    "max_price": "0.50",  # /v2 uses a USD decimal string, never a float
+    "quantity": 1,
+}
+
+with client:
+    created = client.orders.create(body)
+    order = created.orders[0]
+    order_id = int(order["id"])
+
+    try:
+        otp = client.orders.wait_for_otp(order_id, timeout_ms=120_000)
+        print("OTP:", otp.otp_code)
+        # Submit otp.otp_code in your target app here.
+        client.orders.finish(order_id)
+    except (OtpTimeoutError, OrderTerminalError):
+        # No OTP evidence arrived. Cancel remains available only in that case.
+        client.orders.cancel(order_id)
+```
+
+## Async client
+
+The async client has the same surface and uses `httpx.AsyncClient` internally.
+
+```py
+import os
+
+from smscode import AsyncSmscodeClient
+
+
+async def main() -> None:
+    async with AsyncSmscodeClient(token=os.environ["SMSCODE_TOKEN"]) as client:
+        balance = await client.balance.get()
+        print(balance.balance.amount, balance.balance.currency)
+```
+
+## Resend and wait for a new OTP
+
+`finish` does not require a new OTP after resend; the order is finishable once it
+has OTP evidence. If your integration needs to wait for a different post-resend
+code, pass the previous code as `after_code`.
+
+```py
+first = client.orders.wait_for_otp(order_id)
+
+client.orders.resend(order_id)
+
+second = client.orders.wait_for_otp(
+    order_id,
+    after_code=first.otp_code,
+    timeout_ms=120_000,
+)
+
+print("new OTP:", second.otp_code)
+# Submit second.otp_code in your target app here, then finish.
+client.orders.finish(order_id)
+```
+
+If the provider sends the same digits again, code-based polling cannot
+distinguish it from the previous OTP.
+
+## Idempotent order create
+
+Order create is money-sensitive. The SDK resolves an idempotency key before the
+request, sends it as `idempotency-key`, and attaches it to create errors.
+
+```py
+from smscode import SmscodeError
+
+try:
+    created = client.orders.create(body)
+except SmscodeError as err:
+    if err.idempotency_key is None:
+        raise
+    # Retry the exact same body with the same key. Never mint a fresh key for
+    # the same attempted create.
+    created = client.orders.create(body, idempotency_key=err.idempotency_key)
+```
+
+## Webhooks
+
+Verify webhook signatures against the raw request body before parsing JSON.
+
+```py
+from smscode import parse_webhook_event, verify_webhook_signature
+
+
+def handle_webhook(raw_body: bytes, signature_header: str | None, secret: str) -> int:
+    if not verify_webhook_signature(raw_body, signature_header or "", secret):
+        return 401
+
+    event = parse_webhook_event(raw_body)
+    if event["event"] == "order.otp_received":
+        print(event["data"]["otp_code"])
+    return 204
+```
+
+## `/v1` namespace
+
+Use `.v1` only when you intentionally want legacy IDR-only shapes.
+
+```py
+with SmscodeClient(token=os.environ["SMSCODE_TOKEN"]) as client:
+    balance_v2 = client.balance.get()
+    balance_v1 = client.v1.balance.get()
+```
+
+## Error handling
+
+Every API error is a typed `SmscodeError` subclass. Branch on the class or
+`err.code`, not on `err.message`. `RateLimitError` and retryable server errors
+carry `retry_after_seconds` when the API sends `Retry-After`.
+
+## License
+
+MIT

smscode-1.0.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+smscode/__init__.py,sha256=MJdQeFt3Dwg01m85xsyV0lUHTk9Bq1jjUXbJEVALicE,3402
+smscode/_async_transport.py,sha256=XyCwuXwthvQ2J-PTLJT71fIb8zI9MatxWNzJh7xqyjU,3130
+smscode/_decode.py,sha256=gitDcscQmgBoTgaNmzPK-d622Xp0cfdpbNOw_ccGFcM,2446
+smscode/_transport.py,sha256=NOIEY8IxEO5aREGllVXwShh60pzy6MgJphw6-CY-s1Q,3762
+smscode/async_client.py,sha256=VZ4n9kFi7TNSxsxPZuUNnuuAADgmJ68Ja29np-o7cno,2611
+smscode/client.py,sha256=szU5GIXZPYkC67nR8mWuTuopMU8UyZka_dA-K5TPmFw,2399
+smscode/errors.py,sha256=1tZrdYdZPvAp6Xxh8qe2E9TBcLCSQCNIf-U58c8J7TA,6286
+smscode/idempotency.py,sha256=e6AfamexMZguo9IHlrnHkgv5YCsp816OHGSy39z7nm0,620
+smscode/models.py,sha256=DWuyW139XIgDA5W6tbQ3LIeW5UNWPdFLkr-52CSccT0,6313
+smscode/money.py,sha256=cn1LvnHjqTTQd3mj5weBnxz93OgdRzd63b_99Gr9q2A,1224
+smscode/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+smscode/retry.py,sha256=UOzsAt4LAn3zmf_EmNEErjwc4B2ngnrO4yfYWXqbNmM,2207
+smscode/types.py,sha256=oy-sVPrAzUn3uhKLqGQ2uL5bvU4H68lz6VbpcMf8e9o,843
+smscode/wait.py,sha256=DO2SpB7Jkj7wHArmwwFvJkkLeApAWYxkMqRS1disvLw,4076
+smscode/webhook.py,sha256=8RfPzsk5J-dy4YPt2t0a-e9nrO7Vj-ynEJKgVlKr7Eo,2019
+smscode/resources/__init__.py,sha256=zOaE3bBSEqvE4_GgR3cO_hwUfJGYl9FDgkqUt1yc6Kc,1552
+smscode/resources/balance.py,sha256=TZmR-PkKzqnVP4yX30s25kVOU-8_h7y-8CUVItCN6-A,1486
+smscode/resources/catalog.py,sha256=uXoR_eQlRdU9nO49z7jOReRMV-iNYouur3Rk1hWRS6g,10922
+smscode/resources/orders.py,sha256=ipnTkU1MNE93zFD4NPKQHc44U-0nQVvQfbR5qS10BHM,20716
+smscode/resources/webhook.py,sha256=sDheSbx0soO_Pl72zwuVeq59eIcOukdz5vPNwmD1jWg,4450
+smscode-1.0.0.dist-info/METADATA,sha256=xazYDW4-q0iqLKPFbSz1nbGJpuoKHltykjvKrvhPM-4,4998
+smscode-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+smscode-1.0.0.dist-info/licenses/LICENSE,sha256=yu5mpVULGeeXNzlzQaxHSgF-lh5sjI_iTktvwfghZlE,1064
+smscode-1.0.0.dist-info/RECORD,,

smscode-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

smscode-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SMSCode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.