tether-memory 0.1.0__py3-none-any.whl

tether/__init__.py

@@ -0,0 +1,3 @@
+"""tether - a shared memory layer for personal agents, across devices."""
+
+__version__ = "0.1.0"

tether/config.py

@@ -0,0 +1,32 @@
+"""config.py - resolve DB path, sync credentials, and device id from the env.
+
+Pure environment reads, no side effects. The zero-config default (no env vars)
+yields a local-only DB under XDG_DATA_HOME and no sync.
+"""
+
+import os
+import socket
+from collections import namedtuple
+from pathlib import Path
+
+SyncConfig = namedtuple("SyncConfig", ["url", "token"])
+
+
+def db_path() -> Path:
+    override = os.environ.get("TETHER_DB")
+    if override:
+        return Path(override)
+    base = os.environ.get("XDG_DATA_HOME") or str(Path.home() / ".local" / "share")
+    return Path(base) / "tether" / "memory.db"
+
+
+def sync_config():
+    url = os.environ.get("TETHER_SYNC_URL")
+    token = os.environ.get("TETHER_SYNC_TOKEN")
+    if url and token:
+        return SyncConfig(url, token)
+    return None
+
+
+def device_id() -> str:
+    return os.environ.get("TETHER_DEVICE_ID") or socket.gethostname()

