debuganything 1.0.0__py3-none-any.whl

debuganything/__init__.py

@@ -0,0 +1,157 @@
+"""debuganything — Debug Anything from Python.
+
+Thin, dependency-free wrapper around the Debug Anything CLI (``npx -y debuganything``). Every
+method returns the Debug Anything ``ToolResult`` dict: ``findings`` cite ``evidence`` ids,
+``limitations`` say what could not be observed, ``artifacts`` point at raw
+files under ``~/.debuganything/sessions/<id>/``.
+
+    from debuganything import DebugAnything
+    debuganything = DEA()
+    s = da.attach(12345)
+    print(da.profile_cpu(s, duration_s=10)["findings"])
+    da.detach(s)
+
+Framework adapters: ``debuganything.langchain``, ``debuganything.llamaindex``,
+``debuganything.crewai``. Agents that speak MCP can skip this package and run
+``npx -y debuganything serve`` directly.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+from typing import Any, Dict, List, Optional, Sequence
+
+__version__ = "0.1.1"
+__all__ = ["DebugAnything", "DebugAnythingError", "TOOLS", "ToolResult"]
+
+ToolResult = Dict[str, Any]
+
+TOOLS: Dict[str, str] = {
+    "readiness": "OS, arch, which providers are usable, what is missing and how to install it, permission status. Call first.",
+    "attach": "Resolve a target (pid, container, pod, or a command to spawn) and open a session. Returns session_id.",
+    "detach": "Stop captures, write the report, keep artifacts.",
+    "list_processes": "ps-style list (pid, comm, cpu, mem, user, container) with optional substring filter.",
+    "trace_syscalls": "Linux strace for N seconds: top syscalls by time/count, slowest calls, error counts, blocked waits.",
+    "profile_cpu": "CPU profile (py-spy / perf / sample): top frames, hottest stacks, flamegraph.svg artifact.",
+    "dump_stacks": "Every thread's stack; flags lock waits and likely deadlocks.",
+    "inspect_sockets": "Listening ports, connections by remote, CLOSE_WAIT/TIME_WAIT pileups, fd count vs ulimit.",
+    "inspect_files": "Open fds by type, fd growth over a window, largest and deleted-but-open files.",
+    "capture_traffic": "tcpdump scoped to the target's ports (needs consent=True): per-remote bytes, RSTs, retransmits, DNS.",
+    "snapshot_memory": "RSS series; Node heap snapshot with top retainers; Python stacks with locals.",
+    "diff_runs": "Diff two prior runs (e.g. snapshot_memory#1 vs #2): what grew, appeared, disappeared.",
+    "container_info": "docker inspect/stats/top/logs, cgroup limits, OOM kills, restarts.",
+    "report": "Markdown report of the whole session.",
+    "import_artifact": "Analyze raw tool output you captured yourself (strace, fs_usage, perf script, py-spy dump, sample, gdb, lldb, lsof -F, tcpdump text) into Debug Anything evidence and findings.",
+}
+
+
+class DebugAnythingError(RuntimeError):
+    """Raised when the Debug Anything CLI cannot be executed at all (Node/npx missing, bad JSON)."""
+
+
+class DebugAnything:
+    """Client for the Debug Anything CLI.
+
+    Args:
+        command: how to invoke DebugAnything. Defaults to ``["npx", "-y", "debuganything@latest"]``;
+            pass ``["debuganything"]`` if installed globally. ``DEA_COMMAND`` env var (shell-split) overrides.
+        timeout: subprocess timeout in seconds (Debug Anything itself caps tools at 60 s).
+        raise_on_error: raise ``DebugAnythingError`` when ``ok`` is false instead of returning the result.
+    """
+
+    def __init__(self, command: Optional[Sequence[str]] = None, timeout: float = 120.0, raise_on_error: bool = False) -> None:
+        env_cmd = os.environ.get("DEA_COMMAND")
+        if command is None and env_cmd:
+            command = env_cmd.split()
+        if command is None:
+            command = ["debuganything"] if shutil.which("debuganything") else ["npx", "-y", "debuganything@latest"]
+        self.command: List[str] = list(command)
+        self.timeout = timeout
+        self.raise_on_error = raise_on_error
+
+    # -- core ---------------------------------------------------------------
+
+    def call(self, tool: str, **args: Any) -> ToolResult:
+        """Call any Debug Anything tool by name. Returns the ToolResult dict."""
+        if tool not in TOOLS:
+            raise DebugAnythingError(f"unknown tool {tool!r}; known: {', '.join(TOOLS)}")
+        argv = [*self.command, "call", tool, json.dumps({k: v for k, v in args.items() if v is not None})]
+        try:
+            proc = subprocess.run(argv, capture_output=True, text=True, timeout=self.timeout, check=False)
+        except FileNotFoundError as e:
+            raise DebugAnythingError(f"cannot run {argv[0]!r}: install Node.js >= 22 (https://nodejs.org) or set DEA_COMMAND") from e
+        except subprocess.TimeoutExpired as e:
+            raise DebugAnythingError(f"{tool} timed out after {self.timeout}s") from e
+        out = proc.stdout.strip()
+        start = out.find("{")
+        if start < 0:
+            raise DebugAnythingError(f"Debug Anything produced no JSON for {tool}: {proc.stderr.strip()[:500]}")
+        try:
+            result: ToolResult = json.loads(out[start:])
+        except json.JSONDecodeError as e:
+            raise DebugAnythingError(f"bad JSON from Debug Anything for {tool}: {e}") from e
+        if self.raise_on_error and not result.get("ok", False):
+            raise DebugAnythingError(result.get("error") or f"{tool} failed")
+        return result
+
+    # -- convenience --------------------------------------------------------
+
+    def readiness(self) -> ToolResult:
+        return self.call("readiness")
+
+    def list_processes(self, filter: Optional[str] = None, limit: int = 100) -> ToolResult:
+        return self.call("list_processes", filter=filter, limit=limit)
+
+    def attach(self, target: Any, kind: Optional[str] = None) -> str:
+        """Attach and return the session_id. Raises DebugAnythingError if attach failed."""
+        r = self.call("attach", target=str(target), kind=kind)
+        if not r.get("ok"):
+            raise DebugAnythingError(r.get("error") or "attach failed")
+        return str(r["session_id"])
+
+    def detach(self, session_id: str) -> ToolResult:
+        return self.call("detach", session_id=session_id)
+
+    def trace_syscalls(self, session_id: str, duration_s: int = 10, categories: Optional[Sequence[str]] = None) -> ToolResult:
+        return self.call("trace_syscalls", session_id=session_id, duration_s=duration_s, categories=list(categories) if categories else None)
+
+    def profile_cpu(self, session_id: str, duration_s: int = 15) -> ToolResult:
+        return self.call("profile_cpu", session_id=session_id, duration_s=duration_s)
+
+    def dump_stacks(self, session_id: str) -> ToolResult:
+        return self.call("dump_stacks", session_id=session_id)
+
+    def inspect_sockets(self, session_id: str) -> ToolResult:
+        return self.call("inspect_sockets", session_id=session_id)
+
+    def inspect_files(self, session_id: str, window_s: int = 3) -> ToolResult:
+        return self.call("inspect_files", session_id=session_id, window_s=window_s)
+
+    def capture_traffic(self, session_id: str, duration_s: int = 10, filter: Optional[str] = None, consent: bool = False) -> ToolResult:
+        """Requires consent=True — ask the user first; captures can contain secrets."""
+        return self.call("capture_traffic", session_id=session_id, duration_s=duration_s, filter=filter, consent=consent)
+
+    def snapshot_memory(self, session_id: str, heap: bool = True, window_s: int = 3) -> ToolResult:
+        return self.call("snapshot_memory", session_id=session_id, heap=heap, window_s=window_s)
+
+    def diff_runs(self, session_id: str, a: str, b: str) -> ToolResult:
+        return self.call("diff_runs", session_id=session_id, a=a, b=b)
+
+    def container_info(self, session_id: str) -> ToolResult:
+        return self.call("container_info", session_id=session_id)
+
+    def report(self, session_id: str, out: Optional[str] = None) -> ToolResult:
+        return self.call("report", session_id=session_id, out=out)
+
+    def import_artifact(self, session_id: str, tool: str, path: str, duration_s: Optional[int] = None) -> ToolResult:
+        """Analyze output you captured yourself (e.g. `sudo strace …` or `sudo fs_usage …`)."""
+        return self.call("import_artifact", session_id=session_id, tool=tool, path=path, duration_s=duration_s)
+
+    # -- helpers ------------------------------------------------------------
+
+    @staticmethod
+    def findings(result: ToolResult) -> List[str]:
+        """Human-readable finding lines with their evidence ids."""
+        return [f"[{f['severity']}] {f['summary']} ({f['confidence']}; {','.join(f['evidence_ids'])})" for f in result.get("findings", [])]

debuganything/_specs.py

@@ -0,0 +1,43 @@
+"""Shared argument schemas for framework adapters (mirrors src/contracts.ts ToolArgs)."""
+from __future__ import annotations
+
+from typing import Any, Dict
+
+SESSION = {"session_id": {"type": "string", "description": "session id from attach"}}
+
+SPECS: Dict[str, Dict[str, Any]] = {
+    "readiness": {},
+    "attach": {
+        "target": {"type": "string", "description": "pid, container name, k8s pod (ns/name) or a command line"},
+        "kind": {"type": "string", "enum": ["pid", "container", "pod", "command"], "description": "default: auto-detect"},
+    },
+    "detach": {**SESSION},
+    "list_processes": {"filter": {"type": "string"}, "limit": {"type": "integer", "default": 100}},
+    "trace_syscalls": {**SESSION, "duration_s": {"type": "integer", "default": 10, "maximum": 60}, "categories": {"type": "array", "items": {"type": "string", "enum": ["network", "file", "process", "signal", "memory", "all"]}}},
+    "profile_cpu": {**SESSION, "duration_s": {"type": "integer", "default": 15, "maximum": 60}},
+    "dump_stacks": {**SESSION},
+    "inspect_sockets": {**SESSION},
+    "inspect_files": {**SESSION, "window_s": {"type": "integer", "default": 3}},
+    "capture_traffic": {**SESSION, "duration_s": {"type": "integer", "default": 10, "maximum": 30}, "filter": {"type": "string"}, "consent": {"type": "boolean", "description": "REQUIRED true; ask the user first"}},
+    "snapshot_memory": {**SESSION, "heap": {"type": "boolean", "default": True}, "window_s": {"type": "integer", "default": 3}},
+    "diff_runs": {**SESSION, "a": {"type": "string", "description": "earlier run id, e.g. snapshot_memory#2"}, "b": {"type": "string", "description": "later run id"}},
+    "container_info": {**SESSION},
+    "report": {**SESSION, "out": {"type": "string", "description": "optional path to also write the markdown to"}},
+    "import_artifact": {**SESSION, "tool": {"type": "string", "enum": ["strace", "fs_usage", "perf_script", "folded", "pyspy_dump", "sample", "gdb", "lldb", "lsof", "tcpdump"]}, "path": {"type": "string", "description": "raw output file you captured"}, "duration_s": {"type": "integer"}},
+}
+
+REQUIRED: Dict[str, list] = {
+    "import_artifact": ["session_id", "tool", "path"],
+    "attach": ["target"],
+    "diff_runs": ["session_id", "a", "b"],
+    "capture_traffic": ["session_id", "consent"],
+}
+for _name, _spec in SPECS.items():
+    if "session_id" in _spec and _name not in REQUIRED:
+        REQUIRED[_name] = ["session_id"]
+REQUIRED.setdefault("readiness", [])
+REQUIRED.setdefault("list_processes", [])
+
+
+def json_schema(tool: str) -> Dict[str, Any]:
+    return {"type": "object", "properties": SPECS[tool], "required": REQUIRED.get(tool, [])}

debuganything/crewai.py

@@ -0,0 +1,51 @@
+"""CrewAI tools for DebugAnything.
+
+    from debuganything.crewai import dea_tools
+    agent = Agent(role="SRE", goal="diagnose the slow API with evidence", tools=dea_tools(), ...)
+
+Requires ``pip install debuganything[crewai]``.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, List, Optional, Type
+
+from . import DebugAnything, TOOLS
+from ._specs import SPECS, REQUIRED
+
+try:
+    from crewai.tools import BaseTool
+    from pydantic import BaseModel, Field, create_model
+except ImportError as e:  # pragma: no cover
+    raise ImportError("pip install 'debuganything[crewai]'") from e
+
+_PY = {"string": str, "integer": int, "boolean": bool, "array": List[str]}
+
+
+def _model(tool: str) -> Type[BaseModel]:
+    fields: dict = {}
+    for name, spec in SPECS[tool].items():
+        typ = _PY.get(spec.get("type", "string"), str)
+        required = name in REQUIRED.get(tool, [])
+        fields[name] = (typ if required else Optional[typ], Field(... if required else spec.get("default", None), description=spec.get("description", "")))
+    return create_model(f"Dea{tool.title().replace('_', '')}Args", **fields)  # type: ignore[call-overload]
+
+
+def dea_tools(client: Optional[DebugAnything] = None, include: Optional[List[str]] = None) -> List["BaseTool"]:
+    debuganything = client or DEA()
+    out: List[BaseTool] = []
+    for tool_name, desc in TOOLS.items():
+        if include and tool_name not in include:
+            continue
+
+        class _Tool(BaseTool):
+            name: str = f"dea_{tool_name}"
+            description: str = desc + " Findings cite evidence ids; never state a cause without one."
+            args_schema: Type[BaseModel] = _model(tool_name)
+            _da_tool: str = tool_name
+
+            def _run(self, **kwargs: Any) -> str:
+                return json.dumps(_client.call(self._da_tool, **kwargs))
+
+        out.append(_Tool())
+    return out

