solanab-jup-python-sdk 2.0.3__py3-none-any.whl

jup_python_sdk/clients/jupiter_client.py

@@ -0,0 +1,136 @@
+import base64
+import json
+import os
+from typing import Any, Optional
+
+import base58
+from curl_cffi import AsyncSession, requests
+from solders.solders import Keypair, VersionedTransaction
+
+
+class _CoreJupiterClient:
+    """
+    Core non-network-dependent logic for Jupiter clients.
+    Handles private key loading and transaction signing.
+    """
+
+    def __init__(self, api_key: Optional[str], private_key_env_var: str):
+        self.api_key = api_key
+        self.base_url = "https://api.jup.ag" if api_key else "https://lite-api.jup.ag"
+        self.private_key_env_var = private_key_env_var
+
+    def _get_headers(self) -> dict[str, str]:
+        headers = {
+            "Accept": "application/json",
+        }
+        if self.api_key:
+            headers["x-api-key"] = self.api_key
+        return headers
+
+    def _post_headers(self) -> dict[str, str]:
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+        if self.api_key:
+            headers["x-api-key"] = self.api_key
+        return headers
+
+    def _load_private_key_bytes(self) -> bytes:
+        """Loads the private key from the environment
+        variable as base58 or uint8 array."""
+        pk_raw = os.getenv(self.private_key_env_var, "")
+        pk_raw = pk_raw.strip()
+        if pk_raw.startswith("[") and pk_raw.endswith("]"):
+            try:
+                arr = json.loads(pk_raw)
+                if isinstance(arr, list) and all(
+                    isinstance(x, int) and 0 <= x <= 255 for x in arr
+                ):
+                    return bytes(arr)
+                else:
+                    raise ValueError
+            except Exception as e:
+                raise ValueError(f"Invalid uint8-array private key format: {e}") from e
+        try:
+            return base58.b58decode(pk_raw)
+        except Exception as e:
+            raise ValueError(f"Invalid base58 private key format: {e}") from e
+
+    def get_public_key(self) -> str:
+        wallet = Keypair.from_bytes(self._load_private_key_bytes())
+        return str(wallet.pubkey())
+
+    async def get_public_key_async(self) -> str:
+        return self.get_public_key()
+
+    def _sign_base64_transaction(self, transaction_base64: str) -> VersionedTransaction:
+        transaction_bytes = base64.b64decode(transaction_base64)
+        versioned_transaction = VersionedTransaction.from_bytes(transaction_bytes)
+        return self._sign_versioned_transaction(versioned_transaction)
+
+    def _sign_versioned_transaction(
+        self, versioned_transaction: VersionedTransaction
+    ) -> VersionedTransaction:
+        wallet = Keypair.from_bytes(self._load_private_key_bytes())
+        account_keys = versioned_transaction.message.account_keys
+        wallet_index = account_keys.index(wallet.pubkey())
+
+        signers = list(versioned_transaction.signatures)
+        signers[wallet_index] = wallet  # type: ignore
+
+        return VersionedTransaction(
+            versioned_transaction.message,
+            signers,  # type: ignore
+        )
+
+    def _serialize_versioned_transaction(
+        self, versioned_transaction: VersionedTransaction
+    ) -> str:
+        return base64.b64encode(bytes(versioned_transaction)).decode("utf-8")
+
+
+class JupiterClient(_CoreJupiterClient):
+    """
+    The synchronous client for interacting with the Jupiter API.
+    Powered by curl_cffi.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        private_key_env_var: str = "PRIVATE_KEY",
+        client_kwargs: Optional[dict[str, Any]] = None,
+    ):
+        super().__init__(api_key, private_key_env_var)
+        kwargs = client_kwargs or {}
+        kwargs.setdefault("impersonate", "chrome110")
+        self.client = requests.Session(**kwargs)
+
+    def close(self) -> None:
+        self.client.close()
+
+
+class AsyncJupiterClient(_CoreJupiterClient):
+    """
+    The asynchronous client for interacting with the Jupiter API.
+    Powered by curl_cffi.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        private_key_env_var: str = "PRIVATE_KEY",
+        client_kwargs: Optional[dict[str, Any]] = None,
+    ):
+        super().__init__(api_key, private_key_env_var)
+        kwargs = client_kwargs or {}
+        kwargs.setdefault("impersonate", "chrome110")
+        self.client = AsyncSession(**kwargs)
+
+    async def close(self) -> None:
+        await self.client.close()
+
+    # Override get_public_key for async context consistency
+    async def get_public_key(self) -> str:  # type: ignore[override]
+        return super().get_public_key()

