freshctx 0.1.0__tar.gz

freshctx-0.1.0/API.md

@@ -0,0 +1,134 @@
+# FreshCtx Python API contract
+
+Status: frozen v0.1 release-candidate contract.
+
+## `guard()`
+
+```python
+guard(
+    policy: str = "block",
+    store: Store | None = None,
+    run_id: str | None = None,
+    audit_path: str | Path = ".freshctx/audit.jsonl",
+) -> Guard
+```
+
+Creates a run-local enforcement context. Nested guards are permitted only when their dependencies remain isolated. On successful context exit, the guard checks the most recently protected subject. If no subject was protected, it exits without a freshness evaluation.
+
+Supported policies:
+
+- `block`: raise `FreshnessBlocked` for any non-current result.
+- `warn`: emit `RuntimeWarning` and permit exit.
+- `allow`: permit exit and retain the non-current audit result.
+- `refresh`: invoke one registered callback, recheck once, and block unless the replacement subject becomes current.
+
+`Guard.result` contains the final `CheckResult` after automatic enforcement.
+
+## `observe()`
+
+```python
+observe(
+    locator: str | PathLike,
+    adapter: str | None = None,
+    **options: object,
+) -> ObservationToken
+```
+
+Requires an active guard. If `adapter` is omitted, v0.1 selects `filesystem`. The adapter observes the source, the token is persisted, and an audit event is emitted.
+
+Current adapter options:
+
+```python
+observe("config.yaml")
+observe("/repo", adapter="git", scope="repository")
+observe("/repo", adapter="git", scope="path", path="config.yaml", ref="HEAD")
+observe("config.yaml", root=".", max_file_bytes=16 * 1024 * 1024)
+```
+
+Unknown adapters raise the public `ConfigurationError` exception.
+
+## `reasoning()`
+
+```python
+reasoning(
+    kind: str,
+    depends_on: Iterable[ObservationToken | ReasoningNode | ReasoningContext | str],
+    metadata: dict | None = None,
+) -> ReasoningContext
+```
+
+Requires an active guard when the context exits. A successful exit persists one `ReasoningNode`. An exceptional exit does not create a valid node. The completed context may be supplied to `depends_on`; using it before completion raises `FreshCtxError`.
+
+The digest is SHA-256 of canonical JSON over domain `freshctx.reasoning-digest.v1`, reasoning kind, sorted/deduplicated dependency IDs, and redacted metadata. Metadata keys must be strings; dictionary and set ordering are canonical, sets are stored as sorted lists, list ordering is meaningful, and unsupported or non-finite values raise `ConfigurationError`. It stores no raw prompts, hidden reasoning, model output, or source content. The digest identifies the declared reasoning inputs within this contract; it is not a signature, authorization decision, tamper-proof evidence, or proof of correctness. Source freshness always comes from adapter revalidation.
+
+## `Guard.protect()`
+
+```python
+Guard.protect(
+    value: object = None,
+    *,
+    depends_on: Iterable[dependency],
+    boundary: str = "output",
+) -> object
+```
+
+Registers a protected output or action. When one dependency is supplied, it becomes the subject directly. Multiple dependencies create a synthetic boundary node. The input `value` is returned unchanged.
+
+Call `protect()` immediately before the real side effect when possible. Guard exit enforcement cannot prevent a side effect that already happened inside the context.
+
+## `Guard.run()`
+
+```python
+Guard.run(
+    action: Callable,
+    *args: object,
+    depends_on: Iterable[dependency],
+    boundary: str = "action",
+    refresh: Callable[[CheckResult], dependency | None] | None = None,
+    **kwargs: object,
+) -> object
+```
+
+This is the required API for protected side effects. It resolves freshness and records the allow decision before invoking `action`. Under `block` or `refresh`, a non-current result or required audit failure raises `FreshnessBlocked` and the callable is not invoked. Refresh is attempted at most once.
+
+## `Guard.check()`
+
+```python
+Guard.check(subject: dependency | None = None) -> CheckResult
+```
+
+Evaluates a subject without automatically raising. If omitted, the latest protected subject is used. The caller may inspect `state`, `causes`, `adapter_results`, and `policy_decision`.
+
+## `FreshnessBlocked`
+
+```python
+class FreshnessBlocked(RuntimeError):
+    result: CheckResult
+```
+
+Raised by the blocking policy. The message is safe and concise; detailed machine-readable evidence is available through `result`.
+
+## Domain objects
+
+The authoritative fields are defined in `schemas/`. Python dataclasses use immutable instances. IDs are UUID strings in the current implementation; future ULID support must preserve string compatibility.
+
+`ReasoningNode.dependencies` is the canonical graph-edge representation. Stores are immutable by ID: identical repeats are idempotent; different content under an existing ID raises `StorageConflictError` and preserves the original. `SQLiteStore.close()` closes its local connection.
+
+The filesystem adapter accepts `root`, `max_file_bytes` (default 16 MiB), `max_total_bytes` (64 MiB), `max_entries` (10,000), and `follow_symlinks` (false). Followed file symlinks must resolve inside `root`; directory symlink traversal is unsupported. Limit and scope failures validate as `UNVERIFIABLE`. External adapters may keep credentials, readers, or other validation inputs only in process-local state; applications must reconstruct that state after restart.
+
+## Example
+
+```python
+from freshctx import FreshnessBlocked, guard, observe, reasoning
+
+try:
+    with guard(policy="block") as ctx:
+        config = observe("config.yaml")
+        with reasoning("deployment_target", [config]) as decision:
+            target = choose_target(config)
+        ctx.run(deploy, target, depends_on=[decision], boundary="deploy")
+except FreshnessBlocked as blocked:
+    print(blocked.result.state.value)
+```
+
+Asynchronous guard support is not part of v0.1.

