ncrypted 0.1.0__py3-none-any.whl

ncrypted/__init__.py

@@ -0,0 +1,17 @@
+"""ncrypted: one-time, end-to-end encrypted secrets for AI agents. https://ncrypted.ai"""
+
+from .client import CreatedSecret, Ncrypted, NcryptedError, NcryptedSync, __version__, wallet_path
+from .crypto import MAX_PLAINTEXT_BYTES, decrypt, encrypt, parse_link
+
+__all__ = [
+    "Ncrypted",
+    "NcryptedSync",
+    "NcryptedError",
+    "CreatedSecret",
+    "encrypt",
+    "decrypt",
+    "parse_link",
+    "wallet_path",
+    "MAX_PLAINTEXT_BYTES",
+    "__version__",
+]

ncrypted/client.py

@@ -0,0 +1,249 @@
+"""Async client for ncrypted, mirroring the TypeScript SDK (packages/sdk/src/client.ts)."""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from .crypto import decrypt, encrypt, parse_link
+
+__version__ = "0.1.0"
+DEFAULT_BASE_URL = "https://ncrypted.ai"
+MAX_PRICE = "$0.01"
+SETTLE_ATTEMPTS = 3
+GONE = "This secret has already been read, burned, or has expired."
+NO_WALLET = (
+    "Run `npx ncrypted wallet new` (or create ~/.config/ncrypted/wallet.key) for a payer wallet, send it a little "
+    "USDC on Base (0.005 per secret, no ETH needed), or set NCRYPTED_WALLET_PRIVATE_KEY. Requires `pip install ncrypted[pay]`."
+)
+
+
+class NcryptedError(Exception):
+    def __init__(self, message: str, status: int = 0):
+        super().__init__(message)
+        self.status = status
+
+
+@dataclass
+class CreatedSecret:
+    id: str
+    link: str
+    """Full one-time link including the decryption key. Treat it like the secret itself."""
+    expires_at: str
+    receipt_token: str
+    emailed: bool
+    free: bool
+    free_remaining: int | None = None
+    payment_tx: str | None = None
+
+
+def wallet_path() -> Path:
+    return Path(os.environ.get("NCRYPTED_WALLET_FILE") or Path.home() / ".config" / "ncrypted" / "wallet.key")
+
+
+def _normalize_key(raw: str | None) -> str | None:
+    v = (raw or "").strip()
+    if not v or v.startswith("$"):
+        return None
+    hexkey = v if v.startswith("0x") else f"0x{v}"
+    if len(hexkey) != 66 or any(c not in "0123456789abcdefABCDEF" for c in hexkey[2:]):
+        raise ValueError("Wallet private key must be 32 bytes of hex (0x + 64 hex characters)")
+    return hexkey
+
+
+def _wallet_key(explicit: str | None) -> str | None:
+    key = _normalize_key(explicit or os.environ.get("NCRYPTED_WALLET_PRIVATE_KEY"))
+    if key:
+        return key
+    try:
+        return _normalize_key(wallet_path().read_text())
+    except FileNotFoundError:
+        return None
+
+
+def _settlement(res: httpx.Response) -> dict | None:
+    header = res.headers.get("payment-response") or res.headers.get("x-payment-response")
+    if not header:
+        return None
+    try:
+        return json.loads(base64.b64decode(header))
+    except Exception:
+        return None
+
+
+def _error(res: httpx.Response) -> NcryptedError:
+    msg = res.reason_phrase
+    try:
+        msg = res.json().get("error") or msg
+    except Exception:
+        pass
+    if res.status_code == 402:
+        reason = (_settlement(res) or {}).get("errorReason")
+        msg = f"Payment settlement failed ({reason}). You were not charged." if reason else f"Payment required ({msg})."
+    return NcryptedError(msg, res.status_code)
+
+
+class Ncrypted:
+    """Async ncrypted client. The first 3 secrets per day are free; then 0.005 USDC each via x402 (needs ncrypted[pay])."""
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        private_key: str | None = None,
+        client: str = "python",
+        timeout: float = 30.0,
+    ):
+        self.base_url = (base_url or os.environ.get("NCRYPTED_URL") or DEFAULT_BASE_URL).rstrip("/")
+        self._private_key = private_key
+        self._headers = {"x-ncrypted-client": f"{client}/{__version__}"}
+        self._timeout = timeout
+
+    def _paying_client(self) -> httpx.AsyncClient | None:
+        key = _wallet_key(self._private_key)
+        if not key:
+            return None
+        try:
+            from eth_account import Account
+            from x402 import x402Client
+            from x402.http.clients import x402_httpx_transport
+            from x402.mechanisms.evm.exact import register_exact_evm_client
+            from x402.mechanisms.evm.signers import EthAccountSigner
+        except ImportError as e:  # pragma: no cover - depends on extras
+            raise NcryptedError(f"Paying for secrets needs the pay extra: pip install 'ncrypted[pay]' ({e})") from e
+        x402 = x402Client()
+        register_exact_evm_client(x402, EthAccountSigner(Account.from_key(key)))
+        x402.set_spend_controls({"max_amount_per_payment": MAX_PRICE})
+        return httpx.AsyncClient(transport=x402_httpx_transport(x402), timeout=self._timeout)
+
+    async def create(
+        self,
+        secret: str,
+        ttl: int = 86400,
+        passphrase: str | None = None,
+        email_to: str | None = None,
+        email_note: str | None = None,
+        require_payment: bool = False,
+    ) -> CreatedSecret:
+        """Encrypt locally and store the ciphertext; returns a one-time link."""
+        payer = self._paying_client()
+        require_payment = require_payment or bool(email_to)
+        if payer is None and require_payment:
+            raise NcryptedError(("Email delivery needs a paid secret. " if email_to else "") + NO_WALLET, 402)
+        payload, key = encrypt(secret, passphrase)
+        headers = {**self._headers, "content-type": "application/json"}
+        if require_payment:
+            headers["x-ncrypted-no-free"] = "1"
+        http = payer or httpx.AsyncClient(timeout=self._timeout)
+        async with http:
+            for attempt in range(1, SETTLE_ATTEMPTS + 1):
+                res = await http.post(f"{self.base_url}/api/v1/secrets", headers=headers, json={**payload, "ttl": ttl})
+                settled = _settlement(res)
+                if res.status_code == 402 and settled and settled.get("success") is False and attempt < SETTLE_ATTEMPTS:
+                    continue
+                break
+        if res.status_code == 402 and payer is None:
+            max_ttl = int(res.headers.get("x-ncrypted-free-max-ttl", 86400))
+            why = f"Free secrets can last at most {max_ttl // 3600}h." if ttl > max_ttl else "The free secrets for today are used up."
+            raise NcryptedError(f"{why} {NO_WALLET}", 402)
+        if res.status_code >= 400:
+            raise _error(res)
+        data = res.json()
+        link = f"{data['url']}#{key}"
+        emailed = False
+        if email_to:
+            await self.email(data["id"], data["receiptToken"], link, email_to, email_note)
+            emailed = True
+        return CreatedSecret(
+            id=data["id"],
+            link=link,
+            expires_at=data["expiresAt"],
+            receipt_token=data["receiptToken"],
+            emailed=emailed,
+            free=bool(data.get("free")),
+            free_remaining=data.get("freeRemaining"),
+            payment_tx=(_settlement(res) or {}).get("transaction"),
+        )
+
+    async def email(self, id: str, receipt_token: str, link: str, to: str, note: str | None = None) -> None:
+        async with httpx.AsyncClient(timeout=self._timeout) as http:
+            res = await http.post(
+                f"{self.base_url}/api/v1/secrets/{id}/email",
+                headers={**self._headers, "authorization": f"Bearer {receipt_token}"},
+                json={"to": to, "link": link, "note": note},
+            )
+        if res.status_code >= 400:
+            raise _error(res)
+
+    async def read(self, link: str, passphrase: str | None = None) -> str:
+        """Read and destroy a secret. Free. Works with links from any ncrypted host."""
+        p = parse_link(link)
+        async with httpx.AsyncClient(timeout=self._timeout) as http:
+            res = await http.post(f"{p.origin}/api/v1/secrets/{p.id}/reveal", headers=self._headers)
+        if res.status_code in (404, 410):
+            raise NcryptedError(GONE, 410)
+        if res.status_code >= 400:
+            raise _error(res)
+        return decrypt(res.json(), p.key, passphrase)
+
+    async def status(self, id: str, receipt_token: str) -> dict[str, Any]:
+        async with httpx.AsyncClient(timeout=self._timeout) as http:
+            res = await http.get(
+                f"{self.base_url}/api/v1/secrets/{id}/status",
+                headers={**self._headers, "authorization": f"Bearer {receipt_token}"},
+            )
+        if res.status_code >= 400:
+            raise _error(res)
+        return res.json()
+
+    async def burn(self, id: str, receipt_token: str) -> None:
+        async with httpx.AsyncClient(timeout=self._timeout) as http:
+            res = await http.delete(
+                f"{self.base_url}/api/v1/secrets/{id}",
+                headers={**self._headers, "authorization": f"Bearer {receipt_token}"},
+            )
+        if res.status_code >= 400:
+            raise _error(res)
+
+    async def quota(self) -> dict[str, Any]:
+        async with httpx.AsyncClient(timeout=self._timeout) as http:
+            res = await http.get(f"{self.base_url}/api/v1/quota", headers=self._headers)
+        if res.status_code >= 400:
+            raise _error(res)
+        return res.json()
+
+
+def _run(coro):
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)
+    raise RuntimeError("Use the async Ncrypted client inside a running event loop")
+
+
+class NcryptedSync:
+    """Blocking wrapper around Ncrypted for scripts and sync frameworks."""
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        self._c = Ncrypted(*args, **kwargs)
+
+    def create(self, *args: Any, **kwargs: Any) -> CreatedSecret:
+        return _run(self._c.create(*args, **kwargs))
+
+    def read(self, *args: Any, **kwargs: Any) -> str:
+        return _run(self._c.read(*args, **kwargs))
+
+    def status(self, *args: Any, **kwargs: Any) -> dict[str, Any]:
+        return _run(self._c.status(*args, **kwargs))
+
+    def burn(self, *args: Any, **kwargs: Any) -> None:
+        return _run(self._c.burn(*args, **kwargs))
+
+    def quota(self) -> dict[str, Any]:
+        return _run(self._c.quota())