jup_python_sdk/clients/ultra_api_client.py

@@ -0,0 +1,213 @@
+from typing import Any
+
+from jup_python_sdk.clients.jupiter_client import AsyncJupiterClient, JupiterClient
+from jup_python_sdk.models.ultra_api.ultra_execute_request_model import (
+    UltraExecuteRequest,
+)
+from jup_python_sdk.models.ultra_api.ultra_order_request_model import (
+    UltraOrderRequest,
+)
+
+
+class UltraApiClient(JupiterClient):
+    """
+    A synchronous client for interacting with the Jupiter Ultra API.
+    """
+
+    def order(self, request: UltraOrderRequest) -> dict[str, Any]:
+        """
+        Get an order from the Jupiter Ultra API (synchronous).
+
+        Args:
+            request (UltraOrderRequest): The request parameters for the order.
+
+        Returns:
+            dict: The dict api response.
+        """
+        params = request.to_dict()
+
+        url = f"{self.base_url}/ultra/v1/order"
+        response = self.client.get(url, params=params, headers=self._get_headers())
+        response.raise_for_status()
+
+        return response.json()  # type: ignore[no-any-return]  # type: ignore
+
+    def execute(self, request: UltraExecuteRequest) -> dict[str, Any]:
+        """
+        Execute the order with the Jupiter Ultra API (synchronous).
+
+        Args:
+            request (UltraExecuteRequest): The execute request parameters.
+
+        Returns:
+            dict: The dict api response.
+        """
+        payload = request.to_dict()
+
+        url = f"{self.base_url}/ultra/v1/execute"
+        response = self.client.post(url, json=payload, headers=self._get_headers())
+        response.raise_for_status()
+
+        return response.json()  # type: ignore[no-any-return]  # type: ignore
+
+    def order_and_execute(self, request: UltraOrderRequest) -> dict[str, Any]:
+        """
+        Get and execute an order in a single call (synchronous).
+
+        Args:
+            request (UltraOrderRequest): The request parameters for the order.
+
+        Returns:
+            dict: The dict api response.
+        """
+        order_response = self.order(request)
+
+        request_id = order_response["requestId"]
+        signed_transaction = self._sign_base64_transaction(
+            order_response["transaction"]
+        )
+
+        execute_request = UltraExecuteRequest(
+            request_id=request_id,
+            signed_transaction=self._serialize_versioned_transaction(
+                signed_transaction
+            ),
+        )
+
+        return self.execute(execute_request)
+
+    def balances(self, address: str) -> dict[str, Any]:
+        """
+        Get token balances of an account (synchronous).
+
+        Args:
+            address (str): The public key of the account to get balances for.
+
+        Returns:
+            dict: The dict api response.
+        """
+        url = f"{self.base_url}/ultra/v1/balances/{address}"
+        response = self.client.get(url, headers=self._get_headers())
+        response.raise_for_status()
+
+        return response.json()  # type: ignore[no-any-return]  # type: ignore
+
+    def shield(self, mints: list[str]) -> dict[str, Any]:
+        """
+        Get token info and warnings for specific mints (synchronous).
+
+        Args:
+            mints (list[str]): List of token mint addresses
+            to get information for.
+
+        Returns:
+            dict: The dict api response with warnings information.
+        """
+        params = {"mints": ",".join(mints)}
+
+        url = f"{self.base_url}/ultra/v1/shield"
+        response = self.client.get(url, params=params, headers=self._get_headers())
+        response.raise_for_status()
+
+        return response.json()  # type: ignore[no-any-return]  # type: ignore
+
+
+class AsyncUltraApiClient(AsyncJupiterClient):
+    """
+    An asynchronous client for interacting with the Jupiter Ultra API.
+    """
+
+    async def order(self, request: UltraOrderRequest) -> dict[str, Any]:
+        """
+        Get an order from the Jupiter Ultra API (asynchronous).
+
+        Args:
+            request (UltraOrderRequest): The request parameters for the order.
+
+        Returns:
+            dict: The dict api response.
+        """
+        params = request.to_dict()
+
+        url = f"{self.base_url}/ultra/v1/order"
+        response = await self.client.get(
+            url, params=params, headers=self._get_headers()
+        )
+        response.raise_for_status()
+
+        return response.json()  # type: ignore[no-any-return]
+
+    async def execute(self, request: UltraExecuteRequest) -> dict[str, Any]:
+        """
+        Execute the order with the Jupiter Ultra API (asynchronous).
+
+        Args:
+            request (UltraExecuteRequest): The execute request parameters.
+
+        Returns:
+            dict: The dict api response.
+        """
+        payload = request.to_dict()
+
+        url = f"{self.base_url}/ultra/v1/execute"
+        response = await self.client.post(
+            url, json=payload, headers=self._get_headers()
+        )
+        response.raise_for_status()
+
+        return response.json()  # type: ignore[no-any-return]
+
+    async def order_and_execute(self, request: UltraOrderRequest) -> dict[str, Any]:
+        """
+        Get and execute an order in a single call (asynchronous).
+
+        Args:
+            request (UltraOrderRequest): The request parameters for the order.
+
+        Returns:
+            dict: The dict api response.
+        """
+        order_response = await self.order(request)
+
+        request_id = order_response["requestId"]
+        signed_transaction = self._sign_base64_transaction(
+            order_response["transaction"]
+        )
+
+        execute_request = UltraExecuteRequest(
+            request_id=request_id,
+            signed_transaction=self._serialize_versioned_transaction(
+                signed_transaction
+            ),
+        )
+
+        return await self.execute(execute_request)
+
+    async def balances(self, address: str) -> dict[str, Any]:
+        """
+        Get token balances of an account (asynchronous).
+
+        Args:
+            address (str): The public key of the account to get balances for.
+
+        Returns:
+            dict: The dict api response.
+        """
+        url = f"{self.base_url}/ultra/v1/balances/{address}"
+        response = await self.client.get(url, headers=self._get_headers())
+        response.raise_for_status()
+
+        return response.json()  # type: ignore[no-any-return]
+
+    async def shield(self, mints: list[str]) -> dict[str, Any]:
+        """
+        Get token info and warnings for specific mints (asynchronous).
+        """
+        params = {"mints": ",".join(mints)}
+        url = f"{self.base_url}/ultra/v1/shield"
+        response = await self.client.get(
+            url, params=params, headers=self._get_headers()
+        )
+        response.raise_for_status()
+
+        return response.json()  # type: ignore[no-any-return]

