blockspec 0.1.0__py3-none-any.whl

blockspec/edit.py

@@ -0,0 +1,234 @@
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+"""Edit a blockspec document one block at a time: `docs/editing-api.md`.
+
+Three operations, each text in and text out: replace a block, insert one
+beside a block, delete a block. A block is a top-level node (SPEC.md section
+6.1), named by its node path `[i]`. Every function changes only the lines its
+operation is about, reads the result back with the reader, and refuses rather
+than return a document whose other blocks or names read differently. Nothing
+here reads or writes a `<doc>.notes/` record.
+"""
+
+from __future__ import annotations
+
+import re
+
+from .document import Document, Refusal, parse
+
+__all__ = ["EditRefused", "REASONS", "delete_block", "insert_block", "replace_block"]
+
+#: The API's own refusal reasons, none spelled like a SPEC.md section 9 code.
+REASONS = (
+    "bad-position",
+    "no-such-block",
+    "nested-node",
+    "not-one-block",
+    "changes-another-block",
+    "rebinds-name",
+)
+
+
+class EditRefused(Refusal):
+    """An edit refused for a reason of the API's own, in `code`."""
+
+
+def _lines(text: str) -> list[list[str]]:
+    """[body, line ending] per line, split as the reader splits lines."""
+    out = []
+    for match in re.finditer(r"([^\r\n]*)(\r\n|\r|\n|$)", text):
+        if match.start() == len(text) and (not out or out[-1][1]):
+            break
+        out.append([match.group(1), match.group(2)])
+        if not match.group(2):
+            break
+    return out
+
+
+def _join(lines: list[list[str]]) -> str:
+    return "".join(body + eol for body, eol in lines)
+
+
+def _blank(body: str) -> bool:
+    return not body.strip(" \t")
+
+
+def _eol(lines: list[list[str]], at: int) -> str:
+    """The line ending a new line at index `at` takes (editing-api.md, *Where
+    the lines go*)."""
+    if at > 0 and lines[at - 1][1]:
+        return lines[at - 1][1]
+    return next((eol for _, eol in lines if eol), "\n")
+
+
+def _check_types(text, node=None, source=None) -> None:
+    if not isinstance(text, str):
+        raise TypeError(f"text must be a str, not {type(text).__name__}")
+    if source is not None and not isinstance(source, str):
+        raise TypeError(f"source must be a str, not {type(source).__name__}")
+    if node is not None and not (
+        isinstance(node, list | tuple)
+        and all(isinstance(i, int) and not isinstance(i, bool) for i in node)
+    ):
+        raise TypeError("a node path must be a list or tuple of ints")
+
+
+def _block(doc: Document, node) -> int:
+    """The index of the block `node` names, or a refusal."""
+    path = list(node)
+    if len(path) == 1 and 0 <= path[0] < len(doc.blocks):
+        return path[0]
+    at = doc.root
+    for i in path:
+        if not 0 <= i < len(at.children):
+            at = None
+            break
+        at = at.children[i]
+    if len(path) > 1 and at is not None:
+        raise EditRefused("nested-node", f"{path} is a node inside block [{path[0]}]")
+    raise EditRefused("no-such-block", f"{path} names no block of the document")
+
+
+def _source_lines(source: str) -> list[str]:
+    lines = [body for body, _ in _lines(source)]
+    if not lines:
+        raise EditRefused("not-one-block", "the source is empty")
+    return lines
+
+
+def _declared(doc: Document, block: int | None) -> set[str]:
+    """The names markers in block `block` declare."""
+    if block is None:
+        return set()
+    return {
+        node.marker[0]
+        for node in doc.nodes
+        if node.marker is not None and node.path[0] == block and node.marker[1] != ":end"
+    }
+
+
+def _by_block(doc: Document) -> dict[int, list]:
+    out: dict[int, list] = {}
+    for leaf in doc.leaves:
+        out.setdefault(leaf["node"][0], []).append(
+            (leaf["node"][1:], leaf["type"], leaf["content"])
+        )
+    return out
+
+
+def _move(target: dict, mapping) -> dict | None:
+    if "region" in target:
+        region = [_move(n, mapping) for n in target["region"]]
+        return {"region": [n for n in region if n is not None]}
+    first = mapping(target["node"][0])
+    if first is None:
+        return None
+    return {"node": [first, *target["node"][1:]], "type": target["type"]}
+
+
+def _read_back(old: Document, text: str, edited: int | None, new: int | None, span, mapping) -> str:
+    """Refuse `text` unless it reads as `old` with the edit applied: block
+    `edited` of `old` replaced or removed, block `new` of the result made of
+    exactly the lines `span`, and every other block and name as it was."""
+    doc = parse(text)
+    if new is not None:
+        if new >= len(doc.blocks) or doc.blocks[new]["lines"] != list(span):
+            raise EditRefused("not-one-block", "the new lines do not read as one block")
+    expected = len(old.blocks) + (new is not None) - (edited is not None)
+    if len(doc.blocks) != expected or doc.frontmatter != old.frontmatter:
+        raise EditRefused("changes-another-block", "the document's blocks would change")
+    before, after = _by_block(old), _by_block(doc)
+    for j, block in enumerate(old.blocks):
+        if j == edited:
+            continue
+        k = mapping(j)
+        got = doc.blocks[k]
+        if (
+            got["type"] != block["type"]
+            or got["lines"][1] - got["lines"][0] != block["lines"][1] - block["lines"][0]
+            or after.get(k, []) != before.get(j, [])
+        ):
+            raise EditRefused("changes-another-block", f"block [{j}] would read differently")
+    gone, added = _declared(old, edited), _declared(doc, new)
+    want = {n: _move(t, mapping) for n, t in old.names.items() if n not in gone}
+    got = {}
+    for name, target in doc.names.items():
+        if name in added:
+            continue
+        if "region" in target and new is not None:
+            target = {"region": [n for n in target["region"] if n["node"] != [new]]}
+        got[name] = target
+    if want != got:
+        moved = sorted(n for n in set(want) | set(got) if want.get(n) != got.get(n))
+        raise EditRefused("rebinds-name", f"#{moved[0]} would bind to something else")
+    return text
+
+
+def replace_block(text: str, node, source: str, /) -> str:
+    """Replace block `node`'s lines with `source`'s. The diff is the block."""
+    _check_types(text, node, source)
+    doc = parse(text)
+    i = _block(doc, node)
+    new = _source_lines(source)
+    lines = _lines(text)
+    first, last = doc.blocks[i]["lines"]
+    if [body for body, _ in lines[first - 1 : last]] == new:
+        return text
+    eol = _eol(lines, first - 1)
+    lines[first - 1 : last] = [[b, eol] for b in new[:-1]] + [[new[-1], lines[last - 1][1]]]
+    span = (first, first + len(new) - 1)
+    return _read_back(doc, _join(lines), i, i, span, lambda j: j)
+
+
+def insert_block(text: str, source: str, /, *, before=None, after=None) -> str:
+    """Insert `source` as a block before or after the block named, or after
+    the last block. A blank line separates it from a non-blank neighbour."""
+    _check_types(text, before, source)
+    _check_types(text, after)
+    doc = parse(text)
+    if before is not None and after is not None:
+        raise EditRefused("bad-position", "give before= or after=, not both")
+    lines = _lines(text)
+    if after is not None:
+        k = _block(doc, after) + 1
+        at = doc.blocks[k - 1]["lines"][1]
+    elif before is not None:
+        k = _block(doc, before)
+        at = doc.blocks[k]["lines"][0] - 1
+    else:
+        k = len(doc.blocks)
+        at = doc.blocks[-1]["lines"][1] if doc.blocks else len(lines)
+    new = _source_lines(source)
+    eol = _eol(lines, at)
+    above = at > 0 and not _blank(lines[at - 1][0])
+    below = at < len(lines) and not _blank(lines[at][0])
+    added = [[""]] * above + [[b] for b in new] + [[""]] * below
+    added = [[b[0], eol] for b in added]
+    if at == len(lines) and lines and not lines[-1][1]:
+        lines[-1][1] = eol
+        added[-1][1] = ""
+    lines[at:at] = added
+    first = at + 1 + above
+    span = (first, first + len(new) - 1)
+    return _read_back(doc, _join(lines), None, k, span, lambda j: j + (j >= k))
+
+
+def delete_block(text: str, node, /) -> str:
+    """Delete block `node` and the blank lines between it and the next block,
+    or, for the last block, those between it and the line before it."""
+    _check_types(text, node)
+    doc = parse(text)
+    i = _block(doc, node)
+    lines = _lines(text)
+    first, last = doc.blocks[i]["lines"]
+    start, end = first - 1, last
+    following = next((j for j in range(last, len(lines)) if not _blank(lines[j][0])), None)
+    if following is not None:
+        end = following
+    else:
+        while start > 0 and _blank(lines[start - 1][0]):
+            start -= 1
+    took_bare_end = end == len(lines) and not lines[-1][1]
+    del lines[start:end]
+    if took_bare_end and lines:
+        lines[-1][1] = ""
+    return _read_back(doc, _join(lines), i, None, (), lambda j: None if j == i else j - (j > i))

