astro-weights 0.0.1__py3-none-any.whl

astro_weights/__init__.py

@@ -0,0 +1,8 @@
+"""astro-weights: agent-driven weight-space edits for open LLMs."""
+
+from importlib.metadata import version
+
+from astro_weights.edits import Edit, LowRankDelta
+
+__version__ = version("astro-weights")
+__all__ = ["Edit", "LowRankDelta", "__version__"]

astro_weights/cli.py

@@ -0,0 +1,70 @@
+"""Command-line entry point."""
+
+import argparse
+import sys
+from pathlib import Path
+
+import numpy as np
+from safetensors import SafetensorError
+
+from astro_weights import __version__
+from astro_weights.export import load_peft, verify_peft
+from astro_weights.export.peft import CONFIG, MANIFEST, WEIGHTS
+
+
+def _inspect(directory: Path) -> int:
+    if not directory.is_dir():
+        print(f"error: not a directory: {directory}", file=sys.stderr)
+        return 2
+    missing = [n for n in (CONFIG, WEIGHTS) if not (directory / n).is_file()]
+    if missing:
+        print(f"error: not an adapter, missing {', '.join(missing)}", file=sys.stderr)
+        return 2
+    try:
+        problems = verify_peft(directory)
+        if problems:
+            for p in problems:
+                print(f"problem: {p}", file=sys.stderr)
+            return 1
+        edit = load_peft(directory)
+    except (ValueError, KeyError, OSError, SafetensorError) as e:
+        print(f"error: cannot read adapter: {e}", file=sys.stderr)
+        return 2
+
+    print(f"base model: {edit.base_model}")
+    print(f"rank: {edit.rank}")
+    print(f"modules: {len(edit.deltas)}")
+    rows = [
+        (
+            d.module,
+            f"{d.shape[0]}x{d.shape[1]}",
+            *(f"{np.linalg.norm(m):.3g}" for m in (d.B, d.A, d.dense())),
+        )
+        for d in sorted(edit.deltas, key=lambda d: d.module)
+    ]
+    header = ("module", "out x in", "|B|_F", "|A|_F", "|BA|_F")
+    widths = [max(len(r[i]) for r in [header, *rows]) for i in range(5)]
+    for r in [header, *rows]:
+        print(
+            "  ".join(
+                c.ljust(w) if i < 2 else c.rjust(w)
+                for i, (c, w) in enumerate(zip(r, widths, strict=True))
+            ).rstrip()
+        )
+    print("manifest: ok" if (directory / MANIFEST).exists() else "manifest: none")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="astro-weights")
+    parser.add_argument(
+        "--version", action="version", version=f"astro-weights {__version__}"
+    )
+    sub = parser.add_subparsers(dest="command")
+    p = sub.add_parser("inspect", help="summarize and verify a saved PEFT adapter")
+    p.add_argument("directory", metavar="DIR", type=Path)
+    args = parser.parse_args(argv)
+    if args.command == "inspect":
+        return _inspect(args.directory)
+    parser.print_help()
+    return 0

astro_weights/edits/__init__.py

@@ -0,0 +1,20 @@
+"""Edit types and recipes."""
+
+from astro_weights.edits.core import Edit, LowRankDelta
+from astro_weights.edits.recipes import (
+    column_shift,
+    masked_rank1,
+    orthogonal_random,
+    rank1,
+    top_k_mask,
+)
+
+__all__ = [
+    "Edit",
+    "LowRankDelta",
+    "column_shift",
+    "masked_rank1",
+    "orthogonal_random",
+    "rank1",
+    "top_k_mask",
+]

astro_weights/edits/core.py