jup_python_sdk/models/common/dex_enum.py

@@ -0,0 +1,57 @@
+from enum import Enum
+from urllib.parse import quote
+
+
+class DexEnum(str, Enum):
+    WOOFI = "Woofi"
+    PUMP_FUN = "Pump.fun"
+    WHIRLPOOL = "Whirlpool"
+    VIRTUALS = "Virtuals"
+    DAOS_FUN = "Daos.fun"
+    LIFINITY_V2 = "Lifinity V2"
+    STABBLE_STABLE_SWAP = "Stabble Stable Swap"
+    TOKEN_MILL = "Token Mill"  # noqa: S105
+    METEORA = "Meteora"
+    OASIS = "Oasis"
+    ALDRIN = "Aldrin"
+    GOOSEFX_GAMMA = "GooseFX GAMMA"
+    PERPS = "Perps"
+    SOLFI = "SolFi"
+    DEXLAB = "DexLab"
+    TOKEN_SWAP = "Token Swap"  # noqa: S105
+    ZEROFI = "ZeroFi"
+    CROPPER = "Cropper"
+    OBRIC_V2 = "Obric V2"
+    STABBLE_WEIGHTED_SWAP = "Stabble Weighted Swap"
+    SANCTUM_INFINITY = "Sanctum Infinity"
+    MOONIT = "Moonit"
+    SANCTUM = "Sanctum"
+    RAYDIUM_CP = "Raydium CP"
+    PHOENIX = "Phoenix"
+    PUMP_FUN_AMM = "Pump.fun Amm"
+    SABER = "Saber"
+    SABER_DECIMALS = "Saber (Decimals)"
+    RAYDIUM_CLMM = "Raydium CLMM"
+    DEX_1 = "1DEX"
+    PENGUIN = "Penguin"
+    ORCA_V2 = "Orca V2"
+    FLUXBEAM = "FluxBeam"
+    RAYDIUM = "Raydium"
+    METEORA_DLMM = "Meteora DLMM"
+    BONKSWAP = "Bonkswap"
+    SOLAYER = "Solayer"
+    STEPN = "StepN"
+    HELIUM_NETWORK = "Helium Network"
+    MERCURIAL = "Mercurial"
+    PERENA = "Perena"
+    ORCA_V1 = "Orca V1"
+    ALDRIN_V2 = "Aldrin V2"
+    SAROS = "Saros"
+    OPENBOOK_V2 = "OpenBook V2"
+    CREMA = "Crema"
+    OPENBOOK = "Openbook"
+    INVARIANT = "Invariant"
+    GUACSWAP = "Guacswap"
+
+    def __str__(self) -> str:
+        return quote(self.value)

