roboscope-kit 0.8.0b1__tar.gz

roboscope_kit-0.8.0b1/.gitignore

@@ -0,0 +1,11 @@
+.DS_Store
+.pytest_cache/
+.ruff_cache/
+.venv/
+__pycache__/
+*.egg-info/
+build/
+dist/
+sdk-dist/
+.verify-sdk/
+.verify-download/

roboscope_kit-0.8.0b1/AUTHORS.md

@@ -0,0 +1,3 @@
+# Authors
+
+RoboScope Kit is developed and maintained by the RoboScope Team.

roboscope_kit-0.8.0b1/CHANGELOG.md

@@ -0,0 +1,345 @@
+# Changelog
+
+## 0.8.0b1 (Unreleased)
+
+- Rename the SDK to RoboScope Kit. Install it with `pip install roboscope-kit` (previously
+  `roboscope-inference-sdk`) and import it as `roboscope_kit` (previously `roboscope_inference_sdk`).
+  `importlib.metadata.version()` now takes `"roboscope-kit"`. No compatibility alias is provided.
+- Move the package source from `packages/roboscope-inference-sdk/` to `packages/roboscope-kit/`; image
+  Control Runtimes now live under `/opt/roboscope/control-runtime/packages/roboscope-kit/`.
+
+## 0.7.0b77 (Unreleased)
+
+- Add an opt-in CUDA MPS mode for Policy replicas: `--cuda-mps` on the
+  benchmark CLI and `run-benchmark.sh`, off by default. The runtime owns a
+  private MPS control daemon for the run, attaches every replica to it,
+  fails if a replica does not attach, terminates a replica's MPS clients
+  before signalling it, and records the session in `result.json`. Autotune
+  probes run under the same mode as the formal pass.
+
+## 0.7.0b76 (Unreleased)
+
+- Revert the MetaWorld runtime, autotune, native-reference and MPS changes
+  because they regressed the autotune algorithm. Restore the b59 runtime
+  and autotune behavior.
+
+## 0.7.0b59 (Unreleased candidate)
+
+- RoboTwin renders one observation per refresh. The evaluator loop now asks the
+  Policy client whether an observation is due, so steps at chunk or stride
+  boundaries no longer render twice and stride 1 matches the official cadence.
+- Keep the per-step observation cadence under randomized lighting, the viewer,
+  video logging and point-cloud observations, whose output or RNG stream depends
+  on every render.
+- The StarVLA official Policy declares its action horizon as its observation
+  stride, replacing the external stride-16 launcher wrapper.
+
+## 0.7.0b58 (Unreleased candidate)
+
+- Move PyPI upload, artifact-hash verification and clean-install verification to
+  GitHub Actions after the full compatibility gate.
+- Require Python 3.11 or newer for installation and runtime use; remove the
+  Python 3.8–3.10 compatibility tier and its CI/dependency branches.
+- Define maintained CPython support by the upstream lifecycle, currently
+  Python 3.11–3.15, and align package metadata and Ruff with that baseline.
+- Use Hatchling for wheel and source-distribution builds with SPDX metadata.
+- Select the locked Control Runtime NumPy wheel by its CPython/Linux tags so
+  simplified lockfile markers do not break official image bundle builds.
+- Gate changes on installed-artifact imports, the existing regression suites,
+  Python 3.11 API checks and the declared interpreter matrix in CI.
+- Retain strict zip length validation; remove the Python 3.8-only API workarounds
+  from this candidate. Older pinned simulator environments require separate
+  upgrade and image validation before adopting this SDK.
+
+## 0.7.0b50 (Beta)
+
+- Add reproducible builders for CALVIN, RoboCasa, RoboTwin and LIBERO+ runtimes.
+- Lock source revisions, asset checksums and the restored CALVIN dependency set.
+- Include RoboCasa kitchen/GR1 assets and RoboTwin embodiment path preparation
+  in their builders; use CALVIN's validation long-finger Panda configuration.
+- Align RoboTwin Quick Test preparation with its single-task workload.
+- Include all RoboTwin preparation scripts in the shared Control Runtime so its
+  source checksum matches the committed checkout.
+- Reuse the commit-pinned image bundle for offline RoboTwin preparation runtime
+  installation instead of downloading CPython and numpy again.
+
+## 0.7.0b49 (Beta)
+
+- Restore the validation long-finger Panda geometry in CALVIN runtime preparation.
+
+## 0.7.0b48 (Beta)
+
+- Cross-instance sharding is an opt-in Beta. SDK publication does not enable platform sharding
+  or promote any evaluation image to the official catalog.
+
+- Bound automatic shard counts by work-item capacity and reject invalid partitions before autotuning.
+- Validate shard protocol identity, per-item ownership and per-shard accounting before merging.
+- Accept MetaWorld evaluation configuration in the record-tree merge CLI.
+
+## 0.7.0b47
+
+- A shard run records the image's SDK version and evaluation kit commit (from the image manifest)
+  in its `shard.build`, and `merge_shard_results` refuses shards that ran different builds or do
+  not record one, naming each shard's build. The merged result carries the common build.
+- New `roboscope_inference_sdk.runtime.benchmark.suite_sizes.suite_total_records(benchmark, suite)`:
+  how many records one formal run of a suite produces, for callers that must split a run before any
+  instance exists (the platform sizes a sharded run from it instead of keeping its own copy).
+  Covers LIBERO, RoboTwin, CALVIN, RoboCasa and MetaWorld MT50 (50 tasks x 50 episodes).
+  `test_benchmark_suite_sizes` fails when the table drifts from the image manifests or the runtimes'
+  task lists, or when an image manifest is neither sized nor declared unsized. LIBERO+ has no fixed
+  size and returns `None`.
+
+## 0.7.0b46
+
+- New `roboscope_inference_sdk.runtime.benchmark.shard_reduce.merge_shard_results`: merges the
+  `result.json` of every shard into one result using only those documents, with no simulator,
+  benchmark factory or record tree on the merging machine. Coverage is established by accounting
+  (shard indexes exactly `0..N-1`, one benchmark/suite/protocol, record counts summing to the
+  `full_total_records` each shard recorded). `shard_merge` remains the record-level validator.
+- CALVIN and MetaWorld now support sharding. Their `aggregate()` demands the whole workload and
+  raised on a shard's subset, so a sharded run failed after the evaluation had finished. Sharded
+  runs now call an optional adapter `aggregate_partial()`, which reports raw per-sequence lengths
+  (CALVIN) or per-task counts (MetaWorld) and withholds metrics that are undefined on a subset
+  (`avg_seq_len`, `success_at_5`, the MetaWorld difficulty macro `score`). The official result is
+  derived after merging, where full coverage of every sequence or task is asserted. Single-instance
+  `aggregate()` still requires complete coverage.
+
+## 0.7.0b45
+
+- Cross-instance episode sharding for the benchmark runtime: `--shard-index` with
+  `--shard-count` (or workload-derived, one shard per `--shard-episodes` episodes)
+  deterministically partitions the formal evaluation pass across independent GPU
+  instances; autotune probes stay unsharded on every instance.
+- New `roboscope_inference_sdk.runtime.benchmark.shard_merge` module: validates the
+  shard partition (disjoint items, full coverage, terminal accounting) and merges
+  shard results with count metrics only, keeping per-shard rate metrics as provenance.
+- The legacy `testlog.txt` contract now counts a shard's own partition instead of the
+  full workload. It previously reported the unsharded total, so every sharded run
+  showed the whole suite as its denominator and then failed its completeness check
+  with `legacy protocol expected N results, received N/shards`.
+
+## 0.7.0b44
+
+- Add MetaWorld MT50 support to the official StarVLA Policy image: the
+  benchmark-name image preprocessing dispatch now covers `metaworld`, and the
+  official image declares the pinned StarVLA MetaWorld reference observation
+  pipeline (corner2, 480 render, 180-degree rotation, 2/3 center crop,
+  224x224 output) as its `benchmark_config.metaworld` default.
+- Ship the pinned upstream MetaWorld data registry (`metaworld_mt50` mixture
+  and `metaworld_robot` DataConfig) into the official image so StarVLA
+  MetaWorld checkpoints resolve their dataset mixture at Policy load; the
+  image install and verify scripts cover the installed file.
+
+## 0.7.0b43
+
+- Add the MetaWorld MT50 platform benchmark (`metaworld`, protocol
+  `metaworld-v1`, suite `mt50`). The SDK-native adapter reuses the pinned
+  upstream `metaworld.evaluation.evaluation` loop over one frozen
+  `MT50(seed=42)` training-goal artifact and scores the four-difficulty macro
+  average (`difficulty_macro_success_rate`).
+- MetaWorld observations come from the resolved evaluation config: one to four
+  configurable `uint8` camera features plus fixed `float32[4]` proprioception and
+  the verbatim official task instruction.
+- Add `--evaluation-config` to the unified benchmark runtime entrypoint. The
+  resolved configuration feeds both the evaluator workers and the Policy `load`
+  session, so both sides see the same observation features.
+- Bump the Policy process contract to `schema_version` 2 with an optional
+  `benchmark_config` declaration; readiness/preflight returns the declaration
+  without importing the Policy or loading a model.
+
+## 0.7.0b41
+
+- Restore shared-runtime archive timestamps after flushing extracted data on
+  AutoDL FS. Keep full tar comparison as the recovery acceptance gate for
+  benchmark runtimes and the shared Control Runtime.
+
+## 0.7.0b40
+
+- Shared-runtime rollout tooling: select one benchmark per operation, retain
+  the expanded runtime through end-to-end acceptance, and provide explicit
+  rollback and finalization. Preserve complete recovery archives and original
+  preparation scripts; reclaim the shared Control Runtime as a separate batch.
+- The production compaction rollout retains the existing b31 live manifests,
+  launchers and image runtime. This release changes operator tooling only.
+
+## 0.7.0b39
+
+- Revert the PI0.5 checkpoint-loading changes: restore the prior PI0.5 checkpoint loading and
+  normalizer lookup behavior. Retain the Python 3.10 timestamp import fix.
+
+## 0.7.0b38
+
+- Policy HIL: use `timezone.utc` for checkpoint timestamps so the SDK imports
+  successfully on Python 3.10.
+
+## 0.7.0b37
+
+- Policy HIL: resolve normalizer weights from the selected checkpoint's
+  declared preprocessing pipeline instead of assuming a fixed step index.
+
+## 0.7.0b36
+
+- Policy HIL: construct PI0.5 on empty parameters and assign safetensors directly
+  on the target device, avoiding random initialization and the subsequent full
+  checkpoint copy while retaining strict key and materialization checks.
+
+All notable user-visible changes to RoboScope Inference SDK releases are
+recorded here. Versions follow Semantic Versioning; the compatibility rules
+and release-owner responsibilities for the current Beta series are documented
+in `README.md`.
+
+## Unreleased
+
+- AutoDL shared runtimes: store the expanded RoboCasa, RoboTwin, and LIBERO+
+  runtime roots as verified zstd level-3 tar archives, extract the selected
+  runtime onto the instance-local expanded system disk, and keep the shared
+  Control Runtime installer workspace local. RoboTwin excludes retired image
+  and result trees from its cold-start payload. This releases the shared file
+  storage from its 200,000-inode design limit while minimizing transfer time.
+- Benchmark docs: remove the retired `docs/robotwin-vectorized-runtime.md`
+  archive and the redundant `docs/benchmark-results.html` mirror, and fold
+  the archived report's benchmark machine specification, bit-exact fidelity
+  verification, champion resource profile, and cache-grow/recycling analysis
+  into `docs/benchmark-results.md`.
+- Official image bundles now install and checksum the RoboTwin native/cache
+  paired verifier alongside the exact seed scanner used by formal generation.
+- RoboTwin runtime preparation: reconstruct the protocol-pinned pristine
+  checkout from committed Git objects for every run, apply the deterministic
+  Python 3.8 annotation patch as a fixed derived commit, attach large simulator
+  assets as read-only inputs, and generate each formal seed generation against
+  that clean checkout. The launcher now derives its complete evaluator
+  instrumentation from the pinned source instead of relying on manual
+  shared-disk patches.
+- Benchmark autotune: run every concurrency candidate against the same fixed,
+  representative workload and reject candidates whose success rate falls more
+  than 15% below the minimum safe-concurrency baseline. This keeps stateful
+  third-party Policies at the last correctness-preserving K/g pair.
+- Official runtime ownership: move the live StarVLA LIBERO runtime under
+  `benchmarks/libero_official` and remove the obsolete benchmark-autotune
+  examples tree and retired JSON evidence.
+- Policy action contracts: every Policy declares one action representation per
+  supported Benchmark. The runtime validates the identifier and requires all
+  loaded replicas to resolve the same contract before evaluation starts.
+- Benchmark action routing: RoboTwin and CALVIN adapters translate the
+  negotiated action contract into their official worker execution modes.
+- RoboTwin observation cadence: Policies may declare a positive observation
+  stride. Every inference boundary refreshes the current observation, and the
+  resolved value and source are recorded in execution metadata.
+- Benchmark protocol manifests: schema version 2 carries benchmark-owned,
+  versioned protocol definitions. RoboTwin pins its runtime, scanner source,
+  suite seed selection, episode count, horizon, success rule, and aggregation.
+- Immutable RoboTwin seed generations: the SDK can create and validate
+  content-addressed cache directories whose manifest covers every task pickle,
+  runtime source, scanner source, task configuration, and seed-selection rule.
+- Formal RoboTwin runs now select one immutable seed generation by digest,
+  validate its full 50-task identity before workers start, and record the
+  protocol and generation identities in result metadata.
+- RoboTwin cache provenance tooling now ships the exact scanner source in the
+  official bundle and provides a paired native/cache episode-state verifier.
+- Documentation and examples: classify model-specific custom-image validation
+  demos as internal engineering evidence, separate from the official image
+  catalog and product support matrix.
+- RoboTwin full runs: split each task into manifest-sized episode windows and
+  interleave windows across tasks. Records retain their canonical per-task
+  episode indices and seed-cache entries, while idle workers can take later
+  windows from long-horizon tasks instead of waiting for one worker to finish
+  all 100 episodes.
+- RoboTwin cached evaluation: count a cached episode whose real scene setup is
+  unstable as a zero-step failure and continue to the next canonical cache
+  entry. The runtime no longer retries the same randomized seed forever or
+  substitutes a different seed to complete the requested episode count.
+- RoboTwin persistent sessions: apply worker-static seed-cache and video
+  settings before launcher startup. Seed-cache-only planner setup is now
+  enabled in session mode, and `--disable-video` no longer starts per-episode
+  ffmpeg processes. Each completed window also closes its task-scoped Policy
+  socket instead of accumulating idle client threads for the life of the
+  launcher.
+- Benchmark process lifecycle: make SDK-managed processes own their complete
+  process group and keep RoboTwin evaluator sessions inside the worker group,
+  so a rejected or timed-out autotune candidate fully releases simulator GPU
+  contexts before the next candidate or formal evaluation starts. OOM
+  classification now scans the complete diagnostic tail instead of losing an
+  earlier CUDA allocation failure behind a final secondary traceback.
+- Benchmark autotune: bound every real-episode candidate to 15 minutes and the
+  complete tuning phase to 30 minutes, reject OOM/Worker-failure candidates as
+  soon as the runtime observes them, and atomically persist accepted, rejected,
+  timed-out, and running candidate state so the platform can audit partial
+  tuning progress. A rejected or timed-out candidate falls back to the last
+  healthy K/g selection instead of failing the formal evaluation.
+- RoboTwin worker/launcher: add an opt-in persistent evaluation session
+  (`--eval-session`, enabled automatically for full runs with a seed cache)
+  that keeps one launcher process alive across task work items. Combined with
+  the new shared CuroboPlanner patch, the EE path pays cuRobo planner
+  construction once per worker instead of once per task; a crashed task ends
+  the session and the next task starts in a fresh process.
+- RoboTwin launcher: skip the expert-only batch cuRobo `MotionGen` warmup
+  during planner construction when the EE path runs with a seed cache. The
+  batch instance is only reachable through the expert `play_once` grasp
+  search, which the cache replaces, so its warmup is pure per-task planner
+  construction overhead; `plan_single` EE planning semantics are unchanged.
+- RoboTwin launcher: add the explicit image-owned `ROBOTWIN_ACTION_TYPE=ee`
+  path for compact dual-arm end-effector actions while keeping qpos as the
+  platform default. EE execution uses the official `take_action(...,
+  action_type="ee")` and cuRobo planner even with a seed cache.
+- CALVIN worker: add the image-owned `CALVIN_ACTION_TYPE=absolute` opt-in that
+  reconstructs an absolute `(pos, quat_xyzw, grip)` tuple from a compact 7-dim
+  action chunk, validating the quaternion xyz norm and rebuilding the
+  non-negative `w`. The platform default stays the native relative 7-dim
+  action contract.
+- LIBERO runtimes: prepare LIBERO and LIBERO+ with run-local configuration and
+  verify package, SDK worker, and benchmark asset paths in the actual simulator
+  Python before evaluation. Shared simulator environments remain immutable and
+  no longer depend on a baked LIBERO+ configuration path.
+- Policy server: default `TORCHINDUCTOR_CUDAGRAPHS=0` on every policy replica
+  process. Several simulator workers share one torch.compile policy
+  replica; concurrent first-inferences of different input shapes each trigger a
+  new CUDA Graph capture, and capture is device-level exclusive, so the workers
+  collide with `beginAllocateToPool: already recording to mempool_id`. Disabling
+  inductor cudagraph trees removes the capture session while keeping the
+  compiled Triton kernels, so there is no measurable throughput loss on eval
+  workloads. Callers can opt back in by setting `TORCHINDUCTOR_CUDAGRAPHS`
+  explicitly in the adapter environment.
+- RoboTwin worker: a non-OOM native evaluator failure with a positive exit
+  code is recorded as a terminal failed item (episodes completed before the
+  crash are kept and the remainder counted as failures) so the worker continues
+  with the next task instead of aborting the whole evaluation pass. OOM and
+  signal-terminated exits still restart the worker.
+
+## 0.7.0b5 - 2026-08-14
+
+- RoboTwin launcher: when episode cleanup (`end_episode`) fails while a Policy
+  failure is already propagating, keep the original Policy exception as the
+  top-level error and drop the cleanup failure instead of letting it replace
+  the root cause in the native log tail.
+- CALVIN worker: when episode cleanup fails after a failed sequence, keep the
+  original `evaluate_sequence` Policy exception and traceback as the top-level
+  failure and attach the cleanup error as its diagnostic cause instead of
+  letting the cleanup error replace it.
+
+## 0.7.0b3 - 2026-08-14
+
+- Publish the SDK directly to PyPI. The unused TestPyPI gate is removed.
+  Runtime is unchanged from 0.7.0b2.
+
+## 0.7.0b2 - 2026-08-13
+
+- RoboTwin runtime patch: select the episode instruction from the per-episode
+  seeded `random` stream instead of the unseeded NumPy global RNG, so identical
+  seeds yield identical instructions.
+
+## 0.7.0b1 - 2026-08-13
+
+- Remove the retired experimental RoboTwin vectorized runtime from official
+  base-image bundles and preserve its design and benchmark report as archived
+  documentation.
+
+## 0.6.8b2 - 2026-08-13
+
+- Scale down only the newest evaluator worker after an OOM and retry the
+  interrupted work at the reduced concurrency.
+
+## 0.6.8b1 - 2026-08-12
+
+- Preparing the first production PyPI release.
+
+Earlier `0.x` versions were internal image and TestPyPI builds.

roboscope_kit-0.8.0b1/LICENSE

@@ -0,0 +1,203 @@
+Copyright 2026 RoboScope Team
+
+                                 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.