libcontext 0.1.0__py3-none-any.whl

libcontext/renderer.py

@@ -0,0 +1,366 @@
+"""Markdown renderer — converts PackageInfo into LLM-optimized context.
+
+Produces a structured Markdown document designed to give GitHub Copilot
+(or any LLM) the best possible understanding of a library's public API.
+
+The output format prioritises:
+- Complete function/method signatures with type hints
+- Concise docstrings (first paragraph only by default)
+- Clear module hierarchy for correct import generation
+- Compact representation to maximise useful content within context limits
+"""
+
+from __future__ import annotations
+
+from .inspector import is_public_member
+from .models import (
+    ClassInfo,
+    FunctionInfo,
+    ModuleInfo,
+    PackageInfo,
+    ParameterInfo,
+    VariableInfo,
+)
+
+# ---------------------------------------------------------------------------
+# Parameter & signature formatting
+# ---------------------------------------------------------------------------
+
+
+def _format_param(param: ParameterInfo) -> str:
+    """Format a single parameter for display in a signature."""
+    parts: list[str] = []
+
+    parts.append(param.name)
+
+    if param.annotation:
+        parts.append(f": {param.annotation}")
+
+    if param.default is not None:
+        parts.append(f" = {param.default}")
+
+    return "".join(parts)
+
+
+def _format_signature(func: FunctionInfo, *, compact: bool = False) -> str:
+    """Build a human-readable function signature string.
+
+    Args:
+        func: The function to format.
+        compact: If True, omit ``self``/``cls`` and decorators.
+    """
+    # Filter implicit params
+    params = func.parameters
+    if compact:
+        params = [p for p in params if p.name not in ("self", "cls")]
+
+    # Detect positional-only / keyword-only boundaries
+    formatted_parts: list[str] = []
+    prev_kind: str | None = None
+
+    for param in params:
+        # Insert / separator after positional-only params
+        if prev_kind == "POSITIONAL_ONLY" and param.kind != "POSITIONAL_ONLY":
+            formatted_parts.append("/")
+
+        # Insert * separator before keyword-only (when no *args)
+        if param.kind == "KEYWORD_ONLY" and prev_kind not in (
+            "VAR_POSITIONAL",
+            "KEYWORD_ONLY",
+        ):
+            formatted_parts.append("*")
+
+        formatted_parts.append(_format_param(param))
+        prev_kind = param.kind
+
+    # Trailing / if ALL params are positional-only
+    if params and all(p.kind == "POSITIONAL_ONLY" for p in params):
+        formatted_parts.append("/")
+
+    params_str = ", ".join(formatted_parts)
+    prefix = "async def" if func.is_async else "def"
+    ret = f" -> {func.return_annotation}" if func.return_annotation else ""
+
+    return f"{prefix} {func.name}({params_str}){ret}"
+
+
+def _first_paragraph(text: str | None) -> str | None:
+    """Extract the first paragraph of a docstring."""
+    if not text:
+        return None
+    lines: list[str] = []
+    for line in text.strip().splitlines():
+        stripped = line.strip()
+        if not stripped and lines:
+            break
+        if stripped:
+            lines.append(stripped)
+    return " ".join(lines) if lines else None
+
+
+# ---------------------------------------------------------------------------
+# Component renderers
+# ---------------------------------------------------------------------------
+
+
+def _render_variable(var: VariableInfo) -> str:
+    """Render a variable/constant as a Markdown list item."""
+    parts = [f"`{var.name}"]
+    if var.annotation:
+        parts.append(f": {var.annotation}")
+    if var.value is not None:
+        # Truncate very long values
+        val = var.value if len(var.value) <= 80 else var.value[:77] + "..."
+        parts.append(f" = {val}")
+    parts.append("`")
+    return f"- {''.join(parts)}"
+
+
+def _render_function(func: FunctionInfo, *, heading: str = "-") -> str:
+    """Render a function as a Markdown block."""
+    lines: list[str] = []
+
+    # Decorators (only non-trivial ones)
+    notable_decorators = [
+        d
+        for d in func.decorators
+        if d not in ("property", "classmethod", "staticmethod")
+    ]
+    for dec in notable_decorators:
+        lines.append(f"{heading} `@{dec}`")
+
+    sig = _format_signature(func, compact=True)
+    lines.append(f"{heading} `{sig}`")
+
+    doc = _first_paragraph(func.docstring)
+    if doc:
+        indent = "  " if heading == "-" else ""
+        lines.append(f"{indent}{doc}")
+
+    return "\n".join(lines)
+
+
+def _render_class(cls: ClassInfo) -> str:
+    """Render a class as a Markdown section."""
+    lines: list[str] = []
+
+    # Class header
+    bases_str = f"({', '.join(cls.bases)})" if cls.bases else ""
+    dec_str = ""
+    for dec in cls.decorators:
+        dec_str += f"`@{dec}` "
+    lines.append(f"#### {dec_str}`class {cls.name}{bases_str}`")
+
+    # Docstring
+    doc = _first_paragraph(cls.docstring)
+    if doc:
+        lines.append("")
+        lines.append(doc)
+
+    # Class variables (public only)
+    public_vars = [v for v in cls.class_variables if is_public_member(v.name)]
+    if public_vars:
+        lines.append("")
+        lines.append("**Attributes:**")
+        for var in public_vars:
+            lines.append(_render_variable(var))
+
+    # Methods — include public + useful dunders
+    visible_methods = [
+        m for m in cls.methods if is_public_member(m.name, is_method=True)
+    ]
+    if visible_methods:
+        lines.append("")
+        lines.append("**Methods:**")
+        for method in visible_methods:
+            lines.append(_render_function(method))
+
+    # Inner classes
+    public_inner = [c for c in cls.inner_classes if is_public_member(c.name)]
+    for inner in public_inner:
+        lines.append("")
+        lines.append(_render_class(inner))
+
+    return "\n".join(lines)
+
+
+def _render_module(module: ModuleInfo) -> str:
+    """Render a module as a Markdown section."""
+    lines: list[str] = []
+
+    lines.append(f"### `{module.name}`")
+
+    doc = _first_paragraph(module.docstring)
+    if doc:
+        lines.append("")
+        lines.append(doc)
+
+    # Determine public API boundary
+    exports = set(module.all_exports) if module.all_exports is not None else None
+
+    def _is_public(name: str) -> bool:
+        if exports is not None:
+            return name in exports
+        return is_public_member(name)
+
+    # Classes
+    public_classes = [c for c in module.classes if _is_public(c.name)]
+    for cls in public_classes:
+        lines.append("")
+        lines.append(_render_class(cls))
+
+    # Functions
+    public_functions = [f for f in module.functions if _is_public(f.name)]
+    if public_functions:
+        lines.append("")
+        lines.append("**Functions:**")
+        for func in public_functions:
+            lines.append("")
+            lines.append(_render_function(func))
+
+    # Constants (UPPER_CASE variables)
+    public_constants = [
+        v for v in module.variables if _is_public(v.name) and v.name.isupper()
+    ]
+    if public_constants:
+        lines.append("")
+        lines.append("**Constants:**")
+        for var in public_constants:
+            lines.append(_render_variable(var))
+
+    # Module-level variables (non-constant public variables)
+    public_vars = [
+        v for v in module.variables if _is_public(v.name) and not v.name.isupper()
+    ]
+    if public_vars:
+        lines.append("")
+        lines.append("**Module Variables:**")
+        for var in public_vars:
+            lines.append(_render_variable(var))
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+# Markers used to delimit auto-generated sections in existing files
+BEGIN_MARKER = "<!-- BEGIN LIBCONTEXT: {name} -->"
+END_MARKER = "<!-- END LIBCONTEXT: {name} -->"
+
+
+def render_package(
+    package: PackageInfo,
+    *,
+    include_readme: bool = True,
+    max_readme_lines: int = 100,
+    extra_context: str | None = None,
+) -> str:
+    """Render a :class:`PackageInfo` as Markdown optimised for LLM context.
+
+    Args:
+        package: The collected package information.
+        include_readme: Whether to include the README overview section.
+        max_readme_lines: Truncate the README after this many lines.
+        extra_context: Additional free-form context to append (e.g. from
+            ``[tool.libcontext] extra_context``).
+
+    Returns:
+        A complete Markdown string ready to be written to a file or stdout.
+    """
+    lines: list[str] = []
+
+    # --- Header --------------------------------------------------------
+    version = f" v{package.version}" if package.version else ""
+    lines.append(f"# {package.name}{version} — API Reference")
+    lines.append("")
+
+    if package.summary:
+        lines.append(f"> {package.summary}")
+        lines.append("")
+
+    # --- README overview -----------------------------------------------
+    if include_readme and package.readme:
+        lines.append("## Overview")
+        lines.append("")
+        readme_lines = package.readme.strip().splitlines()
+        if len(readme_lines) > max_readme_lines:
+            readme_lines = readme_lines[:max_readme_lines]
+            readme_lines.append("")
+            readme_lines.append("*(README truncated)*")
+        lines.extend(readme_lines)
+        lines.append("")
+
+    # --- Extra context -------------------------------------------------
+    if extra_context:
+        lines.append("## Notes")
+        lines.append("")
+        lines.append(extra_context.strip())
+        lines.append("")
+
+    # --- API Reference -------------------------------------------------
+    modules = package.non_empty_modules
+    if modules:
+        lines.append("## API Reference")
+        lines.append("")
+
+        for module in modules:
+            lines.append(_render_module(module))
+            lines.append("")
+            lines.append("---")
+            lines.append("")
+
+    return "\n".join(lines)
+
+
+def inject_into_file(
+    content: str,
+    package_name: str,
+    existing: str | None = None,
+) -> str:
+    """Inject generated context into an existing file using markers.
+
+    If the file already contains a ``<!-- BEGIN LIBCONTEXT: {name} -->`` /
+    ``<!-- END LIBCONTEXT: {name} -->`` block for this package, that block
+    is replaced.  Otherwise, the content is appended at the end.
+
+    Args:
+        content: The generated Markdown context.
+        package_name: Package name used in the markers.
+        existing: Current file contents (if any).
+
+    Returns:
+        The updated file contents.
+    """
+    begin = BEGIN_MARKER.format(name=package_name)
+    end = END_MARKER.format(name=package_name)
+    block = f"{begin}\n{content}\n{end}"
+
+    if existing is None:
+        return block
+
+    begin_idx = existing.find(begin)
+    end_idx = existing.find(end)
+
+    if begin_idx != -1 and end_idx != -1 and begin_idx < end_idx:
+        # Well-formed existing section — replace it
+        before = existing[:begin_idx]
+        after = existing[end_idx + len(end) :]
+        return f"{before}{block}{after}"
+
+    if begin_idx != -1 or end_idx != -1:
+        # Malformed markers (only one present, or reversed order).
+        # Remove any stale markers before appending the clean block.
+        cleaned = existing
+        if begin_idx != -1:
+            cleaned = cleaned[:begin_idx] + cleaned[begin_idx + len(begin) :]
+        # Recalculate end_idx after potential removal
+        end_idx_clean = cleaned.find(end)
+        if end_idx_clean != -1:
+            cleaned = cleaned[:end_idx_clean] + cleaned[end_idx_clean + len(end) :]
+        existing = cleaned
+
+    # Append
+    separator = "\n\n" if existing.strip() else ""
+    return f"{existing.rstrip()}{separator}{block}\n"

