openvan 0.1.0__py3-none-any.whl

openvan/__init__.py

@@ -0,0 +1,9 @@
+"""OpenVan.camp — free vanlife / RV travel data API client. No API key.
+
+https://openvan.camp/docs · data CC BY 4.0
+"""
+
+from .api import OpenVan
+from .client import OpenVanClient, OpenVanError, __version__
+
+__all__ = ["OpenVan", "OpenVanClient", "OpenVanError", "__version__"]

openvan/api.py

@@ -0,0 +1,332 @@
+"""OpenVan.camp resources — the same surface as the JavaScript SDK, in snake_case."""
+
+from __future__ import annotations
+
+import math
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+from urllib.parse import quote
+
+from .client import DEFAULT_BASE_URL, OpenVanClient, OpenVanError
+
+LITERS_PER_GALLON = 3.78541
+
+JSON = Dict[str, Any]
+
+
+class OpenVan:
+    """OpenVan.camp — free vanlife / RV travel data. No API key.
+
+    >>> from openvan import OpenVan
+    >>> ov = OpenVan()
+    >>> ov.fuel.country("DE")["prices"]["diesel"]
+    >>> ov.visa.check("RU", "TR")
+    >>> ov.tolls.route(["Rome", "Paris"])
+
+    Data is CC BY 4.0 — credit "Data: OpenVan.camp" with a link to https://openvan.camp/.
+    Pass ``source="yourapp.com"`` so we can see and acknowledge your project.
+    """
+
+    def __init__(
+        self,
+        source: str = "openvan-python",
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+    ) -> None:
+        self.client = OpenVanClient(base_url=base_url, source=source, timeout=timeout)
+        self.fuel = Fuel(self.client)
+        self.currency = Currency(self.client)
+        self.basket = Basket(self.client)
+        self.weather = Weather(self.client)
+        self.events = Events(self.client)
+        self.stories = Stories(self.client)
+        self.tolls = Tolls(self.client)
+        self.visa = Visa(self.client)
+        self.plates = Plates(self.client)
+        self.holidays = Holidays(self.client)
+        self.hazards = Hazards(self.client)
+        self.electricity = Electricity(self.client)
+        self.customs = Customs(self.client)
+
+
+class _Resource:
+    def __init__(self, client: OpenVanClient) -> None:
+        self.client = client
+
+
+class Fuel(_Resource):
+    def prices(self) -> Dict[str, JSON]:
+        """Retail fuel prices of every country: ISO code → country entry."""
+        return self.client.get("/api/fuel/prices")["data"]
+
+    def country(self, code: str) -> JSON:
+        """Fuel prices of one country."""
+        entry = self.prices().get(code.upper())
+        if entry is None:
+            raise KeyError(f'No fuel data for country code "{code}"')
+        return entry
+
+    def cheapest(self, fuel_type: str = "diesel", limit: int = 10) -> List[JSON]:
+        """Cheapest countries for a fuel type, in EUR per liter, cheapest first.
+
+        Each grade is converted with its own currency (``currencies``), gallon prices are
+        normalized to liters, and countries whose currency has no rate are left out.
+        """
+        prices = self.prices()
+        try:
+            rates = self.client.get("/api/currency/rates")["rates"]
+        except OpenVanError:
+            rates = {}
+
+        def eur_per_liter(country: JSON) -> float:
+            price = (country.get("prices") or {}).get(fuel_type)
+            if price is None:
+                return math.nan
+            currency = ((country.get("currencies") or {}).get(fuel_type) or country.get("currency") or "").upper()
+            rate = 1 if currency == "EUR" else rates.get(currency)
+            if not rate:
+                return math.nan
+            eur = price / rate
+            return eur / LITERS_PER_GALLON if "gal" in str(country.get("unit", "")).lower() else eur
+
+        ranked = [(eur_per_liter(c), c) for c in prices.values()]
+        ranked = [x for x in ranked if not math.isnan(x[0])]
+        ranked.sort(key=lambda x: x[0])
+        return [c for _, c in ranked[:limit]]
+
+    def route_cost(self, waypoints: Sequence[str], **options: Any) -> JSON:
+        """Fuel cost for a route of 2–10 place names, with per-country prices along the way.
+
+        Options: ``fuel`` ("diesel", "gasoline", …), ``cons`` (l/100 km), ``tank`` (l),
+        ``currency``, ``locale``.
+        """
+        return self.client.post("/api/route-cost", {"waypoints": list(waypoints), **options})
+
+
+class Currency(_Resource):
+    def rates(self) -> Dict[str, float]:
+        """Exchange rates relative to EUR (1 EUR = rate units)."""
+        return self.client.get("/api/currency/rates")["rates"]
+
+    def convert(self, amount: float, from_currency: str, to_currency: str) -> float:
+        """Convert an amount between two currencies via EUR."""
+        rates = self.rates()
+
+        def rate(code: str) -> float:
+            code = code.upper()
+            value = 1 if code == "EUR" else rates.get(code)
+            if not value:
+                raise KeyError(f"Unknown currency: {code}")
+            return value
+
+        return amount / rate(from_currency) * rate(to_currency)
+
+
+class Basket(_Resource):
+    def list(self) -> Dict[str, JSON]:
+        """Food cost index of every country (world average = 100)."""
+        return self.client.get("/api/vanbasket/countries")["data"]
+
+    def country(self, code: str) -> JSON:
+        """Food cost index of one country with historical snapshots."""
+        return self.client.get(f"/api/vanbasket/countries/{code.upper()}")["data"]
+
+    def compare(self, from_country: str, to_country: str) -> JSON:
+        """Compare food cost between two countries."""
+        return self.client.get(
+            "/api/vanbasket/compare", {"from": from_country.upper(), "to": to_country.upper()}
+        )["data"]
+
+
+class Weather(_Resource):
+    def score(self, code: str) -> JSON:
+        """Vanlife weather of one country: ``van_score`` 0–100, ``score_label``, 7-day ``forecast``."""
+        return self.client.get(f"/api/vansky/weather/{code.upper()}")["data"]
+
+    def all(self) -> List[JSON]:
+        """Every country with weather data (one request, ~1 MB)."""
+        return self.client.get("/api/vansky/weather")["data"]
+
+    def top(self, limit: int = 10) -> List[JSON]:
+        """Top countries by vanlife weather suitability today, best first."""
+        return sorted(self.all(), key=lambda c: c.get("van_score") or 0, reverse=True)[:limit]
+
+
+class Events(_Resource):
+    def list(self, **filters: Any) -> JSON:
+        """Vanlife events. Filters: ``locale``, ``status``, ``type``, ``country``, ``search``, ``page``, ``limit``.
+
+        Returns ``{"events": [...], "pagination": {...}}``.
+        """
+        res = self.client.get("/api/events", filters)
+        return {"events": res["events"], "pagination": res["pagination"]}
+
+    def get(self, slug: str, locale: Optional[str] = None) -> JSON:
+        """One event with geo coordinates."""
+        return self.client.get(f"/api/event/{quote(slug)}", {"locale": locale})
+
+
+class Stories(_Resource):
+    def list(self, **filters: Any) -> JSON:
+        """News stories. Filters: ``locale``, ``category``, ``country``, ``search``, ``page``, ``limit``.
+
+        Returns ``{"stories": [...], "pagination": {...}}``.
+        """
+        res = self.client.get("/api/stories", filters)
+        return {"stories": res["stories"], "pagination": res["pagination"]}
+
+    def get(self, slug: str, locale: Optional[str] = None) -> JSON:
+        """One story with all source articles and direct links."""
+        return self.client.get(f"/api/story/{quote(slug)}", {"locale": locale})
+
+    def search(self, query: str, **options: Any) -> JSON:
+        """Semantic search over stories."""
+        return self.client.get("/api/news/search", {"q": query, **options})
+
+
+class Tolls(_Resource):
+    def countries(self, locale: Optional[str] = None) -> JSON:
+        """Countries with toll data: payment system, per-km rates by vehicle class, vignettes."""
+        return self.client.get("/api/tolls/countries", {"locale": locale})
+
+    def country(self, code: str, locale: Optional[str] = None) -> JSON:
+        """Toll reference for one country: rates, vignettes, concession sections, bridges and tunnels."""
+        return self.client.get(f"/api/tolls/countries/{code.upper()}", {"locale": locale})
+
+    def route(self, waypoints: Sequence[str], vehicle_class: str = "van", locale: Optional[str] = None) -> JSON:
+        """Toll cost for a route of 2–10 place names as a EUR range.
+
+        Check ``partial`` and ``unknown_countries``: a country without data is not a free country.
+        """
+        return self.client.get(
+            "/api/tolls/route",
+            {"waypoints": "|".join(waypoints), "vehicle_class": vehicle_class, "locale": locale},
+        )
+
+
+class Visa(_Resource):
+    def check(self, passport: str, destination: str, **options: Any) -> JSON:
+        """Entry rules for one passport and destination. Options: ``weight``, ``plate``, ``locale``."""
+        return self.client.get(
+            "/api/visa/check", {"passport": passport.upper(), "destination": destination.upper(), **options}
+        )
+
+    def route(
+        self,
+        countries: Sequence[str],
+        passports: Sequence[str] = (),
+        weight: Optional[str] = None,
+        plate: Optional[str] = None,
+        locale: Optional[str] = None,
+    ) -> JSON:
+        """Visa rules for a whole route (countries in travel order) for up to 10 passports."""
+        return self.client.get(
+            "/api/visa/route",
+            {
+                "t": ",".join(countries),
+                "p": ",".join(passports) or None,
+                "w": weight,
+                "plate": plate,
+                "locale": locale,
+            },
+        )
+
+    def passport(self, code: str, locale: Optional[str] = None) -> JSON:
+        """Every destination for one passport."""
+        return self.client.get(f"/api/visa/passport/{code.upper()}", {"locale": locale})
+
+    def vehicle(self, place: str, locale: Optional[str] = None) -> JSON:
+        """Temporary import rules for a foreign-plated vehicle in a country."""
+        return self.client.get(f"/api/visa/vehicle/{quote(place)}", {"locale": locale})
+
+
+class Plates(_Resource):
+    def list(self, locale: Optional[str] = None) -> JSON:
+        """Countries with license plate data: international code, regions, example plate."""
+        return self.client.get("/api/plates", {"locale": locale})
+
+    def country(self, code: str, locale: Optional[str] = None) -> JSON:
+        """Plate format and every region code of one country."""
+        return self.client.get(f"/api/plates/{code.lower()}", {"locale": locale})
+
+    def types(self, code: str, locale: Optional[str] = None) -> JSON:
+        """Plate types (private, taxi, diplomatic…). Empty for countries without a breakdown."""
+        return self.client.get(f"/api/plates/{code.lower()}/types", {"locale": locale})
+
+    def validate(self, code: str, number: str, **options: Any) -> JSON:
+        """Validate a plate number and resolve its region. Options: ``region``, ``type``, ``locale``."""
+        return self.client.get(f"/api/plates/{code.lower()}/validate", {"number": number, **options})
+
+    def random(self, code: str, type: Optional[str] = None) -> JSON:
+        """A random valid plate with image URLs."""
+        return self.client.get(f"/api/plates/{code.lower()}/random", {"type": type})
+
+    def image_url(
+        self,
+        code: str,
+        number: str,
+        format: str = "svg",
+        region: Optional[str] = None,
+        type: Optional[str] = None,
+        width: Optional[int] = None,
+    ) -> str:
+        """URL of a ready plate image (SVG or PNG). No request is made."""
+        return self.client.url(
+            f"/api/plates/{code.lower()}/plate.{format}",
+            {"number": number, "region": region, "type": type, "width": width if format == "png" else None},
+        )
+
+
+class Holidays(_Resource):
+    def countries(self, locale: Optional[str] = None) -> JSON:
+        """Countries with holiday data."""
+        return self.client.get("/api/holidays/countries", {"locale": locale})
+
+    def country(self, code: str, **options: Any) -> JSON:
+        """Public holidays, school holidays (ISO 3166-2 regions) and peak traffic days.
+
+        Options: ``from_`` / ``to`` (YYYY-MM-DD, default today + 90 days), ``kind``
+        ("public", "school" or "traffic"), ``locale``.
+        A country without data raises — that is not the same as "no holidays".
+        """
+        if "from_" in options:
+            options["from"] = options.pop("from_")
+        return self.client.get(f"/api/holidays/countries/{code.upper()}", options)
+
+
+class Hazards(_Resource):
+    def country(self, code: str, locale: Optional[str] = None) -> JSON:
+        """UK FCDO travel advice level and current GDACS natural disasters. Not a forecast."""
+        return self.client.get(f"/api/hazards/countries/{code.upper()}", {"locale": locale})
+
+    def fires(self, bbox: Tuple[float, float, float, float]) -> JSON:
+        """NASA FIRMS fires of the last 48 hours in ``(min_lon, min_lat, max_lon, max_lat)``, up to 10°×10°.
+
+        A new area may answer 503 "being loaded, retry in a minute".
+        """
+        return self.client.get("/api/hazards/fires", {"bbox": ",".join(str(v) for v in bbox)})
+
+
+class Electricity(_Resource):
+    def countries(self, locale: Optional[str] = None) -> JSON:
+        """Plug types and mains voltage of every country."""
+        return self.client.get("/api/electricity/countries", {"locale": locale})
+
+    def country(self, code: str, locale: Optional[str] = None) -> JSON:
+        """Plug types (IEC A–N), voltage, frequency and campsite hook-up connector of one country."""
+        return self.client.get(f"/api/electricity/countries/{code.upper()}", {"locale": locale})
+
+
+class Customs(_Resource):
+    def countries(self, locale: Optional[str] = None) -> JSON:
+        """Customs jurisdictions and blocs."""
+        return self.client.get("/api/customs/countries", {"locale": locale})
+
+    def country(self, code: str, from_country: Optional[str] = None, locale: Optional[str] = None) -> JSON:
+        """Customs rules on entry by car, each with an official quote.
+
+        A country without data raises — that is not the same as "nothing is restricted".
+        """
+        return self.client.get(
+            f"/api/customs/countries/{code.upper()}",
+            {"from": from_country.upper() if from_country else None, "locale": locale},
+        )

