gpucheck-cli 0.1.0__py3-none-any.whl

gpucheck/run.py

@@ -0,0 +1,155 @@
+"""Run engine: preflight, baseline phase, load phase, with a safety watchdog.
+
+Time is driven by this module's own schedule: every iteration calls
+adapter.sample() once, then sleeps until the next 1/hz slot (measured with the
+injected clock). Sample timestamps (t_s) come from the adapter. A sample() that
+raises is recorded as an all-None sample whose t_s is the previous sample's t_s
+plus 1/hz (0.0 if there is none yet), so the series stays evenly spaced.
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from dataclasses import dataclass, replace
+from typing import Protocol
+
+from .adapter import GpuInventory, TelemetryAdapter, TelemetrySample
+from .preflight import Preflight, run_preflight
+from .specs import GpuSpec
+
+THERMAL_MARGIN_C = 5.0
+UNKNOWN_GPU_THERMAL_LIMIT_C = 95.0  # abort limit when the model is not in the spec table
+THERMAL_CONSECUTIVE = 3
+ECC_JUMP = 100
+MAX_CONSECUTIVE_SAMPLE_ERRORS = 10
+
+
+@dataclass(frozen=True)
+class RunConfig:
+    baseline_s: float = 60
+    load_s: float = 600
+    hz: float = 1.0
+
+
+class LoadGenerator(Protocol):
+    def start(self) -> None: ...
+
+    def tick(self) -> float | None: ...
+
+    def stop(self) -> None: ...
+
+
+class NullLoad:
+    def start(self) -> None:
+        pass
+
+    def tick(self) -> float | None:
+        return None
+
+    def stop(self) -> None:
+        pass
+
+
+@dataclass(frozen=True)
+class RawRun:
+    inventory: GpuInventory
+    preflight: Preflight
+    baseline: list[TelemetrySample]
+    load: list[TelemetrySample]
+    config: RunConfig
+    aborted: str | None
+
+
+class _Watchdog:
+    def __init__(self, spec: GpuSpec | None) -> None:
+        self._limit = spec.max_temp_c + THERMAL_MARGIN_C if spec is not None else UNKNOWN_GPU_THERMAL_LIMIT_C
+        self._hot = 0
+        self._last_ecc: int | None = None
+
+    def check(self, s: TelemetrySample) -> str | None:
+        if s.temp_c is not None and s.temp_c >= self._limit:
+            self._hot += 1
+            if self._hot >= THERMAL_CONSECUTIVE:
+                return "thermal"
+        else:
+            self._hot = 0
+        if s.ecc_volatile is not None:
+            if self._last_ecc is not None and s.ecc_volatile - self._last_ecc > ECC_JUMP:
+                return "ecc"
+            self._last_ecc = s.ecc_volatile
+        return None
+
+
+def _empty_sample(t_s: float) -> TelemetrySample:
+    return TelemetrySample(
+        t_s=t_s,
+        temp_c=None,
+        power_w=None,
+        sm_clock_mhz=None,
+        fan_pct=None,
+        throttle_reasons=None,  # unknown, not "no throttling"
+        ecc_volatile=None,
+        achieved_tflops=None,
+    )
+
+
+def execute_run(
+    adapter: TelemetryAdapter,
+    load: LoadGenerator,
+    config: RunConfig,
+    spec: GpuSpec | None,
+    *,
+    clock: Callable[[], float] = time.monotonic,
+    sleep: Callable[[float], None] = time.sleep,
+) -> RawRun:
+    inventory = adapter.inventory()
+    preflight = run_preflight(adapter)
+    baseline: list[TelemetrySample] = []
+    loaded: list[TelemetrySample] = []
+    period = 1.0 / config.hz
+    state = {"last_t": None, "errors": 0}
+
+    def result(aborted: str | None) -> RawRun:
+        return RawRun(inventory, preflight, baseline, loaded, config, aborted)
+
+    if preflight.mode == "refuse":
+        return result("preflight_refused")
+
+    def take() -> TelemetrySample:
+        """One sample, or an all-None one if the adapter raised."""
+        try:
+            s = adapter.sample()
+            state["errors"] = 0
+        except Exception:
+            state["errors"] += 1
+            last = state["last_t"]
+            s = _empty_sample(0.0 if last is None else last + period)
+        state["last_t"] = s.t_s
+        return s
+
+    def phase(count: int, out: list[TelemetrySample], watchdog: _Watchdog | None, tick: bool) -> str | None:
+        start = clock()
+        for i in range(count):
+            s = take()
+            if tick:
+                tflops = load.tick()
+                if tflops is not None:
+                    s = replace(s, achieved_tflops=tflops)
+            out.append(s)
+            if watchdog is not None and (reason := watchdog.check(s)):
+                return reason
+            if state["errors"] >= MAX_CONSECUTIVE_SAMPLE_ERRORS:
+                return "telemetry"
+            sleep(max(0.0, start + (i + 1) * period - clock()))
+        return None
+
+    aborted = phase(round(config.baseline_s * config.hz), baseline, None, tick=False)
+    if aborted:
+        return result(aborted)
+    try:
+        load.start()
+        aborted = phase(round(config.load_s * config.hz), loaded, _Watchdog(spec), tick=True)
+    finally:
+        load.stop()
+    return result(aborted)

gpucheck/specs.py

@@ -0,0 +1,59 @@
+"""Bundled published GPU specs and name-based lookup.
+
+Values are the v1 seed set (SXM/PCIe split). Each row is pinned by the plan and
+must be verified against the NVIDIA datasheet before launch.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class GpuSpec:
+    key: str
+    tdp_w: float
+    peak_bf16_tflops: float
+    max_temp_c: float
+    boost_clock_mhz: float
+
+
+_SPECS: dict[str, GpuSpec] = {
+    s.key: s
+    for s in (
+        GpuSpec("rtx-4090", 450.0, 165.2, 90.0, 2520.0),  # pinned by plan; verify against datasheet before launch
+        GpuSpec("rtx-3090", 350.0, 71.0, 93.0, 1695.0),  # pinned by plan; verify against datasheet before launch
+        GpuSpec("a100-80gb-sxm", 400.0, 312.0, 85.0, 1410.0),  # pinned by plan; verify against datasheet before launch
+        GpuSpec("a100-80gb-pcie", 300.0, 312.0, 85.0, 1410.0),  # pinned by plan; verify against datasheet before launch
+        GpuSpec("h100-sxm", 700.0, 989.0, 83.0, 1980.0),  # pinned by plan; verify against datasheet before launch
+        GpuSpec("h100-pcie", 350.0, 756.0, 83.0, 1755.0),  # pinned by plan; verify against datasheet before launch
+    )
+}
+
+# "3090" or "4090" as a standalone number, not followed by "ti" (Ti variants are not in the table).
+_RTX_3090 = re.compile(r"(?<!\d)3090(?!\d|ti)")
+_RTX_4090 = re.compile(r"(?<!\d)4090(?!\d|ti)")
+
+
+def lookup(model_name: str) -> GpuSpec | None:
+    """Return the bundled spec matching an NVML-style model name, or None.
+
+    Matching is case- and whitespace-insensitive.
+    """
+    s = "".join(model_name.lower().split())
+    if "nvl" in s:  # NVL parts (H100/A100/RTX NVL) are not in the v1 table; never silently match
+        return None
+    if "h100" in s:
+        return _SPECS["h100-pcie"] if "pcie" in s else _SPECS["h100-sxm"]
+    if "a100" in s:
+        if "pcie" in s:
+            return _SPECS["a100-80gb-pcie"]
+        if "80gb" in s:
+            return _SPECS["a100-80gb-sxm"]
+        return None
+    if _RTX_4090.search(s):
+        return _SPECS["rtx-4090"]
+    if _RTX_3090.search(s):
+        return _SPECS["rtx-3090"]
+    return None

