sphinx-traceability-view 1.0.0__tar.gz

sphinx_traceability_view-1.0.0/.gitignore

@@ -0,0 +1,28 @@
+docs/_build/
+.venv/
+__pycache__/
+.venv-implementation/
+frontend/node_modules/
+.pytest_cache/
+dist/
+*.egg-info/
+*.pptx
+
+# Routine logs; release execution records retain their linked evidence.
+*.log
+!docs/test-execution/**/*.log
+
+# Python build, coverage and local tool output.
+/build/
+*.py[cod]
+.coverage
+.coverage.*
+/coverage.xml
+/htmlcov/
+.ruff_cache/
+.mypy_cache/
+.tox/
+.nox/
+
+# Keep local security audit reports out of publication.
+/_security-audits/

sphinx_traceability_view-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Henning Heikes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sphinx_traceability_view-1.0.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: sphinx-traceability-view
+Version: 1.0.0
+Summary: Offline interactive views of a Sphinx-Needs traceability graph
+Author: Henning Heikes
+License-Expression: MIT AND ISC AND BSD-3-Clause AND Apache-2.0 AND EPL-1.0 AND EPL-2.0
+License-File: LICENSE
+License-File: src/sphinx_traceability_view/static/THIRD_PARTY_NOTICES.txt
+License-File: src/sphinx_traceability_view/static/vendor/ELK-SOURCE.txt
+Requires-Python: >=3.10
+Requires-Dist: beautifulsoup4==4.13.5
+Requires-Dist: sphinx-needs==8.2.0
+Requires-Dist: sphinx==8.1.3

sphinx_traceability_view-1.0.0/README.rst