ncrypted/crypto.py

@@ -0,0 +1,90 @@
+"""ncrypted v1 envelope, byte-compatible with the TypeScript reference (packages/sdk/src/crypto.ts).
+
+AES-256-GCM with a key derived by HKDF-SHA256 from a random 32-byte link key (plus PBKDF2-SHA256 of an optional
+passphrase). The link key travels only in the share link's #fragment, so the service stores ciphertext only.
+"""
+
+from __future__ import annotations
+
+import base64
+import os
+import re
+from dataclasses import dataclass
+from urllib.parse import urlsplit
+
+from cryptography.exceptions import InvalidTag
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+
+VERSION = 1
+MAX_PLAINTEXT_BYTES = 64 * 1024
+PBKDF2_ITERATIONS = 600_000
+INFO = b"ncrypted v1"
+_LINK_RE = re.compile(r"^/s/([A-Za-z0-9_-]{16,64})/?$")
+
+
+def to_b64url(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+
+
+def from_b64url(s: str) -> bytes:
+    return base64.urlsafe_b64decode(s + "=" * (-len(s) % 4))
+
+
+def _derive_key(link_key: bytes, salt: bytes, passphrase: str | None) -> bytes:
+    ikm = link_key
+    if passphrase:
+        stretched = PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=salt, iterations=PBKDF2_ITERATIONS).derive(
+            passphrase.encode("utf-8")
+        )
+        ikm = link_key + stretched
+    return HKDF(algorithm=hashes.SHA256(), length=32, salt=salt, info=INFO).derive(ikm)
+
+
+def encrypt(plaintext: str, passphrase: str | None = None) -> tuple[dict, str]:
+    """Encrypt with a fresh link key. Returns (payload for the server, base64url link key for the #fragment)."""
+    data = plaintext.encode("utf-8")
+    if not data:
+        raise ValueError("Secret is empty")
+    if len(data) > MAX_PLAINTEXT_BYTES:
+        raise ValueError(f"Secret exceeds {MAX_PLAINTEXT_BYTES} bytes")
+    link_key, salt, iv = os.urandom(32), os.urandom(16), os.urandom(12)
+    ct = AESGCM(_derive_key(link_key, salt, passphrase)).encrypt(iv, data, None)
+    payload = {
+        "v": VERSION,
+        "ciphertext": to_b64url(ct),
+        "iv": to_b64url(iv),
+        "salt": to_b64url(salt),
+        "hasPassphrase": bool(passphrase),
+    }
+    return payload, to_b64url(link_key)
+
+
+def decrypt(payload: dict, link_key: str, passphrase: str | None = None) -> str:
+    """Decrypt a payload. Raises ValueError on a wrong key or passphrase, or tampered data."""
+    if payload.get("hasPassphrase") and not passphrase:
+        raise ValueError("This secret requires a passphrase")
+    key = _derive_key(from_b64url(link_key), from_b64url(payload["salt"]), passphrase if payload.get("hasPassphrase") else None)
+    try:
+        pt = AESGCM(key).decrypt(from_b64url(payload["iv"]), from_b64url(payload["ciphertext"]), None)
+    except InvalidTag:
+        raise ValueError("Decryption failed: wrong key or passphrase, or the data was tampered with") from None
+    return pt.decode("utf-8")
+
+
+@dataclass(frozen=True)
+class ParsedLink:
+    origin: str
+    id: str
+    key: str
+
+
+def parse_link(link: str) -> ParsedLink:
+    """Split https://host/s/{id}#{key}."""
+    u = urlsplit(link)
+    m = _LINK_RE.match(u.path)
+    if not u.scheme or not u.netloc or not m or not u.fragment:
+        raise ValueError("Not a valid ncrypted link (expected https://host/s/{id}#{key})")
+    return ParsedLink(origin=f"{u.scheme}://{u.netloc}", id=m.group(1), key=u.fragment)

