skillstate-kit 0.1.1__py3-none-any.whl

skillstate/store.py

@@ -0,0 +1,332 @@
+"""Transactional checkpoints and a durable operation journal.
+
+SQLite transactions never span model or tool calls. A reserved operation prevents
+other writers from advancing its run until its outcome is recorded or reconciled.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+import threading
+import time
+import uuid
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any
+
+from .errors import ConflictError, NotFoundError, ValidationError
+from .jsonio import dumps, loads
+from .models import Skill
+from .schema import apply_patch, validate
+
+
+def _identifier(value: str) -> str:
+    if type(value) is not str or not value or len(value) > 128:
+        raise ValidationError("Identifiers must be nonempty strings up to 128 characters")
+    return value
+
+
+class SQLiteStore:
+    """One local database, multiple processes, optimistic revision checks.
+
+    Owner identifiers coordinate cooperating clients; they are not authentication.
+    Keep this file private to the local project/user. Do not place it on network FS.
+    """
+
+    def __init__(self, path: str | Path = ":memory:"):
+        self.path = str(path)
+        if self.path != ":memory:":
+            Path(path).parent.mkdir(parents=True, exist_ok=True)
+        self._lock = threading.RLock()
+        self._db = sqlite3.connect(
+            self.path, timeout=10, isolation_level=None, check_same_thread=False
+        )
+        self._db.row_factory = sqlite3.Row
+        self._db.execute("PRAGMA foreign_keys=ON")
+        self._db.execute("PRAGMA busy_timeout=10000")
+        self._db.execute("PRAGMA synchronous=FULL")
+        version = self._db.execute("PRAGMA user_version").fetchone()[0]
+        if version not in (0, 1):
+            self._db.close()
+            raise ValidationError(f"Unsupported database version: {version}")
+        self._db.execute("PRAGMA journal_mode=WAL")
+        self._db.executescript("""
+            CREATE TABLE IF NOT EXISTS runs (
+                id TEXT PRIMARY KEY, skill TEXT NOT NULL, fingerprint TEXT NOT NULL,
+                state TEXT NOT NULL, observation TEXT NOT NULL, revision INTEGER NOT NULL,
+                status TEXT NOT NULL, owner TEXT NOT NULL, pending TEXT,
+                created REAL NOT NULL, updated REAL NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS operations (
+                id TEXT PRIMARY KEY, run_id TEXT NOT NULL REFERENCES runs(id),
+                action TEXT NOT NULL, candidate TEXT NOT NULL, status TEXT NOT NULL,
+                result TEXT, created REAL NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS events (
+                sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+                run_id TEXT NOT NULL REFERENCES runs(id), kind TEXT NOT NULL,
+                payload TEXT NOT NULL, created REAL NOT NULL
+            );
+            PRAGMA user_version=1;
+        """)
+
+    def close(self) -> None:
+        with self._lock:
+            self._db.close()
+
+    def __enter__(self) -> SQLiteStore:
+        return self
+
+    def __exit__(self, *args) -> None:
+        self.close()
+
+    @contextmanager
+    def _transaction(self):
+        with self._lock:
+            self._db.execute("BEGIN IMMEDIATE")
+            try:
+                yield
+                self._db.execute("COMMIT")
+            except BaseException:
+                self._db.execute("ROLLBACK")
+                raise
+
+    def _event(self, run_id: str, kind: str, payload: Any) -> None:
+        self._db.execute(
+            "INSERT INTO events(run_id,kind,payload,created) VALUES(?,?,?,?)",
+            (run_id, kind, dumps(payload), time.time()),
+        )
+
+    def _row(self, run_id: str) -> sqlite3.Row:
+        row = self._db.execute("SELECT * FROM runs WHERE id=?", (run_id,)).fetchone()
+        if row is None:
+            raise NotFoundError(f"Run not found: {run_id}")
+        return row
+
+    def _guard(
+        self, row: sqlite3.Row, owner: str, revision: int | None = None, pending: bool = False
+    ) -> None:
+        if row["owner"] != owner:
+            raise ConflictError("Run belongs to a different owner; use handoff")
+        if revision is not None and (type(revision) is not int or row["revision"] != revision):
+            raise ConflictError("Stale revision; reload context and reconsider the decision")
+        if not pending and row["pending"] is not None:
+            raise ConflictError("An operation is pending or unknown; reconcile it first")
+        if row["status"] in ("completed", "cancelled"):
+            raise ConflictError("Run is already terminal")
+
+    @staticmethod
+    def _snapshot(row: sqlite3.Row) -> dict:
+        return {
+            "run_id": row["id"],
+            "skill": loads(row["skill"]),
+            "state": loads(row["state"]),
+            "observation": loads(row["observation"]),
+            "revision": row["revision"],
+            "status": row["status"],
+            "owner": row["owner"],
+            "pending_operation": row["pending"],
+        }
+
+    def get(self, run_id: str) -> dict:
+        with self._lock:
+            return self._snapshot(self._row(run_id))
+
+    def list_runs(self, limit: int = 100) -> list[dict]:
+        if type(limit) is not int or not 1 <= limit <= 1000:
+            raise ValidationError("Run limit must be between 1 and 1000")
+        with self._lock:
+            rows = self._db.execute(
+                "SELECT id,revision,status,owner,pending FROM runs ORDER BY updated DESC LIMIT ?",
+                (limit,),
+            ).fetchall()
+            return [dict(row) for row in rows]
+
+    def create(self, run_id: str, skill: Skill, owner: str, observation: Any = None) -> dict:
+        _identifier(run_id)
+        _identifier(owner)
+        skill = Skill.from_dict(skill.to_dict())
+        obs = dumps(observation, skill.limits.observation_bytes)
+        with self._transaction():
+            if self._db.execute("SELECT 1 FROM runs WHERE id=?", (run_id,)).fetchone():
+                raise ConflictError("Run already exists; resume it without resetting its state")
+            now = time.time()
+            self._db.execute(
+                "INSERT INTO runs VALUES(?,?,?,?,?,0,'ready',?,NULL,?,?)",
+                (
+                    run_id,
+                    dumps(skill.to_dict()),
+                    skill.fingerprint,
+                    dumps(skill.initial_state),
+                    obs,
+                    owner,
+                    now,
+                    now,
+                ),
+            )
+            self._event(run_id, "created", {"skill": skill.name, "owner": owner})
+        return self.get(run_id)
+
+    def _candidate(self, row, patch: list[dict]) -> dict:
+        skill = Skill.from_dict(loads(row["skill"]))
+        candidate = apply_patch(loads(row["state"]), patch)
+        validate(skill.state_schema, candidate)
+        dumps(candidate, skill.limits.state_bytes)
+        return candidate
+
+    def update(
+        self,
+        run_id: str,
+        owner: str,
+        revision: int,
+        patch: list[dict],
+        observation: Any = None,
+        *,
+        done: bool = False,
+    ) -> dict:
+        """Record agent-reported facts. Does not certify external business truth."""
+        if type(done) is not bool:
+            raise ValidationError("done must be boolean")
+        with self._transaction():
+            row = self._row(run_id)
+            self._guard(row, owner, revision)
+            skill = Skill.from_dict(loads(row["skill"]))
+            candidate = self._candidate(row, patch)
+            obs = dumps(observation, skill.limits.observation_bytes)
+            self._db.execute(
+                "UPDATE runs SET state=?,observation=?,revision=revision+1,status=?,updated=? WHERE id=?",
+                (dumps(candidate), obs, "completed" if done else "ready", time.time(), run_id),
+            )
+            self._event(
+                run_id,
+                "completed" if done else "updated",
+                {"patch": patch, "origin": "agent_reported"},
+            )
+        return self.get(run_id)
+
+    def reserve(
+        self, run_id: str, owner: str, revision: int, action: dict, patch: list[dict]
+    ) -> dict:
+        dumps(action, 32_000)
+        if (
+            type(action) is not dict
+            or set(action) != {"name", "arguments"}
+            or type(action["name"]) is not str
+            or not action["name"]
+            or type(action["arguments"]) is not dict
+        ):
+            raise ValidationError("Invalid action contract")
+        with self._transaction():
+            row = self._row(run_id)
+            self._guard(row, owner, revision)
+            candidate = self._candidate(row, patch)
+            operation_id = uuid.uuid4().hex
+            self._db.execute(
+                "INSERT INTO operations VALUES(?,?,?,?,'pending',NULL,?)",
+                (operation_id, run_id, dumps(action), dumps(candidate), time.time()),
+            )
+            self._db.execute(
+                "UPDATE runs SET pending=?,status='running',revision=revision+1,updated=? WHERE id=?",
+                (operation_id, time.time(), run_id),
+            )
+            self._event(run_id, "reserved", {"operation_id": operation_id, "action": action})
+        return {"operation_id": operation_id, "run": self.get(run_id)}
+
+    def operation(self, operation_id: str) -> dict:
+        with self._lock:
+            row = self._db.execute(
+                "SELECT * FROM operations WHERE id=?", (operation_id,)
+            ).fetchone()
+            if row is None:
+                raise NotFoundError("Operation not found")
+            return {
+                "operation_id": row["id"],
+                "run_id": row["run_id"],
+                "action": loads(row["action"]),
+                "status": row["status"],
+                "result": loads(row["result"]) if row["result"] else None,
+            }
+
+    def mark_unknown(self, operation_id: str, owner: str, reason: str) -> dict:
+        reason = str(reason)[:1000]
+        with self._transaction():
+            op = self.operation(operation_id)
+            row = self._row(op["run_id"])
+            self._guard(row, owner, pending=True)
+            if row["pending"] != operation_id or op["status"] not in ("pending", "unknown"):
+                raise ConflictError("Operation is not outstanding")
+            self._db.execute("UPDATE operations SET status='unknown' WHERE id=?", (operation_id,))
+            self._db.execute(
+                "UPDATE runs SET status='unknown',revision=revision+1,updated=? WHERE id=?",
+                (time.time(), op["run_id"]),
+            )
+            self._event(op["run_id"], "unknown", {"operation_id": operation_id, "reason": reason})
+        return self.get(op["run_id"])
+
+    def record_result(
+        self,
+        operation_id: str,
+        owner: str,
+        success: bool,
+        observation: Any,
+        *,
+        reconcile: bool = False,
+        origin: str = "agent_reported",
+    ) -> dict:
+        if type(success) is not bool or type(reconcile) is not bool:
+            raise ValidationError("success and reconcile must be booleans")
+        if origin not in ("agent_reported", "runtime_observed"):
+            raise ValidationError("Invalid result origin")
+        with self._transaction():
+            op = self.operation(operation_id)
+            row = self._row(op["run_id"])
+            if row["owner"] != owner:
+                raise ConflictError("Run owner mismatch")
+            skill = Skill.from_dict(loads(row["skill"]))
+            obs = dumps(observation, skill.limits.observation_bytes)
+            result = {"success": success, "observation": loads(obs), "origin": origin}
+            if op["status"] in ("succeeded", "failed"):
+                if op["result"] != result:
+                    raise ConflictError("Operation already has a different result")
+                return self._snapshot(row)
+            if row["pending"] != operation_id:
+                raise ConflictError("Operation does not match run's pending operation")
+            if op["status"] == "unknown" and not reconcile:
+                raise ConflictError("Unknown result requires explicit reconciliation")
+            candidate_row = self._db.execute(
+                "SELECT candidate FROM operations WHERE id=?", (operation_id,)
+            ).fetchone()
+            next_state = candidate_row[0] if success else row["state"]
+            self._db.execute(
+                "UPDATE operations SET status=?,result=? WHERE id=?",
+                ("succeeded" if success else "failed", dumps(result), operation_id),
+            )
+            self._db.execute(
+                "UPDATE runs SET state=?,observation=?,pending=NULL,status='ready',revision=revision+1,updated=? WHERE id=?",
+                (next_state, obs, time.time(), op["run_id"]),
+            )
+            self._event(op["run_id"], "result", {"operation_id": operation_id, **result})
+        return self.get(op["run_id"])
+
+    def handoff(self, run_id: str, owner: str, revision: int, target: str) -> dict:
+        _identifier(target)
+        with self._transaction():
+            row = self._row(run_id)
+            self._guard(row, owner, revision)
+            self._db.execute(
+                "UPDATE runs SET owner=?,revision=revision+1,updated=? WHERE id=?",
+                (target, time.time(), run_id),
+            )
+            self._event(run_id, "handoff", {"from": owner, "to": target})
+        return self.get(run_id)
+
+    def events(self, run_id: str, after: int = 0, limit: int = 100) -> list[dict]:
+        if type(after) is not int or after < 0 or type(limit) is not int or not 1 <= limit <= 1000:
+            raise ValidationError("Invalid event pagination")
+        with self._lock:
+            self._row(run_id)
+            rows = self._db.execute(
+                "SELECT sequence,kind,payload FROM events WHERE run_id=? AND sequence>? ORDER BY sequence LIMIT ?",
+                (run_id, after, limit),
+            ).fetchall()
+            return [{"sequence": r[0], "kind": r[1], "payload": loads(r[2])} for r in rows]

skillstate_kit-0.1.1.dist-info/METADATA

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: skillstate-kit
+Version: 0.1.1
+Summary: Compile existing agent skills into portable, validated execution state.
+Project-URL: Homepage, https://github.com/Atakan-Emre/skillstate-kit
+Project-URL: Repository, https://github.com/Atakan-Emre/skillstate-kit
+Project-URL: Documentation, https://github.com/Atakan-Emre/skillstate-kit/tree/main/docs
+Project-URL: Issues, https://github.com/Atakan-Emre/skillstate-kit/issues
+Author: Atakan Emre
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,claude,codex,mcp,skills,state
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: jsonschema<5,>=4.23
+Requires-Dist: pathspec<1,>=0.12
+Requires-Dist: pyyaml<7,>=6.0.2
+Requires-Dist: tomlkit<1,>=0.13
+Provides-Extra: dev
+Requires-Dist: build<2,>=1.2; extra == 'dev'
+Requires-Dist: httpx<1,>=0.28; extra == 'dev'
+Requires-Dist: hypothesis<7,>=6.120; extra == 'dev'
+Requires-Dist: mcp<2,>=1.20; extra == 'dev'
+Requires-Dist: pytest-cov<7,>=6; extra == 'dev'
+Requires-Dist: pytest<9,>=8; extra == 'dev'
+Requires-Dist: ruff<1,>=0.11; extra == 'dev'
+Requires-Dist: twine<7,>=6; extra == 'dev'
+Provides-Extra: http
+Requires-Dist: httpx<1,>=0.28; extra == 'http'
+Provides-Extra: mcp
+Requires-Dist: mcp<2,>=1.20; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# skillstate-kit
+
+**Portable, validated execution state for agent skills.**
+
+Convert an existing `SKILL.md` into a state-backed skill, retain durable checkpoints, and integrate the same execution engine into a Python application.
+
+Python 3.11+ · MIT license · Initial alpha
+
+## Install
+
+```bash
+python -m pip install "skillstate-kit[mcp,http]"
+skillstate demo
+```
+
+The core package requires no model account. The demo uses an explicitly scripted model and local tools; it is not a benchmark of real-model performance.
+
+Optional extras:
+
+- `mcp`: a project-scoped STDIO MCP server and connection diagnostics.
+- `http`: a stateless adapter for a configured JSON-compatible chat-completions endpoint.
+
+## Use an existing skill
+
+Run these commands in your target project. Replace `skills/qa/SKILL.md` with your existing skill file:
+
+```bash
+skillstate init --host codex --host claude-code --host antigravity --mcp
+skillstate generate skills/qa/SKILL.md --name qa-state --install
+skillstate validate qa-state
+skillstate doctor --mcp
+```
+
+After your host discovers the installed `generate-skill-state` skill, ask it to generate state from an existing skill and install the result. Invoke the generated `qa-state` skill to run the procedure with checkpoints. Generating a definition does not execute the task.
+
+`generate` preserves the source procedure and adds bounded progress fields. Domain-specific generation uses the active agent's proposal:
+
+```bash
+skillstate generate skills/qa/SKILL.md --prepare
+skillstate generate skills/qa/SKILL.md --proposal proposal.json --source-hash HASH_FROM_PREPARE --install
+```
+
+The preparation response contains source text, its fingerprint and the proposal schema. The agent writes `proposal.json`; the library validates it and refuses stale source fingerprints. Structural validation is not proof that every business rule is correct.
+
+You can also supply an explicitly configured endpoint with `--base-url` and `--model`. Terminal commands do not borrow your IDE's model credentials.
+
+## Python integration
+
+This complete example uses a scripted model. Replace `model` and `record` with your own model and service functions:
+
+```python
+import asyncio
+from skillstate import Skill, SkillRuntime, SQLiteStore, Tool, ToolResult
+
+skill = Skill(
+    name="record-job",
+    instructions="Record the job, then finish after its result is confirmed.",
+    state_schema={
+        "type": "object",
+        "properties": {"recorded": {"type": "boolean"}},
+        "required": ["recorded"],
+        "additionalProperties": False,
+    },
+    initial_state={"recorded": False},
+)
+
+def model(context):
+    if context["state"]["recorded"]:
+        return {"patch": [], "action": None, "done": True}
+    return {
+        "patch": [{"op": "set", "path": "/recorded", "value": True}],
+        "action": {"name": "record", "arguments": {}},
+        "done": False,
+    }
+
+def record(arguments, operation_id):
+    # For a real API, forward operation_id to its idempotency facility when
+    # supported and inspect the actual response before reporting success.
+    return ToolResult(True, {"recorded": True})
+
+async def main():
+    with SQLiteStore() as store:  # Pass a local file path for durable storage.
+        store.create("job-001", skill, "worker")
+        tool = Tool("record", "Record a job",
+                    {"type": "object", "additionalProperties": False}, record)
+        runtime = SkillRuntime(store, model, [tool],
+                               completion_check=lambda state: state["recorded"])
+        result = await runtime.run("job-001", "worker", max_steps=10)
+        print(result["status"], result["state"])
+
+asyncio.run(main())
+```
+
+For persistent storage, pass a database path to `SQLiteStore`. Reopen the same database and run ID to resume; creating a duplicate run is rejected.
+
+## Execution contract
+
+- Explicit `set`/`delete` patches with JSON Pointer paths, inline JSON Schema and UTF-8 size limits.
+- State and tool arguments validated before a managed tool executes.
+- Persistent operation intent before tool execution; atomic state, result and event commit afterward.
+- Failed tools retain the prior state. Exceptions, timeouts and ambiguous results block replay until reconciliation.
+- Revision checks prevent competing clients from silently overwriting each other.
+- Immutable skill definitions, source drift detection and sequential owner handoff.
+- Large text artifacts kept outside the active context.
+
+Native host skills provide state and checkpoints. They do **not** replace host conversation history or intercept every native tool. Use the managed Python runtime with a stateless model for history-free model inputs.
+
+SQLite does not make external APIs transactional. Owner names coordinate local clients; they are not authentication. The library validates reported results but cannot independently prove external business truth. Keep local state private and test recovery behavior for your application.
+
+## Compatibility and documentation
+
+Adapters generate project skill files and optional MCP configuration for Codex, Claude Code and Antigravity. They target documented integration surfaces. MCP protocol tests and configuration discovery do not certify every IDE version or live task.
+
+The source distribution includes `docs/cli.md`, `docs/architecture.md`, `docs/compatibility.md`, `docs/validation.md`, `docs/README_TR.md` and runnable examples. Download the source archive from this package's files to read them offline. The development repository currently requires collaborator access.
+
+## Research
+
+An independent implementation inspired by [SKILL.state: Scalable Long-Horizon Agent Skills](https://arxiv.org/abs/2608.26263). Not affiliated with the paper's authors. The compiler, host adapters and operation journal are engineering extensions; no reproduction of the paper's benchmark scores or token savings is claimed.

skillstate_kit-0.1.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+skillstate/__init__.py,sha256=HafjazXaBSNs7d092K4h4JenqfjKkWBiVAAxmGnxVr0,757
+skillstate/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+skillstate/artifacts.py,sha256=nJXt1Wmv1-Drja2RcDdVnNdbB7Jbz1OkPrnjSpqeY2A,2083
+skillstate/cli.py,sha256=33XyLwAFTsTdzEtQMKDCXmhiaz2BSHTW4vvic3gADmk,10719
+skillstate/compiler.py,sha256=IYzkzffbRdcQQXCmdpQshpxhTnxI35w8DDQCVvtPdqY,14978
+skillstate/demo.py,sha256=GMbpROEginms1mdaUAFnVqx5lXHR3m2v7_Y9dPKqVQA,2193
+skillstate/errors.py,sha256=5BfKLGTARdABa22bw70KVkmm7d8ZKivP4Bmqe5HPPsw,598
+skillstate/hosts.py,sha256=v8kqZbYQ7SUOlYVpKEwplh5JJsKKvGZDjuoA2MuDy3Q,13784
+skillstate/jsonio.py,sha256=cfvRVds7UK9Nzedl5S6qcPjX_JBpX6KZr3smaBXXjXA,4927
+skillstate/mcp_server.py,sha256=1HC8hJ3U8_Ab33yK95y3U0pqvtH4fqzhF8wlw7pWWk8,5592
+skillstate/models.py,sha256=INE9zYIru0ae4pbWatcpCFRzyM9uCee5R_1vfDLg-bc,2618
+skillstate/providers.py,sha256=dN7RuP-5w0-PNewginE1jyt2IM4PbUk8QEVtfrJFb_o,3650
+skillstate/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+skillstate/runtime.py,sha256=0shW9knRnVu9bxFlPWncq_e0CZ4HTJhl7dXTMzmjdA0,7768
+skillstate/schema.py,sha256=zfbm_euLdCVK8ihM2fO6_67gcXLxL1mdt-M43rPGP4w,3967
+skillstate/service.py,sha256=bRNYgaRSXGIQ0WX6xBpgMm2Ao_BBfR8MybsjfGjLLk0,2233
+skillstate/store.py,sha256=1SQ-lAzWP8cB4YgYwQVA__3CUfu6WNM0I-mLtG_mrEw,14060
+skillstate_kit-0.1.1.dist-info/METADATA,sha256=VRdG7gmSA305HCJLnNhvTpLgJSjHXIe0TQkkaNNm834,7481
+skillstate_kit-0.1.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+skillstate_kit-0.1.1.dist-info/entry_points.txt,sha256=96xGFcS705trwVFkVCR42YJCwYDZjmD8ajaKCOKGx9g,51
+skillstate_kit-0.1.1.dist-info/licenses/LICENSE,sha256=7GRdWqwPbYWWkOBJqMbsMtHkZR_IvUbHoyixEnwXQPI,1068
+skillstate_kit-0.1.1.dist-info/RECORD,,

skillstate_kit-0.1.1.dist-info/WHEEL

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

skillstate_kit-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+skillstate = skillstate.cli:main

skillstate_kit-0.1.1.dist-info/licenses/LICENSE

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