fastapi-unirate 0.1.0__py3-none-any.whl

fastapi_unirate/__init__.py

@@ -0,0 +1,22 @@
+"""FastAPI integration for the UniRate currency-exchange API."""
+
+from fastapi_unirate.client import UniRateAPIError, UniRateClient
+from fastapi_unirate.dependencies import (
+    UniRateDep,
+    get_unirate_client,
+    unirate_lifespan,
+)
+from fastapi_unirate.middleware import CurrencyConversionMiddleware
+from fastapi_unirate.models import Money
+
+__all__ = [
+    "CurrencyConversionMiddleware",
+    "Money",
+    "UniRateAPIError",
+    "UniRateClient",
+    "UniRateDep",
+    "get_unirate_client",
+    "unirate_lifespan",
+]
+
+__version__ = "0.1.0"

fastapi_unirate/client.py

@@ -0,0 +1,150 @@
+"""Async UniRate API client used by the FastAPI dependency."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+DEFAULT_BASE_URL = "https://api.unirateapi.com"
+DEFAULT_TIMEOUT = 30.0
+
+
+class UniRateAPIError(Exception):
+    """Raised when the UniRate API returns a non-success response."""
+
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class UniRateClient:
+    """Thin async client over the UniRate REST API.
+
+    Wraps an ``httpx.AsyncClient`` so it slots cleanly into FastAPI's async
+    request lifecycle. Use :func:`fastapi_unirate.unirate_lifespan` to manage
+    a single client per app, or instantiate directly inside tests.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = DEFAULT_TIMEOUT,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None:
+        if not api_key:
+            msg = "api_key is required"
+            raise ValueError(msg)
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._owns_client = http_client is None
+        self._client = http_client or httpx.AsyncClient(timeout=timeout)
+
+    async def aclose(self) -> None:
+        """Close the underlying HTTP client if this instance owns it."""
+        if self._owns_client:
+            await self._client.aclose()
+
+    async def __aenter__(self) -> UniRateClient:
+        return self
+
+    async def __aexit__(self, *exc_info: object) -> None:
+        await self.aclose()
+
+    async def _request(
+        self, path: str, params: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        full_params: dict[str, Any] = {"api_key": self.api_key}
+        if params:
+            full_params.update(params)
+        try:
+            response = await self._client.get(
+                f"{self.base_url}{path}",
+                params=full_params,
+                headers={"Accept": "application/json"},
+            )
+        except httpx.HTTPError as exc:  # pragma: no cover - network errors
+            raise UniRateAPIError(f"UniRate request failed: {exc}") from exc
+
+        if response.status_code == 401:
+            raise UniRateAPIError("Missing or invalid UniRate API key", status_code=401)
+        if response.status_code == 403:
+            raise UniRateAPIError(
+                "Endpoint requires a UniRate Pro subscription", status_code=403
+            )
+        if response.status_code == 404:
+            raise UniRateAPIError(
+                "Currency not found or no data available", status_code=404
+            )
+        if response.status_code == 429:
+            raise UniRateAPIError("UniRate API rate limit exceeded", status_code=429)
+        if response.status_code >= 400:
+            raise UniRateAPIError(
+                f"UniRate API error: HTTP {response.status_code}",
+                status_code=response.status_code,
+            )
+        return response.json()
+
+    async def get_rate(
+        self, from_currency: str = "USD", to_currency: str | None = None
+    ) -> float | dict[str, float]:
+        """Return the latest rate, or a mapping of every target rate.
+
+        Args:
+            from_currency: ISO 4217 base currency code.
+            to_currency: ISO 4217 target currency. If omitted, every supported
+                target is returned.
+        """
+        params: dict[str, Any] = {"from": from_currency.upper()}
+        if to_currency is not None:
+            params["to"] = to_currency.upper()
+        data = await self._request("/api/rates", params)
+        if to_currency is not None:
+            return float(data["rate"])
+        return {code: float(rate) for code, rate in data["rates"].items()}
+
+    async def convert(
+        self,
+        from_currency: str,
+        to_currency: str,
+        amount: float = 1.0,
+    ) -> float:
+        """Convert ``amount`` from one currency to another at the latest rate."""
+        data = await self._request(
+            "/api/convert",
+            {
+                "from": from_currency.upper(),
+                "to": to_currency.upper(),
+                "amount": amount,
+            },
+        )
+        return float(data["result"])
+
+    async def get_supported_currencies(self) -> list[str]:
+        """Return every supported ISO/ticker code the API can convert between."""
+        data = await self._request("/api/currencies")
+        return list(data["currencies"])
+
+    async def convert_historical(
+        self,
+        from_currency: str,
+        to_currency: str,
+        date: str,
+        amount: float = 1.0,
+    ) -> float:
+        """Convert at the rate observed on ``date`` (YYYY-MM-DD). Pro-gated."""
+        data = await self._request(
+            "/api/historical/rates",
+            {
+                "from": from_currency.upper(),
+                "to": to_currency.upper(),
+                "amount": amount,
+                "date": date,
+            },
+        )
+        if "result" in data:
+            return float(data["result"])
+        return float(data["rate"])

fastapi_unirate/dependencies.py

@@ -0,0 +1,88 @@
+"""FastAPI dependency wiring for :class:`UniRateClient`."""
+
+from __future__ import annotations
+
+import os
+from collections.abc import AsyncIterator, Callable
+from contextlib import asynccontextmanager
+from typing import Annotated, Any
+
+from fastapi import Depends, FastAPI, Request
+
+from fastapi_unirate.client import UniRateClient
+
+_STATE_KEY = "unirate_client"
+
+
+def unirate_lifespan(
+    *,
+    api_key: str | None = None,
+    base_url: str | None = None,
+    timeout: float | None = None,
+) -> Callable[[FastAPI], Any]:
+    """Return a FastAPI ``lifespan`` callable that owns a single shared client.
+
+    Reads ``UNIRATE_API_KEY`` from the environment when ``api_key`` is not
+    passed.
+
+    Example:
+        .. code-block:: python
+
+            from fastapi import FastAPI
+            from fastapi_unirate import unirate_lifespan
+
+            app = FastAPI(lifespan=unirate_lifespan())
+    """
+
+    @asynccontextmanager
+    async def _lifespan(app: FastAPI) -> AsyncIterator[None]:
+        key = api_key or os.environ.get("UNIRATE_API_KEY")
+        if not key:
+            msg = (
+                "UniRate API key not set — pass api_key= to unirate_lifespan() "
+                "or set UNIRATE_API_KEY in the environment"
+            )
+            raise RuntimeError(msg)
+        kwargs: dict[str, Any] = {}
+        if base_url is not None:
+            kwargs["base_url"] = base_url
+        if timeout is not None:
+            kwargs["timeout"] = timeout
+        client = UniRateClient(api_key=key, **kwargs)
+        setattr(app.state, _STATE_KEY, client)
+        try:
+            yield
+        finally:
+            await client.aclose()
+
+    return _lifespan
+
+
+def get_unirate_client(request: Request) -> UniRateClient:
+    """``Depends`` provider that returns the lifespan-managed client.
+
+    Raises:
+        RuntimeError: If the app was started without ``unirate_lifespan``
+            (or another wiring that puts a ``UniRateClient`` on
+            ``app.state.unirate_client``).
+    """
+    client = getattr(request.app.state, _STATE_KEY, None)
+    if client is None:
+        msg = (
+            "UniRateClient is not configured. Wire up the app with "
+            "fastapi_unirate.unirate_lifespan() or assign a client to "
+            "app.state.unirate_client manually."
+        )
+        raise RuntimeError(msg)
+    return client
+
+
+# Convenience alias for path-operation signatures.
+UniRateDep = Annotated[UniRateClient, Depends(get_unirate_client)]
+
+
+__all__ = [
+    "UniRateDep",
+    "get_unirate_client",
+    "unirate_lifespan",
+]

fastapi_unirate/middleware.py

@@ -0,0 +1,217 @@
+"""ASGI middleware that auto-converts Money values in JSON responses.
+
+Reads a target currency from a configurable query parameter (default
+``?currency=``) and rewrites every ``Money``-shaped object in the response
+JSON to that currency at the latest UniRate rate.
+
+A ``Money``-shaped object is a dict (or list of dicts) with both ``amount``
+(numeric) and ``currency`` (string) keys.
+
+Conversions are done concurrently per response and cached for the duration
+of the request.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from collections.abc import Iterator
+from typing import Any
+
+from fastapi import FastAPI
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
+
+from fastapi_unirate.client import UniRateAPIError, UniRateClient
+
+_STATE_KEY = "unirate_client"
+
+
+class CurrencyConversionMiddleware:
+    """Rewrite Money-shaped values in JSON responses to a request-scoped currency.
+
+    Args:
+        app: The ASGI app to wrap.
+        query_param: Name of the query parameter that holds the target
+            currency (default ``"currency"``).
+        client: Override the lifespan-managed client (mostly for tests).
+
+    Behaviour:
+        - Only acts on ``application/json`` responses with a 2xx status.
+        - Skips when the query parameter is absent.
+        - Leaves the response untouched on any UniRate API error so the
+            handler's response still reaches the user.
+    """
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        *,
+        query_param: str = "currency",
+        client: UniRateClient | None = None,
+    ) -> None:
+        self.app = app
+        self.query_param = query_param
+        self._override_client = client
+
+    def _resolve_client(self, scope: Scope) -> UniRateClient | None:
+        if self._override_client is not None:
+            return self._override_client
+        app: FastAPI | None = scope.get("app")
+        if app is None:
+            return None
+        return getattr(app.state, _STATE_KEY, None)
+
+    @staticmethod
+    def _target_from_query(scope: Scope, key: str) -> str | None:
+        raw_qs = scope.get("query_string") or b""
+        if not raw_qs:
+            return None
+        from urllib.parse import parse_qs
+
+        parsed = parse_qs(raw_qs.decode("latin-1"))
+        values = parsed.get(key)
+        if not values:
+            return None
+        target = values[0].strip().upper()
+        return target or None
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        target = self._target_from_query(scope, self.query_param)
+        if target is None:
+            await self.app(scope, receive, send)
+            return
+
+        client = self._resolve_client(scope)
+        if client is None:
+            await self.app(scope, receive, send)
+            return
+
+        body = bytearray()
+        response_start: Message | None = None
+        content_type = ""
+
+        async def _send(message: Message) -> None:
+            nonlocal response_start, content_type
+            if message["type"] == "http.response.start":
+                response_start = message
+                for name, value in message.get("headers", []):
+                    if name.decode("latin-1").lower() == "content-type":
+                        content_type = value.decode("latin-1").lower()
+                        break
+                # Defer sending the start until we know the rewritten body length.
+                return
+            if message["type"] == "http.response.body":
+                body.extend(message.get("body") or b"")
+                if message.get("more_body"):
+                    return
+                # End of body — try to rewrite.
+                rewritten = await _maybe_rewrite(
+                    bytes(body), content_type, client, target
+                )
+                if response_start is not None:
+                    headers = [
+                        (name, value)
+                        for name, value in response_start.get("headers", [])
+                        if name.decode("latin-1").lower() != "content-length"
+                    ]
+                    headers.append(
+                        (
+                            b"content-length",
+                            str(len(rewritten)).encode("latin-1"),
+                        )
+                    )
+                    response_start["headers"] = headers
+                    await send(response_start)
+                await send({"type": "http.response.body", "body": rewritten})
+                return
+            await send(message)
+
+        await self.app(scope, receive, _send)
+
+
+async def _maybe_rewrite(
+    body: bytes,
+    content_type: str,
+    client: UniRateClient,
+    target: str,
+) -> bytes:
+    """Rewrite Money values in a JSON body. Pass-through on any failure."""
+    if "application/json" not in content_type:
+        return body
+    if not body:
+        return body
+    try:
+        data = json.loads(body)
+    except (ValueError, UnicodeDecodeError):
+        return body
+
+    money_nodes = list(_iter_money_nodes(data))
+    if not money_nodes:
+        return body
+
+    cache: dict[tuple[str, float], float] = {}
+    try:
+        await asyncio.gather(
+            *(_rewrite_node(node, target, client, cache) for node in money_nodes)
+        )
+    except UniRateAPIError:
+        return body
+
+    return json.dumps(data, separators=(",", ":")).encode("utf-8")
+
+
+def _iter_money_nodes(value: Any) -> Iterator[dict[str, Any]]:
+    """Yield every dict that looks like a Money value, depth-first."""
+    if isinstance(value, dict):
+        if _is_money(value):
+            yield value
+        for v in value.values():
+            yield from _iter_money_nodes(v)
+    elif isinstance(value, list):
+        for item in value:
+            yield from _iter_money_nodes(item)
+
+
+def _is_money(value: dict[str, Any]) -> bool:
+    if "amount" not in value or "currency" not in value:
+        return False
+    amount = value["amount"]
+    currency = value["currency"]
+    if not isinstance(amount, (int, float)) or isinstance(amount, bool):
+        return False
+    if not isinstance(currency, str) or not currency:
+        return False
+    return True
+
+
+async def _rewrite_node(
+    node: dict[str, Any],
+    target: str,
+    client: UniRateClient,
+    cache: dict[tuple[str, float], float],
+) -> None:
+    src_currency = str(node["currency"]).upper()
+    if src_currency == target:
+        node["currency"] = target
+        return
+    amount = float(node["amount"])
+    cache_key = (src_currency, amount)
+    if cache_key in cache:
+        node["amount"] = cache[cache_key]
+        node["currency"] = target
+        return
+    converted = await client.convert(
+        from_currency=src_currency,
+        to_currency=target,
+        amount=amount,
+    )
+    cache[cache_key] = converted
+    node["amount"] = converted
+    node["currency"] = target
+
+
+__all__ = ["CurrencyConversionMiddleware"]

fastapi_unirate/models.py

@@ -0,0 +1,42 @@
+"""Pydantic ``Money`` type for response bodies."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+if TYPE_CHECKING:
+    from fastapi_unirate.client import UniRateClient
+
+
+class Money(BaseModel):
+    """Amount + currency pair that the conversion middleware can rewrite.
+
+    The middleware looks for response objects shaped like ``{"amount": ...,
+    "currency": "..."}`` and rewrites them to a request-scoped target
+    currency. Use this type in your response models so OpenAPI schemas stay
+    accurate, but the middleware will also rewrite plain dicts of the same
+    shape.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    amount: float
+    currency: str = Field(..., min_length=3, max_length=10)
+
+    @field_validator("currency")
+    @classmethod
+    def _normalize_currency(cls, v: str) -> str:
+        return v.upper()
+
+    async def convert_to(self, client: UniRateClient, currency: str) -> Money:
+        """Return a new ``Money`` converted into ``currency`` at the latest rate."""
+        if currency.upper() == self.currency:
+            return self
+        new_amount = await client.convert(
+            from_currency=self.currency,
+            to_currency=currency,
+            amount=self.amount,
+        )
+        return Money(amount=new_amount, currency=currency.upper())

fastapi_unirate-0.1.0.dist-info/METADATA

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: fastapi-unirate
+Version: 0.1.0
+Summary: FastAPI integration for the UniRate currency-exchange API — async dependency, lifespan manager, Money Pydantic type, and response-conversion middleware.
+Project-URL: Homepage, https://github.com/UniRate-API/fastapi-unirate
+Project-URL: Repository, https://github.com/UniRate-API/fastapi-unirate
+Project-URL: Issues, https://github.com/UniRate-API/fastapi-unirate/issues
+Project-URL: Provider, https://unirateapi.com
+Author: Unirate Team
+License: MIT
+License-File: LICENSE
+Keywords: currency,exchange-rates,fastapi,fintech,forex,money,unirate
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: fastapi<2.0,>=0.100
+Requires-Dist: httpx<1.0,>=0.25
+Requires-Dist: pydantic<3.0,>=2.0
+Description-Content-Type: text/markdown
+
+# fastapi-unirate
+
+[![PyPI](https://img.shields.io/pypi/v/fastapi-unirate.svg)](https://pypi.org/project/fastapi-unirate/)
+[![Python](https://img.shields.io/pypi/pyversions/fastapi-unirate.svg)](https://pypi.org/project/fastapi-unirate/)
+[![License](https://img.shields.io/pypi/l/fastapi-unirate.svg)](https://github.com/UniRate-API/fastapi-unirate/blob/main/LICENSE)
+
+FastAPI integration for the [UniRate](https://unirateapi.com) currency-exchange API:
+
+- **Async dependency** — `Depends(get_unirate_client)` plus a typed
+  `UniRateDep` alias for path-operation signatures.
+- **Lifespan helper** — one shared `httpx.AsyncClient`-backed UniRate client
+  per app, opened on startup and closed on shutdown.
+- **`Money` Pydantic type** — amount + currency pair that round-trips
+  through OpenAPI schemas.
+- **`CurrencyConversionMiddleware`** — auto-rewrites Money-shaped values in
+  JSON responses to a request-scoped target currency
+  (`?currency=EUR`).
+
+UniRate covers 593+ fiat, crypto, and commodity codes. Latest rates and
+conversion are on the free tier; historical endpoints
+(`convert_historical`) require Pro.
+
+## Install
+
+```bash
+pip install fastapi-unirate
+```
+
+Or with uv / Poetry:
+
+```bash
+uv add fastapi-unirate
+poetry add fastapi-unirate
+```
+
+## Quick start
+
+```python
+import os
+
+from fastapi import FastAPI
+from fastapi_unirate import (
+    CurrencyConversionMiddleware,
+    Money,
+    UniRateDep,
+    unirate_lifespan,
+)
+
+app = FastAPI(lifespan=unirate_lifespan())  # reads UNIRATE_API_KEY from env
+app.add_middleware(CurrencyConversionMiddleware)
+
+
+@app.get("/products/widget")
+async def get_widget() -> dict[str, Money]:
+    return {"price": Money(amount=19.99, currency="USD")}
+
+
+@app.get("/rate/{base}/{quote}")
+async def rate(base: str, quote: str, client: UniRateDep) -> dict[str, float]:
+    return {"rate": await client.get_rate(base, quote)}
+```
+
+Then:
+
+```
+$ curl localhost:8000/products/widget
+{"price":{"amount":19.99,"currency":"USD"}}
+
+$ curl localhost:8000/products/widget?currency=EUR
+{"price":{"amount":18.42,"currency":"EUR"}}
+
+$ curl localhost:8000/rate/USD/JPY
+{"rate":151.83}
+```
+
+The middleware finds every `{"amount": <number>, "currency": "<code>"}`
+shape — top-level, nested, or inside lists — and rewrites it. Conversions
+are de-duplicated per request and run concurrently.
+
+## Configuration
+
+`unirate_lifespan` accepts overrides:
+
+```python
+app = FastAPI(
+    lifespan=unirate_lifespan(
+        api_key="...",                         # default: $UNIRATE_API_KEY
+        base_url="https://api.unirateapi.com", # default: production
+        timeout=15.0,                          # default: 30s
+    )
+)
+```
+
+`CurrencyConversionMiddleware` accepts the query-parameter name and an
+explicit client (mostly for testing):
+
+```python
+app.add_middleware(
+    CurrencyConversionMiddleware,
+    query_param="display_currency",
+)
+```
+
+## Why a middleware?
+
+The dossier sketched two integration shapes — DI and middleware — and
+both pull their weight:
+
+- The DI provider is the right tool when a handler explicitly wants to
+  call `convert()` or `get_rate()`.
+- The middleware is the right tool when a service has a stable
+  `Money`-shaped response and wants to expose
+  *one* `?currency=` knob to clients without rewriting every handler.
+
+You can use either, or both together (as in the quick-start example).
+
+## Errors
+
+The client raises `UniRateAPIError` on non-2xx responses (with
+`status_code` set). Common cases:
+
+| HTTP | Meaning                                         |
+|------|-------------------------------------------------|
+| 401  | Missing or invalid API key                      |
+| 403  | Pro subscription required (historical, commodities) |
+| 404  | Currency not found                              |
+| 429  | Rate limit exceeded                             |
+
+The middleware swallows `UniRateAPIError` and passes the original
+response through unchanged — so an upstream UniRate outage never becomes
+a 500 on your service.
+
+## Compatibility
+
+- Python 3.9 – 3.13
+- FastAPI ≥ 0.100
+- Pydantic ≥ 2.0
+
+## Related
+
+- [`unirate-api`](https://pypi.org/project/unirate-api/) — sync UniRate
+  Python client (this package vendors a small async equivalent so it
+  doesn't pull in `requests`).
+- [`langchain-unirate`](https://pypi.org/project/langchain-unirate/) —
+  LangChain partner package.
+- Other UniRate integrations: dbt, Airflow, n8n, Raycast, MCP server.
+  Full list at <https://unirateapi.com>.
+
+## License
+
+MIT

fastapi_unirate-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+fastapi_unirate/__init__.py,sha256=sRYTKHrL8IMfzwvwH-2DjKiKZEddQfZmTZpNKdDKY_w,547
+fastapi_unirate/client.py,sha256=MK5n_m12__s6xmOKULOqK_U4EQ1x7HwIyNjM_-6GBpg,5168
+fastapi_unirate/dependencies.py,sha256=EcGK_h5uqezfYe4xp6vkgaAJwEUqcAcWUE0Rp8QHtl0,2552
+fastapi_unirate/middleware.py,sha256=w-68UbCSGnxGjO7HPN7HOCY7hiTZ_WKgUcprB_ekheo,7049
+fastapi_unirate/models.py,sha256=SLgKc-U5mtmAETyXYUX8144AdVfleziTqJCXGVziMLs,1391
+fastapi_unirate-0.1.0.dist-info/METADATA,sha256=FI6jgosE0FVyp1-nohsEYCL6uLTs6f8ymeKc6-LMARw,5945
+fastapi_unirate-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+fastapi_unirate-0.1.0.dist-info/licenses/LICENSE,sha256=rVrKGfIoSe_67p0Q3sfLhO-3hEJyzoTse2LtLvrD04c,1068
+fastapi_unirate-0.1.0.dist-info/RECORD,,

fastapi_unirate-0.1.0.dist-info/WHEEL

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

fastapi_unirate-0.1.0.dist-info/licenses/LICENSE

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