intempt 1.0.0__tar.gz

intempt-1.0.0/.github/workflows/e2e.yml

@@ -0,0 +1,76 @@
+# Contract test against a real Intempt environment.
+#
+# Everything else in CI is offline: the unit suite runs against a loopback
+# recording server. That proves the SDK sends what it intends to; it cannot prove
+# the API accepts it. This job is the only thing that does.
+#
+# It is not on the PR path, because it writes real events into a real project and
+# needs a credential. Run it manually, or let the nightly schedule catch drift in
+# the ingestion contract.
+#
+# Required repository secrets:
+#   INTEMPT_E2E_API_KEY    a PUBLIC key for a throwaway staging project
+#   INTEMPT_E2E_ORG
+#   INTEMPT_E2E_PROJECT
+#   INTEMPT_E2E_SOURCE_ID
+# Optional but strongly recommended:
+#   INTEMPT_E2E_USER_ID    a stable pre-existing test profile, so runs do not
+#                          create a new throwaway profile every night
+#   INTEMPT_E2E_ACCOUNT_ID a stable test account
+#   INTEMPT_E2E_HOST       defaults to api.staging.intempt.com if unset
+#   INTEMPT_E2E_FEED_ID    a real feed id; recommend skips without it
+#   INTEMPT_E2E_PRODUCT_ID an id that exists in the catalog
+#
+# The same secret names as the Node SDK on purpose: one set of staging
+# credentials serves all three server SDKs, and the three contract tests run the
+# same steps so a divergence shows up as a different table.
+name: E2E (staging)
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '20 6 * * *'
+
+permissions:
+  contents: read
+
+jobs:
+  e2e:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
+
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+        with:
+          python-version: '3.12'
+
+      - run: pip install -e .
+
+      # Skip rather than fail when the secret is absent, so a fork or a repo
+      # without staging credentials does not show a permanently red schedule.
+      - name: Check for credentials
+        id: creds
+        env:
+          KEY: ${{ secrets.INTEMPT_E2E_API_KEY }}
+        run: |
+          if [ -z "$KEY" ]; then
+            echo "::warning::INTEMPT_E2E_API_KEY is not set; skipping the E2E contract test."
+            echo "present=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "present=true" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Run contract test
+        if: steps.creds.outputs.present == 'true'
+        env:
+          INTEMPT_E2E_HOST: ${{ secrets.INTEMPT_E2E_HOST || 'api.staging.intempt.com' }}
+          INTEMPT_E2E_ORG: ${{ secrets.INTEMPT_E2E_ORG }}
+          INTEMPT_E2E_PROJECT: ${{ secrets.INTEMPT_E2E_PROJECT }}
+          INTEMPT_E2E_API_KEY: ${{ secrets.INTEMPT_E2E_API_KEY }}
+          INTEMPT_E2E_SOURCE_ID: ${{ secrets.INTEMPT_E2E_SOURCE_ID }}
+          INTEMPT_E2E_USER_ID: ${{ secrets.INTEMPT_E2E_USER_ID }}
+          INTEMPT_E2E_ACCOUNT_ID: ${{ secrets.INTEMPT_E2E_ACCOUNT_ID }}
+          INTEMPT_E2E_FEED_ID: ${{ secrets.INTEMPT_E2E_FEED_ID }}
+          INTEMPT_E2E_FEED_FIELDS: ${{ secrets.INTEMPT_E2E_FEED_FIELDS }}
+          INTEMPT_E2E_PRODUCT_ID: ${{ secrets.INTEMPT_E2E_PRODUCT_ID }}
+        run: python scripts/e2e.py

intempt-1.0.0/.github/workflows/release.yml

