quickdbd-cli 0.1.0__py3-none-any.whl

quickdbd_cli/project.py

@@ -0,0 +1,69 @@
+"""Input discovery and the compile pipeline shared by every command."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from . import layout
+from .measure import model_json
+from .model import Schema
+from .parser import compile_sources
+
+
+def discover(inputs: list[Path]) -> list[Path]:
+    """Expand directories to every ``*.txt`` beneath them (recursive, sorted)."""
+    files: list[Path] = []
+    for p in inputs:
+        if p.is_dir():
+            files.extend(sorted(f for f in p.rglob("*.txt") if f.is_file()))
+        elif p.exists():
+            files.append(p)
+        else:
+            raise FileNotFoundError(f"no such file or directory: {p}")
+    seen: set[Path] = set()
+    out = []
+    for f in files:
+        r = f.resolve()
+        if r not in seen:
+            seen.add(r)
+            out.append(f)
+    return out
+
+
+def display_path(p: Path) -> str:
+    try:
+        return str(p.resolve().relative_to(Path.cwd().resolve()))
+    except ValueError:
+        return str(p)
+
+
+@dataclass
+class Project:
+    inputs: list[Path]
+    files: list[Path]
+    sidecar: Path
+
+    @classmethod
+    def open(cls, inputs: list[Path], sidecar: Path | None = None) -> Project:
+        files = discover(inputs)
+        if not files:
+            raise FileNotFoundError("no .txt schema files found in: " + ", ".join(map(str, inputs)))
+        return cls(inputs, files, sidecar or layout.default_sidecar(files, inputs))
+
+    def sources(self) -> list[tuple[str, str]]:
+        return [(display_path(f), f.read_text(encoding="utf-8")) for f in self.files]
+
+    def compile(self) -> Schema:
+        return compile_sources(self.sources())
+
+    def build(self, schema: Schema, reset: bool = False) -> tuple[dict, dict]:
+        """Returns (model, positions) with positions keyed by table id as [x, y]."""
+        model = model_json(schema)
+        side = {} if reset else layout.read_sidecar(self.sidecar)
+        pos = layout.resolve_positions(model, side, schema.layout, reset=reset)
+        return model, {k: [v[0], v[1]] for k, v in pos.items()}
+
+    def save_positions(self, model: dict, positions: dict) -> None:
+        by_name = {t["name"]: tuple(positions[t["id"]]) for t in model["tables"] if t["id"] in positions}
+        layout.write_sidecar(self.sidecar, by_name)

quickdbd_cli/serve.py

@@ -0,0 +1,210 @@
+"""`qdbd serve`: local live editor.
+
+Watches the schema files (mtime polling), recompiles on change and pushes a reload event to the
+page over Server-Sent Events. Dragged table positions are saved to the layout sidecar; the
+browser editor pane writes the .txt files, refusing to overwrite a file changed on disk since
+the browser last loaded it.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import threading
+import time
+import webbrowser
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+from . import layout
+from .html import render_page
+from .project import Project, discover, display_path
+
+
+class State:
+    def __init__(self, project: Project):
+        self.project = project
+        self.lock = threading.Condition()
+        self.version = 0
+        self.model: dict = {"style": {}, "tables": [], "rels": [], "zoom": None, "position": None}
+        self.positions: dict = {}
+        self.diagnostics: list[dict] = []
+        self.files: list[Path] = []
+        # mtimes are strings: nanosecond integers exceed JavaScript's safe integer range.
+        self.mtimes: dict[str, str] = {}
+        self.reload(initial=True)
+
+    def _scan(self) -> dict[str, str]:
+        self.files = discover(self.project.inputs)
+        self.project.files = self.files
+        return {display_path(f): str(f.stat().st_mtime_ns) for f in self.files}
+
+    def reload(self, initial: bool = False) -> None:
+        mtimes = self._scan()
+        schema = self.project.compile()
+        diags = [
+            {"path": d.path, "line": d.line, "message": d.message, "severity": d.severity, "text": d.format()}
+            for d in schema.diagnostics
+        ]
+        with self.lock:
+            self.mtimes = mtimes
+            self.diagnostics = diags
+            if not schema.errors:
+                from .measure import model_json
+
+                model = model_json(schema)
+                base = layout.read_sidecar(self.project.sidecar)
+                current = {
+                    t["name"]: tuple(self.positions[t["id"]]) for t in self.model["tables"] if t["id"] in self.positions
+                }
+                base.update(current)
+                pos = layout.resolve_positions(model, base, schema.layout)
+                self.model = model
+                self.positions = {k: [v[0], v[1]] for k, v in pos.items()}
+                self.project.save_positions(model, self.positions)
+            self.version += 1
+            self.lock.notify_all()
+        if not initial:
+            n = len(schema.errors)
+            print(f"[qdbd] reloaded: {len(self.model['tables'])} tables" + (f", {n} error(s)" if n else ""), flush=True)
+
+    def changed(self) -> bool:
+        try:
+            return self._scan() != self.mtimes
+        except FileNotFoundError:
+            return True
+
+    def snapshot(self) -> dict:
+        with self.lock:
+            files = []
+            for f in self.files:
+                p = display_path(f)
+                try:
+                    text = f.read_text(encoding="utf-8")
+                except FileNotFoundError:
+                    continue
+                files.append({"path": p, "text": text, "mtime": self.mtimes.get(p)})
+            return {
+                "version": self.version,
+                "model": self.model,
+                "positions": self.positions,
+                "diagnostics": self.diagnostics,
+                "files": files,
+            }
+
+    def save_layout(self, body: dict) -> None:
+        with self.lock:
+            by_name = {t["name"]: t["id"] for t in self.model["tables"]}
+            for name, xy in body.items():
+                if name in by_name:
+                    self.positions[by_name[name]] = [int(xy[0]), int(xy[1])]
+            self.project.save_positions(self.model, self.positions)
+
+    def write_file(self, path: str, text: str, base_mtime: str | None) -> tuple[int, dict]:
+        target = next((f for f in self.files if display_path(f) == path), None)
+        if target is None:
+            return 404, {"error": "unknown file"}
+        current = str(target.stat().st_mtime_ns)
+        if base_mtime is not None and current != str(base_mtime):
+            return 409, {"error": "changed on disk", "text": target.read_text(encoding="utf-8"), "mtime": current}
+        target.write_text(text, encoding="utf-8")
+        return 200, {"mtime": str(target.stat().st_mtime_ns)}
+
+
+def _handler(state: State, title: str):
+    class Handler(BaseHTTPRequestHandler):
+        def log_message(self, *args) -> None:  # quiet
+            pass
+
+        def _send(self, code: int, body: bytes, ctype: str) -> None:
+            self.send_response(code)
+            self.send_header("Content-Type", ctype)
+            self.send_header("Content-Length", str(len(body)))
+            self.send_header("Cache-Control", "no-store")
+            self.end_headers()
+            self.wfile.write(body)
+
+        def _json(self, code: int, obj) -> None:
+            self._send(code, json.dumps(obj).encode(), "application/json")
+
+        def _body(self) -> dict:
+            n = int(self.headers.get("Content-Length") or 0)
+            return json.loads(self.rfile.read(n) or b"{}")
+
+        def do_GET(self) -> None:
+            if self.path == "/":
+                with state.lock:
+                    page = render_page(state.model, state.positions, title, serve=True)
+                self._send(200, page.encode(), "text/html; charset=utf-8")
+            elif self.path == "/state":
+                self._json(200, state.snapshot())
+            elif self.path == "/events":
+                self.send_response(200)
+                self.send_header("Content-Type", "text/event-stream")
+                self.send_header("Cache-Control", "no-store")
+                self.end_headers()
+                seen = -1
+                try:
+                    while True:
+                        with state.lock:
+                            state.lock.wait_for(lambda s=seen: state.version != s, timeout=15)
+                            v = state.version
+                        msg = f"data: {v}\n\n" if v != seen else ": ping\n\n"
+                        seen = v
+                        self.wfile.write(msg.encode())
+                        self.wfile.flush()
+                except (BrokenPipeError, ConnectionResetError, OSError):
+                    return
+            elif self.path == "/favicon.ico":
+                self._send(204, b"", "image/x-icon")
+            else:
+                self._send(404, b"not found", "text/plain")
+
+        def do_POST(self) -> None:
+            if self.path == "/layout":
+                state.save_layout(self._body())
+                self._json(200, {"ok": True})
+            else:
+                self._send(404, b"not found", "text/plain")
+
+        def do_PUT(self) -> None:
+            if self.path == "/file":
+                b = self._body()
+                code, obj = state.write_file(b.get("path", ""), b.get("text", ""), b.get("mtime"))
+                self._json(code, obj)
+            else:
+                self._send(404, b"not found", "text/plain")
+
+    return Handler
+
+
+def serve(project: Project, port: int = 8765, open_browser: bool = True) -> int:
+    state = State(project)
+    for d in state.diagnostics:
+        print(d["text"], file=sys.stderr)
+    title = project.inputs[0].stem if len(project.inputs) == 1 else "diagram"
+    server = ThreadingHTTPServer(("127.0.0.1", port), _handler(state, title))
+    server.daemon_threads = True
+    url = f"http://127.0.0.1:{server.server_address[1]}/"
+    print(f"[qdbd] serving {len(state.files)} file(s) at {url}  (layout: {display_path(project.sidecar)})")
+    print("[qdbd] Ctrl+C to stop", flush=True)
+
+    def watch() -> None:
+        while True:
+            time.sleep(0.3)
+            if state.changed():
+                try:
+                    state.reload()
+                except Exception as e:  # keep serving on unexpected errors
+                    print(f"[qdbd] reload failed: {e}", file=sys.stderr, flush=True)
+
+    threading.Thread(target=watch, daemon=True).start()
+    if open_browser:
+        threading.Timer(0.3, lambda: webbrowser.open(url)).start()
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\n[qdbd] stopped")
+    finally:
+        server.server_close()
+    return 0

