aiofortiosapi 0.1.0__py3-none-any.whl

aiofortiosapi/__init__.py

@@ -0,0 +1,31 @@
+"""aiofortiosapi — async FortiOS REST API client for Home Assistant."""
+
+from .client import FortiOSClient
+from .const import DEFAULT_ONLINE_THRESHOLD
+from .exceptions import (
+    FortiOSAuthenticationError,
+    FortiOSConnectionError,
+    FortiOSError,
+    FortiOSNotFoundError,
+    FortiOSResponseError,
+)
+from .models import DetectedDevice, ResourceUsage, SystemStatus
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "FortiOSClient",
+    # exceptions
+    "FortiOSError",
+    "FortiOSConnectionError",
+    "FortiOSAuthenticationError",
+    "FortiOSNotFoundError",
+    "FortiOSResponseError",
+    # models
+    "SystemStatus",
+    "ResourceUsage",
+    "DetectedDevice",
+    # constants
+    "DEFAULT_ONLINE_THRESHOLD",
+    "__version__",
+]

aiofortiosapi/client.py

@@ -0,0 +1,200 @@
+"""FortiOSClient — async HTTP client for the FortiOS REST API."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import time
+from typing import Any
+
+import aiohttp
+
+from .const import (
+    DEFAULT_ONLINE_THRESHOLD,
+    DEFAULT_PORT,
+    DEFAULT_TIMEOUT,
+    EP_DETECTED_DEVICES,
+    EP_RESOURCE_USAGE,
+    EP_SYSTEM_STATUS,
+)
+from .exceptions import (
+    FortiOSAuthenticationError,
+    FortiOSConnectionError,
+    FortiOSNotFoundError,
+    FortiOSResponseError,
+)
+from .models import DetectedDevice, ResourceUsage, SystemStatus
+
+_LOGGER = logging.getLogger(__name__)
+
+# FortiOS error envelopes carry the useful string under different keys
+# depending on firmware and failure mode (e.g. bad token, trusted-host
+# violation, CMDB error).  Checked in priority order.
+_ERROR_DETAIL_KEYS: tuple[str, ...] = (
+    "cli_error",
+    "message",
+    "error",
+    "http_message",
+)
+_ERROR_DETAIL_MAX_CHARS = 200
+
+
+def _extract_error_detail(body_text: str) -> str:
+    """Return the most useful human-readable string from an error body.
+
+    Falls back to the raw body (truncated) when the payload is not JSON or
+    carries none of the known detail keys.
+    """
+    try:
+        parsed: Any = json.loads(body_text)
+    except ValueError:
+        return body_text.strip()[:_ERROR_DETAIL_MAX_CHARS]
+    if isinstance(parsed, dict):
+        for key in _ERROR_DETAIL_KEYS:
+            if value := parsed.get(key):
+                return str(value)[:_ERROR_DETAIL_MAX_CHARS]
+    return body_text.strip()[:_ERROR_DETAIL_MAX_CHARS]
+
+
+class FortiOSClient:
+    """Async client for the FortiOS REST API.
+
+    The caller (e.g. Home Assistant) owns the aiohttp.ClientSession lifecycle.
+    This class never creates or closes the session it receives.
+    """
+
+    def __init__(
+        self,
+        host: str,
+        token: str,
+        *,
+        session: aiohttp.ClientSession,
+        port: int = DEFAULT_PORT,
+        verify_ssl: bool = True,
+        vdom: str | None = None,
+        request_timeout: float = DEFAULT_TIMEOUT,
+        device_online_threshold: float = DEFAULT_ONLINE_THRESHOLD,
+    ) -> None:
+        self._host = host
+        self._token = token
+        self._session = session
+        self._port = port
+        self._verify_ssl = verify_ssl
+        self._vdom = vdom
+        self._request_timeout = request_timeout
+        self._device_online_threshold = device_online_threshold
+
+    # ------------------------------------------------------------------
+    # Internal request plumbing
+    # ------------------------------------------------------------------
+
+    def _build_url(self, path: str) -> str:
+        return f"https://{self._host}:{self._port}/{path}"
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Single choke-point for all HTTP.
+
+        Builds URL, injects auth header, merges vdom param, applies timeout,
+        and maps all error conditions to the exception hierarchy.
+        """
+        url = self._build_url(path)
+        merged_params: dict[str, Any] = dict(params) if params else {}
+        if self._vdom is not None:
+            merged_params["vdom"] = self._vdom
+
+        headers = {"Authorization": f"Bearer {self._token}"}
+        ssl: bool = self._verify_ssl
+
+        _LOGGER.debug("FortiOS %s %s params=%s", method, url, list(merged_params.keys()))
+
+        try:
+            async with (
+                asyncio.timeout(self._request_timeout),
+                self._session.request(
+                    method,
+                    url,
+                    headers=headers,
+                    params=merged_params or None,
+                    ssl=ssl,
+                ) as response,
+            ):
+                if response.status in (401, 403):
+                    raise FortiOSAuthenticationError(
+                        f"Authentication failed (HTTP {response.status})"
+                    )
+                if response.status == 404:
+                    raise FortiOSNotFoundError(f"Endpoint not found: {path}")
+
+                if response.status >= 400:
+                    detail = _extract_error_detail(await response.text())
+                    raise FortiOSResponseError(f"HTTP {response.status} from {url}: {detail}")
+
+                try:
+                    data: dict[str, Any] = await response.json()
+                except (aiohttp.ClientError, ValueError) as exc:
+                    raise FortiOSResponseError(f"Invalid JSON from {url}") from exc
+
+                return data
+        except TimeoutError as exc:
+            raise FortiOSConnectionError(f"Request timed out: {url}") from exc
+        except aiohttp.ClientError as exc:
+            raise FortiOSConnectionError(f"Connection error: {exc}") from exc
+
+    # ------------------------------------------------------------------
+    # Public API methods
+    # ------------------------------------------------------------------
+
+    async def get(
+        self,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Perform a raw GET and return the parsed JSON envelope.
+
+        Escape hatch for endpoints without a dedicated typed method: returns
+        the full ``{"results": ..., "status": ..., ...}`` dict so the caller
+        can extract whatever it needs.  Inherits Bearer auth, timeout, and
+        the typed exception hierarchy from ``_request``.
+        """
+        return await self._request("GET", path, params=params)
+
+    async def get_system_status(self) -> SystemStatus:
+        """Return basic device identity: hostname, version, serial, model."""
+        raw = await self._request("GET", EP_SYSTEM_STATUS)
+        return SystemStatus.from_api(raw)
+
+    async def get_resource_usage(self) -> ResourceUsage:
+        """Return CPU, memory, session count, and uptime."""
+        raw = await self._request("GET", EP_RESOURCE_USAGE)
+        return ResourceUsage.from_api(raw)
+
+    async def get_detected_devices(self) -> list[DetectedDevice]:
+        """Return devices seen on the network (for device_tracker).
+
+        ``is_online`` uses the API-reported flag; when a firmware omits it,
+        it is derived from ``last_seen`` freshness using the client's
+        ``device_online_threshold``.
+        """
+        raw = await self._request("GET", EP_DETECTED_DEVICES)
+        return DetectedDevice.list_from_api(
+            raw,
+            now=time.time(),
+            online_threshold=self._device_online_threshold,
+        )
+
+    async def async_validate(self) -> SystemStatus:
+        """Validate credentials cheaply by calling get_system_status.
+
+        Raises FortiOSAuthenticationError for bad tokens, or
+        FortiOSConnectionError for unreachable devices.  Used by the HA
+        config_flow to confirm a token works before saving the entry.
+        """
+        return await self.get_system_status()

aiofortiosapi/const.py

@@ -0,0 +1,29 @@
+"""Constants: endpoint paths and defaults.
+
+WARNING: FortiOS monitor endpoint paths vary by firmware version and must be
+verified against the target version's API reference (FNDN — Fortinet Developer
+Network).  The paths below are known-good starting points for FortiOS 6.4 –
+8.x (verified on v8.0.1); do NOT assume they exist on older or newer
+firmware without checking.
+"""
+
+API_BASE = "api/v2"
+
+EP_SYSTEM_STATUS = f"{API_BASE}/monitor/system/status"
+EP_RESOURCE_USAGE = f"{API_BASE}/monitor/system/resource/usage"
+
+# 7.0+: older firmware used monitor/user/device/select
+EP_DETECTED_DEVICES = f"{API_BASE}/monitor/user/device/query"
+
+# Future endpoints (add intentionally, verify paths per target version):
+#   monitor/vpn/ipsec          — IPsec/VPN tunnel state
+#   monitor/system/interface   — per-interface traffic stats
+#   monitor/system/ha-statistics — HA cluster status
+
+DEFAULT_PORT: int = 443
+DEFAULT_TIMEOUT: float = 10.0
+
+# Fallback window for deriving device online state: when an API response
+# omits the is_online field, a device counts as online if it was last seen
+# within this many seconds (mirrors HA device_tracker "consider_home").
+DEFAULT_ONLINE_THRESHOLD: float = 300.0

aiofortiosapi/exceptions.py

@@ -0,0 +1,35 @@
+"""Exception hierarchy for aiofortiosapi.
+
+Map to Home Assistant config entry states:
+  FortiOSConnectionError      -> ConfigEntryNotReady  (retry)
+  FortiOSAuthenticationError  -> ConfigEntryAuthFailed (reauth)
+  FortiOSNotFoundError        -> inspect / log
+  FortiOSResponseError        -> log / raise
+"""
+
+
+class FortiOSError(Exception):
+    """Base exception for all aiofortiosapi errors."""
+
+
+class FortiOSConnectionError(FortiOSError):
+    """Transport-level or timeout failure.
+
+    Raised for aiohttp.ClientError and asyncio.TimeoutError.
+    Home Assistant should map this to ConfigEntryNotReady.
+    """
+
+
+class FortiOSAuthenticationError(FortiOSError):
+    """HTTP 401 or 403 response.
+
+    Home Assistant should map this to ConfigEntryAuthFailed.
+    """
+
+
+class FortiOSNotFoundError(FortiOSError):
+    """HTTP 404 response — endpoint does not exist on this FortiOS version."""
+
+
+class FortiOSResponseError(FortiOSError):
+    """Unexpected or unparseable response (bad JSON, 5xx, other 4xx)."""

aiofortiosapi/models.py

@@ -0,0 +1,192 @@
+"""Frozen dataclasses for parsed FortiOS API responses.
+
+FortiOS wraps all payloads as:
+  {"results": <dict|list>, "status": "success", "version": "v7.6.1",
+   "serial": "FGT60F...", "vdom": "root", ...}
+
+Each model's from_api() accepts the full envelope dict and parses defensively:
+missing keys, null values, and unexpected shapes all fall back to safe
+defaults instead of raising.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Any
+
+from .const import DEFAULT_ONLINE_THRESHOLD
+
+
+def _first(lst: Any, key: str, default: Any = None) -> Any:
+    """Extract key from the first element of a list of dicts, or default.
+
+    FortiOS returns cpu/memory/session stats as single-element lists of
+    objects; tolerate scalar lists, empty lists, and non-list values.
+    """
+    if isinstance(lst, list) and lst and isinstance(lst[0], dict):
+        return lst[0].get(key, default)
+    return default
+
+
+def _as_str(value: Any) -> str:
+    """Coerce an optional API string field to str; null and non-str become ''."""
+    return value if isinstance(value, str) else ""
+
+
+def _to_int(value: Any, default: int = 0) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def _to_float(value: Any, default: float = 0.0) -> float:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return default
+
+
+@dataclass(frozen=True, slots=True)
+class SystemStatus:
+    """Parsed response from monitor/system/status."""
+
+    hostname: str
+    version: str
+    serial: str
+    model: str
+
+    @classmethod
+    def from_api(cls, raw: dict[str, Any]) -> SystemStatus:
+        results: Any = raw.get("results")
+        if not isinstance(results, dict):
+            results = {}
+        serial = _as_str(raw.get("serial") or results.get("Serial-Number"))
+        version = _as_str(raw.get("version") or results.get("Version"))
+        hostname = _as_str(results.get("Hostname") or results.get("hostname"))
+        # Model name: use FGVM/FGT prefix from serial when not explicit
+        model = _as_str(results.get("Model-Name") or results.get("model") or serial[:6])
+        return cls(hostname=hostname, version=version, serial=serial, model=model)
+
+
+@dataclass(frozen=True, slots=True)
+class ResourceUsage:
+    """Parsed response from monitor/system/resource/usage.
+
+    Real FortiOS (verified on v8.0.1) returns each metric as a single-element
+    list with a ``current`` value, and splits sessions/setup-rate into IPv4
+    and IPv6 buckets:
+
+    ``{"cpu": [{"current": 0}], "mem": [{"current": 34}],
+       "session": [{"current": 279}], "session6": [{"current": 57}],
+       "setuprate": [{"current": 7}], "setuprate6": [{"current": 0}], ...}``
+
+    ``sessions`` and ``session_setup_rate`` are the sum of the v4 + v6
+    buckets.
+    """
+
+    cpu_percent: float
+    memory_percent: float
+    sessions: int  # session + session6
+    session_setup_rate: int  # setuprate + setuprate6
+
+    @classmethod
+    def from_api(cls, raw: dict[str, Any]) -> ResourceUsage:
+        results: Any = raw.get("results")
+        if not isinstance(results, dict):
+            results = {}
+        return cls(
+            cpu_percent=_to_float(_first(results.get("cpu"), "current")),
+            memory_percent=_to_float(_first(results.get("mem"), "current")),
+            sessions=(
+                _to_int(_first(results.get("session"), "current"))
+                + _to_int(_first(results.get("session6"), "current"))
+            ),
+            session_setup_rate=(
+                _to_int(_first(results.get("setuprate"), "current"))
+                + _to_int(_first(results.get("setuprate6"), "current"))
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class DetectedDevice:
+    """A single device from monitor/user/device/query.
+
+    Consumed by the Home Assistant device_tracker platform.
+
+    FortiOS reports an ``is_online`` flag for detected devices, which is used
+    verbatim.  When a firmware omits the field, ``is_online`` is derived from
+    ``last_seen`` freshness instead: True when the device was seen within
+    ``online_threshold`` seconds of the reference time (default
+    ``DEFAULT_ONLINE_THRESHOLD``, mirroring HA's consider_home behaviour).
+    """
+
+    mac: str
+    hostname: str
+    ip: str  # primary IP; may be empty string if unknown
+    os_name: str
+    interface: str
+    last_seen: int  # unix timestamp; 0 when not available
+    is_online: bool  # API-reported; derived from last_seen when absent
+
+    @classmethod
+    def _from_entry(
+        cls,
+        entry: dict[str, Any],
+        *,
+        now: float,
+        online_threshold: float,
+    ) -> DetectedDevice:
+        # IPs may come as a list, a plain string, or null
+        ips: Any = entry.get("ipv4_address", entry.get("ip"))
+        if isinstance(ips, list):
+            ip = _as_str(ips[0]) if ips else ""
+        elif isinstance(ips, str):
+            ip = ips
+        else:
+            ip = ""
+
+        last_seen = _to_int(entry.get("last_seen"))
+
+        api_flag = entry.get("is_online")
+        if api_flag is None:
+            # Field absent on this firmware: fall back to freshness.
+            is_online = last_seen > 0 and (now - float(last_seen)) <= online_threshold
+        else:
+            is_online = bool(api_flag)
+
+        return cls(
+            mac=_as_str(entry.get("mac")),
+            hostname=_as_str(entry.get("hostname") or entry.get("name")),
+            ip=ip,
+            os_name=_as_str(entry.get("os_name") or entry.get("os")),
+            interface=_as_str(entry.get("interface")),
+            last_seen=last_seen,
+            is_online=is_online,
+        )
+
+    @classmethod
+    def list_from_api(
+        cls,
+        raw: dict[str, Any],
+        *,
+        now: float | None = None,
+        online_threshold: float = DEFAULT_ONLINE_THRESHOLD,
+    ) -> list[DetectedDevice]:
+        """Parse the device list envelope.
+
+        ``now`` and ``online_threshold`` only affect the freshness-based
+        fallback used when an entry carries no ``is_online`` field.  ``now``
+        defaults to the current wall clock; pass it explicitly in tests.
+        """
+        results = raw.get("results", [])
+        if not isinstance(results, list):
+            return []
+        reference_now = time.time() if now is None else now
+        return [
+            cls._from_entry(e, now=reference_now, online_threshold=online_threshold)
+            for e in results
+            if isinstance(e, dict)
+        ]

aiofortiosapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.5
+Name: aiofortiosapi
+Version: 0.1.0
+Summary: Async FortiOS REST API client for Home Assistant
+Project-URL: Homepage, https://github.com/kimfrellsen/aiofortiosapi
+Project-URL: Repository, https://github.com/kimfrellsen/aiofortiosapi
+Project-URL: Changelog, https://github.com/kimfrellsen/aiofortiosapi/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/kimfrellsen/aiofortiosapi/issues
+Author-email: Kim <kim@frellsen.se>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api-client,asyncio,fortigate,fortinet,fortios,home-assistant
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Networking :: Monitoring
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: aiohttp>=3.9
+Provides-Extra: test
+Requires-Dist: aresponses>=3; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'test'
+Requires-Dist: pytest-cov>=5; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# aiofortiosapi
+
+Async Python client for the FortiOS REST API, built for the [Home Assistant](https://www.home-assistant.io/) `fortios` integration.
+
+> **Community project** — not affiliated with or supported by Fortinet TAC.
+
+## Install
+
+```bash
+pip install aiofortiosapi
+```
+
+## Usage
+
+The library requires an injected `aiohttp.ClientSession` — Home Assistant provides one via
+`async_get_clientsession(hass)`. You own the session lifecycle; this library never creates or closes it.
+
+```python
+import asyncio
+import aiohttp
+from aiofortiosapi import FortiOSClient, FortiOSAuthenticationError, FortiOSConnectionError
+
+async def main() -> None:
+    session = aiohttp.ClientSession()
+    try:
+        client = FortiOSClient(
+            host="192.168.1.1",
+            token="your-rest-api-token",
+            session=session,
+            verify_ssl=False,   # set True in production with a valid cert
+        )
+        status = await client.get_system_status()
+        print(status.hostname, status.version)
+
+        usage = await client.get_resource_usage()
+        print(f"CPU {usage.cpu_percent}%  MEM {usage.memory_percent}%")
+
+        devices = await client.get_detected_devices()
+        for d in devices:
+            print(d.mac, d.hostname, d.ip, "online" if d.is_online else "offline")
+    except FortiOSAuthenticationError:
+        print("Bad token — re-enter credentials")
+    except FortiOSConnectionError:
+        print("Cannot reach the FortiGate — check host/port")
+    finally:
+        await session.close()
+
+asyncio.run(main())
+```
+
+## Generating a FortiOS REST API token
+
+1. In the FortiGate GUI go to **System → Administrators → Create New → REST API Admin**.
+2. Set a **Trusted Host** (the IP of your Home Assistant instance) to restrict token use.
+3. Assign a read-only profile (`prof_admin` or custom).
+4. Copy the generated token — it is shown only once.
+
+The library uses `Authorization: Bearer <token>` (not the legacy `?access_token=` query string).
+
+### Device online state
+
+`DetectedDevice.is_online` uses the flag reported by FortiOS. On firmware that
+omits the field, it falls back to deriving online state from `last_seen`
+freshness: a device counts as online when seen within
+`DEFAULT_ONLINE_THRESHOLD` seconds (300). Tune the fallback per client:
+
+```python
+client = FortiOSClient(..., device_online_threshold=600)
+```
+
+## Scope
+
+`aiofortiosapi` is intentionally minimal:
+
+- **Three typed monitor endpoints** (`get_system_status`, `get_resource_usage`,
+  `get_detected_devices`) used by the Home Assistant integration.
+- A generic `get(path)` for any other endpoint that returns the raw JSON envelope.
+- **No** config-write, CMDB, file upload, SSH fallback, or CLI helpers.
+- **No** session/cookie login flow — Bearer token only.
+
+This keeps the dependency tree small (runtime dep: `aiohttp` only) and passes HA integration
+quality review requirements.
+
+## Exception hierarchy
+
+| Exception | When raised | HA mapping |
+|---|---|---|
+| `FortiOSConnectionError` | Transport/timeout failure | `ConfigEntryNotReady` |
+| `FortiOSAuthenticationError` | HTTP 401 / 403 | `ConfigEntryAuthFailed` |
+| `FortiOSNotFoundError` | HTTP 404 | log / inspect |
+| `FortiOSResponseError` | Bad JSON, 5xx, other 4xx | log / raise |
+
+## License
+
+MIT

aiofortiosapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+aiofortiosapi/__init__.py,sha256=OVDrncRnDTp8NawKHHbgLMndKzOatMvgWJPzNMsD7JE,734
+aiofortiosapi/client.py,sha256=D-Dv4PWwoqAedc2W2s-ZSxwXkwgDoHIJL69vZSILCrg,6954
+aiofortiosapi/const.py,sha256=RH-WBpYQaRNr6U5EvqRCtBoLQ2IkdUMp1pLR_jNjUGs,1205
+aiofortiosapi/exceptions.py,sha256=26VmAw_n3I3Cr4eeCDA9zwGS9oLJeyt1XmDtDfWSMqE,1009
+aiofortiosapi/models.py,sha256=HTy3zpGDXfsbWc3M8mJ06uo6zmFdS9tHExVeZQvLNfY,6534
+aiofortiosapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiofortiosapi-0.1.0.dist-info/METADATA,sha256=c0NaGu3jINvsjxI2rIojOgj-tQZyDeuWjjWGDhSFoLg,4557
+aiofortiosapi-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+aiofortiosapi-0.1.0.dist-info/licenses/LICENSE,sha256=5Kxo88fmjRi-gGYqqoUnD2FTR1IfW7lmpyWiVi-GTmw,1078
+aiofortiosapi-0.1.0.dist-info/RECORD,,

aiofortiosapi-0.1.0.dist-info/WHEEL

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

aiofortiosapi-0.1.0.dist-info/licenses/LICENSE

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