nomba-python 0.1.0__py3-none-any.whl

nomba_python/webhooks.py

@@ -0,0 +1,190 @@
+"""
+Webhook signature verification, per Nomba's documented scheme
+(https://developer.nomba.com/products/webhooks/signature-verification-new
+and .../webhooks/introduction):
+
+Headers sent with every webhook POST:
+    nomba-signature            base64-encoded HMAC
+    nomba-signature-algorithm  always "HmacSHA256"
+    nomba-signature-version    currently "1.0.0"
+    nomba-timestamp            RFC-3339 timestamp the payload was sent at
+
+Signing scheme (confirmed from Nomba's own sample code):
+    hashing_payload = ":".join([
+        event_type,
+        requestId,
+        data.merchant.userId,
+        data.merchant.walletId,
+        data.transaction.transactionId,
+        data.transaction.type,
+        data.transaction.time,
+        data.transaction.responseCode,
+    ])
+    message = f"{hashing_payload}:{timestamp}"
+    signature = base64(HMAC-SHA256(key=signature_key, msg=message))
+"""
+from __future__ import annotations
+
+import base64
+import hmac
+import json
+from datetime import datetime, timezone
+from hashlib import sha256
+from typing import Any
+
+from .exceptions import NombaValidationError
+
+SIGNATURE_HEADER = "nomba-signature"
+ALGORITHM_HEADER = "nomba-signature-algorithm"
+VERSION_HEADER = "nomba-signature-version"
+TIMESTAMP_HEADER = "nomba-timestamp"
+
+
+def _get_path(payload: dict[str, Any], *path: str, default: str = "") -> str:
+    node: Any = payload
+    for key in path:
+        if not isinstance(node, dict):
+            return default
+        node = node.get(key)
+    return "" if node is None else str(node)
+
+
+def _parse_rfc3339(timestamp: str) -> datetime:
+    # Python's fromisoformat doesn't accept a trailing "Z" before 3.11;
+    # normalize it to an explicit UTC offset for broad compatibility.
+    ts = timestamp.strip()
+    if ts.endswith("Z"):
+        ts = ts[:-1] + "+00:00"
+    return datetime.fromisoformat(ts)
+
+
+def check_timestamp_freshness(timestamp: str, *, max_age_seconds: float) -> None:
+    """
+    Raise NombaValidationError if `timestamp` (the nomba-timestamp header,
+    RFC-3339) is older than `max_age_seconds` compared to now, or is in the
+    future by more than the same window (clock skew allowance). This guards
+    against replay attacks: a captured, validly-signed webhook being resent
+    later. Nomba's signature alone does not protect against replay -- it
+    only proves the payload+timestamp pair was signed with your key.
+    """
+    try:
+        sent_at = _parse_rfc3339(timestamp)
+    except ValueError as exc:
+        raise NombaValidationError(f"Invalid nomba-timestamp format: {timestamp!r}") from exc
+
+    if sent_at.tzinfo is None:
+        sent_at = sent_at.replace(tzinfo=timezone.utc)
+
+    age = (datetime.now(timezone.utc) - sent_at).total_seconds()
+    if age > max_age_seconds:
+        raise NombaValidationError(
+            f"Webhook timestamp is {age:.0f}s old, exceeding max_age_seconds={max_age_seconds} "
+            "(possible replay attack, or a webhook retried long after the original send)"
+        )
+    if age < -max_age_seconds:
+        raise NombaValidationError(
+            f"Webhook timestamp is {-age:.0f}s in the future, exceeding max_age_seconds="
+            f"{max_age_seconds} (check for clock skew, or treat with suspicion)"
+        )
+
+
+def compute_signature(signature_key: str, payload: dict[str, Any], timestamp: str) -> str:
+    """
+    Compute the base64 HMAC-SHA256 signature Nomba expects for a webhook
+    payload + timestamp, per their documented scheme.
+    """
+    hashing_payload = ":".join(
+        [
+            _get_path(payload, "event_type"),
+            _get_path(payload, "requestId"),
+            _get_path(payload, "data", "merchant", "userId"),
+            _get_path(payload, "data", "merchant", "walletId"),
+            _get_path(payload, "data", "transaction", "transactionId"),
+            _get_path(payload, "data", "transaction", "type"),
+            _get_path(payload, "data", "transaction", "time"),
+            _get_path(payload, "data", "transaction", "responseCode"),
+        ]
+    )
+    message = f"{hashing_payload}:{timestamp}"
+    mac = hmac.new(signature_key.encode("utf-8"), message.encode("utf-8"), sha256).digest()
+    return base64.b64encode(mac).decode("ascii")
+
+
+def verify_webhook_signature(
+    signature_key: str,
+    payload: dict[str, Any],
+    *,
+    signature: str,
+    timestamp: str,
+) -> bool:
+    """
+    Verify a webhook's signature using a constant-time comparison.
+
+    Example (Flask):
+        from nomba.webhooks import verify_webhook_signature
+
+        @app.post("/webhooks/nomba")
+        def handle_webhook():
+            payload = request.get_json()
+            ok = verify_webhook_signature(
+                signature_key="...",
+                payload=payload,
+                signature=request.headers["nomba-signature"],
+                timestamp=request.headers["nomba-timestamp"],
+            )
+            if not ok:
+                return "invalid signature", 401
+            ...
+    """
+    expected = compute_signature(signature_key, payload, timestamp)
+    return hmac.compare_digest(expected, signature)
+
+
+def verify_webhook_request(
+    signature_key: str,
+    *,
+    body: bytes | str,
+    headers: dict[str, str],
+    max_age_seconds: float | None = 300.0,
+) -> dict[str, Any]:
+    """
+    Convenience wrapper: parses the raw body as JSON, pulls the
+    nomba-signature/nomba-timestamp headers (case-insensitively), verifies
+    the signature, checks the timestamp isn't stale (replay protection),
+    and returns the parsed payload on success.
+
+    `max_age_seconds` (default 300s / 5 min) rejects webhooks whose
+    nomba-timestamp is older than this -- protects against a captured,
+    validly-signed webhook being replayed later. Pass None to disable this
+    check (signature is still verified).
+
+    Raises NombaValidationError if the signature is missing, invalid, the
+    timestamp is stale, or the body isn't valid JSON. Does not raise on a
+    valid-but-unsigned request -- if you didn't configure a signature key on
+    the Nomba dashboard, no signature header will be sent; check for that
+    yourself if relevant.
+    """
+    lower_headers = {k.lower(): v for k, v in headers.items()}
+    signature = lower_headers.get(SIGNATURE_HEADER)
+    timestamp = lower_headers.get(TIMESTAMP_HEADER)
+    if not signature or not timestamp:
+        raise NombaValidationError(
+            f"Missing '{SIGNATURE_HEADER}' or '{TIMESTAMP_HEADER}' header on webhook request"
+        )
+
+    if max_age_seconds is not None:
+        check_timestamp_freshness(timestamp, max_age_seconds=max_age_seconds)
+
+    if isinstance(body, bytes):
+        body = body.decode("utf-8")
+    try:
+        payload = json.loads(body)
+    except ValueError as exc:
+        raise NombaValidationError(f"Webhook body is not valid JSON: {exc}") from exc
+
+    if not verify_webhook_signature(
+        signature_key, payload, signature=signature, timestamp=timestamp
+    ):
+        raise NombaValidationError("Webhook signature verification failed")
+
+    return payload