quickdbd_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,153 @@
+Metadata-Version: 2.5
+Name: quickdbd-cli
+Version: 0.1.0
+Summary: Compile QuickDBD-syntax schema files into interactive HTML ER diagrams, with no table limit.
+Project-URL: Homepage, https://github.com/MarkPhamm/quickdbd-cli
+Author: Minh (Mark) Pham
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+License-File: src/quickdbd_cli/assets/Inter-LICENSE.txt
+License-File: src/quickdbd_cli/assets/elk-LICENSE.md
+Keywords: database,diagram,erd,quickdbd,schema
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.11
+Requires-Dist: mini-racer>=0.14
+Requires-Dist: resvg-py>=0.5
+Provides-Extra: dev
+Requires-Dist: fonttools>=4.50; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# quickdbd-cli (`qdbd`)
+
+Compile [QuickDBD](https://www.quickdatabasediagrams.com)-syntax schema files into **interactive HTML ER diagrams**, with no table limit, from the command line. Built to stay readable at 200+ tables.
+
+```
+Customer
+-
+CustomerId PK int
+Name string
+
+Order
+-
+OrderId PK int
+CustomerId int FK >- Customer.CustomerId
+```
+
+```bash
+pipx install quickdbd-cli        # or: uvx --from quickdbd-cli qdbd ...
+qdbd build schema.txt -o schema.html
+```
+
+Not affiliated with QuickDBD. It reads the same text syntax, so schemas move freely between the two.
+
+## Features
+
+- **Same syntax as QuickDBD:** tables, aliases, quoted names, all 9 relationship operators, `rel` lines, PK/FK/NULL/UNIQUE/INDEX/IDENTITY, `default=`, doc comments, `[settings]` and `[layout]` sections. Error messages are QuickDBD's own.
+- **Interactive page:**
+  - search and jump to a table (`/`)
+  - minimap
+  - click a table to focus on it and its neighbours
+  - collapse tables: full / keys only / names only
+  - hover a column to highlight its relationship
+  - PNG/SVG export buttons
+- **Live editing:** `qdbd serve` reloads when you save, has a browser editor pane with autosave, and remembers where you drag tables.
+- **Many files, one diagram:** point it at a folder and foreign keys can cross files.
+- **Pip-only install:** no Graphviz, Node or browser needed. Layout uses [ELK](https://eclipse.dev/elk/), running in an embedded V8.
+- **CI-friendly:** builds are deterministic, and errors are `file:line: error: …` with exit code 1.
+
+## Commands
+
+```bash
+qdbd check  PATH... [--strict]                 # validate; "No errors found. Good job!"
+qdbd build  PATH... -o diagram.html            # shareable interactive HTML (positions locked)
+qdbd serve  PATH... [--port 8765]              # live editor + drag-to-arrange
+qdbd export PATH... -o out.png [--focus Customer --depth 1]   # PNG or SVG image
+qdbd layout PATH... [--reset]                  # (re)write the layout file
+```
+
+`PATH` is a `.txt` file or a folder. Every `*.txt` under a folder is read recursively.
+
+### Table positions
+
+The first build auto-arranges the tables. In `qdbd serve`, drag tables where you want them. Positions are saved to a sidecar file you can commit:
+
+- `schema.txt` → `schema.layout.json`
+- a folder → `<folder>/qdbd.layout.json`
+- override either with `--layout FILE`
+
+Once a layout exists, a new table is placed next to the tables it's related to, and nothing else moves. Run `qdbd layout PATH --reset` to re-arrange everything from scratch. A pasted schema's QuickDBD `[layout]` section is used for any table the sidecar doesn't cover.
+
+`qdbd build` never writes the sidecar, so CI builds leave the working tree clean.
+
+### Differences from QuickDBD
+
+`qdbd` accepts a few things QuickDBD rejects, and prints a warning for each one:
+
+- tab characters
+- `decimal(10, 2)` (a space inside a type)
+- an explicit `NOT NULL`
+- indented table names
+- `[layout]` entries for unknown tables
+
+`qdbd check --strict` turns these warnings into errors, so a file that passes is guaranteed to paste into QuickDBD.
+
+`default=` values keep their case, where QuickDBD lowercases them.
+
+## CI
+
+**pre-commit:**
+
+```yaml
+repos:
+  - repo: https://github.com/MarkPhamm/quickdbd-cli
+    rev: v0.1.0
+    hooks:
+      - id: qdbd-check
+        files: ^schema/.*\.txt$   # point at your schema files
+```
+
+**GitHub Actions:**
+
+```yaml
+- uses: actions/setup-python@v5
+  with: { python-version: "3.12" }
+- run: pip install quickdbd-cli
+- run: qdbd check schema/
+- run: qdbd build schema/ -o site/schema.html
+- uses: actions/upload-artifact@v4
+  with: { name: schema-diagram, path: site/schema.html }
+```
+
+**GitLab CI:**
+
+```yaml
+erd:
+  image: python:3.12
+  script:
+    - pip install quickdbd-cli
+    - qdbd check schema/
+    - qdbd build schema/ -o public/schema.html
+  artifacts:
+    paths: [public/schema.html]
+```
+
+## Development
+
+```bash
+uv venv && uv pip install -e ".[dev]"
+.venv/bin/pytest
+python scripts/gen_schema.py        # regenerate examples/synthetic (200 tables)
+python scripts/gen_font_metrics.py  # regenerate font width table
+```
+
+Design notes: `docs/superpowers/specs/2026-10-17-qdbd-design.md`.
+
+## License
+
+Apache-2.0. Bundled third-party files are listed in [NOTICE](NOTICE).

quickdbd_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+quickdbd_cli/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+quickdbd_cli/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+quickdbd_cli/cli.py,sha256=lTuIOnpbsbcXhaOhByeBCKEIXFJ2XJ_-Lonb0JP26zM,5965
+quickdbd_cli/export.py,sha256=9N6ZpLP7F2ZOJwEUURzbzSJ9xLpJjYykvRHuY7DhWU0,2482
+quickdbd_cli/html.py,sha256=kOwdyAU5nQSpFWAuWXbvm-mHzaJArPhGVQGsibHZf5o,3703
+quickdbd_cli/jsrt.py,sha256=f8JuDhCE0qU5YiO7JkxFVcoGbcSgMZMeUi9C6IlB_8s,2594
+quickdbd_cli/layout.py,sha256=zMuY2ttrHoxZ5y97WO5IxrmPp30mZdUaKcT1LmzUdUg,7785
+quickdbd_cli/measure.py,sha256=Yru-f1_MRWEvR6kmjXozHC40M4znix-RQi_3bnL0CGg,3162
+quickdbd_cli/model.py,sha256=rL8rlhyPToPH17m3Sh4bvbIongqF98eEH0bgkOV4mgU,2798
+quickdbd_cli/parser.py,sha256=2w6f1ZRyfPR-VCicGhDVSyUWqHUzVN6TV3gi-vVfyO8,27414
+quickdbd_cli/project.py,sha256=3e1qvsLd1BqHI6nOuaz0qw4ZRyLwHJdRLp-T0-o4Qgw,2315
+quickdbd_cli/serve.py,sha256=b9OjGxnCKWsQGML7HB5RGoJVsc6OVgueOXYMPsbM0qU,8350
+quickdbd_cli/assets/Inter-Bold.ttf,sha256=KIMWCZseCkekcW0VkJgAXu98AGaSHzTjIAOT29sBlH8,420428
+quickdbd_cli/assets/Inter-Bold.woff2,sha256=-oiBJ7baAVtlVp8DUfO1w5GtkokElR8cIOn4RiqNleo,114840
+quickdbd_cli/assets/Inter-LICENSE.txt,sha256=JiSB6ERSGzJvXs0FPlm5jIstp4yO4b27boF0MF5Uk1o,4380
+quickdbd_cli/assets/Inter-Regular.ttf,sha256=QNaS_OGI5EceKzy6k3vpZ4ePYxrT67vc1YdofH6-DII,411640
+quickdbd_cli/assets/Inter-Regular.woff2,sha256=4G9rG8VTqupORmgCPtCrChRxKcMQf1Ebx9A9NhsK4IU,111268
+quickdbd_cli/assets/editor.js,sha256=-_Kjk-kLYzn_UoV58xjPz6GudVYB5ZVfcSBQts9-wXM,8000
+quickdbd_cli/assets/elk-LICENSE.md,sha256=Y36B9KG2tAeVNcSZ_KBeI4z3YFwf9bdtYNfafOlnAMk,14443
+quickdbd_cli/assets/elk.bundled.js,sha256=EiLkT5U853Rq8jgB5yNwj45vQ2uLN3pqX8dVLzSjB7M,1609707
+quickdbd_cli/assets/font-metrics.json,sha256=sXSiElxQSK8md8IEePLwh16TTdAqKt9rV140pvMlVS8,8654
+quickdbd_cli/assets/render.js,sha256=JmnFuBLuY_t0gCwSo02KaRsgN_qfGf-8OUpu0rcmC00,10153
+quickdbd_cli/assets/style.css,sha256=2-7Oam4iy2iJVlzIu36_Bn0_fK-fgsPwg0YIQ2PX4zw,4597
+quickdbd_cli/assets/viewer.js,sha256=vqQi23m7-TMfLJeMuLMYWQWWs3gRGYonz5vUX78lsU4,12932
+quickdbd_cli-0.1.0.dist-info/METADATA,sha256=chGwXKHhXxTaWYWIYTnQIXtAhHph3TN6Hh67Jpp7nsI,5171
+quickdbd_cli-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+quickdbd_cli-0.1.0.dist-info/entry_points.txt,sha256=nRhiYYug-XOY95nWUmi4oanico3Zjkfqk2OHtIE6SQ0,47
+quickdbd_cli-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+quickdbd_cli-0.1.0.dist-info/licenses/NOTICE,sha256=yj0trSHShGZMOuvTCYT2RgMy-h3cqGTtUP4BtW1znYQ,865
+quickdbd_cli-0.1.0.dist-info/licenses/src/quickdbd_cli/assets/Inter-LICENSE.txt,sha256=JiSB6ERSGzJvXs0FPlm5jIstp4yO4b27boF0MF5Uk1o,4380
+quickdbd_cli-0.1.0.dist-info/licenses/src/quickdbd_cli/assets/elk-LICENSE.md,sha256=Y36B9KG2tAeVNcSZ_KBeI4z3YFwf9bdtYNfafOlnAMk,14443
+quickdbd_cli-0.1.0.dist-info/RECORD,,

quickdbd_cli-0.1.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

quickdbd_cli-0.1.0.dist-info/entry_points.txt

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

quickdbd_cli-0.1.0.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.