libcontext-0.1.0.dist-info/METADATA

@@ -0,0 +1,282 @@
+Metadata-Version: 2.4
+Name: libcontext
+Version: 0.1.0
+Summary: Generate optimized LLM context from Python library APIs for GitHub Copilot
+Project-URL: Homepage, https://github.com/Syclaw/libcontext
+Project-URL: Repository, https://github.com/Syclaw/libcontext
+Project-URL: Issues, https://github.com/Syclaw/libcontext/issues
+Author: Jonathan VARELA
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ast,context,copilot,documentation,introspection
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Requires-Dist: click>=8.0
+Requires-Dist: tomli>=1.0; python_version < '3.11'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# libcontext
+
+[![CI](https://github.com/Syclaw/libcontext/actions/workflows/ci.yml/badge.svg)](https://github.com/Syclaw/libcontext/actions/workflows/ci.yml)
+[![PyPI version](https://img.shields.io/pypi/v/libcontext)](https://pypi.org/project/libcontext/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/pypi/pyversions/libcontext)](https://pypi.org/project/libcontext/)
+
+> Make your AI coding assistant aware of any Python library's API — especially the ones it doesn't already know.
+
+**libcontext** inspects any installed Python package via static AST analysis (no code execution) and generates a compact Markdown API reference. Add it to your [`.github/copilot-instructions.md`](https://docs.github.com/en/copilot/how-tos/configure-custom-instructions/add-repository-instructions) and GitHub Copilot will automatically include it as context in **Chat, Agent, and Code Review** interactions.
+
+## Why This Exists
+
+When you ask Copilot Chat how to use a library, or when Copilot Agent generates code that depends on one, the quality of the output depends entirely on what the model knows about that library's API.
+
+For popular, well-established libraries, LLMs generally have good knowledge from training data. But for many real-world scenarios, the model is working blind:
+
+- **Internal / private libraries** — Zero training data exists. The model has never seen the API.
+- **Niche open-source packages** — Sparse or outdated training data leads to hallucinated methods and wrong signatures.
+- **New versions of any library** — Training data has a cutoff. The model knows v2, you're using v3.
+
+GitHub Copilot supports [repository custom instructions](https://docs.github.com/en/copilot/how-tos/configure-custom-instructions/add-repository-instructions) — a `.github/copilot-instructions.md` file that is automatically included as context. According to GitHub's [support matrix](https://docs.github.com/en/copilot/reference/custom-instructions-support), this file is loaded by:
+
+| Copilot feature | Uses custom instructions |
+|---|---|
+| **Copilot Chat** (VS Code, JetBrains, Visual Studio, Eclipse, Xcode, github.com) | ✅ Yes |
+| **Copilot coding agent** (PR generation, agent mode) | ✅ Yes |
+| **Copilot code review** | ✅ Yes |
+| **Inline code completion** (autocomplete as you type) | ❌ Not currently |
+
+libcontext bridges the knowledge gap by pre-generating a structured API reference from installed packages and placing it where Copilot can find it.
+
+## When libcontext makes the biggest difference
+
+| Scenario | Impact | Why |
+|---|---|---|
+| **Internal / private libraries** | 🔴 Critical | Zero training data exists for proprietary code |
+| **Niche open-source packages** | 🟠 High | Sparse training data → hallucinated methods and wrong signatures |
+| **New versions of any library** | 🟠 High | Training data has a cutoff — the LLM knows v2, you're using v3 |
+| **Popular, stable libraries** | ⚪ Low | The LLM already has good knowledge from training data |
+
+> **If Copilot has ever suggested a function that doesn't exist** in one of your dependencies, or got the parameters wrong — libcontext can help prevent that.
+
+## Quick Start
+
+```bash
+pip install libcontext
+
+# Generate context for any installed package
+libctx requests -o .github/copilot-instructions.md
+
+# Done — Copilot Chat and Agent now know the complete requests API
+# (15 modules, 44 classes, 70 functions → ~800 lines of compact reference)
+```
+
+## How It Works
+
+1. **AST parsing** — Reads source files of installed packages using Python's `ast` module. No code is ever executed, making it safe for any package.
+2. **Extraction** — Classes, functions, methods, parameters, type annotations, decorators, and docstrings are collected.
+3. **Compact rendering** — Everything is rendered into structured Markdown optimised for LLM context windows (signatures and docstrings only, no implementation code).
+4. **Marker injection** — Output is wrapped in `<!-- BEGIN/END LIBCONTEXT -->` markers, so re-running updates only its section without touching the rest of the file.
+
+```
+installed package         libcontext              .github/copilot-instructions.md
+  (source files)    ──▶  (AST analysis)   ──▶   (compact API reference)
+                                                        │
+                                                        ▼
+                                                 Copilot Chat, Agent &
+                                                 Code Review now know
+                                                 the full API
+```
+
+## Installation
+
+```bash
+pip install libcontext
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add libcontext
+```
+
+For development:
+
+```bash
+git clone https://github.com/Syclaw/libcontext.git
+cd libcontext
+uv sync --all-extras   # or: pip install -e ".[dev]"
+```
+
+## Usage
+
+### Command Line
+
+```bash
+# Generate context for an installed library (stdout)
+libctx requests
+
+# Write to the Copilot instructions file
+libctx requests -o .github/copilot-instructions.md
+
+# Multiple libraries at once
+libctx requests httpx pydantic -o .github/copilot-instructions.md
+
+# Include private members
+libctx mypackage --include-private
+
+# Without the README
+libctx mypackage --no-readme
+
+# With an explicit configuration file
+libctx mypackage --config path/to/pyproject.toml
+```
+
+### Python API
+
+```python
+from libcontext import collect_package, render_package
+
+# Collect the API of an installed package
+pkg = collect_package("requests")
+
+# Generate the Markdown
+context = render_package(pkg)
+print(context)
+```
+
+### Injection into an Existing File
+
+When using `-o`, libcontext injects content between markers:
+
+```markdown
+<!-- BEGIN LIBCONTEXT: requests -->
+... generated content ...
+<!-- END LIBCONTEXT: requests -->
+```
+
+Subsequent runs update only that section, preserving the rest of the file.
+
+## Configuration (Optional)
+
+Library authors can customise what libcontext exposes from their package by adding a `[tool.libcontext]` section to their `pyproject.toml`. **The library does not need to depend on libcontext** — this is purely opt-in metadata that libcontext reads at generation time.
+
+```
+┌──────────────────┐     ┌──────────────────────┐     ┌──────────────────────┐
+│  libcontext       │     │  Library B            │     │  Your project        │
+│  (CLI tool)       │     │  (any Python pkg)     │     │  (end user)          │
+│                   │     │                       │     │                       │
+│  Reads            │     │  Can optionally add   │     │  Runs:               │
+│  [tool.libcontext]│◀────│  [tool.libcontext]    │     │  libctx lib_b        │
+│  from library B   │     │  to pyproject.toml    │     │                       │
+└──────────────────┘     └──────────────────────┘     └──────────────────────┘
+```
+
+```toml
+[tool.libcontext]
+# Only include specific modules
+include_modules = ["mylib.core", "mylib.models"]
+
+# Exclude modules
+exclude_modules = ["mylib._internal", "mylib.tests"]
+
+# Include private members
+include_private = false
+
+# Free-form extra context
+extra_context = """
+This library uses the Repository pattern for data access.
+All async operations use httpx internally.
+"""
+
+# Maximum README lines
+max_readme_lines = 150
+```
+
+## Output Example
+
+```markdown
+# requests v2.31.0 — API Reference
+
+> Python HTTP for Humans.
+
+## Overview
+
+# Requests
+Requests is a simple HTTP library for Python...
+
+## API Reference
+
+### `requests`
+
+#### `class Session()`
+A Requests session. Provides cookie persistence, connection-pooling, and configuration.
+
+**Methods:**
+- `def get(url: str, **kwargs) -> Response`
+  Sends a GET request.
+- `def post(url: str, data: Any = None, json: Any = None, **kwargs) -> Response`
+  Sends a POST request.
+
+**Functions:**
+
+- `def get(url: str, params: dict | None = None, **kwargs) -> Response`
+  Sends a GET request.
+- `def post(url: str, data: Any = None, **kwargs) -> Response`
+  Sends a POST request.
+```
+
+## Architecture
+
+| Module | Description |
+|---|---|
+| `models.py` | Dataclasses to represent Python components |
+| `inspector.py` | Static AST analysis (no code execution) |
+| `collector.py` | Discovery and collection of all modules in a package |
+| `config.py` | Reads `[tool.libcontext]` from pyproject.toml |
+| `renderer.py` | LLM-optimised Markdown generation |
+| `cli.py` | CLI entry point (`libctx`) |
+
+## Development
+
+```bash
+# Install in development mode
+uv sync --all-extras
+
+# Run tests
+uv run pytest
+
+# Run tests with coverage
+uv run pytest --cov=libcontext
+
+# Lint & format
+uv run ruff check src/ tests/
+uv run ruff format src/ tests/
+
+# Type checking
+uv run mypy src/libcontext
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed contribution guidelines.
+
+## Dependencies
+
+See [DEPENDENCIES.md](DEPENDENCIES.md) for the full list of dependencies and their licenses.
+
+## License
+
+MIT — see [LICENSE](LICENSE) for details.

libcontext-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+libcontext/__init__.py,sha256=3VbCO4BeksaABIhiMgjz3WQNgZ-tRtXjIdQ923HU6_A,1489
+libcontext/cli.py,sha256=Xov4bd5ZiYlL3DnDD_h46Z7Nt3PGJnAcjJndtuodNkk,6676
+libcontext/collector.py,sha256=sVgZav9lspoKUIXVTnatYiDzebBc3svo6bu__e8qv14,9961
+libcontext/config.py,sha256=E6EzxigCBQfD8dzFmOK-JK9QxTryRiCfrRvR2reBebM,5363
+libcontext/inspector.py,sha256=aIQ_fAx9B0RNZKQMhet96eYMqJgiCioDAXCCLiyScDs,12511
+libcontext/models.py,sha256=XL9ohheI9GN12ui9AKknKYZKzICtOTdt0lnmZvOCEC0,2644
+libcontext/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libcontext/renderer.py,sha256=XWQfH101_nffunusOekIXI8n1BWp2OZzDqel0pxGIIw,12016
+libcontext-0.1.0.dist-info/METADATA,sha256=EExmcaFEIEyhL7iL9itNOLs0CiIXqQTAWeh_VsZm2Kg,10678
+libcontext-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+libcontext-0.1.0.dist-info/entry_points.txt,sha256=a5nWJ2NNcQKxys77Ov84qZjFj7fsmi7fVHuQL3ulcsw,47
+libcontext-0.1.0.dist-info/licenses/LICENSE,sha256=xogpsEBXhxtnSGpSzzCsA9qGXEpoZACBfEZW4clFXNc,1093
+libcontext-0.1.0.dist-info/RECORD,,

libcontext-0.1.0.dist-info/WHEEL

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

libcontext-0.1.0.dist-info/entry_points.txt

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

libcontext-0.1.0.dist-info/licenses/LICENSE

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