debuganything/langchain.py

@@ -0,0 +1,48 @@
+"""LangChain tools for DebugAnything.
+
+    from debuganything.langchain import dea_tools
+    tools = dea_tools()                 # 14 StructuredTools, one per Debug Anything tool
+    agent = create_react_agent(llm, tools)
+
+Each tool returns the ToolResult as a JSON string. Requires ``pip install debuganything[langchain]``.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, List, Optional, Type
+
+from . import DebugAnything, TOOLS
+from ._specs import SPECS, REQUIRED
+
+try:
+    from langchain_core.tools import StructuredTool
+    from pydantic import BaseModel, Field, create_model
+except ImportError as e:  # pragma: no cover
+    raise ImportError("pip install 'debuganything[langchain]'") from e
+
+_PY = {"string": str, "integer": int, "boolean": bool, "array": List[str]}
+
+
+def _model(tool: str) -> Type[BaseModel]:
+    fields: dict = {}
+    for name, spec in SPECS[tool].items():
+        typ = _PY.get(spec.get("type", "string"), str)
+        required = name in REQUIRED.get(tool, [])
+        default = ... if required else spec.get("default", None)
+        fields[name] = (typ if required else Optional[typ], Field(default, description=spec.get("description", "")))
+    return create_model(f"Dea{tool.title().replace('_', '')}Args", **fields)  # type: ignore[call-overload]
+
+
+def dea_tools(client: Optional[DebugAnything] = None, include: Optional[List[str]] = None) -> List["StructuredTool"]:
+    """Build one LangChain StructuredTool per Debug Anything tool."""
+    debuganything = client or DEA()
+    out: List[StructuredTool] = []
+    for name, desc in TOOLS.items():
+        if include and name not in include:
+            continue
+
+        def _run(_name: str = name, **kwargs: Any) -> str:
+            return json.dumps(_client.call(_name, **kwargs))
+
+        out.append(StructuredTool.from_function(func=_run, name=f"dea_{name}", description=desc + " Findings cite evidence ids; never state a cause without one.", args_schema=_model(name)))
+    return out

debuganything/llamaindex.py

@@ -0,0 +1,33 @@
+"""LlamaIndex FunctionTools for DebugAnything.
+
+    from debuganything.llamaindex import dea_tools
+    agent = ReActAgent.from_tools(dea_tools(), llm=llm)
+
+Requires ``pip install debuganything[llamaindex]``.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, List, Optional
+
+from . import DebugAnything, TOOLS
+
+try:
+    from llama_index.core.tools import FunctionTool
+except ImportError as e:  # pragma: no cover
+    raise ImportError("pip install 'debuganything[llamaindex]'") from e
+
+
+def dea_tools(client: Optional[DebugAnything] = None, include: Optional[List[str]] = None) -> List["FunctionTool"]:
+    debuganything = client or DEA()
+    out: List[FunctionTool] = []
+    for name, desc in TOOLS.items():
+        if include and name not in include:
+            continue
+
+        def _run(_name: str = name, **kwargs: Any) -> str:
+            """Run a Debug Anything tool. Pass arguments as keyword arguments (session_id, duration_s, ...)."""
+            return json.dumps(_client.call(_name, **kwargs))
+
+        out.append(FunctionTool.from_defaults(fn=_run, name=f"dea_{name}", description=desc + " Findings cite evidence ids."))
+    return out