@@ -0,0 +1,80 @@
+# Publishes to PyPI, only on a version tag.
+#
+# Mirrors the Node SDK's release workflow, including the guard that cost that
+# package 21 months of silence: a tag that disagrees with the version in the
+# source puts a mislabelled artifact on the index forever, and PyPI will not let
+# you replace it.
+#
+# Authenticates with an API token in `PYPI_API_TOKEN`, not Trusted Publishing.
+# Trusted Publishing (OIDC) is the better default — nothing to leak, nothing to
+# rotate — and the switch is a small one if it is ever preferred: drop the `with:`
+# block below, add `id-token: write`, and register a pending publisher on PyPI for
+# owner `intempt`, repo `intempt-python`, workflow `release.yml`, environment
+# `pypi`.
+#
+# The token starts account-scoped, because a project-scoped token cannot be
+# created for a project that does not exist yet. Narrow it to the `intempt`
+# project after the first successful upload — an account-scoped token can publish
+# to every project the owner has, which is more authority than this job needs.
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+
+permissions:
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: write   # create the GitHub Release
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+        with:
+          python-version: '3.12'
+
+      - run: pip install -e ".[dev]" build
+
+      # The same gates the PR runs. A release is not the place to find out the
+      # suite is red.
+      - run: ruff check .
+      - run: ruff format --check .
+      - run: mypy
+      - run: pytest --cov --cov-report=term-missing --cov-fail-under=90
+
+      - name: Verify the tag matches the packaged version
+        run: |
+          TAG="${GITHUB_REF_NAME#v}"
+          PKG="$(python -c 'import re,pathlib; print(re.search(r"__version__\s*=\s*\"([^\"]+)\"", pathlib.Path("src/intempt/__init__.py").read_text()).group(1))')"
+          if [ "$TAG" != "$PKG" ]; then
+            echo "::error::Tag $GITHUB_REF_NAME does not match __version__ $PKG"
+            exit 1
+          fi
+          echo "version $PKG"
+
+      - run: python -m build
+
+      # Refuses malformed metadata before anything is uploaded, which is the
+      # only chance to catch it: PyPI accepts a bad long_description and then
+      # renders it as plain text on the project page permanently.
+      - run: pip install twine && twine check dist/*
+
+      - uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}
+
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh release create "$GITHUB_REF_NAME" \
+            --title "$GITHUB_REF_NAME" \
+            --generate-notes

intempt-1.0.0/.github/workflows/tests.yml

@@ -0,0 +1,80 @@
+name: Tests
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        # Every runtime `requires-python = ">=3.9"` promises, not a sample of
+        # them. Testing 3 of 6 CPython versions meant 3.10, 3.12 and 3.14 were
+        # supported on paper and never executed. PyPy is here because the SDK
+        # has no dependencies and no C extensions, so it should work — and if it
+        # does not, that is worth knowing rather than assuming.
+        python: ['3.9', '3.10', '3.11', '3.12', '3.13', '3.14', 'pypy3.11']
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+        with:
+          python-version: ${{ matrix.python }}
+      - run: pip install -e ".[dev]"
+      - run: ruff check .
+      - run: ruff format --check .
+      # mypy refuses to run on PyPy ("Running mypy on PyPy is not supported yet").
+      # Skipping the step rather than the runtime: type checking on one
+      # interpreter is enough, and the point of the PyPy job is to exercise the
+      # SDK there, which it could not do while this step failed the whole matrix
+      # entry before the suite ran.
+      - run: mypy
+        if: "!startsWith(matrix.python, 'pypy')"
+      - run: pytest --cov --cov-report=term-missing --cov-fail-under=90
+
+  mutation:
+    # Pinned to one version on purpose. The mutants do not vary by runtime, so
+    # running this across the matrix triples a multi-minute job for no signal.
+    #
+    # 3.12 specifically: mutmut needs libcst, and libcst has no prebuilt wheel
+    # for 3.14 yet, so it tries to compile Rust and fails.
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
+      - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+        with:
+          python-version: '3.12'
+      - run: pip install -e ".[dev,mutation]"
+      - name: Mutation score
+        # 70, not the 85 the Node SDK uses, because the two numbers are not
+        # comparable. Stryker and Infection leave string literals alone by
+        # default; mutmut rewrites every one of them twice — "track" becomes
+        # "XXtrackXX" and "TRACK" — so it generates 1524 mutants for 1404 lines
+        # of source. 240 of the survivors are log-message text and internal
+        # labels nothing reads.
+        #
+        # Measured on the same commit, same suite:
+        #
+        #     Node    Stryker    85.84%
+        #     PHP     Infection  95%      (covered-code MSI 99%)
+        #     Python  mutmut     72.48%
+        #
+        # Raising this past ~75 means asserting the exact wording of every log
+        # line, which buys a number and costs a suite that fails on a reworded
+        # message. The rejection messages are already asserted in full, in
+        # tests/test_messages.py, because those are a contract callers see.
+        #
+        # 70 sits ~2.5 points under the measured score: low enough to be green,
+        # tight enough that a real regression trips it.
+        run: python scripts/mutation_gate.py --threshold 70
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        if: always()
+        with:
+          name: mutation-report
+          path: mutants/
+          retention-days: 14

intempt-1.0.0/.gitignore

@@ -0,0 +1,23 @@
+__pycache__/
+.coverage
+.mutlogs/
+.mutmut-cache
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.venv-mut/
+.venv/
+.venv312/
+*.egg-info/
+*.py.bak
+*.py[cod]
+build/
+dist/
+htmlcov/
+mutants/
+mutation-summary.json
+setup.cfg
+
+# Local staging credentials for scripts/e2e.*  Never commit: these repos are public.
+.env.local
+.env

intempt-1.0.0/ARCHITECTURE.md

@@ -0,0 +1,156 @@
+# Server SDK architecture
+
+One contract, three implementations: `intempt-node`, `intempt-python`, `intempt-php`.
+
+This file is the same in all three repos. Change it in one, change it in all, or the
+SDKs drift and a customer switching languages gets different delivery semantics for
+the same call.
+
+## Where this came from
+
+The shape is derived from [mixpanel-node] / [mixpanel-python] / [mixpanel-php]: the
+consumer/buffer split, the chunking, the keep-alive connection reuse and the bounded
+concurrency are theirs. Both projects are Apache 2.0 and this one retains their
+notices; see `NOTICE`.
+
+What is **not** inherited is the delivery guarantees. mixpanel-node has no request
+timeout, no retry, and discards errors when no callback is passed
+(`lib/mixpanel-node.js:80`, `callback = callback || function () {}`). mixpanel-python
+is stronger — it has real backoff — but its retry policy is still not ours. Every
+guarantee below was added deliberately.
+
+[mixpanel-node]: https://github.com/mixpanel/mixpanel-node
+[mixpanel-python]: https://github.com/mixpanel/mixpanel-python
+[mixpanel-php]: https://github.com/mixpanel/mixpanel-php
+
+## The surface
+
+Identical across all three, allowing for language idiom (`snake_case` in Python,
+`camelCase` in Node/PHP).
+
+| call | endpoint |
+| ---- | -------- |
+| `track(event, options)` | `POST …/sources/{sourceId}/track` |
+| `track_batch(events)` | same, chunked at `max_request_events` |
+| `identify(options)` | same, reserved event `Identify` |
+| `group(options)` | same, reserved event `Identify` |
+| `alias(options)` | same, reserved event `Identify` |
+| `consent.grant(options)` / `consent.revoke(options)` | `POST …/consents/data` |
+| `ecommerce.product_viewed / added_to_cart / ordered` | `POST …/track` |
+| `recommend(options)` | `POST …/feeds/{feedId}/data` |
+| `opt_in()` / `opt_out()` / `is_opted_in()` | — |
+| `flush()` / `close()` | — |
+| `set_config(patch)` / `config` / `buffered` | — |
+
+Base path is `{path}/v1/{org}/projects/{project}`. Without a `source_id` the track
+path is `…/track` rather than `…/sources/{id}/track`.
+
+### Deliberately absent
+
+- **Experiments and personalizations.** They resolve a web experience against a page.
+  A server has no page. These belong to the browser SDK.
+- **`profile_id` and `master_id`.** `profile_id` is the anonymous id the browser SDK
+  mints on the device; a server that invents one creates an orphan profile that never
+  stitches to a real visitor. `master_id` is assigned internally after identity
+  resolution, cannot be read from here, and breaks the moment two profiles merge.
+  The only identifiers are `user_id` and `account_id`, both values the caller owns.
+- **Console and configuration operations.** Journeys, dashboards, segments and brand
+  belong to the CLI and MCP server, not to a data-plane SDK.
+
+## Delivery guarantees
+
+### Errors surface. Nothing is swallowed
+
+Every method raises/rejects on failure. No callback-swallow, no silent discard. This
+is the single biggest departure from mixpanel-node.
+
+### Retry policy
+
+| response | behaviour |
+| -------- | --------- |
+| 413, batch > 1 | halve the batch width, retry |
+| 413, batch = 1 | drop the event, log it, return the width to full |
+| 429 | honour `Retry-After`, else exponential backoff |
+| 5xx, 408, timeout | exponential backoff, floored at 100ms, capped at 10 min |
+| other 4xx | drop the batch, log status and body |
+| 5 consecutive failures | stop batching, report how many events are stranded |
+| 3 consecutive 413 drops | say the gateway body limit is the likely cause, once |
+
+Two width rules that are easy to get wrong, and were:
+
+1. **A reduced width must recover.** Compare successes against the *current* width,
+   not the full width — `batch` is sliced to the current width, so a comparison
+   against full is unreachable and the reduction becomes permanent. Widen by doubling
+   after 10 consecutive successful sends that filled the width.
+2. **The drop tally must not change behaviour.** It is diagnostic only. Stopping on it
+   strands the queue; pinning the width to 1 on it caps throughput to one event per
+   round trip and loses more events than it saves requests.
+
+### Timestamps
+
+Client timestamps are honoured by the platform between 2010 and 2040. Below
+`LOW_TIMESTAMP_LIMIT` the request is rejected; **above `UP_TIMESTAMP_LIMIT` the server
+silently replaces the value with its own clock**. Send milliseconds. `/track` is
+milliseconds, `/consents/data` is **seconds** — the consent path divides.
+
+### Platform ids are strings, never numbers
+
+A 19-digit snowflake exceeds every language's safe integer range.
+`Number("1841710181319290880")` rounds to `1841710181319290900` and addresses a
+different source. Never coerce an id numerically, in any language, at any layer.
+
+### Delivery is at-least-once
+
+Ingestion has no idempotency key. `event_id` travels in the payload but is not a
+column in the events table, and the table is a plain `MergeTree` — nothing collapses
+duplicates. A retry after a lost response therefore duplicates rows. Say so in the
+README rather than letting callers infer exactly-once from the retry table.
+
+### close() is bounded
+
+`close()` drains for at most 30 seconds, then stops retrying and logs how many events
+it abandoned. Unbounded, a shutdown hook blocks for minutes against a failing
+endpoint. `flush()` is **not** bounded — a caller who is not shutting down has not
+asked to give up.
+
+Enforce the deadline in two places, because one leaks: before starting a backoff (the
+first wait alone can exceed the whole budget) and at the top of each drain iteration
+(sends that succeed but are slow never reach the backoff check).
+
+### opt-out gates buffered events too
+
+The gate lives in the send path, not only at the call site. Otherwise events captured
+before `opt_out()` are still transmitted by a later `flush()`, `close()` or exit hook,
+and a consent revocation between capture and flush is not honoured.
+
+## Quality bar
+
+Every implementation ships with:
+
+| gate | threshold |
+| ---- | --------- |
+| unit tests, HTTP intercepted | full method surface |
+| integration tests, real socket | framing, keep-alive, timeout, concurrency |
+| statement coverage | 100% |
+| mutation score | **≥ 85%, enforced in CI as its own job** |
+| lint + format + type check | clean, tests included in the type check |
+| contract test against production | every method, negative controls included |
+
+Mutation testing is not optional decoration. On the Node SDK it found two defects that
+100% statement coverage did not: a 413 that permanently halved throughput because the
+recovery condition was unreachable, and four dead conditionals that could not fail.
+It also found three assertions that were green and asserted nothing.
+
+Read the mutation score from CI, never from a developer machine. A timed-out mutant is
+scored as killed, so a loaded laptop inflates the number — 86.19% locally against
+84.70% on CI for the same commit, with a gate at 85.
+
+## Contract test inputs
+
+Every id must be real. Ingestion returns **201 for unknown accounts and products**, so
+a fabricated `product_id` is a green test that proves nothing. Any missing input makes
+its step SKIP, never silently pass.
+
+Read endpoints need a negative control. A missing feed and a real feed with no matches
+both answer 200 with an empty array, so an empty result proves nothing on its own. A
+bogus feed id answers 400, and that is what makes the 200 meaningful.

intempt-1.0.0/CHANGELOG.md

@@ -0,0 +1,43 @@
+# Changelog
+
+## 1.0.0 — unreleased
+
+First release. Server-side SDK, Apache 2.0, derived from mixpanel-python; see
+[NOTICE](./NOTICE) for what was taken and what changed.
+
+### The surface
+
+`track`, `track_batch`, `identify`, `group`, `alias`, `consent.grant/revoke`,
+`ecommerce.product_viewed/added_to_cart/ordered`, `recommend`,
+`opt_in`/`opt_out`/`is_opted_in`, `flush`, `close`, `set_config`, `config`,
+`buffered`.
+
+Identical to `intempt-node` and `intempt-php` allowing for language idiom, so a
+customer switching languages gets the same delivery semantics for the same call.
+The shared contract is in [ARCHITECTURE.md](./ARCHITECTURE.md).
+
+### Deliberately absent
+
+- **Experiments and personalizations.** They resolve a web experience against a
+  page, and a server has no page. Browser SDK territory.
+- **`profile_id` and `master_id`.** The only identifiers are `user_id` and
+  `account_id`, both values the caller already owns.
+- **Console and configuration operations.** Journeys, dashboards, segments and
+  brand belong to the CLI and MCP server.
+
+### Delivery guarantees
+
+- Every method raises on failure. Nothing is swallowed.
+- Retry policy: 413 halves the batch width and recovers by doubling after ten
+  full-width successes; 429 honours `Retry-After`; 5xx/408/timeout back off
+  exponentially, floored at 100ms and capped at 10 minutes; other 4xx drop the
+  batch; five consecutive failures stop batching and report what is stranded.
+- `close()` is bounded at 30 seconds and says how many events it abandoned.
+  `flush()` is unbounded.
+- Opt-out is enforced in the send path, so events buffered before `opt_out()`
+  are discarded rather than transmitted by a later flush.
+- A platform id never goes through `int()`. A 19-digit snowflake exceeds float
+  precision and a numeric round trip addresses a different source.
+- Consent timestamps are epoch **seconds**; `/track` is milliseconds.
+- Delivery is at-least-once. Ingestion has no idempotency key, so a retry after
+  a lost response duplicates rows.

intempt-1.0.0/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.