@@ -0,0 +1,279 @@
+Interactive traceability view
+=============================
+
+Sphinx-Needs extension providing offline interactive traceability exploration.
+Requirements and architecture are indexed in ``docs/index.rst``.
+Project maturity and review records are maintained in ``docs/maturity.rst``.
+
+Build documentation
+-------------------
+
+Run the PowerShell script using the project's existing ``.venv`` (Python 3.11+ for documentation tooling).
+On the first run, install the pinned documentation dependencies and build::
+
+   .\build-docs.ps1 -InstallDependencies
+
+For subsequent builds::
+
+   .\build-docs.ps1
+
+The script works independently of the current working directory, treats Sphinx
+warnings as errors, and returns a nonzero exit code on failure. Successful output
+is written to ``docs/_build/html/index.html``. Virtual environment activation is
+not required.
+
+Each build uses a fresh staging directory. After success, it replaces the HTML
+tree and writes ``_stv-publication.json`` with file sizes and SHA-256 hashes.
+A failed build preserves the previous HTML tree. Earlier output and diagnostic
+staging are retained beside ``html`` under ``docs/_build/``; publish only the
+``html`` directory. Rebuilding into an existing output with a direct Sphinx
+command does not provide this clean-publication guarantee.
+
+The configuration imports the shared model, status-chart extension and styling
+directly, and includes the live central method. It discovers the shared skill
+under an ancestor's ``-agents/skills`` or ``~/.agents/skills``. To select another
+location, set ``REQUIREMENTS_SKILL_DIR`` to the shared
+``reverse-engineer-requirements`` skill directory. Its repository-level
+``method.md`` must also be present.
+
+After building, run the shared validator (replace ``<shared-skill>`` with the
+selected reverse-engineer-requirements skill directory)::
+
+   .\.venv\Scripts\python.exe <shared-skill>/scripts/validate_traceability.py docs/_build/html/needs.json --version <major.minor> --repo-root . --require-test-coverage --csv docs/_build/traceability.csv --test-csv docs/_build/test-traceability.csv
+
+The internal specification includes conventional and channeled derivation paths,
+allocations and containment. Graph validation establishes structural checks;
+it does not establish semantic correctness, internal design acceptance or
+successful runtime verification.
+
+Architecture diagrams
+---------------------
+
+Keep each .drawio source and its same-named .svg export together in
+``docs/architecture/diagrams``. Edit the Draw.io source and export SVG only::
+
+   & <shared-skill>/scripts/export-architecture.ps1 -ProjectRoot .
+
+Use the selected shared skill checkout directly. No project-local symbolic
+links or administrator rights for link creation are required.
+
+The export script uses Draw.io and restores portable links from each paired
+Draw.io source. It accepts ``-ProjectRoot`` and ``-DiagramDirectory`` for other
+project layouts. To validate the published targets after building::
+
+   .\.venv\Scripts\python.exe <shared-skill>/scripts/normalize-diagram-links.py --diagram-dir docs/architecture/diagrams --published-dir docs/_build/html
+
+Sphinx embeds the linked SVGs as interactive objects.
+
+Implementation handover
+-----------------------
+
+Start with ``docs/implementation-plan.rst`` for module contracts and delivery
+steps, ``docs/technology-stack.rst`` for selected libraries/versions/licenses,
+and ``docs/verification-plan.rst`` for completion gates. Exact npm manifests and
+lock are in ``docs/architecture/implementation``; Python direct implementation
+pins are alongside them. Runtime verification is tracked in ``docs/maturity.rst``.
+
+Build and use the extension
+---------------------------
+
+Maintainers build the checked-in browser assets and Python distribution::
+
+   cd frontend
+   npm.cmd ci
+   node build.js
+   cd ..
+   .\.venv-implementation\Scripts\python.exe -m build --no-isolation
+
+Install the generated wheel from ``dist/`` in the host's
+Python environment and add ``sphinx_traceability_view`` to ``extensions`` in
+``conf.py``. Node is needed only when rebuilding browser assets. Host types and
+relationships remain authoritative; see ``docs/internal-interfaces.rst`` for
+replacement model configuration. Embed a project root or explicit seeds::
+
+   .. traceability-view::
+
+   .. traceability-view:: NEED_A NEED_B
+
+Build the host with Sphinx's HTML builder. Open the output directly from disk
+or serve it through static HTTP. On Windows, keep the output root short enough
+that content-addressed detail paths stay below Firefox's local file-path limit.
+The project's documentation includes a live ``demo.html`` using its own Needs.
+
+Use in another Sphinx project
+-----------------------------
+
+See `Getting Started <docs/getting-started.rst>`_ for installation, the live
+demonstration and the minimal integration steps for an existing Sphinx project.
+The following sections provide additional host-model and compatibility details.
+
+Host model configuration
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+The default mapping expects exactly the five Need types ``shr``, ``sysr``,
+``syse``, ``swr`` and ``swe`` used by this project's requirements model.
+For other schemas, set ``traceability_view_model`` in the host's ``conf.py``.
+For example, a host defining types ``goal``, ``requirement`` and ``component``
+can use::
+
+   traceability_view_model = {
+       "levels": ["goals", "requirements", "components"],
+       "types": {
+           "goal": {"level": "goals", "role": "stakeholder"},
+           "requirement": {"level": "requirements"},
+           "component": {"level": "components"},
+       },
+       "accepted_statuses": ["accepted"],
+   }
+
+Map every configured host Need type, using its directive name as the key.
+Project-root mode requires a type with the ``stakeholder`` role. Test types
+use ``{"role": "test"}`` without a level. Adapt ``accepted_statuses`` to the
+host's status vocabulary. Relationships come from the host's ``needs_links``
+configuration and require both incoming and outgoing labels. See
+``docs/internal-interfaces.rst`` for the full interface contract.
+
+Current compatibility and delivery limits
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. stv-compatibility-start
+
+The current package requires Python 3.10 or newer and pins Sphinx 8.1.3,
+Sphinx-Needs 8.2.0 and Beautiful Soup 4.13.5. Check compatibility with the host's
+documentation dependencies before installation. Only the ``html`` builder is
+supported when a traceability view is present. Each view supports up to 200
+visible graph nodes. On Windows, use a short HTML output path when opening
+files directly in Firefox.
+
+.. stv-compatibility-end
+
+STV-owned code and documentation are licensed under MIT; see Licensing below.
+
+User issue handover
+-------------------
+
+Report issues in ``docs/problem-tickets/`` and keep screenshots/logs beside the report.
+The folder index and ``report.rst.template`` describe the format; informal text
+is also accepted for normalization by the problem solver. Reports use stable
+``problem_report`` Need IDs and ``new``, ``analyzed``, ``fixed`` states. Fixed
+reports remain in place, with evidence and any pending owner/release review.
+
+Development verification
+------------------------
+
+``scripts/normalize-diagram-links.py`` is a relative symbolic link to the
+shared ``-agents`` diagram utility. Keep that repository alongside this
+checkout. Make utility changes explicitly in the shared repository rather
+than editing through this link. The documentation and release workflow also
+depend on the shared method, model and tools as described above.
+
+Verify development changes::
+
+   .\.venv-implementation\Scripts\python.exe -m pytest -m "not browser"
+   node --test frontend/src/*/tests/*.test.js
+   .\.venv-implementation\Scripts\python.exe scripts/check-coverage.py --strict
+
+For Firefox verification set ``STV_GECKODRIVER`` to an explicitly provisioned
+driver and run ``pytest docs/test-scripts/test_browser.py`` in the implementation environment.
+The packaging test needs a built wheel and an offline runtime wheelhouse at
+``docs/_build/wheelhouse``. Source tests, release results and deferred criteria
+are linked from the central maturity page.
+
+The documentation's ``test-cases/index`` specifies canonical cases and their
+requirement links. Per-case execution records retain actual attempts, while
+``last_result`` shows each case's latest recorded outcome. Planned
+occurrence-mode cases remain unexecuted. Review acceptance and recorded test
+results are independent.
+
+For full qualification, select the shared skill explicitly (the release
+runner's legacy fallback predates the directory rename)::
+
+   $env:REQUIREMENTS_SKILL_DIR = '<shared-skill>'
+   .\.venv-implementation\Scripts\python.exe scripts/verify-release.py --record <new-record-name> --driver <provisioned-geckodriver>
+   .\.venv-implementation\Scripts\python.exe docs/test-execution/import-case-results.py <new-record-name>
+
+Replace the placeholders with the shared ``reverse-engineer-requirements``
+directory, a unique execution name and the provisioned driver path. Retain failed
+attempts. Import results only after the runner has finished; then rebuild and
+validate the published requirement/test/execution graph. Inspect the generated
+cleanup proposal and approve exact paths before deleting disposable output.
+
+Retain the entire ``dist/`` directory during cleanup, including wheels and
+source archives for current and older versions. The owner removes older
+versions manually after uploading them to GitHub. Copies retained as test
+evidence do not replace the distribution files in ``dist/``.
+
+
+Architecture-to-code navigation
+-------------------------------
+
+Each software element owns a directory named after the lowercase suffix of
+its canonical ``STV_SWE_*`` ID. Python build components live under
+``src/sphinx_traceability_view/``; browser components live under ``frontend/src/``.
+Each component contains its unit tests in ``tests/`` and a ``README.rst``
+explaining its boundary. ``docs/elements-software.rst`` identifies each element
+through its component and test naming conventions. Run all Python tests with ``python -m pytest``
+and browser-component unit tests with ``node --test frontend/src/*/tests/*.test.js``.
+Host integration, browser and release checks remain in ``docs/test-scripts/``.
+Component tests are excluded from the installed wheel.
+
+
+Licensing
+---------
+
+Copyright (c) 2026 Henning Heikes. STV-owned code and documentation are licensed
+under the MIT License. The standard terms are in the repository-root ``LICENSE``
+file and in the package license files. Credit to Henning Heikes and STV is
+appreciated; this is a request, not an additional license condition.
+
+Bundled third-party code retains its own licenses: Floating UI uses MIT,
+D3 components use ISC/BSD-3-Clause, and ELK.js uses EPL-2.0. The distribution's
+combined SPDX expression reflects these bundled components; it does not change
+the MIT license of STV-owned code. See ``THIRD_PARTY_NOTICES.txt`` and
+``vendor/ELK-SOURCE.txt`` in the packaged static assets. Generated views copy
+these notices and ``LICENSE.txt`` alongside their browser assets.
+
+The Sphinx documentation includes a Licensing page with the MIT text,
+third-party notices and upstream source-availability information. This license
+selection does not assert employer approval or resolve employment-related IP
+ownership; those questions remain separate from the repository license.
+
+Version maintenance
+-------------------
+
+The sole maintained STV version is ``src/sphinx_traceability_view/_version.py``.
+Hatch reads it for distributions; Sphinx configuration, extension metadata and
+the release runner derive their versions from it. The private frontend build
+is unversioned. Replace the validator example's ``<major.minor>`` with the
+documentation version. Historical release/review records and dependency versions
+are immutable evidence, not values to update during a version bump.
+
+Historical distributions
+------------------------
+
+Retained historical archives require the license supplement in
+``docs/licensing/historical/`` (project MIT license, full third-party notices,
+source references and archive hashes). Keep those materials with any copy.
+Historical artifacts remain evidence; their original bytes are unchanged and
+current documentation no longer offers them as binary downloads.
+
+Source archive contents
+------------------------
+
+The source distribution uses an explicit file allowlist in ``pyproject.toml``.
+It contains the Python implementation, prepared browser assets, editable browser
+sources, audited legal inputs, frontend lock/build files and Python build inputs.
+A wheel can be rebuilt from this archive without Node. Engineering documentation,
+execution history and local build/tool environments remain in the repository;
+they are not source-package inputs. Archive selection ignores VCS negations so
+retaining execution logs in Git cannot accidentally publish them in a package.
+
+Automated validation and provenance
+-----------------------------------
+
+GitHub workflows validate package/fixture changes with read-only tokens and
+immutable action pins. A separate manual main-branch workflow prepares
+checksummed candidate bytes and, for a public repository, build provenance.
+Neither workflow publishes a release. ``docs/ci-and-provenance.rst`` describes
+the check scope, verification commands and unapplied branch-protection proposal.
+Hosted runs and protection activation remain separate owner steps.

sphinx_traceability_view-1.0.0/conftest.py

@@ -0,0 +1,23 @@
+"""Collect stable executable identities and put requirement IDs in JUnit output."""
+import json
+from pathlib import Path
+
+
+def pytest_addoption(parser):
+    parser.addoption('--requirement-map', default=None, help='Write collected requirement/test metadata as JSON')
+
+
+def pytest_collection_finish(session):
+    target=session.config.getoption('--requirement-map')
+    if target:
+        cases=[]
+        for item in session.items:
+            ids=sorted({identity for marker in item.iter_markers('requirements') for identity in marker.args})
+            cases.append({'test':item.nodeid,'requirements':ids})
+        path=Path(target);path.parent.mkdir(parents=True,exist_ok=True)
+        path.write_text(json.dumps(cases,indent=2),encoding='utf-8')
+
+
+def pytest_runtest_setup(item):
+    ids=sorted({identity for marker in item.iter_markers('requirements') for identity in marker.args})
+    item.user_properties.append(('requirement_ids',','.join(ids)))

sphinx_traceability_view-1.0.0/frontend/build.js

@@ -0,0 +1,42 @@
+import {build} from 'esbuild';
+import {readFile,writeFile,mkdir,readdir} from 'node:fs/promises';
+import path from 'node:path';
+import {createHash} from 'node:crypto';
+const output='../src/sphinx_traceability_view/static';
+await mkdir(output,{recursive:true});
+const audit=JSON.parse(await readFile('legal/elk-inventory.json','utf8'));
+const elkBytes=await readFile('node_modules/elkjs/lib/elk.bundled.js');
+const elkMeta=JSON.parse(await readFile('node_modules/elkjs/package.json','utf8'));
+if(elkMeta.version!==audit.elkjs.version || createHash('sha256').update(elkBytes).digest('hex')!==audit.elkjs.sha256) throw Error('ELK dependency changed: renew the compiled-dependency audit before building');
+for(const name of audit.notice_files) {
+  const data=await readFile(`legal/${name}`);
+  if(createHash('sha256').update(data).digest('hex')!==audit.notice_sha256[name]) throw Error(`Audited legal input changed: ${name}`);
+}
+const built=await build({metafile:true,entryPoints:['src/render/index.js'],bundle:true,format:'iife',platform:'browser',target:['firefox115'],outfile:`${output}/stv.js`,legalComments:'eof',minify:true});
+await writeFile(`${output}/stv.css`,await readFile('src/render/stv.css'));
+const notices=[];
+// Derive npm attributions from the actual bundle inputs; do not maintain a
+// second dependency allowlist that silently omits newly bundled packages.
+const bundled=new Set(Object.keys(built.metafile.inputs).filter(p=>p.startsWith('node_modules/')).map(p=>{
+  const parts=p.split('/').slice(1);return parts[0].startsWith('@')?parts.slice(0,2).join('/'):parts[0];
+}));
+// esbuild also supplies generated runtime scaffolding.
+bundled.add('esbuild');
+for(const name of [...bundled].sort()) {
+  const base=`node_modules/${name}`;
+  const metadata=JSON.parse(await readFile(`${base}/package.json`,'utf8'));
+  notices.push(`${metadata.name} ${metadata.version} (${metadata.license})`);
+  const files=(await readdir(base)).filter(n=>/^(license|notice|copying)/i.test(n));
+  if(!files.length) throw Error(`No legal notice found for bundled dependency ${name}`);
+  for(const name of files) notices.push(await readFile(path.join(base,name),'utf8'));
+}
+notices.push('ELK compiled dependency inventory\n'+JSON.stringify(audit,null,2));
+for(const name of audit.notice_files) notices.push(name+'\n'+await readFile(`legal/${name}`,'utf8'));
+await writeFile(`${output}/THIRD_PARTY_NOTICES.txt`,notices.join('\n\n'));
+await mkdir(`${output}/vendor`,{recursive:true});
+await writeFile(`${output}/vendor/elk.bundled.js`,elkBytes);
+await writeFile(`${output}/vendor/ELK-INVENTORY.json`,JSON.stringify(audit,null,2)+'\n');
+// Legal inputs are maintained with the project, not regenerated as a source claim.
+await writeFile(`${output}/LICENSE.txt`,await readFile('../LICENSE'));
+const sourceNotice=await readFile(`${output}/vendor/ELK-SOURCE.txt`,'utf8');
+await writeFile(`${output}/THIRD_PARTY_NOTICES.txt`,notices.join('\n\n')+'\n\n'+sourceNotice);

sphinx_traceability_view-1.0.0/frontend/legal/Apache-2.0.txt

@@ -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.