tether/server.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""server.py - the MCP server. The agent-facing edge.
+
+Four verbs over a persistent SQLite-backed memory store, plus an auto-loaded
+boot index exposed as an MCP resource. The store is built lazily on first use
+so importing the module (and listing tools) never touches the filesystem.
+
+Run it as an MCP stdio server:
+
+    tether                     # installed entry point
+    python -m tether.server    # or as a module
+"""
+
+import json
+
+from mcp.server.fastmcp import FastMCP
+
+from . import config
+from .store import Store
+from .sync import open_connection
+
+mcp = FastMCP("tether")
+
+_store = None
+
+
+def _get_store() -> Store:
+    global _store
+    if _store is None:
+        path = config.db_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        conn, sync_now = open_connection(path, config.sync_config())
+        store = Store(conn, device_id=config.device_id(), sync_now=sync_now)
+        store.migrate()
+        _store = store
+    return _store
+
+
+@mcp.tool()
+def remember(type: str, title: str, body: str,
+             tags: str = "", links: list = None) -> dict:
+    """Save a durable memory. UPSERTS: a memory of the same `type` with the same
+    (whitespace/case-normalized) `title` is updated in place instead of
+    duplicated, so re-remembering a fact refines it rather than cluttering.
+
+    Args:
+        type: one of "user", "feedback", "project", "reference".
+        title: a short label; also the dedup key within a type.
+        body: the fact. For feedback/project, a "Why:" / "How to apply:" line helps.
+        tags: optional comma-separated tags.
+        links: optional list of related memory ids.
+
+    Returns {"id", "action"} where action is "created" or "updated".
+    """
+    try:
+        return _get_store().remember(type, title, body, tags=tags, links=links)
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@mcp.tool()
+def recall(query: str, type: str = None, limit: int = 20) -> dict:
+    """Search memories by keyword (title/body/tags), newest-relevant first.
+
+    Each hit carries {id, type, title, body, tags, updated_at} - use
+    `updated_at` to judge staleness (an old fact may no longer hold; verify
+    before relying on it) and `id` to cite what you update via remember/link.
+
+    Args:
+        query: free text; punctuation is safe.
+        type: optional filter ("user"/"feedback"/"project"/"reference").
+        limit: max results (default 20).
+    """
+    try:
+        return {"results": _get_store().recall(query, type=type, limit=limit)}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@mcp.tool()
+def link(id_a: int, id_b: int) -> dict:
+    """Create a bidirectional link between two memories by id."""
+    try:
+        return _get_store().link(id_a, id_b)
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@mcp.tool()
+def forget(id: int) -> dict:
+    """Permanently delete a memory by id. Returns {"forgotten", "existed"}."""
+    try:
+        return _get_store().forget(id)
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@mcp.resource("tether://memory-index")
+def memory_index() -> str:
+    """A compact index of ALL memories - one line per memory as `[type] #id
+    title`, newest first. Auto-loaded each session so memory helps even without
+    an explicit recall; pull full bodies with recall() using the id.
+    """
+    try:
+        return _get_store().boot_index()
+    except Exception as e:
+        return f"(memory index unavailable: {e})"
+
+
+def main():
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

tether/store.py

@@ -0,0 +1,171 @@
+"""store.py - the memory store. Owns ALL SQL.
+
+One table (`memories`) plus an external-content FTS5 index kept in sync by
+triggers. The four verbs and the boot index are the only public surface;
+nothing outside this module speaks SQL.
+"""
+
+import json
+import re
+from datetime import datetime, timezone
+
+VALID_TYPES = ("user", "feedback", "project", "reference")
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS memories (
+    id         INTEGER PRIMARY KEY AUTOINCREMENT,
+    type       TEXT NOT NULL CHECK (type IN ('user','feedback','project','reference')),
+    title      TEXT NOT NULL,
+    title_norm TEXT NOT NULL,
+    body       TEXT NOT NULL,
+    tags       TEXT NOT NULL DEFAULT '',
+    links      TEXT NOT NULL DEFAULT '[]',
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    device_id  TEXT NOT NULL DEFAULT ''
+);
+CREATE INDEX IF NOT EXISTS idx_memories_dedup ON memories(type, title_norm);
+CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts
+    USING fts5(title, body, tags, content='memories', content_rowid='id');
+CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+    INSERT INTO memories_fts(rowid, title, body, tags)
+        VALUES (new.id, new.title, new.body, new.tags);
+END;
+CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, title, body, tags)
+        VALUES ('delete', old.id, old.title, old.body, old.tags);
+END;
+CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, title, body, tags)
+        VALUES ('delete', old.id, old.title, old.body, old.tags);
+    INSERT INTO memories_fts(rowid, title, body, tags)
+        VALUES (new.id, new.title, new.body, new.tags);
+END;
+"""
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _norm(title: str) -> str:
+    """Normalize a title for the dedup probe: lowercase, collapse whitespace."""
+    return re.sub(r"\s+", " ", title.strip().lower())
+
+
+def _tags_to_str(tags) -> str:
+    if not tags:
+        return ""
+    if isinstance(tags, str):
+        parts = tags.split(",")
+    else:
+        parts = list(tags)
+    return ",".join(t.strip() for t in parts if t and t.strip())
+
+
+def _fts_query(raw: str):
+    """Turn a free-text query into a safe FTS5 MATCH string.
+
+    Each whitespace token is escaped and double-quoted so punctuation in the
+    query can never produce an FTS5 syntax error (degrade, never throw).
+    Returns None when the query has no usable tokens.
+    """
+    toks = [t for t in re.split(r"\s+", raw.strip()) if t]
+    if not toks:
+        return None
+    return " ".join('"' + t.replace('"', '""') + '"' for t in toks)
+
+
+class Store:
+    def __init__(self, conn, device_id: str, sync_now):
+        self._conn = conn
+        self._device_id = device_id
+        self._sync_now = sync_now
+
+    def migrate(self) -> None:
+        self._conn.executescript(_SCHEMA)
+        self._conn.commit()
+
+    def remember(self, type, title, body, tags=None, links=None) -> dict:
+        if type not in VALID_TYPES:
+            raise ValueError(f"type must be one of {VALID_TYPES}, got {type!r}")
+        now = _now()
+        norm = _norm(title)
+        tags_s = _tags_to_str(tags)
+        links_s = json.dumps(links or [])
+        existing = self._conn.execute(
+            "SELECT id FROM memories WHERE type=? AND title_norm=?", (type, norm)
+        ).fetchone()
+        if existing:
+            mid = existing[0]
+            self._conn.execute(
+                "UPDATE memories SET title=?, body=?, tags=?, links=?, "
+                "updated_at=?, device_id=? WHERE id=?",
+                (title, body, tags_s, links_s, now, self._device_id, mid))
+            action = "updated"
+        else:
+            cur = self._conn.execute(
+                "INSERT INTO memories(type, title, title_norm, body, tags, links, "
+                "created_at, updated_at, device_id) VALUES (?,?,?,?,?,?,?,?,?)",
+                (type, title, norm, body, tags_s, links_s, now, now, self._device_id))
+            mid = cur.lastrowid
+            action = "created"
+        self._conn.commit()
+        self._sync_now()
+        return {"id": mid, "action": action}
+
+    def recall(self, query, type=None, limit=20) -> list:
+        match = _fts_query(query)
+        if match is None:
+            return []
+        sql = ("SELECT m.id, m.type, m.title, m.body, m.tags, m.updated_at "
+               "FROM memories_fts f JOIN memories m ON m.id = f.rowid "
+               "WHERE memories_fts MATCH ?")
+        params = [match]
+        if type is not None:
+            sql += " AND m.type = ?"
+            params.append(type)
+        sql += " ORDER BY rank LIMIT ?"
+        params.append(limit)
+        rows = self._conn.execute(sql, params).fetchall()
+        return [
+            {"id": r[0], "type": r[1], "title": r[2],
+             "body": r[3], "tags": r[4], "updated_at": r[5]}
+            for r in rows
+        ]
+
+    def _links_of(self, mid) -> list:
+        row = self._conn.execute("SELECT links FROM memories WHERE id=?", (mid,)).fetchone()
+        if row is None:
+            raise ValueError(f"no memory with id {mid}")
+        return json.loads(row[0])
+
+    def link(self, id_a, id_b) -> dict:
+        a = self._links_of(id_a)
+        b = self._links_of(id_b)
+        if id_b not in a:
+            a.append(id_b)
+        if id_a not in b:
+            b.append(id_a)
+        now = _now()
+        self._conn.execute("UPDATE memories SET links=?, updated_at=? WHERE id=?",
+                           (json.dumps(a), now, id_a))
+        self._conn.execute("UPDATE memories SET links=?, updated_at=? WHERE id=?",
+                           (json.dumps(b), now, id_b))
+        self._conn.commit()
+        self._sync_now()
+        return {"linked": [id_a, id_b]}
+
+    def forget(self, id) -> dict:
+        cur = self._conn.execute("DELETE FROM memories WHERE id=?", (id,))
+        self._conn.commit()
+        self._sync_now()
+        return {"forgotten": id, "existed": cur.rowcount > 0}
+
+    def boot_index(self) -> str:
+        rows = self._conn.execute(
+            "SELECT id, type, title FROM memories ORDER BY updated_at DESC, id DESC"
+        ).fetchall()
+        if not rows:
+            return "(no memories yet)"
+        return "\n".join(f"[{t}] #{i} {title}" for i, t, title in rows)

