arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/test_stage_r.py

@@ -0,0 +1,108 @@
+"""Stage R boundaries are structural, never selected by a vector's name."""
+import copy
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+import deliver
+import plan
+
+STD = "urn:law:std#"
+
+
+def program(nodes=()):
+    return {"semanticVersion": "0.2.11", "schemaVersion": "law.core.ir/0.7", "nodes": list(nodes)}
+
+
+class StageRPlanningTests(unittest.TestCase):
+    def test_admission_has_its_own_plan_version_and_includes_world_nodes(self):
+        root = program([{"kind": "source_work", "id": "urn:root#work"}])
+        p = plan.build_plan(root)
+        self.assertEqual(p["planVersion"], "law-backend-plan/0.20")
+        self.assertIn("admission:current", p["capabilities"])
+        self.assertEqual(p["admission"]["reservedAssertionIds"], ["urn:root#work"])
+
+    def test_norms_refuse_for_every_query_including_plain_truth(self):
+        ir = program([{"kind": "norm_template", "id": "urn:test#duty"}])
+        for entry in (plan.build_plan, plan.survey_plan, plan.Builder):
+            with self.subTest(entry=entry.__name__), self.assertRaisesRegex(plan.Refused, "NORM_RANKS_UNAVAILABLE"):
+                entry(ir)
+
+    def test_hand_built_norm_plans_cannot_reach_retired_emitters(self):
+        for lang in ("py", "ts", "go"):
+            with self.subTest(lang=lang), self.assertRaisesRegex(ValueError, "NORM_RANKS_UNAVAILABLE"):
+                deliver.emitter(lang).check_plan({"planVersion": "law-backend-plan/0.10", "norms": []})
+
+    def test_invalid_typed_bounds_refuse_before_planning(self):
+        for node, suffix in [
+            ({"kind": "rule", "effective": {"start": "2026-02-30"}}, "/effective/start"),
+            ({"kind": "assertion", "valid": {"end": "2026-01-01T12:00:00"}}, "/valid/end"),
+            ({"kind": "rule", "governs": [{"start": "2026-01-01T00:00:00+00:99"}]}, "/governs/0/start"),
+            ({"kind": "source_edition", "lifecycle": [{"extent": "0000-01-01"}]}, "/lifecycle/0/extent"),
+        ]:
+            with self.subTest(node=node), self.assertRaisesRegex(plan.Refused, "TEMPORAL_BOUND_INVALID") as exc:
+                plan.build_plan(program([node]))
+            self.assertIn("/nodes/0" + suffix, str(exc.exception))
+
+    def test_temporal_looking_metadata_is_not_a_typed_bound(self):
+        from temporal import validate_ir
+        validate_ir(program([{"kind": "source_work", "payload": {"valid": {"start": "bad"}}}]), plan.Refused)
+
+    def test_go_factory_does_not_read_closure_names_inside_json_as_dependencies(self):
+        source = ('package main\n'
+                  'var BACKCHAIN = planJSON("{\\"status\\": \\"established\\"}").([]interface{})\n'
+                  'func status() string { return "ok" }\n')
+        generated = deliver.emitter("go")._factory(source, {})
+        self.assertIn('var BACKCHAIN = planJSON(', generated)
+
+    def test_valid_arbitrary_fraction_and_infinity_are_admitted(self):
+        from temporal import validate_ir
+        validate_ir(program([{"kind": "rule", "effective": {
+            "start": "0001-01-01T00:00:00.123456789123456789+23:59", "end": "infinity"}}]), plan.Refused)
+        with self.assertRaisesRegex(plan.Refused, "TEMPORAL_BOUND_INVALID"):
+            validate_ir(program([{"kind": "rule", "effective": {"start": "infinity"}}]), plan.Refused)
+
+
+@unittest.skipUnless(os.environ.get("LAW_CODEGEN_TEST_CORE_KIT"), "requires current core kit")
+class StageRRunnerTests(unittest.TestCase):
+    def test_primary_runners_enforce_admission_and_positions_before_computation(self):
+        # One small emitted model per target, then several independent requests.
+        import core_support
+        core_support.configure_core_kit(Path(os.environ["LAW_CODEGEN_TEST_CORE_KIT"]))
+        ir = program([{"kind": "source_work", "id": "urn:test#work"}])
+        pl = plan.build_plan(ir)
+        cases = [
+            ({}, {"kind": "positions"}, "POSITIONS_UNAVAILABLE"),
+            ({"assertions": [{"id": "urn:test#work"}]}, {"kind": "truth"}, "LDC-E1382"),
+            ({"assertions": [{"valid": {"start": "2026-02-30"}}]}, {"kind": "truth"}, "TEMPORAL_BOUND_INVALID"),
+            ({"assertions": [{"literal": {"kind": "literal", "args": [
+                {"kind": "value", "type": {"name": STD + "Number"}, "value": "3/2"}]}}]},
+             {"kind": "truth"}, "NUMBER_UNAVAILABLE"),
+        ]
+        with tempfile.TemporaryDirectory(prefix="stage-r-runners-") as raw:
+            root = Path(raw)
+            for lang in ("py", "ts", "go"):
+                em = deliver.emitter(lang)
+                project = root / lang
+                deliver.emit_project(pl, lang, project)
+                step = em.build(str(project))
+                if step:
+                    command, cwd = step
+                    subprocess.run(command, cwd=cwd, check=True, capture_output=True, text=True)
+                for case, query, code in cases:
+                    with self.subTest(lang=lang, code=code):
+                        c, q = root / "case.json", root / "query.json"
+                        c.write_text(json.dumps(case)); q.write_text(json.dumps(query))
+                        command, cwd = em.run(str(project), "runner")
+                        result = subprocess.run(command + [str(c), str(q)], cwd=cwd,
+                                                capture_output=True, text=True, timeout=15)
+                        self.assertEqual(result.returncode, 3, result.stderr)
+                        self.assertTrue(json.loads(result.stdout)["refused"].startswith(code), result.stdout)
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_standalone_inputs.py

