ishtaran 0.1.0__tar.gz

ishtaran-0.1.0/.github/RELEASE_NOTES_TEMPLATE.md

@@ -0,0 +1,13 @@
+## Ishtaran Python SDK -- first public release
+
+This is the first public **Development Preview** release of the official Ishtaran Python SDK. It
+is not GA, not stable, and not production-ready -- see
+[Project status](../README.md#project-status) in the README for the current, up-to-date state.
+
+- Official Ishtaran SDK, covering the current HTTP API surface (Easy Mode + Core API).
+- Self-custody wallet generation and transaction signing supported end to end -- see
+  [Self-custody](../README.md#self-custody) in the README.
+- The public Sandbox is not live yet.
+- Production blockchain execution is not available yet.
+
+See the [README](../README.md) and [CHANGELOG](../CHANGELOG.md) for full detail.

ishtaran-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,67 @@
+name: Release
+
+# Triggered only by a protected version tag (never a pull request, never a
+# branch push) -- pushing a `v*` tag requires write access to this repository,
+# so a fork/PR can never trigger a publish. Least privilege: `test` only
+# reads the repo; `publish` is the only job with `id-token: write` (PyPI
+# Trusted Publishing/OIDC -- no long-lived PyPI API token secret needed) and
+# runs behind the `pypi-release` environment, which the repository owner can
+# gate with required reviewers in Settings -> Environments.
+#
+# PyPI Trusted Publishing must be configured once on pypi.org (a "pending
+# publisher" for a not-yet-existing project) pointing at this exact repo,
+# this workflow filename, and this environment name before the first run of
+# this workflow can succeed -- that one-time setup is a manual owner action,
+# see the release report for the exact steps.
+
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+      - run: pip install -e ".[dev]"
+      - run: python -m mypy src/
+      - run: python -m pytest -q
+
+  publish:
+    needs: test
+    runs-on: ubuntu-latest
+    environment: pypi-release
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+      - run: pip install build
+      # Fails the job if the tag and pyproject.toml version ever drift --
+      # never publish a version that doesn't match what was tagged/reviewed.
+      - name: Verify tag matches pyproject.toml version
+        run: |
+          TAG_VERSION="${GITHUB_REF_NAME#v}"
+          # No TOML parser dependency (tomllib needs Python 3.11+, this job runs
+          # 3.10 to match the SDK's own minimum) -- pyproject.toml's `version =
+          # "x.y.z"` line is simple enough for grep/sed.
+          PKG_VERSION="$(grep -m1 '^version = ' pyproject.toml | sed -E 's/^version = "(.*)"$/\1/')"
+          if [ "$TAG_VERSION" != "$PKG_VERSION" ]; then
+            echo "Tag v$TAG_VERSION does not match pyproject.toml version $PKG_VERSION"
+            exit 1
+          fi
+      - run: python -m build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

ishtaran-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+.venv/
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.mypy_cache/
+.pytest_cache/

ishtaran-0.1.0/AUTHENTICATION.md

@@ -0,0 +1,26 @@
+# Authentication
+
+Two real mechanisms (see `SDK_CAPABILITY_SPEC.md` §3).
+
+## `X-Api-Key` (recommended)
+
+```python
+client = IshtaranClient.create(api_key="<your API Key>", environment=Environment.LOCAL)
+```
+
+Works for read and write on the 8 Data Plane modules. Does not work today for Control Plane,
+reading the AssetNetworkCatalog, or WebhookEndpoint management (real API gaps, §12.3/§12.4).
+
+## Member JWT (human login)
+
+```python
+client.auth.login(email, password)
+# the client now uses the token internally for every subsequent Control Plane call.
+org = client.organizations.get(organization_id)
+```
+
+## Never mix them silently
+
+The SDK never sends the API Key as a Bearer token nor the JWT as `X-Api-Key`. If both are
+configured, both headers are sent on Data Plane routes — avoid configuring both at once
+against different Organizations (precedence not verified live by this SDK).

ishtaran-0.1.0/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+Follows [SemVer](https://semver.org/). Not yet published (PyPI).
+
+## [1.0.0.dev0] — 2026-08-17
+
+Third implementation of the Ishtaran Official SDK Program — 100% functional parity with the
+Java SDK (reference implementation).
+
+### Added
+
+- Central client (`IshtaranClient.create(...)`).
+- Complete Core API — 16 modules, 93 real operations.
+- Easy Mode — `receive_payment`/`get_payment`/`wait_for_payment`, `withdraw`, `get_balance`,
+  `verify_webhook_signature`.
+- `X-Api-Key` + Member JWT authentication.
+- Complete `IshtaranError` hierarchy.
+- Safe retry with backoff+jitter.
+- Idempotency (body and header, depending on the endpoint).
+- Real pagination via lazy generators.
+- Forward-compatible enums (`from_raw`/`is_unknown`, `UNKNOWN` fallback).
+- Money always as `decimal.Decimal` (never `float`), via `json.loads(parse_float=Decimal,
+  parse_int=Decimal)`.
+- `verify_webhook_signature`/`compute_webhook_signature` (HMAC-SHA256, constant time).
+- Opt-in logging with central redaction.
+- HTTP redirects never followed automatically (`follow_redirects=False`).
+- `mypy --strict` clean across all 63 modules of the SDK.
+- Packaging validated — real wheel + sdist (`python -m build`), installed in a clean venv.
+
+### Known, still pending
+
+- Sync only in this version (`httpx.Client`) — async support is a documented future extension,
+  same pacing allowed for Java ("sync-first initially").
+- Real PyPI publication — blocked on a pending licensing decision.

ishtaran-0.1.0/CONFIGURATION.md

@@ -0,0 +1,35 @@
+# Configuration
+
+```python
+client = IshtaranClient.create(
+    api_key="...",
+    environment=Environment.LOCAL,
+    base_url="http://localhost:8080",  # always explicit when present
+    connect_timeout_seconds=5.0,       # default
+    request_timeout_seconds=30.0,      # default
+    enable_logging=True,               # opt-in, never on by default
+)
+```
+
+## `base_url`/`Environment`
+
+| Environment | Default | Explicit `base_url`? |
+|---|---|---|
+| `LOCAL` | `http://localhost:8080` | No |
+| `SANDBOX`/`PRODUCTION` | **none** — infra not yet provisioned | **Yes, required** |
+
+Constructing without `base_url` for `SANDBOX`/`PRODUCTION` raises `ValueError` immediately — it
+never points to a made-up URL.
+
+## TLS
+
+Verified by default (native `httpx` behavior); never disabled by this SDK.
+
+## Redirects
+
+`httpx.Client(follow_redirects=False)` — any 3xx is treated as a `NetworkError`, never followed
+automatically (same policy as Java/TypeScript).
+
+## User-Agent
+
+`ishtaran-python/<version>` — fixed, no personal data.

ishtaran-0.1.0/CORE_API.md

@@ -0,0 +1,47 @@
+# Core API
+
+Complete, literal coverage of the real API — 83 routes, 16 modules (see `SDK_FEATURE_MATRIX.md`,
+`SDK_METHOD_MAP.md`). No invented endpoint, no admin-only/platform-only route exposed.
+
+## Control Plane (always Member JWT)
+
+`client.organizations`, `client.applications`, `client.environments`, `client.api_keys`,
+`client.members`, `client.asset_network_catalog`, `client.webhook_endpoints`, `client.webhook_deliveries`.
+
+## Data Plane (API Key or Member JWT)
+
+`client.accounts`, `client.transactions`, `client.deposits`, `client.ledger`, `client.settlements`,
+`client.refunds`, `client.withdrawals`, `client.workflows`/`event_types`/`events`, `client.sandbox`.
+
+## Example — full flow without Easy Mode
+
+```python
+from decimal import Decimal
+
+account = client.accounts.create(organization_id, "customer-123")
+client.accounts.authorize_application(account.account_id, application_id)
+
+txn = client.transactions.create(organization_id, application_id, None, asset_network_id, Decimal("100"), [payer, recipient])
+intent = client.deposits.create_payment_intent(organization_id, txn.transaction_id, asset_network_id, Decimal("100"))
+full_intent = client.deposits.get_payment_intent(intent.payment_intent_id)
+# full_intent.deposit_address -- real address to watch on-chain
+
+settlement = client.settlements.execute_settlement(txn.transaction_id)
+```
+
+## Real anonymous objects
+
+Several real POSTs return a minimal object (`CreateAccountResult(account_id=...)`,
+`CreateTransactionResult(transaction_id=...)`) instead of the full resource — confirmed in the
+real handler source code. Fetch the full resource with the corresponding `get(...)`.
+
+## Real pagination (lazy generators)
+
+Only 2 endpoints have real pagination: `withdrawals.list`/`.list_all` and
+`ledger.list_entries`/`.list_all_entries`. The `.list_all*` variants are generators — they fetch
+the next page on demand:
+
+```python
+for withdrawal in client.withdrawals.list_all(organization_id, page_size=20):
+    print(withdrawal.withdrawal_id)
+```

ishtaran-0.1.0/EASY_MODE.md

@@ -0,0 +1,27 @@
+# Easy Mode vs. Core API
+
+## Use Easy Mode when...
+
+- You want to integrate fast: `client.receive_payment(...)`, `client.withdraw(...)`, `client.get_balance(...)`.
+- You need to safely wait for an asynchronous result: `client.wait_for_payment(...)`,
+  `client.withdrawals.wait_for(...)`, `client.transactions.wait_for(...)` — always with a timeout.
+- You only need to verify a webhook signature: `client.verify_webhook_signature(...)`.
+
+## Use Core API when...
+
+- You need granular control (`client.transactions.reserve(...)` vs. `client.settlements.execute_settlement(...)`).
+- You need a resource that Easy Mode doesn't cover — 93 real operations, see `SDK_FEATURE_MATRIX.md`.
+- You want real pagination: `client.withdrawals.list_all(...)`/`client.ledger.list_all_entries(...)`
+  (lazy generators) instead of a single call.
+
+## Concrete equivalence
+
+| Easy Mode | Core equivalent |
+|---|---|
+| `client.receive_payment(...)` | `transactions.create()` + `deposits.create_payment_intent()` + `deposits.get_payment_intent()` |
+| `client.withdraw(...)` | `withdrawals.create_destination()` + `withdrawals.request()` |
+| `client.get_balance(...)` | `ledger.get_balance(...)` |
+
+Easy Mode never hides the real `withdrawal_id`/`transaction_id`/`payment_intent_id`. `withdraw()`
+always returns `estimated_network_fee`/`estimated_recipient_amount`/`status` — never just
+success/failure.

ishtaran-0.1.0/ERROR_HANDLING.md

@@ -0,0 +1,51 @@
+# Error Handling
+
+Every exception is a subclass of `IshtaranError` (see `SDK_CAPABILITY_SPEC.md` §6):
+
+```
+IshtaranError
+├── AuthenticationError       (401 — no code/details)
+├── AuthorizationError        (403 — same)
+├── ValidationError           (400, code=VALIDATION_ERROR — 1 string, never a per-field list)
+├── NotFoundError             (404, code=NOT_FOUND)
+├── ConflictError             (409 — various codes)
+├── IdempotencyConflictError  (409, code=IDEMPOTENCY_KEY_CONFLICT — extends ConflictError)
+├── RateLimitError            (429, code=RATE_LIMITED — retry_after_seconds)
+├── NetworkError              (transport failure)
+├── TimeoutError              (request timeout, or wait_for exceeding its deadline)
+└── ApiError                  (fallback — preserves raw http_status/code/details)
+```
+
+## Usage
+
+```python
+from ishtaran import ValidationError, RateLimitError, IshtaranError
+import time
+
+try:
+    client.withdrawals.request(org_id, account_id, dest_id, asset_network_id, amount)
+except ValidationError as e:
+    print("Validation failed:", e.message)
+except RateLimitError as e:
+    time.sleep(e.retry_after_seconds or 1)
+except IshtaranError as e:
+    print(f"Failed ({e.http_status}):", e.message)
+```
+
+## Available fields
+
+`http_status`, `code`, `request_id` (always `None` today — the real API has no correlation ID
+mechanism, §12.1), `details` (raw body), `retryable`.
+
+## Why 401/403 have no `code`/`details`
+
+No backend `AuthenticationHandler` registers a custom challenge — the authentication middleware
+responds with an empty body before reaching the handler that produces `ProblemDetails`.
+
+## Naming note
+
+`ishtaran.TimeoutError` deliberately shadows `builtins.TimeoutError`, to keep exact name parity
+with Java/TypeScript (rule from the brief). Internal SDK code that needs the real network timeout
+uses `httpx.TimeoutException`, not the builtin — no practical collision. If your own code also
+uses `builtins.TimeoutError`, import with an alias: `from ishtaran import TimeoutError as
+IshtaranTimeoutError`.

ishtaran-0.1.0/FEATURES.md

@@ -0,0 +1,17 @@
+# Features
+
+Derived from the real API contract (see the [API Reference](https://ishtaran.com/docs/api/ishtaran-api)). Core API: 93/93 real
+operations (16/16 modules). Easy Mode: 100%. Cross-cutting: 100% (config, auth, errors, retry,
+idempotency, pagination, forward-compatible enums, security/redaction, opt-in logging, safe
+wait_for, validated wheel+sdist packaging).
+
+100% functional parity with the Java SDK (reference implementation) — same business-concept
+names, same defaults, same retry/idempotency/timeout policy, differing only in the language's
+idiom (`client.withdrawals.quote(...)` identical in Python and TypeScript; Java uses
+`client.withdrawals().quote(...)`).
+
+## Extra compared to Java/TypeScript
+
+- `mypy --strict` clean (full static verification).
+- Money as a native `decimal.Decimal` — more idiomatic than TypeScript's `string`, with no
+  third-party dependency for precision (the stdlib `json`/`decimal` already solve the problem).

ishtaran-0.1.0/GETTING_STARTED.md

@@ -0,0 +1,59 @@
+# Getting Started
+
+## 1. Install
+
+```bash
+pip install -e ".[dev]"   # local, see README.md — not yet published on PyPI
+```
+
+## 2. Build the client
+
+```python
+import os
+from ishtaran import IshtaranClient, Environment
+
+client = IshtaranClient.create(
+    api_key=os.environ["ISHTARAN_API_KEY"],
+    environment=Environment.LOCAL,
+)
+```
+
+`Environment.SANDBOX`/`PRODUCTION` don't have a known real URL yet — use an explicit `base_url=`
+(see [`CONFIGURATION.md`](CONFIGURATION.md)).
+
+## 3. Check a balance (Easy Mode)
+
+```python
+balance = client.get_balance(account_id, asset_network_id)
+print("Available:", balance.available)  # decimal.Decimal
+```
+
+## 4. Receive a payment (Easy Mode)
+
+```python
+from decimal import Decimal
+
+payment = client.receive_payment(organization_id, application_id, payer_account_id, recipient_account_id, asset_network_id, Decimal("100"))
+print("Deposit address:", payment.deposit_address)
+
+finished = client.wait_for_payment(payment.transaction_id, payment.payment_intent_id, timeout_seconds=600, poll_interval_seconds=5)
+```
+
+## 5. Withdrawal with visible Network Fee (Easy Mode)
+
+```python
+withdrawal = client.withdraw(organization_id, account_id, asset_network_id, Decimal("50"), "TDestinationAddressReal")
+print(f"You receive {withdrawal.estimated_recipient_amount} (fee: {withdrawal.estimated_network_fee})")
+```
+
+## 6. Or use Core directly
+
+```python
+account = client.accounts.get(account_id)
+quote = client.withdrawals.quote(organization_id, account_id, destination_id, asset_network_id, Decimal("50"))
+```
+
+## Next steps
+
+- [`AUTHENTICATION.md`](AUTHENTICATION.md), [`EASY_MODE.md`](EASY_MODE.md), [`ERROR_HANDLING.md`](ERROR_HANDLING.md)
+- [`examples/`](examples/) — 11 numbered examples

ishtaran-0.1.0/IDEMPOTENCY.md

@@ -0,0 +1,22 @@
+# Idempotency
+
+Two real mechanisms (see `SDK_CAPABILITY_SPEC.md` §9):
+
+## Body field — every financial endpoint
+
+`transactions.create`, `deposits.create_payment_intent`, `settlements.execute_settlement`,
+`refunds.execute_refund`, `withdrawals.request`, `events.ingest` — optional parameter
+`idempotency_key`; if omitted, the SDK generates a UUID v4 automatically; if explicit, it is
+never overwritten.
+
+## `Idempotency-Key` header — only 2 real endpoints
+
+`organizations.create(...)` and `organizations.create_application(...)` — the only 2 places in
+the backend that use a header instead of a body field (confirmed in source code). Same
+auto-generation policy.
+
+## Resubmission
+
+Same key + same payload = safe (replay). Same key + different payload =
+`IdempotencyConflictError` (409). Automatic retry (`RETRIES.md`) reuses the same key from the
+first attempt, never generates a new one per attempt.

ishtaran-0.1.0/LICENSE

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