tether/sync.py

@@ -0,0 +1,100 @@
+"""sync.py - the connection factory.
+
+Zero config -> a stdlib sqlite3 connection (the local-only default). Sync
+credentials present -> a libSQL embedded replica: local-speed reads, writes
+that round-trip to the hosted primary. ANY failure on the replica path
+degrades to the local file. Memory must never break the agent's work, so
+open_connection never raises.
+
+SPIKE FINDINGS (verified live against libsql-experimental, PyPI releases
+0.0.41/0.0.55, on macOS arm64):
+  - Import name and connect signature match what's used below:
+    `libsql_experimental.connect(database, sync_url=None, auth_token="", ...)`.
+  - `.sync()` on a connection opened WITHOUT sync_url raises ValueError
+    ("Sync is not supported in databases opened in File mode.") -- confirms
+    the local path must never call `.sync()`, which is why `_local()` below
+    uses a no-op.
+  - Cross-thread `.execute()`/`.sync()` calls did not hit any thread-safety
+    guard in the versions tested, so the background-thread + join(timeout)
+    pattern is safe to use.
+  - IMPORTANT DEVIATION FROM THE ORIGINAL PLAN: `.sync()` does NOT fail fast
+    against an unreachable/bogus sync_url. It retries the handshake
+    internally (observed every ~2-3s) and does not return control or raise
+    -- it was still retrying after 20+ seconds in testing. A bare, inline
+    `conn.sync()` used as an initial connectivity probe would therefore hang
+    server startup indefinitely instead of raising. So the initial probe
+    below is bounded by the same background-thread + timeout pattern used
+    for later syncs, and a timeout is treated as a failure.
+  - KNOWN LIMITATION (accepted for v0.1's experimental, opt-in sync layer):
+    if the initial probe times out, the abandoned libSQL connection's
+    background thread keeps retrying against the same db_path that the
+    local fallback then also opens. This is a daemon thread (never blocks
+    process exit) and, in the common failure case (persistently unreachable
+    network), it never actually writes -- so there is no realistic data
+    corruption path, but it is not a fully clean cancellation.
+"""
+
+import sqlite3
+import sys
+import threading
+
+_INITIAL_SYNC_TIMEOUT = 5.0
+
+
+def _local(db_path):
+    conn = sqlite3.connect(str(db_path), check_same_thread=False)
+    return conn, (lambda timeout=2.0: None)
+
+
+def _safe_sync(conn):
+    try:
+        conn.sync()
+    except Exception:
+        pass  # a failed background sync must never surface
+
+
+def _open_replica(db_path, sync_cfg):
+    """Open a libSQL embedded replica. Raises on any failure; caller degrades.
+
+    See the module docstring's SPIKE FINDINGS for why the initial sync is
+    bounded with a background thread rather than called inline.
+    """
+    import libsql_experimental as libsql
+
+    conn = libsql.connect(
+        str(db_path), sync_url=sync_cfg.url, auth_token=sync_cfg.token,
+        check_same_thread=False)
+
+    errors = []
+
+    def probe():
+        try:
+            conn.sync()  # initial pull; part of "did the backend work?"
+        except Exception as e:
+            errors.append(e)
+
+    t = threading.Thread(target=probe, daemon=True)
+    t.start()
+    t.join(_INITIAL_SYNC_TIMEOUT)
+    if t.is_alive():
+        raise TimeoutError(
+            f"sync backend unreachable after {_INITIAL_SYNC_TIMEOUT}s: {sync_cfg.url}")
+    if errors:
+        raise errors[0]
+
+    def sync_now(timeout=2.0):
+        t = threading.Thread(target=_safe_sync, args=(conn,), daemon=True)
+        t.start()
+        t.join(timeout)  # bounded: a hung sync never blocks a read
+
+    return conn, sync_now
+
+
+def open_connection(db_path, sync_cfg):
+    if sync_cfg is None:
+        return _local(db_path)
+    try:
+        return _open_replica(db_path, sync_cfg)
+    except Exception as e:  # import missing, connect failed, initial sync failed
+        sys.stderr.write(f"tether: sync offline ({e}); using local file\n")
+        return _local(db_path)