@@ -0,0 +1,71 @@
+"""Regression checks for explicit standalone input boundaries."""
+import hashlib
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import inputs
+import plan
+
+
+class StandaloneInputsTests(unittest.TestCase):
+    def test_world_indexes_do_not_leak_between_roots(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            roots = [Path(tmp) / name for name in ("a", "b")]
+            for root in roots:
+                directory = root / "corpus" / "clir"
+                directory.mkdir(parents=True)
+                (directory / "p.lawir.json").write_text(json.dumps({"package": {"name": root.name}}))
+            self.assertEqual({"a"}, set(plan.world_index(roots[0])))
+            self.assertEqual({"b"}, set(plan.world_index(roots[1])))
+
+    def test_duplicate_dependencies_are_not_silently_selected(self):
+        doc = {"package": {"name": "dep"}}
+        with self.assertRaisesRegex(plan.Refused, "неоднозначная"):
+            plan.resolve_world({"imports": []}, {}, [doc, doc])
+
+    def test_resources_are_verified_and_confined(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            data = b'{"calendar": true}'
+            (root / "calendar.json").write_bytes(data)
+            manifest = root / "resources.json"
+            entry = {"path": "calendar.json", "sha256": "sha256:" + hashlib.sha256(data).hexdigest()}
+            manifest.write_text(json.dumps({"artifact:calendar": entry}))
+            self.assertEqual({"artifact:calendar": data}, inputs.load_resources(manifest))
+            (root / "calendar.json").write_bytes(b"changed")
+            with self.assertRaisesRegex(plan.Refused, "хэш"):
+                inputs.load_resources(manifest)
+            entry["path"] = "../outside"
+            manifest.write_text(json.dumps({"artifact:calendar": entry}))
+            with self.assertRaisesRegex(plan.Refused, "вне комплекта"):
+                inputs.load_resources(manifest)
+
+    def test_corpus_resources_read_only_explicit_root(self):
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            (root / "calendar.json").write_bytes(b"fixture")
+            node = {"kind": "calendar_snapshot", "resourceUri": "artifact:calendar.json"}
+            self.assertEqual({"artifact:calendar.json": b"fixture"},
+                             inputs.corpus_resources([{"nodes": [node]}], root))
+            node["resourceUri"] = "artifact:../outside"
+            with self.assertRaisesRegex(plan.Refused, "escapes"):
+                inputs.corpus_resources([{"nodes": [node]}], root)
+
+    def test_explicit_empty_resources_do_not_fall_back_to_checkout(self):
+        # The URI names a file that exists in this checkout. Explicit resource
+        # maps must still report it missing rather than read ambient bytes.
+        builder = object.__new__(plan.Builder)
+        builder.ir = {"semanticVersion": "0.2.11", "nodes": [{"kind": "calendar_snapshot",
+            "id": "calendar", "resourceUri": "artifact:engines/backends/plan.py"}]}
+        builder.resources = {}
+        builder.repository_resources = False
+        env = builder._calendar_env()
+        self.assertIn("MISSING_CALENDAR", json.dumps(env))
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_support.py

@@ -0,0 +1,150 @@
+"""Portable data roots for backend tests.
+
+When exported deliveries are supplied, tests validate and copy those immutable
+inputs instead of reaching into a law-dsl checkout.  The tracked-source path
+remains available for backend development until the standalone cutover.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import shutil
+import sys
+
+
+HERE = Path(__file__).resolve().parent
+MONOREPO_ROOT = HERE.parents[1]
+FIXTURES_ENV = "LAW_CODEGEN_TEST_FIXTURES"
+CORE_KIT_ENV = "LAW_CODEGEN_TEST_CORE_KIT"
+XLSX_ENV = "LAW_CODEGEN_TEST_XLSX"
+CANARIES_ENV = "LAW_CODEGEN_TEST_CANARIES"
+SEMANTIC_ENV = "LAW_CODEGEN_TEST_SEMANTIC"
+
+
+def _external(name: str) -> Path | None:
+    value = os.environ.get(name)
+    return Path(value).resolve() if value else None
+
+
+def fixture_root() -> Path:
+    root = _external(FIXTURES_ENV)
+    if root is None:
+        return MONOREPO_ROOT
+    manifest_path = root / "manifest.json"
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise RuntimeError(f"{FIXTURES_ENV}: fixture manifest unreadable") from exc
+    if manifest.get("format") != "law.codegen-fixtures/0.1":
+        raise RuntimeError(f"{FIXTURES_ENV}: unsupported fixture format")
+    listed = set()
+    for row in manifest.get("files") or []:
+        relative = row.get("path")
+        if not isinstance(relative, str) or not relative or Path(relative).is_absolute() or ".." in Path(relative).parts:
+            raise RuntimeError(f"{FIXTURES_ENV}: invalid fixture path")
+        path = root / relative
+        data = path.read_bytes()
+        if relative in listed or path.is_symlink() or row.get("bytes") != len(data) or row.get("sha256") != "sha256:" + hashlib.sha256(data).hexdigest():
+            raise RuntimeError(f"{FIXTURES_ENV}: invalid fixture inventory")
+        listed.add(relative)
+    required = {"runtime/runtime-cert.json", "data/backends-vectors.json"}
+    if not required <= listed:
+        raise RuntimeError(f"{FIXTURES_ENV}: incomplete fixture kit")
+    actual = {path.relative_to(root).as_posix() for path in root.rglob("*") if path.is_file()}
+    if actual != listed | {"manifest.json"}:
+        raise RuntimeError(f"{FIXTURES_ENV}: fixture inventory differs from files")
+    return root
+
+
+def vector(relative: str) -> Path:
+    root = fixture_root()
+    path = (root / "vectors" / relative) if _external(FIXTURES_ENV) else (root / "verify/vectors" / relative)
+    if not path.is_dir():
+        raise RuntimeError(f"test vector is absent: {relative}")
+    return path
+
+
+def materialize_core_kit(destination: Path, *, source_commit: str) -> dict:
+    """Create a test kit at *destination*, validating an exported source first."""
+    sys.path.insert(0, str(HERE))
+    import core_support
+    exported = _external(CORE_KIT_ENV)
+    if exported is not None:
+        source_manifest = core_support.validate_core_kit(exported)
+        shutil.copytree(exported, destination)
+        copied_manifest = core_support.validate_core_kit(destination)
+        if copied_manifest != source_manifest:
+            raise RuntimeError("copied core kit differs from validated export")
+        return copied_manifest
+    registry = MONOREPO_ROOT / "apps/registry"
+    if not registry.is_dir():
+        raise RuntimeError(f"{CORE_KIT_ENV} is required outside the monorepo")
+    sys.path.insert(0, str(registry))
+    import codegen_core_pack
+    codegen_core_pack.pack(destination, source_commit=source_commit)
+    return codegen_core_pack.validate(destination)
+
+
+def materialize_xlsx(destination: Path) -> Path:
+    """Copy a structurally validated XLSX delivery, or publish one in-tree."""
+    source = _external(XLSX_ENV)
+    sys.path.insert(0, str(HERE))
+    import check_xlsx
+    if source is not None:
+        _manifest, expected = check_xlsx.load(source)
+        check_xlsx.structural(source, expected)
+        shutil.copytree(source, destination)
+        _manifest, copied = check_xlsx.load(destination)
+        check_xlsx.structural(destination, copied)
+        return destination
+    tools = MONOREPO_ROOT / "verify/ci/tools"
+    if not tools.is_dir():
+        raise RuntimeError(f"{XLSX_ENV} is required outside the monorepo")
+    sys.path.insert(0, str(tools))
+    import export_codegen_xlsx
+    export_codegen_xlsx.export(destination)
+    return destination
+
+
+def materialize_canaries(destination: Path) -> Path:
+    """Copy a provenance-validated canary delivery, or publish one in-tree."""
+    source = _external(CANARIES_ENV)
+    sys.path.insert(0, str(HERE))
+    import check_active_canaries
+    if source is not None:
+        check_active_canaries.load(source)
+        shutil.copytree(source, destination)
+        check_active_canaries.load(destination)
+        return destination
+    tools = MONOREPO_ROOT / "verify/ci/tools"
+    if not tools.is_dir():
+        raise RuntimeError(f"{CANARIES_ENV} is required outside the monorepo")
+    sys.path.insert(0, str(tools))
+    import export_codegen_active_canaries
+    export_codegen_active_canaries.export(destination)
+    return destination
+
+
+def materialize_semantic_probes(destination: Path) -> Path:
+    """Copy a hash-validated semantic-probe delivery, or publish it in-tree."""
+    source = _external(SEMANTIC_ENV)
+    sys.path.insert(0, str(HERE))
+    import check_semantic_probes
+    if source is not None:
+        check_semantic_probes.load(source)
+        shutil.copytree(source, destination)
+        check_semantic_probes.load(destination)
+        return destination
+    tools = MONOREPO_ROOT / "verify/ci/tools"
+    if not tools.is_dir():
+        raise RuntimeError(f"{SEMANTIC_ENV} is required outside the monorepo")
+    sys.path.insert(0, str(tools))
+    import export_codegen_semantic_probes
+    export_codegen_semantic_probes.export(destination)
+    return destination
+
+
+def uses_exported_inputs() -> bool:
+    return _external(FIXTURES_ENV) is not None or _external(CORE_KIT_ENV) is not None

arxo_codegen/test_survey_inputs.py

@@ -0,0 +1,115 @@
+"""Bounded regression tests for the standalone survey CLI."""
+from __future__ import annotations
+
+import contextlib
+import io
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import survey
+
+
+def document(name: str, imports: list[str] | None = None) -> dict:
+    return {
+        "semanticVersion": "0.2.11", "schemaVersion": "law.core.ir/0.7",
+        "package": {"name": name, "namespace": f"urn:test:{name}", "version": "0.1"},
+        "imports": [{"package": {"name": dependency}} for dependency in imports or []],
+        "nodes": [],
+    }
+
+
+class SurveyInputsTests(unittest.TestCase):
+    def run_survey(self, args: list[str]) -> tuple[int, str, str]:
+        stdout, stderr = io.StringIO(), io.StringIO()
+        with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
+            try:
+                result = survey.main(args)
+            except SystemExit as error:
+                result = int(error.code)
+        return result, stdout.getvalue(), stderr.getvalue()
+
+    def write(self, root: Path, name: str, doc: dict) -> Path:
+        path = root / name
+        path.write_text(json.dumps(doc), encoding="utf-8")
+        return path
+
+    def test_explicit_dependencies_form_each_root_world(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            first = self.write(root, "first.lawir.json", document("first", ["dep-a"]))
+            second = self.write(root, "second.lawir.json", document("second", ["dep-b"]))
+            dep_a = self.write(root, "dep-a.lawir.json", document("dep-a"))
+            dep_b = self.write(root, "dep-b.lawir.json", document("dep-b"))
+            code, output, errors = self.run_survey([
+                str(first), str(second), "--dep", str(dep_a), "--dep", str(dep_b),
+            ])
+            self.assertEqual(0, code, errors)
+            self.assertIn("принят: first (first.lawir.json)", output)
+            self.assertIn("принят: second (second.lawir.json)", output)
+
+    def test_missing_dependency_is_a_named_refusal_without_discovery(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            program = self.write(root, "program.lawir.json", document("program", ["missing"]))
+            code, output, errors = self.run_survey([str(program), "--package", "program"])
+            self.assertEqual(0, code, errors)
+            self.assertIn("импорт без снимка CLIR в мире: missing", output)
+
+    def test_input_directory_is_bounded_and_report_uses_relative_name(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            inputs = root / "inputs"
+            nested = inputs / "nested"
+            nested.mkdir(parents=True)
+            self.write(inputs, "one.lawir.json", document("one"))
+            self.write(nested, "two.lawir.json", document("two"))
+            report = root / "report.md"
+            code, output, errors = self.run_survey(["--input-dir", str(inputs), "--report", str(report)])
+            self.assertEqual(0, code, errors)
+            self.assertIn("принят: one (one.lawir.json)", output)
+            self.assertIn("принят: two (nested/two.lawir.json)", output)
+            self.assertIn("`one` (one.lawir.json)", report.read_text(encoding="utf-8"))
+
+    def test_input_directory_forms_a_bounded_dependency_bundle(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary) / "inputs"
+            root.mkdir()
+            self.write(root, "a.lawir.json", document("a", ["b"]))
+            self.write(root, "b.lawir.json", document("b"))
+            code, output, errors = self.run_survey(["--input-dir", str(root)])
+            self.assertEqual(0, code, errors)
+            self.assertIn("принят: a (a.lawir.json)", output)
+            self.assertIn("принят: b (b.lawir.json)", output)
+
+    def test_duplicate_named_inputs_are_rejected_before_planning(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            self.write(root, "first.lawir.json", document("same"))
+            self.write(root, "second.lawir.json", document("same"))
+            code, _output, errors = self.run_survey(["--input-dir", str(root)])
+            self.assertEqual(2, code)
+            self.assertIn("неоднозначный CLIR пакета same", errors)
+
+    def test_no_input_is_an_argument_error(self):
+        code, _output, errors = self.run_survey([])
+        self.assertEqual(2, code)
+        self.assertIn("укажите CLIR-файлы", errors)
+
+    def test_explicit_corpus_root_preserves_legacy_discovery(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            clir = root / "corpus" / "clir"
+            clir.mkdir(parents=True)
+            self.write(clir, "legacy.lawir.json", document("legacy"))
+            code, output, errors = self.run_survey(["--corpus-root", str(root)])
+            self.assertEqual(0, code, errors)
+            self.assertIn("принят: legacy (corpus/clir/legacy.lawir.json)", output)
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen-0.4.0.dist-info/LICENSE

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