gpucheck/upload.py

@@ -0,0 +1,95 @@
+"""Opt-in upload client (stdlib only). Never raises: failures become UploadOutcome(ok=False)."""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+
+from .resultjson import canonical_dumps, run_id
+
+
+@dataclass(frozen=True)
+class UploadOutcome:
+    ok: bool
+    url: str | None
+    grade: dict | None
+    delete_token: str | None
+    error: str | None
+    n: int | None = None
+    reason: str | None = None  # server's explanation when grade is None
+    certifiable: bool | None = None  # server's verdict on a --certify upload (None: not said)
+    certify_note: str | None = None  # why the server refused to certify
+
+
+def _fail(e: BaseException) -> UploadOutcome:
+    msg = " ".join(f"{type(e).__name__}: {e}".split())
+    return UploadOutcome(False, None, None, None, msg)
+
+
+class ChallengeUnavailable(Exception):
+    """The server could not issue a certification challenge."""
+
+
+def fetch_challenge(server: str, timeout_s: float = 20) -> dict:
+    """POST /v1/challenges; raises ChallengeUnavailable with a one-line message."""
+    try:
+        req = urllib.request.Request(
+            f"{server.rstrip('/')}/v1/challenges",
+            data=b"{}",
+            method="POST",
+            headers={"Content-Type": "application/json"},
+        )
+        with urllib.request.urlopen(req, timeout=timeout_s) as resp:
+            body = json.loads(resp.read().decode())
+        if not isinstance(body, dict) or not isinstance(body.get("workload"), dict):
+            raise ValueError("unexpected challenge response shape")
+        for k in ("challenge_id", "nonce"):
+            if not isinstance(body.get(k), str):
+                raise ValueError(f"challenge missing {k}")
+        w = body["workload"]
+        offs = w.get("gemm_n_offsets")
+        if (
+            not isinstance(offs, list)
+            or not offs
+            or not all(type(o) is int for o in offs)  # type() rejects bools
+            or type(w.get("order_seed")) is not int
+        ):
+            raise ValueError("challenge workload malformed")
+        return body
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            raise ChallengeUnavailable("server has certification disabled") from e
+        raise ChallengeUnavailable(f"challenge request failed (HTTP {e.code})") from e
+    except Exception as e:  # noqa: BLE001
+        msg = " ".join(f"{type(e).__name__}: {e}".split())
+        raise ChallengeUnavailable(f"could not fetch challenge ({msg})") from e
+
+
+def upload(result: dict, server: str, timeout_s: float = 20) -> UploadOutcome:
+    try:
+        req = urllib.request.Request(
+            f"{server.rstrip('/')}/v1/runs",
+            data=canonical_dumps(result).encode(),
+            method="POST",
+            headers={"Content-Type": "application/json", "X-Run-Id": run_id(result)},
+        )
+        with urllib.request.urlopen(req, timeout=timeout_s) as resp:
+            body = json.loads(resp.read().decode())
+        if not isinstance(body, dict):
+            raise ValueError("unexpected response shape")
+        grade = body.get("grade")
+        return UploadOutcome(
+            True,
+            body.get("url"),
+            grade if isinstance(grade, dict) else None,
+            body.get("delete_token"),
+            None,
+            body.get("n") if isinstance(body.get("n"), int) else None,
+            body.get("reason") if isinstance(body.get("reason"), str) else None,
+            body.get("certifiable") if isinstance(body.get("certifiable"), bool) else None,
+            body.get("certify_note") if isinstance(body.get("certify_note"), str) else None,
+        )
+    except Exception as e:  # noqa: BLE001 - upload must never break the local run
+        return _fail(e)