tether_memory-0.1.0.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: tether-memory
+Version: 0.1.0
+Summary: A shared memory layer for personal agents, across devices: an MCP server over local SQLite with opt-in libSQL/Turso sync.
+Project-URL: Homepage, https://github.com/sidyellur/tether
+Project-URL: Issues, https://github.com/sidyellur/tether/issues
+Author-email: sidyellur <20009719+sidyellur@users.noreply.github.com>
+License: MIT License
+        
+        Copyright (c) 2026 sidyellur
+        
+        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.
+License-File: LICENSE
+Keywords: agent,claude,claude-code,libsql,mcp,memory,sqlite,turso
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.0
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Provides-Extra: sync
+Requires-Dist: libsql-experimental>=0.0.30; extra == 'sync'
+Description-Content-Type: text/markdown
+
+# tether
+
+**A shared memory layer for personal agents, across devices.** `tether` is an
+[MCP](https://modelcontextprotocol.io) server backed by a local SQLite file. Any
+MCP-compatible agent can `remember`, `recall`, `link`, and `forget` durable notes
+— facts about you, your projects, your preferences — so context follows you
+instead of dying with each session.
+
+It runs **local-only with zero configuration**. Point it at a hosted
+[libSQL/Turso](https://turso.tech) primary and the same file becomes an embedded
+replica that syncs your memory across every device in near-real-time.
+
+## Why
+
+The near future is personal agents living across many devices — laptop, desktop,
+phone. For that to feel like *one* assistant rather than several amnesiac ones,
+memory has to be a substrate that follows you: readable and writable from every
+device and from any agent, not siloed inside a single tool.
+
+`tether` is that substrate. It is deliberately a *convenience layer* — it makes an
+agent more useful when present, and never breaks the agent's work when degraded.
+
+## Status
+
+v0.1 is implemented. Design and rationale: [`docs/superpowers/specs/2026-07-03-tether-design.md`](docs/superpowers/specs/2026-07-03-tether-design.md). Implementation plan: [`docs/superpowers/plans/2026-07-03-tether-v0.1-implementation.md`](docs/superpowers/plans/2026-07-03-tether-v0.1-implementation.md).
+
+## Design at a glance
+
+- **Four verbs**, nothing more: `remember` · `recall` · `link` · `forget`.
+- **Upsert on write** so the store doesn't rot into near-duplicates.
+- **Rich recall** (id, type, title, body, tags, `updated_at`) so an agent can
+  judge staleness and cite what it updates.
+- **An auto-loaded boot index** — a compact one-line-per-memory list surfaced to
+  the agent each session, so memory helps even when the agent doesn't think to
+  search.
+- **Local-first, sync optional** — the local path is untouched when no backend is
+  configured; degradation never throws.
+- **Keyword search now, embeddings later** — the SQLite schema is built so
+  semantic search and a full entity/edge graph slot in without migrating data.
+
+## Install
+
+Requires Python ≥3.10 on a POSIX system (Linux/macOS).
+
+Register it with Claude Code — with [uv](https://docs.astral.sh/uv/):
+
+```sh
+claude mcp add tether -- uvx --from tether-memory tether
+```
+
+…or install it first:
+
+```sh
+pip install tether-memory
+claude mcp add tether -- tether
+```
+
+(The PyPI package is named `tether-memory` — `tether` was already reserved on
+PyPI as a common brand name — but the installed command is still `tether`.)
+
+By default memory lives in a local SQLite file at
+`~/.local/share/tether/memory.db` (override with `TETHER_DB`). No accounts, no
+network — this is the whole tool for a single machine.
+
+## Sync across devices (optional)
+
+Point tether at a [Turso](https://turso.tech) / libSQL database and the local
+file becomes an embedded replica — local-speed reads, writes that propagate to
+your other devices. Install the extra and set two env vars:
+
+```sh
+pip install 'tether-memory[sync]'
+export TETHER_SYNC_URL='libsql://<your-db>.turso.io'
+export TETHER_SYNC_TOKEN='<your-auth-token>'
+```
+
+If the backend is unreachable, tether logs `sync offline` and keeps working
+against the local file; writes converge when it comes back.
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `remember(type, title, body, tags?, links?)` | Save a memory; upserts on `type`+`title` so facts refine rather than duplicate |
+| `recall(query, type?, limit?)` | Keyword search; returns id/type/title/body/tags/updated_at |
+| `link(id_a, id_b)` | Bidirectional link between two memories |
+| `forget(id)` | Delete a memory |
+
+Plus an auto-loaded resource `tether://memory-index` — a compact one-line-per-memory index surfaced each session.
+
+## License
+
+MIT

tether_memory-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+tether/__init__.py,sha256=3lHrnX-vXMFVAVjfEpHCAAY3AAZVqWPiRbRo2E49DsI,97
+tether/config.py,sha256=k_3SZ8FS3uorZjFCYQsF-7_bZZGus8SCSbWiCigZrls,891
+tether/server.py,sha256=0OZV-Lbuxz9kVT0nEt9m4MqGNwBgHoRfPg__4QLoavI,3555
+tether/store.py,sha256=cqbXC6zlcMQNNgHXimVUuruKR9-Sz3eUt2aqTqh3PFM,6341
+tether/sync.py,sha256=AdW-V1jYEO3MjPUgATeWql393abTruT0gUIEkz4pzr0,3919
+tether_memory-0.1.0.dist-info/METADATA,sha256=kv529bbPuo4TVZ2dHNWD3UBz1W6zGQFWvaZZugW7ZXM,6048
+tether_memory-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+tether_memory-0.1.0.dist-info/entry_points.txt,sha256=prkyBTvX_yaMPGoq7GMsTq74BQDuSVohgLSTBHn064A,46
+tether_memory-0.1.0.dist-info/licenses/LICENSE,sha256=Sg94Ihi25be7gJwtLYUArJURv2BS1xwdV5Yxepj9X7w,1066
+tether_memory-0.1.0.dist-info/RECORD,,

tether_memory-0.1.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

tether_memory-0.1.0.dist-info/entry_points.txt

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

tether_memory-0.1.0.dist-info/licenses/LICENSE

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