jup_python_sdk/models/ultra_api/ultra_execute_request_model.py

@@ -0,0 +1,16 @@
+from typing import Any
+
+from pydantic import BaseModel
+from pydantic.alias_generators import to_camel
+
+
+class UltraExecuteRequest(BaseModel):
+    signed_transaction: str
+    request_id: str
+
+    def to_dict(self) -> dict[str, Any]:
+        params = self.model_dump(exclude_none=True)
+
+        camel_case_params = {to_camel(key): value for key, value in params.items()}
+
+        return camel_case_params

jup_python_sdk/models/ultra_api/ultra_order_request_model.py

@@ -0,0 +1,20 @@
+from typing import Any, Optional
+
+from pydantic import BaseModel
+from pydantic.alias_generators import to_camel
+
+
+class UltraOrderRequest(BaseModel):
+    input_mint: str
+    output_mint: str
+    amount: int
+    taker: Optional[str] = None
+    referral_account: Optional[str] = None
+    referral_fee: Optional[int] = None
+
+    def to_dict(self) -> dict[str, Any]:
+        params = self.model_dump(exclude_none=True)
+
+        camel_case_params = {to_camel(key): value for key, value in params.items()}
+
+        return camel_case_params

solanab_jup_python_sdk-2.0.3.dist-info/METADATA

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: solanab-jup-python-sdk
+Version: 2.0.3
+Summary: High-performance sync/async Python SDK for Jupiter Exchange APIs, powered by curl_cffi.
+Project-URL: homepage, https://github.com/solanab/jup-python-sdk
+Project-URL: repository, https://github.com/solanab/jup-python-sdk
+Author-email: Fiji <charismoutafidis@gmail.com>, solanab <whiredj@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: jupiter,sdk,solana
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: base58>=2.1.1
+Requires-Dist: curl-cffi>=0.12
+Requires-Dist: pydantic>=2.11.3
+Requires-Dist: solana>=0.36.6
+Requires-Dist: solders>=0.26.0
+Provides-Extra: dev
+Requires-Dist: bandit>=1.7; extra == 'dev'
+Requires-Dist: black>=25.1.0; extra == 'dev'
+Requires-Dist: flake8>=7.1.1; extra == 'dev'
+Requires-Dist: isort>=6.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.15.0; extra == 'dev'
+Requires-Dist: pre-commit>=4.1.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.7; extra == 'dev'
+Requires-Dist: pytest-cov>=6.1.1; extra == 'dev'
+Requires-Dist: pytest>=8.3.4; extra == 'dev'
+Requires-Dist: python-dotenv>=1.1.0; extra == 'dev'
+Requires-Dist: responses>=0.25.6; extra == 'dev'
+Requires-Dist: safety>=2.3; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# **Jup Python SDK**
+
+A high-performance, async-first Python SDK for seamless interaction with the Jupiter Ultra API, powered by `curl_cffi` for maximum speed and flexibility.<br>
+With Ultra API, you don't need to manage or connect to any RPC endpoints, or deal with complex configurations.<br>
+Everything from getting quotes to transaction execution happens directly through a powerful API.<br>
+
+Or as we like to say around here:<br>
+**"RPCs are for NPCs."**
+
+For a deeper understanding of the Ultra API, including its features and benefits, check out the [Ultra API Docs](https://dev.jup.ag/docs/ultra-api/).
+
+## **Installation**
+
+To install the SDK in your project, run:
+```sh
+pip install jup-python-sdk
+```
+
+## **Quick Start (Async)**
+
+Below is a simple asynchronous example to fetch and execute an Ultra order.
+
+```python
+import asyncio
+from dotenv import load_dotenv
+from jup_python_sdk.clients.ultra_api_client import AsyncUltraApiClient
+from jup_python_sdk.models.ultra_api.ultra_order_request_model import UltraOrderRequest
+
+async def main():
+   load_dotenv()
+   # Note: For async client, methods are awaited.
+   client = AsyncUltraApiClient()
+
+   order_request = UltraOrderRequest(
+      input_mint="So11111111111111111111111111111111111111112",  # WSOL
+      output_mint="EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",  # USDC
+      amount=10000000,  # 0.01 WSOL
+      taker=await client.get_public_key(),
+   )
+
+   try:
+      client_response = await client.order_and_execute(order_request)
+      signature = str(client_response["signature"])
+
+      print("Order and Execute API Response:")
+      print(f"  - Status: {client_response.get('status')}")
+      if client_response.get("status") == "Failed":
+         print(f"  - Code: {client_response.get('code')}")
+         print(f"  - Error: {client_response.get('error')}")
+
+      print(f"  - Transaction Signature: {signature}")
+      print(f"  - View on Solscan: https://solscan.io/tx/{signature}")
+
+   except Exception as e:
+      print("Error occurred while processing the swap:", str(e))
+   finally:
+      await client.close()
+
+if __name__ == "__main__":
+   asyncio.run(main())
+```
+
+> **Note**: A synchronous client (`UltraApiClient`) is also available. See the [examples](./examples) folder for both sync and async usage.
+
+## **Setup Instructions**
+
+Before using the SDK, please ensure you have completed the following steps:
+
+1. **Environment Variables**:  
+   Set up your required environment variables.  
+   The SDK supports both base58 string and uint8 array formats for your private key.
+   ```sh
+   # Base58 format
+   export PRIVATE_KEY=your_base58_private_key_here
+
+   # OR as a uint8 array
+   export PRIVATE_KEY=[10,229,131,132,213,96,74,22,...]
+   ```
+   
+> **Note**: `PRIVATE_KEY` can be either a base58-encoded string (default Solana format), or a uint8 array (e.g. `[181,99,240,...]`). The SDK will automatically detect and parse the format.
+
+2. **Optional Configuration**:  
+   Depending on your credentials and setup, you have a couple of options for initializing the `UltraApiClient`:
+   - **API Key**: Use an API key from [the Jupiter Portal](https://portal.jup.ag/onboard) for enhanced access. This will use the `https://api.jup.ag/` endpoint.
+   - **Custom Private Key Env Var**: Specify a different environment variable name for your private key.
+
+    ```python
+    from jup_python_sdk.clients.ultra_api_client import AsyncUltraApiClient
+
+    client = AsyncUltraApiClient(
+        api_key="YOUR_API_KEY",
+        private_key_env_var="YOUR_CUSTOM_ENV_VAR"
+    )
+    ```
+
+## **Advanced Configuration (Proxies, Custom DNS)**
+
+The SDK is built on `curl_cffi`, allowing you to pass any valid `curl_cffi` client parameter during initialization for advanced network control.
+
+### Using a SOCKS5 Proxy
+
+```python
+from jup_python_sdk.clients.ultra_api_client import AsyncUltraApiClient
+
+proxies = {"httpss": "socks5://user:pass@host:port"}
+client = AsyncUltraApiClient(client_kwargs={"proxies": proxies, "impersonate": "chrome110"})
+```
+
+### Using Custom DNS Resolution
+
+This is useful for bypassing local DNS caches or using a specialized DNS resolver.
+
+```python
+from jup_python_sdk.clients.ultra_api_client import AsyncUltraApiClient
+
+# Tell the client to resolve jup.ag to a specific IP address
+resolve_string = "jup.ag:443:1.2.3.4"
+client = AsyncUltraApiClient(client_kwargs={"resolve": [resolve_string]})
+```
+
+## **Disclaimer**
+
+🚨 **This project is actively worked on.**  
+While we don't expect breaking changes as the SDK evolves, we recommend you stay updated with the latest releases.  
+Any important updates will be announced in the [Discord server](https://discord.gg/jup).

solanab_jup_python_sdk-2.0.3.dist-info/RECORD

@@ -0,0 +1,14 @@
+jup_python_sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jup_python_sdk/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jup_python_sdk/clients/jupiter_client.py,sha256=3zX4e9iEmLP5KqSzmHt2vrry4UVbAKLaKSir6HFLf-U,4607
+jup_python_sdk/clients/ultra_api_client.py,sha256=jgNgf04bDSJxu8MY1oGRx3Bxemyy4B4y5eUuQBN61qA,6750
+jup_python_sdk/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jup_python_sdk/models/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jup_python_sdk/models/common/dex_enum.py,sha256=javWWg5TTbPAVNhoBQJlaVEUlpTkwfin7SO4xGKToaI,1510
+jup_python_sdk/models/ultra_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jup_python_sdk/models/ultra_api/ultra_execute_request_model.py,sha256=jvoPgCa5QxUFuMmZ7brFPcAyQzU7WgxtnwXH1KgxIPM,403
+jup_python_sdk/models/ultra_api/ultra_order_request_model.py,sha256=DSxQtLALHgHGwr5gw3Iu1fkg4LbydUUmEo-aHF55G4Y,534
+solanab_jup_python_sdk-2.0.3.dist-info/METADATA,sha256=OoA0fmw4M3EEXukcMU_LcViHFLl-oa1_vxdc6U6fh2A,5992
+solanab_jup_python_sdk-2.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+solanab_jup_python_sdk-2.0.3.dist-info/licenses/LICENSE,sha256=3va7FgUbc2istAEEchr1jkoUjBoSYPMkguY1BGuHt2U,1061
+solanab_jup_python_sdk-2.0.3.dist-info/RECORD,,

solanab_jup_python_sdk-2.0.3.dist-info/WHEEL

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

solanab_jup_python_sdk-2.0.3.dist-info/licenses/LICENSE

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