gpucheck_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: gpucheck-cli
+Version: 0.1.0
+Summary: Open-source CLI that health-checks NVIDIA GPUs
+Author: narekkeshishyan
+Author-email: narekkeshishyan <keshishyan01@gmail.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Dist: pynvml
+Requires-Dist: torch ; extra == 'load'
+Requires-Python: >=3.10
+Project-URL: Homepage, https://gpucheck.dev
+Project-URL: Repository, https://github.com/narek-keshishyan/gpucheck
+Provides-Extra: load
+Description-Content-Type: text/markdown
+
+# gpucheck
+
+One command that stress-tests an NVIDIA GPU and tells you whether it is healthy, throttling, or degraded.
+
+Website: [gpucheck.dev](https://gpucheck.dev) — includes the optional $29 signed certificate for used-GPU listings.
+
+It records a short idle baseline, runs a sustained matrix-multiply load, and samples temperature, clocks, power, and throttle reasons the whole time. It then explains what it saw in plain language: thermal throttling, power-limit throttling, memory problems, or throughput well below what that model should deliver.
+
+## Install
+
+```
+uvx --from "gpucheck-cli[load]" gpucheck --quick
+# or
+pip install "gpucheck-cli[load]"
+```
+
+The load generator needs PyTorch with CUDA. It is an optional extra (`[load]`) because torch is large; if you already have a CUDA build of torch installed, plain `pip install gpucheck-cli` is enough. (The PyPI package is `gpucheck-cli`; the installed command is `gpucheck`.) Without torch/CUDA the tool still runs but generates no load (it prints a warning), so performance metrics are left blank.
+
+## Usage
+
+```
+gpucheck                 # standard run: 60 s baseline, 10 min load
+gpucheck --quick         # 30 s baseline, 150 s load
+gpucheck --long          # 60 s baseline, 30 min load
+gpucheck --offline       # never contacts a server
+gpucheck --dry-run       # print exactly what would be uploaded, upload nothing
+gpucheck --yes-upload    # upload without the prompt
+gpucheck --server URL    # upload server (http or https); default https://gpucheck-api.fly.dev
+gpucheck --json PATH     # where to write result.json (default ./gpucheck-result.json)
+gpucheck --certify       # use a one-time server challenge so the result can earn a certificate
+```
+
+The result is always written locally to `result.json` first. The tool only reads from the GPU; it does not change any settings. Ctrl-C stops a run at any time; an interrupted run writes no result.json and uploads nothing.
+
+### Upload flow
+
+After a run, unless you passed `--offline`, gpucheck asks whether to upload (to `https://gpucheck-api.fly.dev` unless you pass `--server URL`). If you say yes you get a result page URL, a grade such as `Grade B — delivers 94.1% of a healthy <model> (n=12, low confidence)` (or the reason there is none, for example "insufficient reference (n=X)" while too few comparable runs exist, or "measurements only" for MIG), and a delete token. Save the token: it is the only way to delete the page later.
+
+```
+curl -X DELETE -H "X-Delete-Token: <token>" <server>/v1/runs/<run_id>
+```
+
+## What gets uploaded
+
+Nothing, unless you opt in. Uploading is off in non-interactive shells unless you pass `--yes-upload`. `--dry-run` prints the exact payload so you can read it first.
+
+The payload is the contents of `result.json`: GPU model and driver details, measurements, findings, and the time series of samples. The GPU identifier is replaced by a salted-hash UUID, so the raw serial is never sent. The salt is a public constant in this source code, so anyone who already knows your GPU's UUID can recompute the hash and recognise your card.
+
+Result pages are public to anyone with the link, and the server also serves back the full uploaded JSON (every field above, including the sample time series) at `/v1/runs/<run_id>`. The run ID is derived from the content, and the server returns a delete token (stored only as a hash) that lets you remove your page.
+
+## Certificates (`--certify`)
+
+`gpucheck --certify` asks the server for a one-time challenge, runs the workload the server prescribes (a set of matrix sizes and an execution order) instead of the default one, and uploads the result with the challenge attached. If the run qualifies, the result page offers a signed certificate for it. Certifying a run is a separate purchase, made on the result page.
+
+What you need:
+
+- A server that has certification turned on. The default server is `https://gpucheck-api.fly.dev`; pass `--server URL` for another one. If the challenge cannot be fetched (the server has certification turned off, or cannot be reached), gpucheck stops before the run with a message and exit code 1.
+- Working PyTorch with CUDA. Without it, `--certify` stops with exit code 1 instead of falling back to a run with no load.
+- The normal upload prompt still applies. A certificate can only be made from an uploaded result, so answer yes, or pass `--yes-upload` in a script.
+
+`--certify` cannot be combined with `--offline`, `--dry-run`, or `--quick`; the argument parser rejects the combination at startup. Certificates need a full-length run (at least 600 s of load), so a quick run could never earn one.
+
+If the challenge expires before the run finishes (challenges are valid for 2 hours), gpucheck prints one warning, `challenge expired before upload; run again to certify — result saved locally`, does not upload, and exits normally. The result is still written to the `--json` path.
+
+Fake mode: `--fake` with `--certify` runs mechanically, but a real server rejects it with "upload arrived too soon after challenge", because the simulated run finishes instantly. This is intended: fakes cannot earn certificates.
+
+After a `--certify` upload, gpucheck prints the server's verdict: `Certifiable: yes`, or `Not certifiable: <reason>` with the reason the server gave (`certify_note`). If the server refuses to certify a run, the upload still succeeds and the result is still stored; the run simply gets no purchase button. A certifiable run also needs a grade, a complete (not aborted, not quarantined) load phase, and a card identity before the result page offers a certificate.
+
+### What a certificate proves
+
+A certificate raises the cost of lying about a GPU. It is not proof of anything on its own.
+
+- The run used a fresh one-time server challenge and could not be uploaded before the full run time had passed. The uploaded result echoes the challenge's workload parameters, but the server cannot see whether that workload actually ran.
+- The signed payload binds that certificate to one stored result (by its SHA-256), one card (its salted-hash identifier, the same one in the uploaded result), one grade, and one run.
+- Certificates issued while the server is in payment test mode carry a TEST banner and `livemode: false` in the signed payload. They are not real purchases.
+
+### What a certificate does not prove
+
+- It does not show that the card is healthy or will stay healthy. A single run is a snapshot, as described under Limitations.
+- It does not stop someone who controls the machine. Someone with full control can fabricate telemetry that matches the prescribed workload and timing. The server cannot see the hardware directly.
+- It does not stop re-running. A card owner can keep running until a run looks good and then buy a certificate for that one. When a newer certificate is issued for the same card, the older one is marked as superseded, which makes this visible, but it is not prevented.
+- Revocation is not part of the signature. A revoked certificate still verifies offline; only the live verify endpoint knows about revocation.
+
+Verifying a certificate offline needs the certificate payload, its signature, and the public key from `/v1/pubkey`. The exact steps and a one-line Python check are on the server's `/verify` page and in the server's README.
+
+## Exit codes
+
+| Code | Meaning |
+| --- | --- |
+| 0 | Run completed |
+| 1 | Preflight refused to run (for example the GPU is busy) |
+| 2 | No NVIDIA GPU or driver available |
+| 3 | Run aborted partway (thermal limit, ECC errors, or lost telemetry); result.json is still written |
+
+## Limitations
+
+- NVIDIA GPUs on Linux only.
+- MIG instances give measurements only; they are not graded.
+- Needs PyTorch with CUDA to generate load; without it, performance numbers are blank.
+- It refuses to run on a GPU that is already busy.
+- Grades depend on a reference set of comparable runs; for new or rare models you will see "insufficient reference".
+- A single run is a snapshot. A healthy result does not guarantee the card will never fail.
+
+## License
+
+Apache-2.0

gpucheck_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+gpucheck/__init__.py,sha256=a1DhEHgibDOB2JTiR86AaGG-Y4hPiN3h0LY9EsGoKAQ,42
+gpucheck/adapter.py,sha256=lhtvwJFK0225dGGoc6vQbCGLuyzjSz8Ec5RRR6SQmLo,7147
+gpucheck/cli.py,sha256=6nQ2wdKQNqAvfJLUpUyYWoyzAGxejC95sVaYd8bvHe4,9149
+gpucheck/diagnose.py,sha256=dIXk19ouGY1R3WVmMfmiwTHjq4PSVj3IIi2AyeRhc4s,7118
+gpucheck/fakes.py,sha256=v1r-IMPyrmpm4pFVgIPbcxIWweKehfNGKeFY3nSLSd4,4065
+gpucheck/load.py,sha256=2nQChYhKlKd4zirx5BXGegBnv4KjfPlivnAmENesABk,4812
+gpucheck/metrics.py,sha256=44OE_P-szAlhty_v8tQpOGG08Cs-e-lHaKk3ITcjVcE,3491
+gpucheck/preflight.py,sha256=BGnHsuzh2LQpTXLWOem3GarsOeJddEUD036G7v6QmYs,3353
+gpucheck/report.py,sha256=phS-H8ocGgRYYdO4qPdyMkFd2n5nvHB6JmNR88gPuPI,3645
+gpucheck/resultjson.py,sha256=4ISOQaPyw6-WLo8BHl9KjI_lJniQcgFPXa5mL3TmF1g,2413
+gpucheck/run.py,sha256=reV-ZMfL-4h1d0upGInWc1WwXoykbksEi1qyNqm9Iqc,4665
+gpucheck/specs.py,sha256=THpmuhsHhjGHng9zpfaZTlDD5eCUrepuDctQWBPJZ8o,2150
+gpucheck/upload.py,sha256=LJnruD5dpmK6wqXbRVvbG4FdHHXFQXDI3uLOD_cfAPc,3773
+gpucheck_cli-0.1.0.dist-info/licenses/LICENSE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174
+gpucheck_cli-0.1.0.dist-info/WHEEL,sha256=s_zqWxHFEH8b58BCtf46hFCqPaISurdB9R1XJ8za6XI,80
+gpucheck_cli-0.1.0.dist-info/entry_points.txt,sha256=qv4fBcVrYZ7U_LQ2SKo5n7thDyKP1KV5uWFaN8vH92U,48
+gpucheck_cli-0.1.0.dist-info/METADATA,sha256=htoScVW8j5oRlCOACh2cciZ5YDW1sS61_laBGWygUd8,8570
+gpucheck_cli-0.1.0.dist-info/RECORD,,

gpucheck_cli-0.1.0.dist-info/WHEEL

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

gpucheck_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+gpucheck = gpucheck.cli:main
+

gpucheck_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,177 @@
+
+                                 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