@@ -0,0 +1,68 @@
+"""Edit types: a set of rank-r deltas on named linear modules."""
+
+from dataclasses import dataclass, field
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class LowRankDelta:
+    """dW = B @ A for one linear module; B is [out, r], A is [r, in]."""
+
+    module: str
+    B: np.ndarray
+    A: np.ndarray
+
+    def __post_init__(self) -> None:
+        if not self.module:
+            raise ValueError("module name must be non-empty")
+        b = np.ascontiguousarray(self.B, dtype=np.float32)
+        a = np.ascontiguousarray(self.A, dtype=np.float32)
+        if b.ndim != 2 or a.ndim != 2:
+            raise ValueError(
+                f"{self.module}: B and A must be 2-D, got {b.ndim}-D and {a.ndim}-D"
+            )
+        if b.shape[1] != a.shape[0] or a.shape[0] < 1:
+            raise ValueError(
+                f"{self.module}: rank mismatch, B {b.shape} vs A {a.shape}"
+            )
+        object.__setattr__(self, "B", b)
+        object.__setattr__(self, "A", a)
+
+    @property
+    def rank(self) -> int:
+        return int(self.A.shape[0])
+
+    @property
+    def shape(self) -> tuple[int, int]:
+        return (int(self.B.shape[0]), int(self.A.shape[1]))
+
+    def dense(self) -> np.ndarray:
+        return np.asarray(self.B @ self.A, dtype=np.float32)
+
+
+@dataclass(frozen=True)
+class Edit:
+    """A set of low-rank deltas against one base model."""
+
+    deltas: tuple[LowRankDelta, ...]
+    base_model: str
+    base_sha256: dict[str, str] = field(default_factory=dict)
+    meta: dict[str, object] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if not self.deltas:
+            raise ValueError("an edit needs at least one delta")
+        names = [d.module for d in self.deltas]
+        if len(set(names)) != len(names):
+            raise ValueError("duplicate module names in edit")
+        ranks = {d.rank for d in self.deltas}
+        if len(ranks) != 1:
+            # llama.cpp's LoRA converter ignores per-module ranks
+            raise ValueError(
+                f"mixed ranks {sorted(ranks)}; all deltas must share one rank"
+            )
+
+    @property
+    def rank(self) -> int:
+        return self.deltas[0].rank

astro_weights/edits/recipes.py

@@ -0,0 +1,56 @@
+"""Edit recipes that produce rank-1 LowRankDeltas (numpy only)."""
+
+import numpy as np
+
+from astro_weights.edits.core import LowRankDelta
+
+
+def rank1(module: str, b: np.ndarray, a: np.ndarray) -> LowRankDelta:
+    """dW = outer(b, a)."""
+    return LowRankDelta(module, b[:, None], a[None, :])
+
+
+def top_k_mask(scores: np.ndarray, k: int) -> np.ndarray:
+    """float32 0/1 vector with ones at the k largest scores."""
+    mask = np.zeros(len(scores), dtype=np.float32)
+    if k > 0:
+        mask[np.argsort(scores)[-k:]] = 1.0
+    return mask
+
+
+def masked_rank1(
+    module: str, W0: np.ndarray, u: np.ndarray, mask: np.ndarray, alpha: float
+) -> LowRankDelta:
+    """Low-rank form of W = W0 - alpha * outer(u, mask * (u @ W0))."""
+    if W0.ndim != 2 or u.shape != (W0.shape[0],) or mask.shape != (W0.shape[1],):
+        raise ValueError(
+            f"{module}: shape mismatch, W0 {W0.shape}, u {u.shape}, mask {mask.shape}"
+        )
+    u64 = u.astype(np.float64)
+    a = -alpha * mask.astype(np.float64) * (u64 @ W0.astype(np.float64))
+    return LowRankDelta(module, u64[:, None], a[None, :])
+
+
+def column_shift(
+    module: str, shift: np.ndarray, idx: np.ndarray, coef: np.ndarray, n_in: int
+) -> LowRankDelta:
+    """Bake a constant shift into input columns: W = W0 + outer(shift, c), c[idx] = coef."""
+    if shift.ndim != 1 or idx.ndim != 1 or coef.shape != idx.shape:
+        raise ValueError(
+            f"{module}: shift must be 1-D; idx and coef must be 1-D, same length"
+        )
+    if len(idx) and (idx.min() < 0 or idx.max() >= n_in):
+        raise ValueError(f"{module}: idx out of range for n_in={n_in}")
+    if len(np.unique(idx)) != len(idx):
+        raise ValueError(f"{module}: idx must be unique")
+    c = np.zeros(n_in, dtype=np.float64)
+    c[idx] = coef
+    return LowRankDelta(module, shift[:, None], c[None, :])
+
+
+def orthogonal_random(u: np.ndarray, seed: int) -> np.ndarray:
+    """Seeded unit vector orthogonal to u (random-edit control)."""
+    u64 = u.astype(np.float64)
+    r = np.random.default_rng(seed).standard_normal(len(u64))
+    r -= (r @ u64) / (u64 @ u64) * u64
+    return r / np.linalg.norm(r)

astro_weights/export/__init__.py