openvan/client.py

@@ -0,0 +1,89 @@
+"""HTTP transport for the OpenVan.camp API — standard library only."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Mapping, Optional
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+__version__ = "0.1.0"
+
+DEFAULT_BASE_URL = "https://openvan.camp"
+
+Query = Mapping[str, Any]
+
+
+class OpenVanError(Exception):
+    """An API request failed. ``message`` is the API's own explanation when it gave one."""
+
+    def __init__(self, message: str, status: int, url: str, body: Any = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.url = url
+        self.body = body
+
+
+class OpenVanClient:
+    """Low-level client: builds URLs with the attribution tag and decodes JSON."""
+
+    def __init__(
+        self,
+        base_url: str = DEFAULT_BASE_URL,
+        source: str = "openvan-python",
+        timeout: float = 30.0,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.source = source
+        self.timeout = timeout
+
+    def url(self, path: str, query: Optional[Query] = None) -> str:
+        """Absolute API URL; empty values are dropped and ``source`` is always added."""
+        params = {k: _query_value(v) for k, v in (query or {}).items() if v is not None and v != ""}
+        params["source"] = self.source
+        return f"{self.base_url}{path}?{urlencode(params)}"
+
+    def get(self, path: str, query: Optional[Query] = None) -> Any:
+        return self._request(Request(self.url(path, query), method="GET"))
+
+    def post(self, path: str, body: Any) -> Any:
+        request = Request(
+            self.url(path),
+            data=json.dumps(body).encode(),
+            method="POST",
+            headers={"Content-Type": "application/json"},
+        )
+        return self._request(request)
+
+    def _request(self, request: Request) -> Any:
+        request.add_header("Accept", "application/json")
+        request.add_header("User-Agent", f"openvan-python/{__version__}")
+        try:
+            with urlopen(request, timeout=self.timeout) as response:
+                return json.loads(response.read().decode())
+        except HTTPError as error:
+            # The API explains most errors in the body ("Place not found: …"); keep that message.
+            body: Any = None
+            try:
+                body = json.loads(error.read().decode())
+            except (ValueError, OSError):
+                pass
+            message = None
+            if isinstance(body, dict):
+                message = body.get("message") or body.get("error")
+            raise OpenVanError(
+                message if isinstance(message, str) else f"HTTP {error.code}: {error.reason}",
+                error.code,
+                request.full_url,
+                body,
+            ) from None
+        except URLError as error:
+            raise OpenVanError(f"Network error: {error.reason}", 0, request.full_url) from None
+
+
+def _query_value(value: Any) -> str:
+    if isinstance(value, bool):
+        return "1" if value else "0"
+    return str(value)

openvan-0.1.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.5
+Name: openvan
+Version: 0.1.0
+Summary: Free vanlife & RV travel data: fuel prices in 160+ countries, toll roads, visa rules, holidays, travel hazards, weather scores, currency. No API key.
+Project-URL: Homepage, https://openvan.camp/en/developers?utm_source=pypi&utm_medium=referral&utm_campaign=python-sdk
+Project-URL: Documentation, https://openvan.camp/docs?utm_source=pypi&utm_medium=referral&utm_campaign=python-sdk
+Project-URL: Source, https://github.com/openvancamp/openvan-camp-public-api/tree/main/python-sdk
+Project-URL: Changelog, https://github.com/openvancamp/openvan-camp-public-api/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/openvancamp/openvan-camp-public-api/issues
+Author-email: "OpenVan.camp" <hello@openvan.camp>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api-client,campervan,currency,fuel-prices,gas-prices,holidays,motorhome,open-data,road-trip,rv,toll-roads,travel,vanlife,visa,weather
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# openvan — Python client for the OpenVan.camp API
+
+Free vanlife & RV travel data in Python: fuel prices in 160+ countries, toll roads, visa and
+vehicle-import rules, public and school holidays, travel hazards and wildfires, customs rules,
+power plugs, weather suitability scores, food cost index, currency rates, events, news and
+license plates of the world.
+
+**No API key, no registration, no dependencies** — standard library only, Python 3.9+.
+
+```bash
+pip install openvan
+```
+
+## Quick start
+
+```python
+from openvan import OpenVan
+
+ov = OpenVan(source="myapp.com")  # source is optional: it lets us see and credit your project
+
+# Cheapest diesel in the world right now, EUR per liter
+for c in ov.fuel.cheapest("diesel", 5):
+    print(c["country_name"], c["prices"]["diesel"], c["currency"])
+
+# Can a Russian passport enter Turkey, and for how long?
+print(ov.visa.check("RU", "TR")["data"])
+
+# Toll cost Rome → Paris for a van, as a EUR range
+print(ov.tolls.route(["Rome", "Paris"], vehicle_class="van"))
+
+# Best countries for vanlife weather today
+for c in ov.weather.top(5):
+    print(c["code"], c["van_score"], c["score_label"])
+
+# School holidays in Germany this autumn, by federal state
+ov.holidays.country("DE", from_="2026-10-01", to="2026-12-31", kind="school")
+```
+
+### With pandas
+
+```python
+import pandas as pd
+from openvan import OpenVan
+
+ov = OpenVan()
+fuel = pd.DataFrame.from_dict(ov.fuel.prices(), orient="index")
+basket = pd.DataFrame.from_dict(ov.basket.list(), orient="index")
+```
+
+## Resources
+
+| Resource | Methods |
+|----------|---------|
+| `ov.fuel` | `prices()`, `country(code)`, `cheapest(fuel_type, limit)`, `route_cost(waypoints, **options)` |
+| `ov.currency` | `rates()`, `convert(amount, from_currency, to_currency)` |
+| `ov.basket` | `list()`, `country(code)`, `compare(from_country, to_country)` — food cost index |
+| `ov.weather` | `score(code)`, `all()`, `top(limit)` — VanSky weather suitability |
+| `ov.tolls` | `countries()`, `country(code)`, `route(waypoints, vehicle_class)` |
+| `ov.visa` | `check(passport, destination)`, `route(countries, passports)`, `passport(code)`, `vehicle(place)` |
+| `ov.holidays` | `countries()`, `country(code, from_=, to=, kind=)` |
+| `ov.hazards` | `country(code)`, `fires((min_lon, min_lat, max_lon, max_lat))` |
+| `ov.electricity` | `countries()`, `country(code)` — plug types and voltage |
+| `ov.customs` | `countries()`, `country(code, from_country=)` |
+| `ov.plates` | `list()`, `country(code)`, `types(code)`, `validate(code, number)`, `random(code)`, `image_url(code, number)` |
+| `ov.events` | `list(**filters)`, `get(slug)` |
+| `ov.stories` | `list(**filters)`, `get(slug)`, `search(query)` |
+
+Methods return the API's JSON as plain `dict` / `list`. Field reference:
+[interactive docs](https://openvan.camp/docs?utm_source=pypi&utm_medium=referral&utm_campaign=python-sdk) ·
+[OpenAPI spec](https://openvan.camp/docs.openapi).
+
+Errors raise `OpenVanError` with `status`, `url`, `body` and the API's own `message`:
+
+```python
+from openvan import OpenVan, OpenVanError
+
+try:
+    OpenVan().tolls.route(["Atlantis", "Paris"])
+except OpenVanError as e:
+    print(e.status, e.message)  # 422 and the reason, e.g. no road route
+```
+
+## License and attribution
+
+Code: MIT. Data: [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) — credit it as
+`Data: OpenVan.camp` with a link to https://openvan.camp/.
+
+Also available: [JavaScript SDK](https://www.npmjs.com/package/@openvancamp/sdk) ·
+[MCP server for AI agents](https://github.com/openvancamp/openvan-camp-public-api/tree/main/mcp-server) ·
+[all API docs](https://github.com/openvancamp/openvan-camp-public-api).

openvan-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+openvan/__init__.py,sha256=g8eOm0MVVvCwo15wM5O-cSWKPhbVtXQMMyoCG7VmsGE,281
+openvan/api.py,sha256=8wsTxD6iQ_EdCsXrc9p7oxFPaThk4bhPBXgarqsp8Nw,13954
+openvan/client.py,sha256=D0PbzBrTYbLq0mEYnpDM9lKN0MeihnnmtpMWraUCgBw,3144
+openvan/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openvan-0.1.0.dist-info/METADATA,sha256=5p0u6M3mgKsL3AxZC9Lb9c8pIKSvWSP2DssSq5NVa3w,5043
+openvan-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+openvan-0.1.0.dist-info/licenses/LICENSE,sha256=VwWnJHQUHwGxoA_mrdQeg0D4y4-fyVXYq_tl4pETK1I,1069
+openvan-0.1.0.dist-info/RECORD,,

openvan-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

openvan-0.1.0.dist-info/licenses/LICENSE

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