freshctx-0.1.0/ARCHITECTURE.md

@@ -0,0 +1,101 @@
+# FreshCtx architecture
+
+## System purpose
+
+FreshCtx determines whether evidence and the reasoning derived from it remain current at the moment an AI agent produces a protected output or performs a protected action.
+
+The core data flow is:
+
+```text
+source -> adapter.observe() -> ObservationToken
+ObservationToken(s) -> reasoning() -> ReasoningNode
+ReasoningNode -> guard.check() -> CheckResult
+CheckResult + policy -> allow, warn, refresh, or block
+all significant transitions -> AuditEvent
+```
+
+## Components
+
+### Public API
+
+`guard()`, `observe()`, `reasoning()`, and `Guard.run()` provide the framework-neutral Python surface. The API establishes a run-local context, records declared dependencies, and validates plus audits immediately before protected actions.
+
+### Adapter registry
+
+Adapters translate heterogeneous source state into versioned observation tokens. Every adapter implements:
+
+```python
+observe(locator, **options) -> ObservationToken
+validate(token) -> AdapterResult
+```
+
+Validation must be read-only. An adapter returns `equivalent`, `changed`, or `indeterminate`; it never directly selects a FreshCtx policy.
+
+### Dependency graph
+
+Observation tokens are leaves. Reasoning nodes reference observations or other reasoning nodes. The evaluator traverses the declared subgraph, detects missing objects and cycles, validates unique observations, and propagates stale or unverifiable states toward the protected subject.
+
+### Evaluator
+
+Evaluation order is deterministic:
+
+1. Resolve the protected subject.
+2. Load and validate the dependency graph.
+3. Deduplicate and validate source observations.
+4. Propagate source outcomes through reasoning nodes.
+5. Aggregate the final state.
+6. Apply policy.
+7. Emit the audit result before returning or raising.
+
+State precedence is stale over unverifiable over current. A stale observation produces `STALE_SOURCE`; a reasoning node depending on stale input produces `STALE_REASONING`.
+
+### Policy engine
+
+The policy layer consumes a `CheckResult`. The default `block` policy fails closed. `warn` and `allow` preserve the non-current result in audit events. The implemented `refresh` policy performs at most one caller-supplied refresh and one recheck before blocking.
+
+### Storage
+
+The default local store is SQLite at `.freshctx/freshctx.db`, using WAL mode and atomic transactions. Tests may use `MemoryStore`. Stored objects are immutable by ID; replacement is permitted only for identical logical records during idempotent writes.
+
+SQLite is FreshCtx persistence. The Postgres adapter only observes application query results. Conflicting writes raise `StorageConflictError` and leave the original record unchanged.
+
+### Audit
+
+The default sink is append-only JSONL at `.freshctx/audit.jsonl`. Events include `schema_version`, `event_id`, `run_id`, type, timestamp, subject, and redacted details. An audit failure under the blocking policy must eventually produce `UNVERIFIABLE` and prevent the protected operation.
+
+## Trust boundaries
+
+- FreshCtx trusts adapters to implement side-effect-free validation.
+- FreshCtx does not trust source availability, credentials, source metadata, or adapter exceptions.
+- Raw source content, prompts, model outputs, credentials, and authorization material are excluded by default.
+- FreshCtx guarantees only declared dependencies. Undeclared evidence cannot be evaluated.
+- `CURRENT` covers only reachable declared dependencies successfully revalidated under configured adapters at check time; it does not prove source truth, logical correctness, authorization, safety, compliance, or global reality.
+- HTTP, Postgres, and MCP perform external calls only when explicitly selected. Their readers, credentials, and other process-local validation state must be reconstructed after restart.
+
+### Reasoning digest
+
+`ReasoningNode.dependencies` is the canonical edge representation. IDs are sorted and deduplicated. The v0.1 digest is SHA-256 over canonical JSON containing domain `freshctx.reasoning-digest.v1`, the reasoning kind, normalized dependencies, and redacted metadata. It is identity/integrity metadata for those fields, not a signature, correctness proof, authorization result, or freshness check.
+
+## Concurrency model
+
+Run-local state uses `contextvars` to prevent dependency leakage between concurrent guards. SQLite access must be safe for supported thread usage. v0.1 does not guarantee multi-host coordination or distributed consensus.
+
+## Extension model
+
+New adapters register a unique name, version their validator evidence, return only safe audit evidence, and satisfy the shared adapter test suite. Model or framework integrations must remain optional extras layered above the core API.
+
+## Package layout
+
+```text
+src/freshctx/
+  __init__.py   public exports
+  model.py      canonical domain objects and states
+  adapters.py   adapter implementations and registry
+  core.py       contexts, evaluator, policies, and audit
+  store.py      SQLite and memory persistence
+schemas/        JSON Schema contracts
+docs/           concept and technical specifications
+adr/            architectural decisions
+examples/       executable demonstrations
+tests/          behavioral and acceptance tests
+```

