windhover 0.7.0__py3-none-any.whl

windhover/tracer.py

@@ -0,0 +1,325 @@
+"""Windhover tracer — one LangChain callback, two sinks.
+
+`SpanBuilder` turns LangGraph/LangChain callbacks into a run + span tree and hands
+each event to a `sink`. In-process runs use a DB sink; external apps use
+`WindhoverTracer` (HTTP sink) — identical span logic, so the trace looks the same
+wherever it came from.
+
+Callback realities handled:
+  * LangGraph exposes the node name only on `on_chain_start` (metadata.langgraph_node),
+    never on end → we map langchain run_id -> our span.
+  * Token usage lives in either `llm_output.token_usage` (OpenAI-style) or a
+    generation's `usage_metadata` (input_tokens/output_tokens) — we read both.
+  * Parent linkage uses LangChain's parent_run_id.
+Best-effort: a sink error never propagates into the user's graph.
+"""
+from __future__ import annotations
+import json, time, uuid
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+try:
+    from langchain_core.callbacks import BaseCallbackHandler
+except Exception:  # pragma: no cover - allows import without langchain
+    BaseCallbackHandler = object  # type: ignore
+
+_PRICING: Optional[dict] = None
+
+
+def _load_pricing() -> dict:
+    global _PRICING
+    if _PRICING is None:
+        try:
+            p = Path(__file__).parent / "pricing.json"
+            _PRICING = {k: v for k, v in json.loads(p.read_text()).items()
+                        if not k.startswith("_")}
+        except Exception:
+            _PRICING = {}
+    return _PRICING
+
+
+def cost_of(model: Optional[str], pt: Optional[int], ct: Optional[int]) -> Optional[float]:
+    if not model or (pt is None and ct is None):
+        return None
+    table = _load_pricing()
+    best = max((k for k in table if model.startswith(k)), key=len, default=None)
+    if not best:
+        return None
+    rate = table[best]
+    return round((pt or 0) / 1e6 * rate["input"] + (ct or 0) / 1e6 * rate["output"], 6)
+
+
+def _err_text(error: Any) -> str:
+    """Full traceback when we have one — the UI maps 'File …, line N' frames
+    onto node source so you can see exactly where a run broke."""
+    try:
+        if isinstance(error, BaseException) and error.__traceback__ is not None:
+            import traceback
+            return "".join(traceback.format_exception(
+                type(error), error, error.__traceback__))[-4000:]
+    except Exception:
+        pass
+    return str(error)
+
+
+def _trunc(v: Any, n: int = 4000) -> Any:
+    s = json.dumps(v, default=str)
+    return json.loads(s) if len(s) <= n else s[:n] + "…"
+
+
+def _model_name(serialized: dict, kw: dict) -> str:
+    inv = kw.get("invocation_params") or {}
+    for src in (inv, (serialized or {}).get("kwargs", {}), serialized or {}):
+        for key in ("model", "model_name", "model_id", "deployment_name"):
+            if src.get(key):
+                return str(src[key])
+    ids = (serialized or {}).get("id") or []
+    return ids[-1] if ids else "llm"
+
+
+def _usage(response: Any) -> tuple[Optional[int], Optional[int]]:
+    # OpenAI-style aggregate
+    out = getattr(response, "llm_output", None) or {}
+    for key in ("token_usage", "usage"):
+        u = out.get(key) if isinstance(out, dict) else None
+        if u:
+            return (u.get("prompt_tokens") or u.get("input_tokens"),
+                    u.get("completion_tokens") or u.get("output_tokens"))
+    # per-generation usage_metadata (chat models)
+    try:
+        for gens in response.generations:
+            for g in gens:
+                um = getattr(getattr(g, "message", None), "usage_metadata", None)
+                if um:
+                    return um.get("input_tokens"), um.get("output_tokens")
+    except Exception:
+        pass
+    return None, None
+
+
+def _gen_text(response: Any) -> str:
+    try:
+        parts = []
+        for gens in response.generations:
+            for g in gens:
+                msg = getattr(g, "message", None)
+                text = getattr(g, "text", "") or str(getattr(msg, "content", "") or "")
+                if not text and msg is not None:
+                    # structured-output / function-calling: content is empty,
+                    # the payload lives in the tool calls
+                    tc = (getattr(msg, "tool_calls", None) or
+                          (getattr(msg, "additional_kwargs", None) or {}).get("tool_calls"))
+                    if tc:
+                        text = json.dumps(tc, default=str)
+                parts.append(text)
+        return "\n".join(p for p in parts if p)
+    except Exception:
+        return ""
+
+
+class SpanBuilder(BaseCallbackHandler):
+    def __init__(self, sink: Callable[[dict], None], run_name: str = "external",
+                 session: Optional[str] = None, tags: Optional[list] = None):
+        self.sink = sink
+        self.run_name = run_name
+        self.session = session
+        self.tags = tags
+        self.run_id = uuid.uuid4().hex[:12]
+        self._root = None            # langchain run_id of the graph root
+        self._t0: Optional[float] = None
+        self._open: dict[str, dict] = {}   # langchain run_id -> pending span
+        self._span_of: dict[str, str] = {} # langchain run_id -> our span id (for parent links)
+        self._seq = 0
+
+    # -- infra --
+    def _emit(self, ev: dict) -> None:
+        try:
+            self.sink(ev)
+        except Exception:
+            pass  # observability must never break the graph
+
+    def _rel(self, t: float) -> int:
+        return int((t - (self._t0 or t)) * 1000)
+
+    def _finish_span(self, info: dict, *, output=None, status="ok", error=None,
+                     model=None, pt=None, ct=None):
+        now = time.time()
+        sid = info["span_id"]
+        self._emit({"kind": "span", "id": sid, "run_id": self.run_id,
+                    "parent_id": self._span_of.get(info.get("parent")),
+                    "seq": self._seq, "type": info["type"], "name": info["name"],
+                    "status": status, "started_ms": int(info["t"] * 1000),
+                    "ended_ms": int(now * 1000), "offset_ms": self._rel(info["t"]),
+                    "dur_ms": int((now - info["t"]) * 1000),
+                    "input": info.get("input"), "output": output, "model": model,
+                    "prompt_tokens": pt, "completion_tokens": ct,
+                    "cost_usd": cost_of(model, pt, ct), "error": error})
+        self._seq += 1
+
+    # -- chains / nodes --
+    _INTERNAL_TAG_PREFIXES = ("graph:", "langsmith:", "seq:", "langgraph_")
+
+    def on_chain_start(self, serialized, inputs, *, run_id=None, parent_run_id=None,
+                       metadata=None, tags=None, **kw):
+        node = (metadata or {}).get("langgraph_node")
+        if parent_run_id is None and self._root is None:
+            self._root = run_id
+            self._t0 = time.time()
+            # standard LangChain idioms work from ANY app, no constructor needed:
+            #   config={"metadata": {"windhover_session": ..., "windhover_tags": [...]},
+            #           "tags": [...]}
+            md = metadata or {}
+            if md.get("windhover_session"):
+                self.session = str(md["windhover_session"])
+            user_tags = [t for t in (tags or [])
+                         if not str(t).startswith(self._INTERNAL_TAG_PREFIXES)]
+            extra = md.get("windhover_tags") or []
+            merged = list(dict.fromkeys(
+                [*(self.tags or []), *map(str, extra), *map(str, user_tags)]))
+            self.tags = merged or None
+            self._emit({"kind": "run_open", "run_id": self.run_id, "graph": self.run_name,
+                        "input": _trunc(inputs), "started_ms": int(self._t0 * 1000),
+                        "session": self.session, "tags": self.tags})
+        if node:
+            sid = uuid.uuid4().hex[:12]
+            self._span_of[run_id] = sid
+            self._open[run_id] = {"span_id": sid, "type": "node", "name": node,
+                                  "t": time.time(), "parent": parent_run_id,
+                                  "input": None}
+
+    def on_chain_end(self, outputs, *, run_id=None, **kw):
+        info = self._open.pop(run_id, None)
+        if info:
+            self._finish_span(info, output=_trunc(outputs))
+        elif run_id == self._root:
+            # LangGraph human-in-the-loop: a paused graph surfaces __interrupt__
+            # in its final output — that's a pause awaiting Command(resume=...),
+            # not a completion.
+            interrupted = isinstance(outputs, dict) and "__interrupt__" in outputs
+            if interrupted:
+                self._finish_span(
+                    {"span_id": uuid.uuid4().hex[:12], "type": "interrupt",
+                     "name": "interrupt", "t": time.time(), "parent": None,
+                     "input": None},
+                    output=_trunc(outputs.get("__interrupt__")))
+            self._emit({"kind": "run_close", "run_id": self.run_id,
+                        "status": "interrupted" if interrupted else "done",
+                        "ended_ms": int(time.time() * 1000)})
+
+    def on_chain_error(self, error, *, run_id=None, **kw):
+        info = self._open.pop(run_id, None)
+        err = _err_text(error)
+        if info:
+            self._finish_span(info, status="error", error=err)
+        if run_id == self._root:
+            self._emit({"kind": "run_close", "run_id": self.run_id, "status": "error",
+                        "ended_ms": int(time.time() * 1000), "error": err})
+
+    # -- LLMs --
+    def _llm_start(self, serialized, prompt, run_id, parent_run_id, kw):
+        sid = uuid.uuid4().hex[:12]
+        self._span_of[run_id] = sid
+        self._open[run_id] = {"span_id": sid, "type": "llm",
+                              "name": _model_name(serialized, kw), "t": time.time(),
+                              "parent": parent_run_id, "input": _trunc(prompt)}
+
+    def on_llm_start(self, serialized, prompts, *, run_id=None, parent_run_id=None, **kw):
+        self._llm_start(serialized, prompts, run_id, parent_run_id, kw)
+
+    def on_chat_model_start(self, serialized, messages, *, run_id=None, parent_run_id=None, **kw):
+        flat = [[getattr(m, "content", str(m)) for m in conv] for conv in messages]
+        self._llm_start(serialized, flat, run_id, parent_run_id, kw)
+
+    def on_llm_end(self, response, *, run_id=None, **kw):
+        info = self._open.pop(run_id, None)
+        if not info:
+            return
+        pt, ct = _usage(response)
+        self._finish_span(info, output=_gen_text(response)[:4000],
+                          model=info["name"], pt=pt, ct=ct)
+
+    def on_llm_error(self, error, *, run_id=None, **kw):
+        info = self._open.pop(run_id, None)
+        if info:
+            self._finish_span(info, status="error", error=_err_text(error), model=info["name"])
+
+    # -- retrievers (LangChain RAG) --
+    def on_retriever_start(self, serialized, query, *, run_id=None, parent_run_id=None, **kw):
+        sid = uuid.uuid4().hex[:12]
+        self._span_of[run_id] = sid
+        self._open[run_id] = {"span_id": sid, "type": "retriever",
+                              "name": (serialized or {}).get("name") or "retriever",
+                              "t": time.time(), "parent": parent_run_id,
+                              "input": _trunc(query)}
+
+    def on_retriever_end(self, documents, *, run_id=None, **kw):
+        info = self._open.pop(run_id, None)
+        if not info:
+            return
+        docs = list(documents or [])
+        preview = [{"content": str(getattr(d, "page_content", d))[:300],
+                    "metadata": _trunc(getattr(d, "metadata", None), 500)}
+                   for d in docs[:8]]
+        self._finish_span(info, output=_trunc({"count": len(docs), "documents": preview}))
+
+    def on_retriever_error(self, error, *, run_id=None, **kw):
+        info = self._open.pop(run_id, None)
+        if info:
+            self._finish_span(info, status="error", error=_err_text(error))
+
+    # -- tools --
+    def on_tool_start(self, serialized, input_str, *, run_id=None, parent_run_id=None, **kw):
+        sid = uuid.uuid4().hex[:12]
+        self._span_of[run_id] = sid
+        self._open[run_id] = {"span_id": sid, "type": "tool",
+                              "name": (serialized or {}).get("name", "tool"),
+                              "t": time.time(), "parent": parent_run_id,
+                              "input": _trunc(input_str)}
+
+    def on_tool_end(self, output, *, run_id=None, **kw):
+        info = self._open.pop(run_id, None)
+        if info:
+            self._finish_span(info, output=_trunc(str(output)[:4000]))
+
+    def on_tool_error(self, error, *, run_id=None, **kw):
+        info = self._open.pop(run_id, None)
+        if info:
+            self._finish_span(info, status="error", error=_err_text(error))
+
+
+def apply_to_store(store, ev: dict, source: str = "ui") -> None:
+    """Route one tracer event into the store. Shared by the local sink and the
+    HTTP ingest endpoint so both persist identically. (Events carry `run_id`;
+    the runs table keys on `id` — translate here.)"""
+    kind = ev.get("kind")
+    if kind == "run_open":
+        store.open_run({"id": ev["run_id"], "graph": ev.get("graph"), "source": source,
+                        "session": ev.get("session"), "tags": ev.get("tags"),
+                        "input": ev.get("input"), "started_ms": ev["started_ms"]})
+    elif kind == "span":
+        store.add_span(ev)
+    elif kind == "run_close":
+        store.close_run(ev["run_id"], ev.get("status", "done"),
+                        ev.get("ended_ms"), ev.get("error"))
+
+
+def db_sink(store) -> Callable[[dict], None]:
+    return lambda ev: apply_to_store(store, ev, source="ui")
+
+
+def http_sink(base_url: str) -> Callable[[dict], None]:
+    import urllib.request
+    url = base_url.rstrip("/") + "/api/ingest"
+
+    def sink(ev: dict) -> None:
+        req = urllib.request.Request(url, data=json.dumps(ev).encode(),
+                                     headers={"Content-Type": "application/json"})
+        urllib.request.urlopen(req, timeout=3)
+    return sink
+
+
+class WindhoverTracer(SpanBuilder):
+    """Drop into any app: config={"callbacks": [WindhoverTracer("http://host:8090")]}."""
+    def __init__(self, base_url: str, name: str = "external",
+                 session: Optional[str] = None, tags: Optional[list] = None):
+        super().__init__(http_sink(base_url), run_name=name, session=session, tags=tags)