blockspec-0.1.0.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.5
+Name: blockspec
+Version: 0.1.0
+Summary: A specification and conformance suite for prose documents that must survive version control
+Project-URL: Homepage, https://github.com/kindspec/blockspec
+Project-URL: Source, https://github.com/kindspec/blockspec
+Project-URL: Issues, https://github.com/kindspec/blockspec/issues
+Project-URL: Specification, https://github.com/kindspec/blockspec/blob/main/SPEC.md
+Author: Cameron Brooks
+License-Expression: Apache-2.0 OR MIT
+License-File: LICENSE
+License-File: LICENSES/Apache-2.0.txt
+License-File: LICENSES/CC-BY-4.0.txt
+License-File: LICENSES/CC0-1.0.txt
+License-File: LICENSES/MIT.txt
+License-File: LICENSES/PSF-2.0.txt
+Keywords: conformance,git,markdown,merge,specification
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# blockspec
+
+A file format and test suite for prose documents that must survive version
+control.
+
+A blockspec document is a markdown file that renders and edits correctly in
+today's markdown tools. It adds one convention, a marker that lets an author
+name a part of the document. It refuses the markdown constructs that mature
+parsers read differently, or that hide what a merge did.
+
+```markdown
+# Runbook
+
+<!-- #restart -->
+## Restart the service
+
+Run `systemctl restart app`, then check the logs.
+```
+
+The marker names the heading after it, and renders as nothing. A comment or a
+transclusion can point at `restart` and keep working when the text around it moves.
+
+Unlike a [rowspec](https://github.com/kindspec/rowspec) row, **a block gets no
+minted id**, so nothing has to be written into the prose. Identity is computed
+from content where it can be, and named by an author where it must be.
+[`DESIGN-BRIEF.md`](DESIGN-BRIEF.md) has the measurement behind that.
+
+## Status
+
+Draft 0. [`SPEC.md`](SPEC.md) is the format, `conformance/cases/` encodes it,
+and `reference/blockspec/` is the reference. `reference/blockspec_alt/`, written
+from the spec by an author who never read it, passes the same cases. Released on
+[PyPI](https://pypi.org/project/blockspec/).
+
+The experiment behind the format found that prose does have a silent wrong
+merge worth a format. That verdict came from a second run under an owner ruling
+made after the first run's result was public, so read
+[the status page](docs/status.md) before relying on it.
+
+## Try it
+
+From a clone, with Python 3.11 or newer and no dependencies:
+
+```sh
+git clone https://github.com/kindspec/blockspec
+cd blockspec
+PYTHONPATH=reference python3 -c '
+import blockspec
+doc = blockspec.parse("<!-- #intro -->\nHello.\n")
+print(doc.names)
+'
+```
+
+`parse` raises `Refusal`, with a `SPEC.md` §9 code, on a document it won't
+accept.
+
+## Check documents
+
+```sh
+pip install blockspec
+blockspec check docs/    # refuses a document the profile cannot read safely
+```
+
+A document is refused for what would quietly break under a merge, including a
+link to a section that no longer exists and a marker that takes a name from a
+heading. It exits 0 when every document reads, 1 when one is refused, and 2 when
+nothing was checked or a file could not be read. `--format github` writes annotations. In CI:
+
+```yaml
+- uses: actions/checkout@v7
+- uses: kindspec/blockspec@v0.1.0
+  with:
+    paths: docs
+```
+
+## The reference's API
+
+`reference/blockspec/` is standard library only, and run from its source
+tree (`pythonpath = ["reference"]`).
+
+| function | what it does |
+| --- | --- |
+| `parse(text)` | reads a document, or raises `Refusal` with a `SPEC.md` §9 code; the `Document` has `frontmatter`, `blocks`, `leaves`, `names` and `resolve(name)` |
+| `conform(text, queries)` | `parse` as the conformance runner calls it |
+| `resolve(repo, queries)` | §11's anchors and transclusions, as the runner calls it (`anchor.py`) |
+| `edit.replace_block(text, node, source)` | the text with block `node`'s lines replaced by `source` |
+| `edit.insert_block(text, source, before=, after=)` | the text with `source` inserted as a block before or after a block, or after the last |
+| `edit.delete_block(text, node)` | the text without block `node` |
+
+A block is named by its node path, `[i]`. Each `edit` function reads its
+result back and raises `Refusal`, or its subclass `edit.EditRefused` for the
+API's own reasons, rather than return a document whose other blocks or names
+read differently. It never touches a `<doc>.notes/` record.
+[`docs/editing-api.md`](docs/editing-api.md) gives the rules, and `tests/edit-cases/` pins them.
+
+## Develop
+
+```sh
+just setup      # install dependencies
+just check      # format and lint
+just test       # the tests
+just conform    # the conformance tree against the reference
+just mutants    # break the reference; the suite must notice
+```
+
+## More
+
+- [`DESIGN-BRIEF.md`](DESIGN-BRIEF.md): what was decided and measured before the
+  format was written.
+- [`docs/adjudications/`](docs/adjudications/): the decisions that define draft 0.
+- [`spike/`](spike/README.md): the experiment.
+- [kindspec](https://github.com/kindspec): the other formats.

blockspec-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+blockspec/__init__.py,sha256=KCwI50nca_U9sCHD-StKIQeSalLHhSWtZSogPIXEerA,361
+blockspec/__main__.py,sha256=EP1EUbJ89RQlVwOPA7oUSukFXKaaYux4VRPr6IXKAwU,102
+blockspec/anchor.py,sha256=UjU8dX8tr4m2rH3rLWxV07n2lbNWNyIqq0g_SlfCiK8,47648
+blockspec/cli.py,sha256=wsJY0ilmd4avm8sNucr-1qGF3UDXUerxYBGwlDcBfgw,4928
+blockspec/document.py,sha256=jOm0HLg1JNvobBj5esjnpXBCcu_6yGZ5NtrNv1ei_U8,51250
+blockspec/edit.py,sha256=IaOjQhtEUxIW5_fHoctuVkd3AkVWKfAe0h4dkedLhx4,8837
+blockspec-0.1.0.dist-info/METADATA,sha256=yU4Yn_ZIY8vX8l7kxQObwfAxlQosBvhkIfP3hVeumKU,5279
+blockspec-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+blockspec-0.1.0.dist-info/entry_points.txt,sha256=SQDY2W0zwVBSPxCmdOXLljUXDoiyAkEHEO0mMnMWjrc,49
+blockspec-0.1.0.dist-info/licenses/LICENSE,sha256=Gekps-Ekbuv0wMGEeeF36-zIr4xHGilFhD75yre8dEU,4347
+blockspec-0.1.0.dist-info/licenses/LICENSES/Apache-2.0.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+blockspec-0.1.0.dist-info/licenses/LICENSES/CC-BY-4.0.txt,sha256=1VdTnfaOdxzB7tzJHRP3D8qTDlCNEe7cr6SxXbSeN0Q,17023
+blockspec-0.1.0.dist-info/licenses/LICENSES/CC0-1.0.txt,sha256=ogEPNDSH0_dhiv_lT3ifVIdgIzHAqNA_SemnxUfPBJk,7048
+blockspec-0.1.0.dist-info/licenses/LICENSES/MIT.txt,sha256=nfn2VV8K3vVj-0YSVqB3mLrkdWUl0yvlGLbZm0rH8tA,1063
+blockspec-0.1.0.dist-info/licenses/LICENSES/PSF-2.0.txt,sha256=eLEsOoE2CzVwAjNPDnDqDpLuv3qbNYgFwDxISElF87s,13809
+blockspec-0.1.0.dist-info/RECORD,,

blockspec-0.1.0.dist-info/WHEEL

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

blockspec-0.1.0.dist-info/entry_points.txt

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

blockspec-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,87 @@
+blockspec is licensed per directory, on the same split as rowspec. This is
+deliberate, not an oversight.
+
+  SPEC.md, docs/            CC-BY-4.0
+  conformance/cases/        CC0-1.0
+  conformance/*.py          MIT
+  reference/, tests/,
+  tools/                    Apache-2.0 OR MIT
+  justfile, pyproject.toml,
+  uv.lock                   Apache-2.0 OR MIT
+  README.md, AGENTS.md, CHANGELOG.md,
+  DESIGN-BRIEF.md           CC-BY-4.0
+  .editorconfig,
+  .gitattributes,
+  .gitignore                Apache-2.0 OR MIT
+  .github/workflows/,
+  action.yml                Apache-2.0 OR MIT
+  LICENSE, NOTICE           CC0-1.0
+  LICENSES/                 each text under its own terms, copied verbatim
+  spike/*.md                CC-BY-4.0
+  spike/harness/            MIT
+  spike/harness/plant_cases/  CC0-1.0
+  spike/harness3/           MIT
+  spike/ruling/             MIT
+  spike/results/            CC-BY-4.0, except corpus text (below)
+  spike/results/prereg3/    CC-BY-4.0, except corpus text and third-party
+                            excerpts (below)
+
+A path ending in "/" covers everything below it, subdirectories included. A
+"*" matches within one directory. Where two rows cover the same path, the more
+specific one applies: spike/harness/plant_cases/ is CC0-1.0 inside the MIT
+spike/harness/, and spike/results/prereg3/ keeps its own row and its own
+exceptions inside spike/results/.
+
+The rows for SPEC.md, docs/, conformance/, reference/ and tests/ are decided
+ahead of the files: those paths may be empty, and the split applies to whatever
+lands there.
+
+CORPUS TEXT IN spike/results/
+
+The spike measures third-party corpora, and its results carry their text,
+spike/results/prereg3/ included. In spike/results/prereg2/export/packets/ and
+spike/results/prereg3/export/packets/, every .md file in a packet other than
+QUESTIONS.md is a whole file copied from a corpus: before.md and after.md, or
+in a merge packet base.md, leg-a.md, leg-c.md and after.md. Each packet's packet.json
+quotes from them. The exception is the plant packets, whose text the harness
+generates (spike/harness/prereg2_plants.py, spike/harness3/prereg3_plants.py).
+Other result files quote shorter excerpts where they report a block, a quote
+or a target, merge-arm-candidates.jsonl and cheap-arm/anchors-silent-wrongs.txt
+among them. The corpora and their pins are named where each result was
+produced: spike/LOG.md and spike/PRE-REGISTRATION-2.md section 6.2, which
+prereg 3 keeps (spike/PRE-REGISTRATION-3.md section 1).
+
+That text is not this project's work and is not offered under CC-BY-4.0. It
+stays under its upstream terms, whatever they are at the pin it was taken
+from. NOTICE lists each corpus, its pins and the licence its tree holds there.
+The CC-BY-4.0 row covers what this project wrote around it: the records,
+figures, prompts, questions and plant texts.
+
+THIRD-PARTY EXCERPTS IN spike/results/prereg3/
+
+The rehearsal evidence under spike/results/prereg3/rehearsals/, the archives
+included, quotes synthetic test text. That text is taken from the docstrings
+of CPython 3.13 standard-library modules, as rendered by pydoc (the rehearsal
+builder, rehearsals/tools/build.py, lists the modules). The pydoc output links
+to docs.python.org/3.13. A few docstrings link to docs.python.org/3.11 in their
+own text. These excerpts are Copyright (c) the Python Software Foundation and
+contributors, and they keep their own licence, the Python Software Foundation
+License Version 2 (https://docs.python.org/3.13/license.html), whose text is
+in LICENSES/PSF-2.0.txt. That file is the Python 3.13 distribution's own
+licence file, /usr/lib/python3.13/LICENSE.txt from Debian's
+libpython3.13-stdlib 3.13.5-2+deb13u5, copied verbatim. The excerpts are not
+offered under CC-BY-4.0. The builder used no other outside source. The plant
+texts, prompts and harness output are this project's own.
+
+Full texts are in LICENSES/.
+
+WHY THE SPLIT
+
+The point of this project is independent implementations. That makes the
+reusability of the SPEC and the FIXTURES more important than the licence on any
+reference code.
+
+CommonMark embeds its conformance examples inside a CC-BY-SA spec document, so
+vendoring the test cases arguably vendors share-alike prose. These fixtures are
+meant to be vendored: copy them into an implementation in any language, under
+any licence, without obligation.

blockspec-0.1.0.dist-info/licenses/LICENSES/Apache-2.0.txt

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