@@ -0,0 +1,5 @@
+"""Export and import of edits."""
+
+from astro_weights.export.peft import load_peft, save_peft, verify_peft
+
+__all__ = ["load_peft", "save_peft", "verify_peft"]

astro_weights/export/peft.py

@@ -0,0 +1,154 @@
+"""Save and load an Edit as a standard PEFT LoRA adapter plus a hash manifest."""
+
+import hashlib
+import json
+import struct
+from importlib.metadata import version
+from pathlib import Path
+
+import numpy as np
+from safetensors.numpy import load_file, save_file
+
+from astro_weights.edits import Edit, LowRankDelta
+
+WEIGHTS = "adapter_model.safetensors"
+CONFIG = "adapter_config.json"
+MANIFEST = "astro_manifest.json"
+PREFIX = "base_model.model."
+SUFFIX_A = ".lora_A.weight"
+SUFFIX_B = ".lora_B.weight"
+FLOAT_DTYPES = {"F32", "F16"}
+
+
+def _write_json(path: Path, obj: object) -> None:
+    path.write_text(json.dumps(obj, indent=1, sort_keys=True) + "\n")
+
+
+def _sha256(arr: np.ndarray) -> str:
+    return hashlib.sha256(
+        np.ascontiguousarray(arr, dtype=np.float32).tobytes()
+    ).hexdigest()
+
+
+def save_peft(edit: Edit, out_dir: Path | str) -> None:
+    """Write edit as a PEFT LoRA adapter (scaling 1) with an astro manifest."""
+    out = Path(out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    tensors: dict[str, np.ndarray] = {}
+    for d in edit.deltas:
+        tensors[f"{PREFIX}{d.module}{SUFFIX_A}"] = d.A
+        tensors[f"{PREFIX}{d.module}{SUFFIX_B}"] = d.B
+    save_file(tensors, str(out / WEIGHTS))
+    _write_json(
+        out / CONFIG,
+        {
+            "peft_type": "LORA",
+            "task_type": "CAUSAL_LM",
+            "base_model_name_or_path": edit.base_model,
+            "r": edit.rank,
+            "lora_alpha": edit.rank,
+            "lora_dropout": 0.0,
+            "bias": "none",
+            "fan_in_fan_out": False,
+            "target_modules": sorted(d.module for d in edit.deltas),
+        },
+    )
+    _write_json(
+        out / MANIFEST,
+        {
+            "format": 1,
+            "astro_weights_version": version("astro-weights"),
+            "base_model": edit.base_model,
+            "base_sha256": edit.base_sha256,
+            "meta": edit.meta,
+            "factors": {k: _sha256(v) for k, v in tensors.items()},
+        },
+    )
+
+
+def _safetensors_dtypes(path: Path) -> dict[str, str]:
+    with path.open("rb") as f:
+        (n,) = struct.unpack("<Q", f.read(8))
+        header = json.loads(f.read(n))
+    return {k: v["dtype"] for k, v in header.items() if k != "__metadata__"}
+
+
+def _check_config(cfg: dict[str, object]) -> None:
+    if cfg.get("peft_type") != "LORA":
+        raise ValueError(f"unsupported peft_type: {cfg.get('peft_type')!r}")
+    for field in ("use_dora", "use_rslora", "fan_in_fan_out"):
+        if cfg.get(field):
+            raise ValueError(f"unsupported adapter config: {field} is true")
+
+
+def _read(directory: Path) -> tuple[Edit, list[str]]:
+    """Parse the adapter; ValueError on structural problems, hash problems returned."""
+    cfg = json.loads((directory / CONFIG).read_text())
+    _check_config(cfg)
+    r, alpha = cfg["r"], cfg["lora_alpha"]
+    scaling = np.float32(alpha / r)
+
+    dtypes = _safetensors_dtypes(directory / WEIGHTS)
+    bad = {k: t for k, t in dtypes.items() if t not in FLOAT_DTYPES}
+    if bad:
+        hint = " (BF16 cannot be read by numpy; re-save the adapter as float32)"
+        raise ValueError(
+            f"unsupported tensor dtypes {bad}{hint if 'BF16' in bad.values() else ''}"
+        )
+    raw = {
+        k: v.astype(np.float32) for k, v in load_file(str(directory / WEIGHTS)).items()
+    }
+
+    a_of: dict[str, np.ndarray] = {}
+    b_of: dict[str, np.ndarray] = {}
+    for key, arr in raw.items():
+        if not key.startswith(PREFIX):
+            raise ValueError(f"unexpected tensor key: {key}")
+        name = key.removeprefix(PREFIX)
+        if name.endswith(SUFFIX_A):
+            a_of[name.removesuffix(SUFFIX_A)] = arr
+        elif name.endswith(SUFFIX_B):
+            b_of[name.removesuffix(SUFFIX_B)] = arr
+        else:
+            raise ValueError(f"unexpected tensor key: {key}")
+    missing = sorted(set(a_of) ^ set(b_of))
+    if missing:
+        raise ValueError(f"modules missing lora_A or lora_B: {missing}")
+
+    deltas = tuple(LowRankDelta(m, b_of[m] * scaling, a_of[m]) for m in sorted(a_of))
+    if any(d.rank != r for d in deltas):
+        raise ValueError(f"tensor rank does not match config r={r}")
+
+    manifest_path = directory / MANIFEST
+    if not manifest_path.exists():
+        return Edit(deltas, cfg.get("base_model_name_or_path") or ""), []
+    manifest = json.loads(manifest_path.read_text())
+    problems = [
+        f"hash mismatch or missing factor: {k}"
+        for k, h in sorted(manifest["factors"].items())
+        if k not in raw or _sha256(raw[k]) != h
+    ]
+    edit = Edit(
+        deltas,
+        manifest["base_model"],
+        base_sha256=manifest.get("base_sha256", {}),
+        meta=manifest.get("meta", {}),
+    )
+    return edit, problems
+
+
+def verify_peft(directory: Path | str) -> list[str]:
+    """Human-readable problems with an adapter directory; empty when fine."""
+    try:
+        _, problems = _read(Path(directory))
+    except (ValueError, KeyError, OSError) as e:
+        return [str(e)]
+    return problems
+
+
+def load_peft(directory: Path | str) -> Edit:
+    """Load a PEFT LoRA adapter as an Edit with scaling folded into B."""
+    edit, problems = _read(Path(directory))
+    if problems:
+        raise ValueError("; ".join(problems))
+    return edit

astro_weights/runners/__init__.py

@@ -0,0 +1 @@
+"""Model runners (torch/transformers/peft live here)."""

astro_weights/runners/hf.py

@@ -0,0 +1,43 @@
+"""Apply and remove an Edit on a transformers model through PEFT."""
+
+import torch
+from peft import LoraConfig, PeftModel, get_peft_model, set_peft_model_state_dict
+from torch import nn
+
+from astro_weights.edits import Edit
+from astro_weights.export.peft import PREFIX, SUFFIX_A, SUFFIX_B
+
+
+def apply(model: nn.Module, edit: Edit, adapter_name: str = "astro") -> PeftModel:
+    """Wrap only the edit's modules in LoRA layers carrying the edit's factors."""
+    modules = dict(model.named_modules())
+    state: dict[str, torch.Tensor] = {}
+    for d in edit.deltas:
+        layer = modules.get(d.module)
+        if not isinstance(layer, nn.Linear):
+            # ValueError (not TypeError): the module may simply be absent
+            raise ValueError(f"{d.module}: not an nn.Linear in the model")  # noqa: TRY004
+        if layer.weight.shape != d.shape:
+            raise ValueError(
+                f"{d.module}: edit shape {d.shape} != weight {tuple(layer.weight.shape)}"
+            )
+        dtype = layer.weight.dtype
+        state[f"{PREFIX}{d.module}{SUFFIX_A}"] = torch.from_numpy(d.A).to(dtype)
+        state[f"{PREFIX}{d.module}{SUFFIX_B}"] = torch.from_numpy(d.B).to(dtype)
+
+    cfg = LoraConfig(
+        r=edit.rank,
+        lora_alpha=edit.rank,
+        lora_dropout=0.0,
+        bias="none",
+        target_modules=[d.module for d in edit.deltas],
+    )
+    peft_model = get_peft_model(model, cfg, adapter_name=adapter_name)
+    set_peft_model_state_dict(peft_model, state, adapter_name=adapter_name)
+    return peft_model
+
+
+def remove(peft_model: PeftModel) -> nn.Module:
+    """Drop the LoRA layers (no merge); base weights were never modified."""
+    base: nn.Module = peft_model.unload()
+    return base

astro_weights-0.0.1.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: astro-weights
+Version: 0.0.1
+Summary: Agent-driven weight-space edits for open LLMs, exported as standard LoRA adapters.
+Keywords: llm,lora,peft,model-editing,interpretability,mcp
+Author: Indranil Biswas
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Dist: numpy>=2.3
+Requires-Dist: safetensors>=0.5
+Requires-Dist: torch ; extra == 'hf'
+Requires-Dist: transformers>=5.4 ; extra == 'hf'
+Requires-Dist: peft>=0.21.3 ; extra == 'hf'
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/astro-weights/astro-weights
+Project-URL: Issues, https://github.com/astro-weights/astro-weights/issues
+Project-URL: Changelog, https://github.com/astro-weights/astro-weights/blob/main/CHANGELOG.md
+Provides-Extra: hf
+Description-Content-Type: text/markdown
+
+# astro-weights
+
+Agent-driven weight-space edits for open LLMs. An agent proposes small, targeted edits to a model's weights, the edits are judged against paired statistical tests on held-out data, and the ones that hold up are exported as standard PEFT LoRA adapters (and GGUF) that existing tools already load.
+
+> **Status: pre-alpha.** Nothing is released yet and the API will change without notice until 1.0.
+
+## Install
+
+```bash
+pip install astro-weights
+```
+
+## Quick look
+
+```python
+import numpy as np
+from astro_weights.edits import Edit, masked_rank1
+from astro_weights.export import save_peft
+
+W0 = np.random.default_rng(0).standard_normal((16, 48), dtype=np.float32)
+u = np.eye(16, dtype=np.float32)[0]
+mask = np.ones(48, dtype=np.float32)
+delta = masked_rank1("model.layers.1.mlp.down_proj", W0, u, mask, alpha=0.5)
+save_peft(Edit(deltas=(delta,), base_model="org/name"), "my-edit")
+```
+
+```bash
+astro-weights inspect my-edit
+```
+
+To apply a saved edit to a transformers model:
+
+```bash
+pip install "astro-weights[hf]"
+```
+
+```python
+from astro_weights.export import load_peft
+from astro_weights.runners.hf import apply
+
+peft_model = apply(model, load_peft("my-edit"))  # model: a transformers causal LM
+```
+
+## Development
+
+```bash
+git clone https://github.com/astro-weights/astro-weights
+cd astro-weights
+uv run pytest
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+[Apache-2.0](LICENSE).

astro_weights-0.0.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+astro_weights/__init__.py,sha256=jzycHjwn-vuN-60PoqfaXdCP3uB1RDhr8S81dHZ2PEQ,250
+astro_weights/cli.py,sha256=p9iAL2yvp_peBcGWC_TbUx8WoXC62VIiuO7EHmg2Ev8,2396
+astro_weights/edits/__init__.py,sha256=L0Oh3_qRnpbENrcAVaqyUKuF9ipfr1X4b51EN5qdZi4,360
+astro_weights/edits/core.py,sha256=QCMwrvMpqT2YiZqyFc8QcF_aw7ASY4JAsWfazZTWg6E,2160
+astro_weights/edits/recipes.py,sha256=kHYXnKjcpA3AhRqeeEX6eRVHnQoyR5J62MU6qch4B1A,2143
+astro_weights/export/__init__.py,sha256=U7hx32U9LeAobob_-eIz7BMRs_H2d52I5N5oxbK9JUg,160
+astro_weights/export/peft.py,sha256=5k8Pj5x5ZI_rN1gsQFdlKgQBjMJ1t4wWOUPYGakKwa8,5248
+astro_weights/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astro_weights/runners/__init__.py,sha256=s0kPlncuYGCjBxy6IbflFhs1J4_y3k3KSve67nLWnCU,57
+astro_weights/runners/hf.py,sha256=2MJLRRoLqNUDUY0puqiP6FoLKU1WvqkRapc_748If0Q,1723
+astro_weights-0.0.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+astro_weights-0.0.1.dist-info/WHEEL,sha256=3OmCxFA0ffBIsX4x0o8CdfSvZAOvO3mzEG8U_z5TvV4,80
+astro_weights-0.0.1.dist-info/entry_points.txt,sha256=scaw2glbHJZZF97axJRLGLADHTP3DOrXcxDCErS-vVg,58
+astro_weights-0.0.1.dist-info/METADATA,sha256=lFq9kLbZFrVrD4K242JW78z9MLYmYN0tInoFvoqO1d0,2608
+astro_weights-0.0.1.dist-info/RECORD,,

astro_weights-0.0.1.dist-info/WHEEL

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

astro_weights-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+astro-weights = astro_weights.cli:main
+

astro_weights-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.