freshctx-0.1.0/BACKLOG.md

@@ -0,0 +1,66 @@
+# FreshCtx v0.1 implementation backlog
+
+Issues are ordered for a single initial milestone. Each item should become one Git-hosting issue and reference the technical specification.
+
+## Completed v0.1 implementation items
+
+1. Protected action wrapper — completed
+   - Validate immediately before invoking a side effect.
+   - Add tests proving blocked actions never execute.
+2. Graph validation — completed
+   - Detect cycles and missing dependencies without recursion failure.
+   - Implements acceptance test A8.
+3. Audit failure behavior — completed
+   - Convert write failures to `UNVERIFIABLE` under block policy.
+   - Implements A11.
+4. Redaction layer — completed baseline
+   - Redact credentials, DSNs, headers, cookies, and configurable keys.
+   - Implements A12.
+5. Refresh policy — completed
+   - One bounded callback cycle; rebuild and recheck; otherwise block.
+   - Implements A9.
+
+## Completed adapter contracts
+
+6. HTTP adapter — completed
+   - Conditional GET, strong and weak ETag rules, Last-Modified, body hash, standard-library redirects, and timeout handling.
+   - Implements A3-A4.
+7. Postgres adapter — completed with injected-connector tests
+   - Read-only validation, statement timeout, canonical rows, ordered/unordered query semantics.
+   - Implements A6.
+8. MCP adapter — completed with safe-reader tests
+   - Server identity, normalized arguments, safe resource/tool validator, non-idempotent protection.
+   - Implements A7.
+
+## P1 — runtime quality
+
+9. Concurrency isolation — completed for concurrent thread guards
+   - Concurrent guards, run IDs, SQLite access, context propagation.
+   - Implements A10.
+10. Public exception hierarchy — completed for v0.1 behaviors
+    - Configuration, storage-conflict, filesystem-boundary, audit, and enforcement exceptions.
+11. Store migrations
+    - Schema version table, forward migration command, corruption handling.
+12. Shared adapter conformance tests
+    - Equivalent/changed/indeterminate, timeouts, redaction, side-effect safety.
+
+## P2 — packaging and developer experience
+
+13. CLI
+    - `freshctx check`, `freshctx audit`, `freshctx doctor`, and schema version reporting.
+14. Type-checking and formatting
+    - Add Ruff and mypy or Pyright configuration after dependency policy is approved.
+15. Package build verification
+    - Build wheel and source distribution; install into a clean environment.
+16. Documentation examples
+    - Filesystem, Git, HTTP, Postgres, MCP, and framework-neutral agent examples.
+17. Performance baseline
+    - Graph traversal, hash cost, validation latency, and large-directory behavior.
+
+## Release gate
+
+- Acceptance tests A1-A12 pass.
+- Python 3.10-3.13 CI passes.
+- Wheel and source distribution install cleanly.
+- No required account, telemetry, or model framework.
+- License, security policy, changelog, API contract, and schemas are present. Store migrations remain future work because v0.1 has no prior public schema.