windhover-0.7.0.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: windhover
+Version: 0.7.0
+Summary: Self-hosted, mobile-friendly observability for LangGraph — traces, run history, cost, and a living graph view.
+Project-URL: Repository, https://github.com/justfeltlikerunning/windhover
+Author: justfeltlikerunning
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,langchain,langgraph,llm,observability,tracing
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn>=0.29
+Provides-Extra: demo
+Requires-Dist: langgraph>=0.2; extra == 'demo'
+Provides-Extra: dev
+Requires-Dist: langgraph>=0.2; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<p align="center"><img src="docs/logo.svg" width="112" alt="Windhover — a hovering kestrel"></p>
+<h1 align="center">Windhover</h1>
+
+> *Windhover* — the old poetic name for the kestrel, the falcon that hangs motionless
+> in the wind, watching everything below. This tool does the same for your agent graphs.
+
+**Self-hosted, mobile-friendly observability for [LangGraph](https://github.com/langchain-ai/langgraph).**
+Trace depth like LangSmith (LLM prompts, tokens, cost, latency — plus retrievers and
+human-in-the-loop interrupts), run history, a timing waterfall, per-node stats, error
+forensics down to the throwing source line — and a **living graph view** that auto-updates
+when your code's topology changes. Point it at any compiled graph, or trace runs in from
+your own app. No LangSmith account, no cloud tunnel, no fragile websocket. HTTP + SSE, MIT.
+
+> Nothing about your graph's domain is baked in. Topology, the input form, and run
+> outputs all come from the graph itself. Windhover observes — it never edits your graph.
+
+| Living graph (parallel fan-out) | Trace drawer — retrievers, LLM calls, cost, state |
+|---|---|
+| ![Graph view](docs/graph.png) | ![Trace drawer](docs/trace.png) |
+
+| Runs — search, tags, sessions, interrupts | Dashboards — per-day, per-model |
+|---|---|
+| ![Runs table](docs/runs.png) | ![Stats](docs/stats.png) |
+
+## Quick start
+```bash
+pip install fastapi uvicorn langgraph
+WINDHOVER_GRAPH=windhover.demo_graph:graph python -m windhover.server   # -> :8090
+```
+Open `http://<host>:8090`. **New run** (input pre-filled from the graph's schema) →
+watch it execute → **Runs** for history, span trees, and replay → **Stats** for cost/latency.
+Edit the graph file while it runs and the canvas updates itself.
+
+Your own graph: `WINDHOVER_GRAPH="myapp.graphs:g" WINDHOVER_GRAPH_DIR=/path python -m windhover.server`
+
+## Trace runs from any app
+```python
+from windhover import WindhoverTracer
+graph.invoke(input, config={"callbacks": [WindhoverTracer("http://HOST:8090")]})
+```
+Node spans, LLM calls (model/prompt/response/tokens/cost), and tools show up in **Runs** —
+wherever your app runs. Non-blocking, best-effort; never raises into your graph.
+
+Sessions and tags use standard LangChain config — no Windhover imports needed beyond the tracer:
+```python
+graph.invoke(input, config={
+    "callbacks": [WindhoverTracer("http://HOST:8090")],
+    "metadata": {"windhover_session": "chat-42", "windhover_tags": ["prod"]},
+    "tags": ["also-captured"],          # langgraph-internal tags are filtered out
+})
+```
+
+## Features
+- **Any graph** — topology from `graph.get_graph()`; input form from its state schema.
+- **Full trace tree** — nodes → nested LLM / tool / **retriever** spans: prompts, responses,
+  tokens, cost, latency, retrieved documents with their metadata.
+- **Clickable graph** — tap a node for health, latency, wiring, its **source code**, and recent executions with payloads.
+- **Error forensics** — failed runs show the full traceback; the failing node turns red on the
+  graph, and the node's source renders with the **throwing line highlighted**.
+- **Human-in-the-loop aware** — a graph paused on `interrupt()` shows an amber **interrupted**
+  status plus the payload it's asking a human about.
+- **State evolution** — every trace shows which state keys each node wrote, in order.
+- **X-ray** — graphs with subgraphs get a canvas toggle that expands composite nodes
+  (`get_graph(xray=True)`).
+- **Search & filters** — full-text over prompts/payloads/errors (FTS5, LIKE fallback),
+  status/tag/session filters, bookmarks, pagination, CSV/JSON export.
+- **Sessions** — group runs into threads/batches; roll-up tokens, cost, errors.
+- **Scores** — attach numeric evals to runs (API or UI): eval harnesses, LLM-as-judge, human review.
+- **Run history + replay** — SQLite; runs persist even if the browser closes (worker thread).
+- **Living graph** — file watcher re-extracts topology in a subprocess and pushes it to the UI.
+- **Dashboards** — runs/tokens per day, per-model usage and latency, per-node latency, error rate.
+- **Mobile-first PWA**, light/dark. Fully local (FastAPI + Cytoscape.js).
+
+## Scores API
+```bash
+curl -X POST :8090/api/runs/RUN_ID/scores -H 'Content-Type: application/json' \
+     -d '{"name": "accuracy", "value": 0.92, "comment": "vs golden set"}'
+```
+
+## Config (env)
+`WINDHOVER_GRAPH` (module:attr; unset = ingest-only) · `WINDHOVER_GRAPH_DIR` · `WINDHOVER_DB`
+· `WINDHOVER_HOST`/`WINDHOVER_PORT` (0.0.0.0/8090) · `WINDHOVER_WATCH` (1) · `WINDHOVER_PRICING`
+· `WINDHOVER_RETENTION_DAYS` (0 = keep forever; else prune older runs on startup + every 6h).
+Edit `windhover/pricing.json` for your models' $/1M rates (unknown model → cost null).
+
+## Notes
+Runs use the imported graph (restart to run new code); the *view* always reflects
+current-on-disk topology. All frontend assets are vendored — no CDN, works fully offline.
+Deep links: `#runs`, `#sessions`, `#stats`, `#run=<id>`.
+
+## License
+MIT.

windhover-0.7.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+windhover/__init__.py,sha256=U2jUQF-jNb8VlWsEufEv6msDC1JgIpB0DM8ei5q1cqA,189
+windhover/config.py,sha256=q77ZzFfzVwHA0vzMcM_pMQtGC3Ry4JYzRvTeb8RLYjA,1288
+windhover/demo_graph.py,sha256=QGzuC4-FnvH7ySC0UplyKQVnieYTg-CJmn1GU44_rFU,1784
+windhover/extract.py,sha256=PNSmccsvKWgS1DaGwVAk6G1_kgNMBRNNc4GGv3dBFKw,3572
+windhover/pricing.json,sha256=PFVIaMKOV_m6WwUFIbATiG6ezqK4aFHetWLHqbjYqMU,737
+windhover/server.py,sha256=Ycjm88jbqIBCuZTBJvvnKi4zT9PhBYYF3vqAu8EFRzU,11520
+windhover/store.py,sha256=ftBBIehrcPFmGwBmnOjjBD1Z4ylS9M50TaYwK0laebc,18485
+windhover/tracer.py,sha256=HIN44_lYdjqYSolZmQ7Ga4ViuwQ4xOWzVez1G18HXos,14359
+windhover/static/icon.svg,sha256=bk8o_MuQUDktZr7gkDJcjBXYua4MGWsqLpk4X80h09M,5223
+windhover/static/index.html,sha256=8646IwKv-39OQZRlyL-EkFRjDy2SxJwXA8amTr4geeg,70319
+windhover/static/manifest.json,sha256=7iI_nFz2vDlUXEu0-yM48VxTgheIZ-IyILsBQeRzqx4,478
+windhover/static/vendor/cytoscape-dagre.js,sha256=v3D-QCmR3L_zPgWn5KUnHHgCC7dehdHICrdTjkFXES4,12665
+windhover/static/vendor/cytoscape.min.js,sha256=g-jFSmvsZVv9gd8H32BWScJor2muymel6i2lTqQtrIE,373304
+windhover/static/vendor/dagre.min.js,sha256=YuuXh8z9vfQUjU2Z0x2_nuR3Dq_ugeY311m1KqwizVE,283803
+windhover/static/vendor/fonts/fraunces-500.woff2,sha256=eXXB73yvidBgbdmF01q-MaYZwZJizxP1oFk4zGj7J7I,18000
+windhover/static/vendor/fonts/fraunces-600-italic.woff2,sha256=I3EtthHQeZ34YFBPDmYmreIFiPqyuPSILQ5xGjMNobc,23032
+windhover/static/vendor/fonts/fraunces-600.woff2,sha256=Oh3ncR0Ue61EIoJQRfh1l_13zKcufJbTsKgXNdAN2oI,18096
+windhover-0.7.0.dist-info/METADATA,sha256=1Lazx7ccwNzmghG7y03A1UkbMqqhZNTdX6jLHIPPgEs,5716
+windhover-0.7.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+windhover-0.7.0.dist-info/entry_points.txt,sha256=fS7ufKlG8-6PsU_-S2NTLVT-gP5RC3j7YlAeJt_PIZM,52
+windhover-0.7.0.dist-info/licenses/LICENSE,sha256=VTp3f8eoENYAaleKt6xdLDOtIvUFCZJxTXt6G4FqsT0,1076
+windhover-0.7.0.dist-info/RECORD,,

windhover-0.7.0.dist-info/WHEEL

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

windhover-0.7.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+windhover = windhover.server:main

windhover-0.7.0.dist-info/licenses/LICENSE

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