ncrypted/langchain.py

@@ -0,0 +1,101 @@
+"""LangChain tools for ncrypted (pip install 'ncrypted[langchain]', plus 'ncrypted[pay]' to pay beyond the free tier).
+
+    from ncrypted.langchain import ncrypted_tools
+    tools = ncrypted_tools()  # pass to create_agent / bind_tools as usual
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+from langchain_core.tools import StructuredTool
+from pydantic import BaseModel, Field
+
+from .client import Ncrypted, NcryptedError
+
+
+class _CreateInput(BaseModel):
+    secret: str = Field(description="The sensitive value to share (password, API key, token, note). Max 64 KB.")
+    ttl_seconds: int = Field(86400, ge=300, le=604800, description="Expiry if never opened. Default 86400 (24h).")
+    passphrase: Optional[str] = Field(None, description="Optional second factor; deliver it through a different channel.")
+    email_to: Optional[str] = Field(None, description="Email the link to this address (requires a paid secret).")
+
+
+class _ReadInput(BaseModel):
+    link: str = Field(description="The full ncrypted link including the #key fragment.")
+    passphrase: Optional[str] = Field(None, description="Required only if the sender set one.")
+
+
+class _ReceiptInput(BaseModel):
+    id: str = Field(description="The secret id returned by ncrypted_create.")
+    receipt_token: str = Field(description="The receipt token returned by ncrypted_create.")
+
+
+def ncrypted_tools(client: Ncrypted | None = None) -> list[StructuredTool]:
+    """ncrypted_create, ncrypted_read, ncrypted_status and ncrypted_burn as LangChain tools (sync and async)."""
+    nc = client or Ncrypted(client="langchain")
+
+    async def create(secret: str, ttl_seconds: int = 86400, passphrase: str | None = None, email_to: str | None = None) -> str:
+        try:
+            r = await nc.create(secret, ttl=ttl_seconds, passphrase=passphrase, email_to=email_to)
+        except (NcryptedError, ValueError) as e:
+            return f"Error: {e}"
+        return json.dumps(
+            {
+                "link": r.link,
+                "id": r.id,
+                "expires_at": r.expires_at,
+                "receipt_token": r.receipt_token,
+                "emailed": r.emailed,
+                "free": r.free,
+                "note": "The link opens exactly once. Share only the link, never the secret itself.",
+            }
+        )
+
+    async def read(link: str, passphrase: str | None = None) -> str:
+        try:
+            return await nc.read(link, passphrase)
+        except (NcryptedError, ValueError) as e:
+            return f"Error: {e}"
+
+    async def status(id: str, receipt_token: str) -> str:
+        try:
+            return json.dumps(await nc.status(id, receipt_token))
+        except NcryptedError as e:
+            return f"Error: {e}"
+
+    async def burn(id: str, receipt_token: str) -> str:
+        try:
+            await nc.burn(id, receipt_token)
+            return json.dumps({"burned": True})
+        except NcryptedError as e:
+            return f"Error: {e}"
+
+    def tool(name: str, description: str, coro, schema) -> StructuredTool:
+        def sync(**kwargs):
+            import asyncio
+
+            return asyncio.run(coro(**kwargs))
+
+        return StructuredTool.from_function(func=sync, coroutine=coro, name=name, description=description, args_schema=schema)
+
+    return [
+        tool(
+            "ncrypted_create",
+            "Encrypt a password, API key, token or private note and return a one-time link that self-destructs after a "
+            "single read. Use it whenever a credential must be shared with a person or another agent, instead of writing "
+            "the value in a message. Never repeat the secret; share only the link. 3 free per day, then 0.005 USDC each.",
+            create,
+            _CreateInput,
+        ),
+        tool(
+            "ncrypted_read",
+            "Open an ncrypted link (https://ncrypted.ai/s/{id}#{key}) and return the secret. This destroys it permanently. "
+            "Free. Use the value only for the task at hand and do not repeat it.",
+            read,
+            _ReadInput,
+        ),
+        tool("ncrypted_status", "Check whether a secret you created has been opened (pending, read, burned or expired). Free.", status, _ReceiptInput),
+        tool("ncrypted_burn", "Destroy a secret you created before anyone opens it. Free.", burn, _ReceiptInput),
+    ]

ncrypted-0.1.0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.5
+Name: ncrypted
+Version: 0.1.0
+Summary: One-time, end-to-end encrypted secrets for AI agents. 3 free per day, then 0.005 USDC per secret via x402.
+Project-URL: Homepage, https://ncrypted.ai
+Project-URL: Documentation, https://ncrypted.ai/guides
+Project-URL: Source, https://github.com/Seidl-Family/ncrypted
+Project-URL: Issues, https://github.com/Seidl-Family/ncrypted/issues
+Author: Seidl Family
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,crewai,encryption,langchain,mcp,one-time,secrets,x402
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.10
+Requires-Dist: cryptography>=42
+Requires-Dist: httpx>=0.27
+Provides-Extra: all
+Requires-Dist: eth-account>=0.13; extra == 'all'
+Requires-Dist: langchain-core>=0.3; extra == 'all'
+Requires-Dist: x402[evm,httpx]>=2.25; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: eth-account>=0.13; extra == 'dev'
+Requires-Dist: langchain-core>=0.3; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: x402[evm,httpx]>=2.25; extra == 'dev'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3; extra == 'langchain'
+Provides-Extra: pay
+Requires-Dist: eth-account>=0.13; extra == 'pay'
+Requires-Dist: x402[evm,httpx]>=2.25; extra == 'pay'
+Description-Content-Type: text/markdown
+
+# ncrypted (Python)
+
+One-time, end-to-end encrypted secrets for AI agents. Encrypt a password, API key or note locally and get a link that opens exactly once. The first 3 secrets per day are free; after that each costs 0.005 USDC on Base, paid via x402. Reading is always free.
+
+```sh
+pip install ncrypted               # free tier, reading
+pip install "ncrypted[pay]"        # pay beyond the free tier (x402 on Base)
+pip install "ncrypted[langchain]"  # LangChain tools
+```
+
+```python
+import asyncio
+from ncrypted import Ncrypted
+
+async def main():
+    nc = Ncrypted()
+    s = await nc.create("hunter2", ttl=3600)
+    print(s.link)                    # share this; it opens once
+    print(await nc.read(s.link))     # "hunter2", and now it's gone
+
+asyncio.run(main())
+```
+
+Blocking code can use `NcryptedSync` with the same methods.
+
+## LangChain
+
+```python
+from ncrypted.langchain import ncrypted_tools
+
+tools = ncrypted_tools()  # ncrypted_create, ncrypted_read, ncrypted_status, ncrypted_burn
+```
+
+## Paying for more than the free tier
+
+Install `ncrypted[pay]` and provide a dedicated Base wallet holding a little USDC (no ETH needed): `NCRYPTED_WALLET_PRIVATE_KEY`, or the key file at `~/.config/ncrypted/wallet.key` (create it with `npx ncrypted wallet new`). Payments are capped at 0.01 USDC per secret.
+
+The wire format is byte-compatible with the TypeScript SDK (`npm install ncrypted`); both decrypt each other's links. Docs: https://ncrypted.ai/guides · Source: https://github.com/Seidl-Family/ncrypted

ncrypted-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+ncrypted/__init__.py,sha256=CR_37zcUb6tCwkvW7aL99VlGhGF_zEMkicLsEymVLBg,466
+ncrypted/client.py,sha256=-B7KOcafu2QPENFFH_cJxPsOQu389vVyRoZE2bhoRE0,9614
+ncrypted/crypto.py,sha256=HtpRmhcxLR_Q0xk3u3HG64kXkS19f0_5k_dQLgY85Ms,3469
+ncrypted/langchain.py,sha256=BkTwZiJPR-tZCDXEPFNxJDgDg6jG517jlAdJXnFXUes,4349
+ncrypted-0.1.0.dist-info/METADATA,sha256=ebgB3asxhgm-zlEmAfxfLROKGmyocS4sPPknlbn1iOk,2956
+ncrypted-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+ncrypted-0.1.0.dist-info/licenses/LICENSE,sha256=VBVdviLqGa1cYb9KrGBDOmq4T6bu2AhfwLpo14yLX3c,1069
+ncrypted-0.1.0.dist-info/RECORD,,

ncrypted-0.1.0.dist-info/WHEEL

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

ncrypted-0.1.0.dist-info/licenses/LICENSE

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