freshctx-0.1.0/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+All notable FreshCtx changes will be documented here.
+
+## 0.1.0 - 2026-08-27
+
+### Added
+
+- Core observation and reasoning data models
+- Filesystem adapter
+- Git repository- and path-scoped adapter
+- Transitive freshness evaluation
+- Blocking, warning, and allow policies
+- SQLite and in-memory stores
+- Local JSONL audit events
+- Initial end-to-end tests
+- Pre-action protected execution
+- Graph corruption and depth safeguards
+- Fail-closed audit handling and redaction
+- HTTP, Postgres, and MCP adapter contracts
+- Bounded refresh and concurrency isolation
+- Wheel packaging and release automation
+- External developer gate coverage for selective invalidation and safe connection-loss behavior
+- Three executable reference demos for file, configuration/API, and audit reasoning drift
+- Versioned deterministic reasoning digests over normalized dependencies and redacted metadata
+- Immutable-by-ID SQLite and memory-store writes with conflict errors
+- Runtime-produced JSON Schema conformance and negative-fixture coverage
+- Bounded streaming filesystem traversal with explicit symlink and root policy
+- Community security, conduct, support, ownership, trademark, and third-party notices

freshctx-0.1.0/CODE_OF_CONDUCT.md

@@ -0,0 +1,71 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socioeconomic status, nationality, personal appearance, race, caste, color, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment include:
+
+- Demonstrating empathy and kindness toward other people.
+- Respecting differing opinions, viewpoints, and experiences.
+- Giving and gracefully accepting constructive feedback.
+- Accepting responsibility, apologizing to those affected by our mistakes, and learning from the experience.
+- Focusing on what is best for the overall community.
+
+Examples of unacceptable behavior include:
+
+- Sexualized language or imagery, and sexual attention or advances of any kind.
+- Trolling, insulting or derogatory comments, and personal or political attacks.
+- Public or private harassment.
+- Publishing another person’s private information without explicit permission.
+- Other conduct which could reasonably be considered inappropriate in a professional setting.
+
+## Enforcement Responsibilities
+
+Project maintainers are responsible for clarifying and enforcing standards of acceptable behavior. They will take appropriate and fair corrective action in response to behavior they deem inappropriate, threatening, offensive, or harmful.
+
+Maintainers may remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned with this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code applies within all community spaces and when an individual officially represents the community in public spaces. Examples include using an official email address, posting through an official social-media account, or acting as an appointed representative at an event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported confidentially to `conduct@hyperwise.io`. Hyperwise LLC’s project maintainers will review complaints promptly and fairly. All maintainers must respect the privacy and security of the reporter. A maintainer with a conflict of interest must recuse themselves. Do not use the security inbox for conduct reports.
+
+## Enforcement Guidelines
+
+Maintainers will follow these Community Impact Guidelines when determining consequences:
+
+### 1. Correction
+
+**Community impact:** Use of inappropriate language or other behavior deemed unprofessional or unwelcome.
+
+**Consequence:** A private written warning that explains the violation and why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community impact:** A violation through a single incident or series of actions.
+
+**Consequence:** A warning with consequences for continued behavior. The person may not interact with the people involved, including unsolicited interaction with those enforcing this Code, for a specified period. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community impact:** A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence:** A temporary ban from interaction or public communication with the community for a specified period. Violating the terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community impact:** A pattern of violations, harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence:** A permanent ban from public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant, version 2.1](https://www.contributor-covenant.org/version/2/1/code_of_conduct.html). Community Impact Guidelines were inspired by Mozilla’s code-of-conduct enforcement ladder.

freshctx-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# Contributing to FreshCtx
+
+FreshCtx is owned and stewarded by Hyperwise LLC and welcomes focused contributions that preserve its core guarantees: explicit freshness states, deterministic evaluation, safe validation, local-first operation, and no required telemetry. Contributors retain rights to their contributions. By submitting a contribution, you agree that it is accepted under the project's Apache License 2.0. FreshCtx v0.1 does not require a Contributor License Agreement (CLA) or Developer Certificate of Origin (DCO).
+
+## Contribution licensing
+
+The same Apache-2.0 terms apply to project code and accepted contributions. Hyperwise LLC does not require contributors to grant separate proprietary relicensing rights for v0.1. Commercial services and possible future products remain separate from FreshCtx core.
+
+If Hyperwise LLC later considers a genuine dual-licensing model, it will publish and review any proposed contribution terms before accepting code that would need those additional rights. Existing contributions will not silently receive new terms.
+
+The Apache-2.0 software license does not grant rights to use FreshCtx™ names, logos, or branding beyond truthful reference to the project. See `TRADEMARKS.md`.
+
+## Development setup
+
+1. Use Python 3.10 or newer.
+2. Create and activate a virtual environment.
+3. Install the development dependencies in editable mode.
+4. Run the test suite before submitting changes.
+
+```console
+python -m venv .venv
+source .venv/bin/activate
+python -m pip install -e '.[dev]'
+python -m unittest discover -s tests -v
+```
+
+## Contribution requirements
+
+- Add tests for behavioral changes.
+- Preserve the normative requirements in the versioned `SPEC.md`.
+- Treat validation as side-effect free.
+- Never treat an unknown or failed check as `CURRENT`.
+- Do not persist credentials or enable telemetry by default.
+- Keep model and agent-framework integrations optional.
+
+Open an issue before making a breaking API or data-schema change.
+
+See `CODE_OF_CONDUCT.md`, `SECURITY.md`, and `SUPPORT.md` for the correct private reporting and support routes.

freshctx-0.1.0/GOVERNANCE.md

@@ -0,0 +1,5 @@
+# Governance
+
+FreshCtx™ is owned and commercially stewarded by Hyperwise LLC as an independent Apache-2.0 open-source project. Community contains the complete usable v0.1 runtime, schemas, adapter contract, examples, compatibility tests, and five initial adapters for local developer use. Maintainers appointed by Hyperwise LLC decide changes through review against the versioned specification, security requirements, compatibility tests, and project scope. Contributor identity and commit attribution are preserved, and contributors retain rights to their contributions subject to accepted contribution terms unless a different executed agreement applies.
+
+The v0.1 contract is frozen. Breaking changes require a documented proposal, migration guidance, and a new specification version. Other Hyperwise products and possible future commercial services are separate from FreshCtx core. Hyperwise LLC may offer architecture, integration, deployment, or support separately; this statement does not claim that a hosted service, control plane, enterprise edition, or SLA exists today.

freshctx-0.1.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.