nomba_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,312 @@
+Metadata-Version: 2.4
+Name: nomba-python
+Version: 0.1.0
+Summary: Unofficial Python SDK for the Nomba payments API
+Keywords: nomba,payments,nigeria,fintech,sdk
+Author: Righteousness
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pytest>=8.4.2
+Requires-Python: >=3.9
+Project-URL: Homepage, https://github.com/RightFix/nomba
+Project-URL: Documentation, https://rightfix.github.io/nomba-docs/
+Project-URL: Repository, https://github.com/RightFix/nomba
+Description-Content-Type: text/markdown
+
+# nomba
+
+Unofficial Python SDK for the [Nomba](https://developer.nomba.com) payments API, built with [`uv`](https://docs.astral.sh/uv/) and [`httpx`](https://www.python-httpx.org/).
+
+Covers **every endpoint** in Nomba's official [OpenAPI spec](https://github.com/kudi-inc/vendor-openapi-spec) — 64 methods across 10 resource groups, generated directly from the spec so field names and required/optional parameters match Nomba's docs exactly.
+
+## Install
+
+```bash
+uv add nomba-python
+# or
+pip install nomba-python
+```
+
+## Usage
+
+```python
+from nomba import Nomba
+
+nomba = Nomba(
+    client_id="...",
+    client_secret="...",
+    account_id="...",
+    sandbox=True,  # set False for live
+)
+
+account = nomba.virtual_accounts.create_virtual_account(
+    account_ref="ref-123",
+    account_name="Jane Doe",
+)
+
+nomba.close()
+```
+
+Or as a context manager:
+
+```python
+with Nomba(client_id=..., client_secret=..., account_id=...) as nomba:
+    nomba.virtual_accounts.fetch_a_virtual_account("ref-123")
+```
+
+## Async
+
+Every resource is also available via `AsyncNomba`, built on `httpx.AsyncClient`:
+
+```python
+import asyncio
+from nomba import AsyncNomba
+
+async def main():
+    async with AsyncNomba(
+        client_id="...",
+        client_secret="...",
+        account_id="...",
+        sandbox=True,
+    ) as nomba:
+        account = await nomba.virtual_accounts.create_virtual_account(
+            account_ref="ref-123",
+            account_name="Jane Doe",
+        )
+        transfer = await nomba.transfers.perform_bank_account_transfer_the_parent_account(
+            amount="5000.00",
+            account_number="0123456789",
+            account_name="John Doe",
+            bank_code="058",
+            merchant_tx_ref="txn-001",
+            sender_name="Jane Sender",
+        )
+
+asyncio.run(main())
+```
+
+## Resource groups
+
+Each group is available on both `Nomba` and `AsyncNomba` (async methods are awaited):
+
+| Group               | Examples |
+|---------------------|----------|
+| `accounts`           | `list_all_accounts`, `create_a_sub_account`, `fetch_account_balance`, `suspend_an_account` |
+| `virtual_accounts`   | `create_virtual_account`, `fetch_a_virtual_account`, `update_a_virtual_account`, `expire_a_virtual_account` |
+| `checkout`           | `create_an_online_checkout_order`, `charge_customer_with_tokenized_card_data`, `list_all_tokenized_cards_for_merchant` |
+| `charge`             | `submit_customer_card_details`, `submit_customer_payment_otp`, `fetch_checkout_order_details` |
+| `transfers`          | `perform_bank_account_lookup`, `perform_bank_account_transfer_the_parent_account`, `perform_wallet_transfer_from_a_sub_account` |
+| `terminals`          | `assign_a_terminal_to_the_parent_account`, `un_assign_terminal_from_an_account` |
+| `transactions`       | `fetch_transactions_on_the_parent_account`, `filter_account_transactions`, `confirm_a_transaction_s_status_by_session_id` |
+| `airtime_data`       | `make_airtime_purchases_via_parent_account`, `vend_data_bundles_via_parent_account`, `fetch_data_plans_available_on_a_telco_network_provider` |
+| `cabletv`            | `cabletv_lookup`, `cable_tv_subscription_via_parent_account` |
+| `electricity`        | `fetch_electricity_providers`, `electricity_customer_lookup`, `vend_electricity_via_parent_account` |
+
+Every method's docstring lists its required and optional body fields straight from Nomba's schema — check `help(nomba.transfers.perform_bank_account_transfer_the_parent_account)` or your editor's signature hints.
+
+## Reliability (token locking + retry/backoff)
+
+`NombaClient`/`AsyncNombaClient` guard token fetching with a lock, so
+concurrent requests never race to re-fetch a token — only one fetch happens,
+the rest wait and reuse it. Requests that hit a `429` or transient `5xx` are
+automatically retried with exponential backoff (respecting `Retry-After` if
+Nomba sends one):
+
+```python
+nomba = Nomba(
+    client_id="...", client_secret="...", account_id="...",
+    max_retries=3,       # default
+    backoff_factor=0.5,  # default; delay ~= backoff_factor * 2^attempt
+)
+```
+
+## Typed responses
+
+Every method's return type is a `TypedDict` generated from Nomba's response
+schema (in `nomba.models`), giving editor autocomplete and type-checking on
+the actual JSON keys (e.g. `resp["data"]["accountNumber"]`). This costs
+nothing at runtime — methods still return plain dicts; the TypedDict is
+purely a type hint, which matters on constrained hardware.
+
+## Nested body validation
+
+Flat method signatures (e.g. `order_reference=`, `amount=`) are validated by
+Python itself. But some fields are nested objects — like `order={...}` in
+checkout order creation — whose *inner* required fields a flat signature
+can't enforce. Every write call is checked against Nomba's own OpenAPI spec
+(bundled with the package) before any network call, so a typo or missing
+nested field fails fast locally instead of round-tripping to Nomba's API:
+
+```python
+from nomba import NombaValidationError
+
+try:
+    nomba.checkout.create_an_online_checkout_order(order={"orderReference": "x"})
+except NombaValidationError as e:
+    print(e)  # Missing required field(s) in request body: order.amount, order.currency, ...
+```
+
+## Webhook signature verification
+
+Implements Nomba's documented HMAC-SHA256 scheme
+(`nomba-signature` / `nomba-timestamp` headers, base64-encoded signature),
+including replay protection via the timestamp:
+
+```python
+from nomba import verify_webhook_request, NombaValidationError
+
+@app.post("/webhooks/nomba")
+def handle_webhook():
+    try:
+        payload = verify_webhook_request(
+            signature_key="...",  # the key you set up on the Nomba dashboard
+            body=request.get_data(),
+            headers=request.headers,
+            max_age_seconds=300,  # default; reject webhooks older than 5 min
+        )
+    except NombaValidationError:
+        return "invalid signature", 401
+
+    if payload["event_type"] == "payment_success":
+        ...
+    return "", 200
+```
+
+A valid signature alone doesn't prove a webhook wasn't captured and resent
+later — `max_age_seconds` rejects stale ones. Pass `max_age_seconds=None` to
+disable that check if you have your own replay protection.
+
+## Bounded concurrency for fan-out calls
+
+`asyncio.gather` has no built-in limit — firing off many calls at once can
+trigger a retry storm if several start failing together, or just trip
+Nomba's rate limit by bursting too many requests in one window.
+`gather_limited` runs the same calls with a concurrency cap:
+
+```python
+from nomba import AsyncNomba, gather_limited
+
+async with AsyncNomba(...) as nomba:
+    calls = [
+        (lambda ref=ref: nomba.virtual_accounts.fetch_a_virtual_account(ref))
+        for ref in account_refs
+    ]
+    results = await gather_limited(calls, limit=5)
+```
+
+Extra/undocumented fields can always be passed as kwargs; they get merged into the JSON body verbatim.
+
+## Pagination
+
+Nomba's list endpoints are cursor-paginated server-side (they return a
+`cursor` you feed back in for the next page). `paginate`/`apaginate` just
+drive that loop for you — no extra pagination scheme is introduced.
+
+```python
+from nomba import Nomba, paginate
+
+nomba = Nomba(...)
+for account in paginate(nomba.accounts.list_all_accounts, limit=50):
+    print(account["accountRef"])
+```
+
+Async:
+
+```python
+from nomba import AsyncNomba, apaginate
+
+async with AsyncNomba(...) as nomba:
+    async for txn in apaginate(nomba.transactions.fetch_transactions_on_the_parent_account, limit=50):
+        print(txn)
+```
+
+Confirmed paginated endpoints (per Nomba's spec): `accounts.list_all_accounts`,
+`accounts.fetch_terminals_assigned_to_an_account`,
+`accounts.fetch_terminals_assigned_to_the_parent_account`,
+`virtual_accounts.filter_virtual_accounts`, and all six
+`transactions.*` list/filter methods.
+
+## Card payment flow
+
+Card checkout is a multi-step sequence (submit card → maybe OTP → maybe 3D
+Secure → confirm). `CardPaymentFlow` wraps it so you don't have to track
+`transactionId` by hand or look up what Nomba's `responseCode` values mean:
+
+```python
+order = nomba.checkout.create_an_online_checkout_order(
+    order={"orderReference": "order-001", "amount": "1000", ...}
+)
+
+flow = nomba.card_payment(order_reference="order-001")
+step = flow.submit_card(card_details="...", key="")
+
+if step.requires_otp:
+    step = flow.submit_otp("123456")
+elif step.requires_3ds:
+    # redirect the user using step.secure_authentication_data
+    ...
+
+if step.completed:
+    result = flow.confirm()
+```
+
+`nomba.card_payment(...)` returns a `CardPaymentFlow` (or `AsyncCardPaymentFlow`
+off `AsyncNomba`). `step` is a `CardPaymentStep` with `.completed`,
+`.requires_otp`, `.requires_3ds`, `.transaction_id`, `.message`, etc.
+
+## Error handling
+
+```python
+from nomba import NombaAPIError, NombaAuthError
+
+try:
+    nomba.virtual_accounts.fetch_a_virtual_account("missing-ref")
+except NombaAuthError as e:
+    print("auth failed:", e)
+except NombaAPIError as e:
+    print("api error:", e.status_code, e.code, e.response_body)
+```
+
+## Authentication
+
+The SDK handles the OAuth2 client-credentials flow automatically: it fetches an
+access token on first request, caches it, and refreshes it transparently when
+it expires or is rejected (a 401 triggers exactly one retry with a fresh token).
+Get your `client_id` / `client_secret` / `accountId` from your Nomba dashboard
+under **Webhook & API Keys**.
+
+## Regenerating from the spec
+
+The resource modules in `src/nomba/resources/` and response models in
+`src/nomba/models.py` are generated from `src/nomba/data/nomba_openapi.json`
+(a snapshot of Nomba's published OpenAPI spec, also bundled into the package
+for runtime nested-body validation). To pick up upstream API changes:
+
+```bash
+curl -sL -o src/nomba/data/nomba_openapi.json \
+  "https://github.com/kudi-inc/vendor-openapi-spec/raw/refs/heads/main/openapi3_0_v_1_0_0.json"
+uv run python scripts/generate_resources.py
+```
+
+## Development
+
+```bash
+uv sync
+uv run python -m pytest   # once tests are added
+```
+
+## Status
+
+Generated from Nomba's official OpenAPI spec (v1.0.0) — all 64 documented
+endpoints across Accounts, Virtual Accounts, Online Checkout, Charge,
+Transfers, Terminals, Transactions, Airtime/Data, CableTV, and Electricity.
+
+Also includes: typed responses, cursor pagination helpers, a guided
+card-payment flow, locked/retrying HTTP clients, local nested-body
+validation against Nomba's own spec, and webhook signature verification.

nomba_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+nomba_python/__init__.py,sha256=EqZbsXjq9agMJaBHqjxHjGvjchFDhqWehDQYAMb21uI,941
+nomba_python/client.py,sha256=TwieNaDU-eHRIsgiVRITPc7aIuIiF1LyzF6Mn-UdMHA,4781
+nomba_python/concurrency.py,sha256=0wTRJ57uLR-rXaIEMfivSRr4qEKvZMu3j5EXgAyLKoo,1870
+nomba_python/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nomba_python/data/nomba_openapi.json,sha256=92D2QdcKaC6oe45fEQv_sJTbKV1oXqVDjSJUIFJxU-4,437490
+nomba_python/exceptions.py,sha256=Dx6OASM-7bvzsejmVbw_Iy6PXhm09K6Cu52mxlOjVY8,1484
+nomba_python/flows/__init__.py,sha256=v2yT_QfBLIzWRvhCiDXXELFMWFTf3ye_VkVlEGA2kb0,155
+nomba_python/flows/card_payment.py,sha256=Z0eJeFYrvJ_Za_JWl4qxalhU9Q-s-3LjO318ShtbN_k,7512
+nomba_python/http.py,sha256=DVuw6Btcnwlqq95FFE2x62Zd-lp9QtB8-qVvB9sFc6Q,14078
+nomba_python/models.py,sha256=5m4lG7B4yMUaLvH7DpFAHBAnI9HFS_pGRTP-ue33_DU,19898
+nomba_python/pagination.py,sha256=g5EagLomsdkN9YojCCnp55mm9IrFCfXBaU9500G_Ri8,3678
+nomba_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nomba_python/resources/__init__.py,sha256=Is2J4R6YQhUKzl4KF9nHE1qXCqWfinrgBY5cY9xe1ew,927
+nomba_python/resources/accounts.py,sha256=60Z3pKulFjw1wbxej3Qp7plAOFS2r3w9jTPPoJTLWcg,16774
+nomba_python/resources/airtime_data.py,sha256=rQEOpteN8rjMTyY0qSh2ilivwhW1Yy_nUvKGnU1Z0tM,12281
+nomba_python/resources/cabletv.py,sha256=Xa2tNdjNP7D5jsu9Q-7J6mhK8oGQvxw3jLaO9IhcnRI,7180
+nomba_python/resources/charge.py,sha256=9Nz0AE0YLo3vCvBqcyjnTTRkNVaqN2cKEZQ_RaCweTM,19549
+nomba_python/resources/checkout.py,sha256=g-K9eBRZ0mR_H8o7GpKHKxrrD0tWpfWzdaUkRfBY5rs,10090
+nomba_python/resources/electricity.py,sha256=t-Cq34fJwsMlUn4Gar5VCMZh8Ami34z758CNMZsMEts,8403
+nomba_python/resources/terminals.py,sha256=Ftdl4bOeeoeh8lOy3ARhYWYP_SORs9zOnXX2n1OV9dY,7769
+nomba_python/resources/transactions.py,sha256=HSDsuhYaZ3SIM4KyNOFxA6_4f1nfno1URyAU7xbZyk8,22269
+nomba_python/resources/transfers.py,sha256=Rkqp18KgzHcOoJSx7VRgF8M3tvT3i3H-dmQGgU6XfCc,14089
+nomba_python/resources/virtual_accounts.py,sha256=FpHhnBxJS5-C-dQ-jt-Fb8OoMP2Qq96wyFi7hDTD8hw,9873
+nomba_python/validation.py,sha256=sAlddQ0TDtQO4AiTgNQRRRg9GN-fHArJEfCsulPpNyw,3489
+nomba_python/webhooks.py,sha256=wNJwMqNgkrWmk8zR8Ein_ynlW0XkW6wwrDfhh4gB4Ic,7016
+nomba_python-0.1.0.dist-info/licenses/LICENSE,sha256=5ddBfMvz-MOkk_vJtDwfqiDR8gchx1KRaetdXNL238s,1070
+nomba_python-0.1.0.dist-info/WHEEL,sha256=8ZlpUMJ7mlDirmlHRhDirEx_nPnARrwDjeE92mlk68E,81
+nomba_python-0.1.0.dist-info/METADATA,sha256=2RKImLUdgWQ8Qxw477-3ySTC4jo6w7xwdB7uaIKz9p8,11232
+nomba_python-0.1.0.dist-info/RECORD,,

nomba_python-0.1.0.dist-info/WHEEL

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

nomba_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Righteousness
+
+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.