debuganything-1.0.0.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.5
+Name: debuganything
+Version: 1.0.0
+Summary: Debug Anything from Python agents: observe running processes (strace, py-spy, perf, lsof, tcpdump, gdb/lldb, heap snapshots) and get evidence-backed findings. Wraps the Debug Anything CLI/MCP server; tool adapters for LangChain, LlamaIndex and CrewAI.
+Project-URL: Homepage, https://github.com/shreyassaw5394/debuganything
+Project-URL: Documentation, https://github.com/shreyassaw5394/debuganything/tree/main/docs
+Project-URL: Issues, https://github.com/shreyassaw5394/debuganything/issues
+Author: Shreyas Sawant
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,crewai,debugging,langchain,llamaindex,mcp,observability,perf,profiling,py-spy,strace
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.30; extra == 'crewai'
+Requires-Dist: pydantic>=2; extra == 'crewai'
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.2; extra == 'langchain'
+Requires-Dist: pydantic>=2; extra == 'langchain'
+Provides-Extra: llamaindex
+Requires-Dist: llama-index-core>=0.10; extra == 'llamaindex'
+Description-Content-Type: text/markdown
+
+<p align="center"><a href="https://debuganything.dev"><img src="https://raw.githubusercontent.com/shreyassaw5394/debuganything/main/assets/debuganything-logo.png" alt="Debug Anything" width="560"></a></p>
+
+# debuganything (Python)
+
+**Debug Anything from Python.** Observe a running process, container or pod —
+syscalls, CPU profiles, thread stacks, sockets, packets, heap retainers — and
+get findings that cite evidence. This package wraps the
+[DebugAnything](https://github.com/shreyassaw5394/debuganything) CLI (Node ≥ 22 required:
+`npx -y debuganything` is used automatically) and ships tool adapters for
+LangChain, LlamaIndex and CrewAI.
+
+```bash
+pip install debuganything                 # core (no deps)
+pip install 'debuganything[langchain]'    # + LangChain StructuredTools
+pip install 'debuganything[llamaindex]'   # + LlamaIndex FunctionTools
+pip install 'debuganything[crewai]'       # + CrewAI BaseTools
+```
+
+## Plain Python
+
+```python
+from debuganything import DebugAnything
+
+debuganything = DEA()                       # uses `debuganything` if installed, else `npx -y debuganything@latest`
+print(da.readiness()["findings"])
+s = da.attach(12345)             # pid, "my-container", "ns/pod", or a command
+before = da.snapshot_memory(s)
+# ... exercise the target ...
+after = da.snapshot_memory(s)
+diff = da.diff_runs(s, before["run_id"], after["run_id"])
+for line in DebugAnything.findings(diff):
+    print(line)                   # [high] heap_retainer: name=Array grew 2.0 KB → 50.1 MB (observed; e4,e1)
+da.report(s, out="report.md")
+da.detach(s)
+```
+
+Every call returns the Debug Anything `ToolResult` dict (`ok`, `findings`, `evidence`,
+`limitations`, `suggested_next`, `artifacts`). `capture_traffic` needs
+`consent=True` — ask your user first.
+
+## LangChain
+
+```python
+from debuganything.langchain import dea_tools
+from langgraph.prebuilt import create_react_agent
+
+agent = create_react_agent(llm, dea_tools())
+agent.invoke({"messages": [("user", "pid 12345 is slow — attach and tell me why, with evidence")]})
+```
+
+## LlamaIndex
+
+```python
+from debuganything.llamaindex import dea_tools
+from llama_index.core.agent import ReActAgent
+
+agent = ReActAgent.from_tools(dea_tools(), llm=llm, verbose=True)
+```
+
+## CrewAI
+
+```python
+from debuganything.crewai import dea_tools
+from crewai import Agent
+
+sre = Agent(role="SRE", goal="Diagnose the hung worker with evidence, never guess", tools=dea_tools(), llm=llm)
+```
+
+## Or just use MCP
+
+Any framework with MCP support (LangChain `langchain-mcp-adapters`, LlamaIndex
+`McpToolSpec`, CrewAI `MCPServerAdapter`, Claude Code, Codex, Cursor…) can run
+Debug Anything directly: `{"command": "npx", "args": ["-y", "debuganything@latest", "serve"]}`.
+Same 14 tools, same ToolResult, plus the guided prompts.
+
+## Safety
+
+Debug Anything is read-only, never runs sudo, caps every tool at 60 s, redacts secrets in
+what it returns, and keeps raw artifacts under `~/.debuganything/sessions/`. See
+[docs/safety.md](https://github.com/shreyassaw5394/debuganything/blob/main/docs/safety.md).
+
+## License and disclaimer
+
+MIT. Provided "as is", without warranty of any kind; the authors accept no liability for any damage arising from use. Only observe systems you own or are explicitly authorized to debug — you are solely responsible for authorization and legal compliance. Findings are automated diagnostics, not professional advice. See the full [DISCLAIMER](https://github.com/shreyassaw5394/debuganything/blob/main/DISCLAIMER.md).

debuganything-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+debuganything/__init__.py,sha256=b2GKdTl1BUYji2EL8TJ4gHRRflfhcfJwgjm2oC_1Rhk,8583
+debuganything/_specs.py,sha256=YPUuXDSmXxEJV_SHgTXZ0ZlGeDQwI1LZNwcnWC1PR2w,2675
+debuganything/crewai.py,sha256=UJA8aSncxYvXSt1CkIKMv70L0sSZl53EB9Ch2-uJHD4,1901
+debuganything/langchain.py,sha256=PVBxQjPl6U9MyeqSZwAgn6G9POZ8Aj5VKhyDq7ZFbzI,1994
+debuganything/llamaindex.py,sha256=buvST_cEoNvgXyFbPBCRKDiDA610O7nhpo2XDPWXNcE,1175
+debuganything-1.0.0.dist-info/METADATA,sha256=Gh7kRWbsw1JLx3D9sztK-Ce_pvFKVYNc4GY37-cwOUM,4877
+debuganything-1.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+debuganything-1.0.0.dist-info/licenses/LICENSE,sha256=V9bU4now33bic6AzH8t3Xn0qMirFwm_2n_dwAPnYzh8,1092
+debuganything-1.0.0.dist-info/RECORD,,

debuganything-1.0.0.dist-info/WHEEL

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

debuganything-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shreyas Sawant and DEA contributors
+
+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.