leancontext 2.0.0__py3-none-any.whl

leancontext/tokens.py

@@ -0,0 +1,79 @@
+"""Token counting.
+
+By default LeanContext uses the best tokenizer available: if ``tiktoken`` is
+installed it is used automatically for accurate counts, otherwise a fast
+character-based estimate (about 4 characters per token) is used. You can also
+plug in your own counter with ``set_token_counter`` or ``use_tiktoken(model)``.
+
+Token counts only affect the reported numbers and the saving threshold, never the
+reduced text, so the reduction is the same whichever tokenizer is active.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from collections.abc import Callable
+
+_counter: Callable[[str], int] | None = None   # explicit override, if set
+_auto: Callable[[str], int] | None = None       # resolved once, on first use
+_auto_name = "unresolved"
+
+
+def content_ref(text: str) -> str:
+    """Short, stable content hash used as a handle for caching and paging."""
+    return hashlib.sha1(text.encode("utf-8")).hexdigest()[:12]
+
+
+def _heuristic(text: str) -> int:
+    return max(1, (len(text) + 3) // 4)   # about 4 characters per token
+
+
+def _resolve_auto() -> None:
+    """Pick the default tokenizer once: tiktoken if present, else the estimate."""
+    global _auto, _auto_name
+    try:
+        import tiktoken
+
+        enc = tiktoken.get_encoding("cl100k_base")
+
+        def _tok(text: str) -> int:
+            return len(enc.encode(text, disallowed_special=()))
+
+        _auto, _auto_name = _tok, "tiktoken/cl100k_base"
+    except Exception:
+        _auto, _auto_name = _heuristic, "heuristic (~4 chars/token)"
+
+
+def count_tokens(text: str) -> int:
+    """Count the tokens in ``text`` using the active tokenizer."""
+    if _counter is not None:
+        return _counter(text)
+    if _auto is None:
+        _resolve_auto()
+    return _auto(text)  # type: ignore[misc]
+
+
+def set_token_counter(fn: Callable[[str], int] | None) -> None:
+    """Set a custom token counter, or pass None to fall back to auto-detection."""
+    global _counter
+    _counter = fn
+
+
+def use_tiktoken(model: str = "gpt-4o") -> None:
+    """Count tokens with tiktoken for a specific model. Requires the tiktoken extra."""
+    import tiktoken
+
+    try:
+        enc = tiktoken.encoding_for_model(model)
+    except KeyError:
+        enc = tiktoken.get_encoding("cl100k_base")
+    set_token_counter(lambda text: len(enc.encode(text, disallowed_special=())))
+
+
+def active_tokenizer() -> str:
+    """Name of the tokenizer currently in use."""
+    if _counter is not None:
+        return "custom"
+    if _auto is None:
+        _resolve_auto()
+    return _auto_name

leancontext-2.0.0.dist-info/METADATA

@@ -0,0 +1,224 @@
+Metadata-Version: 2.4
+Name: leancontext
+Version: 2.0.0
+Summary: Deterministic, type-aware reduction of agent tool outputs at the source. Cut LLM token cost without making the agent do less.
+Project-URL: Homepage, https://github.com/pankajniet/LeanContext
+Project-URL: Repository, https://github.com/pankajniet/LeanContext
+Project-URL: Issues, https://github.com/pankajniet/LeanContext/issues
+Project-URL: Changelog, https://github.com/pankajniet/LeanContext/blob/main/CHANGELOG.md
+Author: Pankaj Pandey
+License: Apache-2.0
+License-File: LICENSE
+Keywords: agents,compression,context,cost,llm,rag,tokens
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Provides-Extra: dev
+Requires-Dist: mypy>=1.19; extra == 'dev'
+Requires-Dist: opentelemetry-sdk>=1.39; extra == 'dev'
+Requires-Dist: pytest-asyncio>=1.3; extra == 'dev'
+Requires-Dist: pytest-cov>=7; extra == 'dev'
+Requires-Dist: pytest>=8.3; extra == 'dev'
+Requires-Dist: ruff>=0.15; extra == 'dev'
+Provides-Extra: integrations
+Requires-Dist: anthropic>=0.87; extra == 'integrations'
+Requires-Dist: fastapi>=0.125; extra == 'integrations'
+Requires-Dist: httpx>=0.28; extra == 'integrations'
+Requires-Dist: litellm>=1.82; extra == 'integrations'
+Requires-Dist: openai>=2.14; extra == 'integrations'
+Requires-Dist: starlette>=0.45; extra == 'integrations'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; extra == 'mcp'
+Provides-Extra: otel
+Requires-Dist: opentelemetry-api>=1.39; extra == 'otel'
+Provides-Extra: tiktoken
+Requires-Dist: tiktoken>=0.12; extra == 'tiktoken'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="assets/logo.png" alt="LeanContext" width="460">
+</p>
+
+<p align="center">
+  <b>Trim the tool output your AI agent re-sends every turn. Keep the signal, drop the noise.</b>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/leancontext/"><img alt="PyPI" src="https://img.shields.io/pypi/v/leancontext.svg"></a>
+  <a href="LICENSE"><img alt="License: Apache 2.0" src="https://img.shields.io/badge/license-Apache--2.0-blue.svg"></a>
+  <img alt="Python 3.14+" src="https://img.shields.io/badge/python-3.14%2B-blue.svg">
+  <a href="https://github.com/pankajniet/LeanContext/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/pankajniet/LeanContext/actions/workflows/ci.yml/badge.svg"></a>
+  <a href="https://github.com/astral-sh/ruff"><img alt="Ruff" src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json"></a>
+  <img alt="mypy" src="https://img.shields.io/badge/types-mypy-blue.svg">
+</p>
+
+---
+
+AI agents re-send every tool result (logs, JSON, diffs, stack traces, HTML) to the model on
+every turn, and most of it is redundancy you pay for again and again. LeanContext sits between
+your agent and the model and reduces those payloads to their signal: deterministically, with a
+fidelity score on every reduction, and without ever breaking the agent.
+
+```python
+from leancontext import reduce
+
+@reduce
+def search_logs(query: str) -> str:
+    return run_log_search(query)   # ~10k tokens of logs in, ~1k out, error lines kept
+```
+
+## See it
+
+```text
+$ python bench.py
+sample              kind          before   after  saved  fidelity
+-----------------------------------------------------------------
+log (incident)      log            52642     100   100%      100%
+json (RAG chunks)   json            1862    1390    25%      100%
+html (web fetch)    html            1672    1093    35%      100%
+diff (patch)        diff             639      81    87%      100%
+stacktrace          stacktrace       896      94    90%      100%
+-----------------------------------------------------------------
+TOTAL                              57711    2758    95%
+```
+
+A real incident log, before and after:
+
+```text
+# before  (902 lines)
+2026-06-21T09:00:01Z INFO  [gateway] req id=a1 path="/v1/render" status=200 ms=12
+... 900 near-identical INFO lines ...
+2026-06-21T09:10:43Z FATAL [render] OOM killed worker=7 doc="deck-8842" root cause
+
+# after
+2026-06-21T09:00:01Z INFO  [gateway] req id=a1 path="/v1/render" status=200 ms=12   ⟪×900 similar⟫
+2026-06-21T09:10:43Z FATAL [render] OOM killed worker=7 doc="deck-8842" root cause
+```
+
+The redundant lines collapse to a count. The FATAL line that explains the crash is kept intact.
+
+## Why it works
+
+The model API is the bulk of an agent's cost, and most of that is *input* tokens. A tool result
+added on one turn is re-sent on every later turn, so the bill grows with the length of the
+conversation, not just the work done. Those payloads are mostly repetition. LeanContext keeps the
+errors, anomalies, and identifiers, and collapses the rest.
+
+## How it compares
+
+|                                  | LeanContext | LLM-based compressor | Wire-level proxy |
+| -------------------------------- | :---------: | :------------------: | :--------------: |
+| No model in the reduction path   |      ✓      |          ✗           |      varies      |
+| Deterministic                    |      ✓      |          ✗           |      varies      |
+| Prompt-cache safe                |      ✓      |       often ✗        |     often ✗      |
+| Type-aware (keeps error lines)   |      ✓      |          ✗           |        ✗         |
+| Fidelity score per reduction     |      ✓      |          ✗           |        ✗         |
+| Added latency / cost             |    none     |     a model call     |  a network hop   |
+
+## Install
+
+```bash
+pip install -e .                  # core, standard library only
+pip install -e ".[integrations]"  # openai, anthropic, litellm, fastapi adapters
+pip install -e ".[otel]"          # OpenTelemetry metrics
+pip install -e ".[tiktoken]"      # exact token counts (used automatically when present)
+```
+
+## Use it
+
+Three levels, one core. Every path fails open: if anything goes wrong, you get the original text back.
+
+```python
+import leancontext
+
+clean = leancontext.reduce(tool_output).text     # 1) manual
+
+@leancontext.reduce                              # 2) decorator, one line per tool
+def search_logs(q: str) -> str:
+    ...
+
+tools  = leancontext.wrap(tools)                 # 3) wrap all tools, or an SDK client
+client = leancontext.wrap(openai_client)         #    (wrap_anthropic / wrap_gemini too)
+```
+
+Every reduction is inspectable:
+
+```python
+r = leancontext.reduce(tool_output)
+r.text                            # what to send to the model
+r.tokens_before, r.tokens_after
+r.ratio                           # fraction saved
+r.fidelity                        # 0..1 signal preserved
+```
+
+## Integrations
+
+| Surface | How |
+| --- | --- |
+| Decorator / tools | `@leancontext.reduce`, `leancontext.wrap(tools)` |
+| OpenAI / Anthropic / Gemini SDK | `wrap_openai(c)`, `wrap_anthropic(c)`, `wrap_gemini(c)` |
+| LiteLLM (proxy) | `callbacks: leancontext.integrations.litellm.proxy_handler_instance` |
+| LiteLLM (SDK) | `import leancontext.integrations.litellm as ll; ll.patch()` |
+| Standalone proxy | `from leancontext.integrations.proxy import create_app` (OpenAI-compatible, any language) |
+| Messages | `leancontext.reduce_messages(messages)` (OpenAI, Anthropic, Gemini) |
+| Telemetry | `import leancontext.integrations.otel as o; o.instrument()` |
+| Anthropic native | `wrap_anthropic_native(client, ...)` composes with `clear_tool_uses` context editing |
+| Frameworks | LangChain, LangGraph, Agno via `wrap(tools)`; any framework via `@reduce` on tool functions (sync or async) |
+| MCP server | `python -m leancontext.integrations.mcp_server` — reduce / expand / stats over stdio |
+
+## Reducers
+
+| Kind | What it does |
+| --- | --- |
+| `log` | Collapse near-identical lines, keep every error, anomaly, and unique line verbatim |
+| `json` | Factor repeated keys out once, lay values out columnar (near-lossless) |
+| `diff` | Keep all change, hunk, and header lines, collapse unchanged context |
+| `stacktrace` | Keep the exception and boundary frames, collapse the deep middle |
+| `html` | Strip tags, scripts, and styles, keep visible text and links |
+
+Anything else, or any payload below the size, saving, or fidelity thresholds, passes through unchanged.
+
+## How it works
+
+Each tool output flows through fail-open gates (hash, size check, type detection, the typed
+reducer, then a saving and fidelity check) and returns either the reduced text or the original.
+Results are cached by content hash, so a payload re-sent across turns is reduced only once.
+See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for diagrams.
+
+## Cost and telemetry
+
+```python
+from leancontext.cost import CostTracker
+
+tracker = CostTracker(model="claude-sonnet-4-6").install()
+# ... run your agent ...
+tracker.report()    # {tokens_saved, usd_saved, ratio, cache_safe: True}
+```
+
+## Configuration
+
+```python
+leancontext.disable()                         # global kill switch (or env LEANCONTEXT_DISABLED=1)
+leancontext.reduce(x, min_saving=0.1, min_fidelity=0.85)
+leancontext.on_reduction(callback)            # telemetry hook (composable)
+leancontext.use_tiktoken("gpt-4o")            # force a specific model's tokenizer
+```
+
+## Roadmap
+
+Accurate provider tokenizers by default, an MCP server, tested LangChain / LlamaIndex / CrewAI
+adapters, broader Anthropic native interop, and a PyPI release.
+
+## Contributing
+
+Issues and PRs welcome. Run `pytest`. Reducers are pure functions, `str -> (reduced, notes)`,
+and must be deterministic and value-preserving. See [AGENTS.md](AGENTS.md) for the design rules.
+
+## License
+
+[Apache-2.0](LICENSE)

leancontext-2.0.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+leancontext/__init__.py,sha256=pvbacCUBLLWDeV26ndMrtKQzOBI-LR4oPgzvV6Ke0Yw,2467
+leancontext/cli.py,sha256=rloytVoYKMpRgA_HgWKTyAlvWN7G5Px0hkQfhJZiIR0,1355
+leancontext/core.py,sha256=Fm760FGArHAWzBd72OnwOvfsiLHNxWDXh_TEL9mBulQ,7041
+leancontext/cost.py,sha256=DbcQDx6l2-aPC9_DU2Hciu7EJtBpcJCHzKh2PTyMaJM,3831
+leancontext/fidelity.py,sha256=HAFyO_IUn6wCR804C5rK-2Tkie9Ph0YiAj7AjqLPHrg,3593
+leancontext/messages.py,sha256=Td1OylBz3U2BH174xIP7ekjRMVAyzsXrME5YPI8uklE,5650
+leancontext/paging.py,sha256=9KtvTZRYMj3li9K9mVrOSLGGib55ottly45ypL66Qeo,3449
+leancontext/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+leancontext/tokens.py,sha256=gFPSC97Ja44uH3axaKCefmHHsib9CJr_MsCFqZOEaCQ,2540
+leancontext/integrations/__init__.py,sha256=crbtxKoTEMVFXXFiE70wab3UexoLOsZvPJhMy8IWmjQ,282
+leancontext/integrations/_common.py,sha256=EeGbUGbdlkaTdOjXVX7QY-Fdkverumnbb_8dqzhUfZY,1958
+leancontext/integrations/anthropic_native.py,sha256=MIFddBKEMieJzjsCaXpvK4zoidEZO7gs3k8TCoDel5o,3336
+leancontext/integrations/clients.py,sha256=RXE9_4HJRpMsRte2hbtJMz_GT8vn4kztC4P1uKpdB7M,1939
+leancontext/integrations/decorator.py,sha256=1YGxkEYY0R_0jUdYn8e_u4KEvsAa2jSRadDyBmTGd3M,3548
+leancontext/integrations/frameworks.py,sha256=7k1dUAqy4th1kVSKfHQu9vDnKtLftRPK-u4Z6P4sBOA,1959
+leancontext/integrations/litellm.py,sha256=ESpiAWmKkfDPeYFmQAilK15u9mjcc--kxqojWvofO10,2646
+leancontext/integrations/mcp_server.py,sha256=kdbFbjyDuCyGLq383jC08b4_gVu4lC_nymrQm9MChjo,1919
+leancontext/integrations/otel.py,sha256=mGtRHREyg114vJr7iywa_PHCvR-G5sdl9HSLG4ffeIM,3283
+leancontext/integrations/proxy.py,sha256=2ePoAOnb9zzFe4aE_CjZNE77KA-mbSQQ14Eo4y7waio,3585
+leancontext/reducers/__init__.py,sha256=bFF1CNHNZpfS3bokv9VARd1nZXRLs3P0v89--uNh4js,1080
+leancontext/reducers/base.py,sha256=LR4jquQzD7QymT_HORRpZHyVhh68KKNqlD0hnpj5AT4,524
+leancontext/reducers/diff.py,sha256=Q3UftO9Pd3w_NfRR3-8kd8tqxLTlz_lR-05MJCN_ssY,1479
+leancontext/reducers/html.py,sha256=eukvfSpcV9hCatbgpayRDgS9Gm6sxwFTKrTpf9-QC0k,1814
+leancontext/reducers/json_data.py,sha256=077G7NyIYXPsExAg05vbIjleORslIn_3MuQjpSit6GE,2064
+leancontext/reducers/logs.py,sha256=21DRISCYExAW7c6TlP4z_NEWweV-AfItbIRi7_bsWzc,2956
+leancontext/reducers/stacktrace.py,sha256=bOTQHSe_roomtVQO7wUt0hS3cEyWVqaraU4tTlOIia4,1886
+leancontext/reducers/table.py,sha256=TAh2fcWOL6re05gXp8GD6Z0T_wasDaYgKscmXkLmAPQ,1044
+leancontext-2.0.0.dist-info/METADATA,sha256=9mcig1dCBDYVILMFbGEZ3JEabR4takeiVNju2w4mkBo,9817
+leancontext-2.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+leancontext-2.0.0.dist-info/entry_points.txt,sha256=F-z6fgKf3HSA4lQF7Z1FF7qI-_eNkjI3iykvx5VdWws,53
+leancontext-2.0.0.dist-info/licenses/LICENSE,sha256=DHwm-PXPugUGVdIXY5VAQtW5LgBB9le5SuYY5Ikr8hI,10575
+leancontext-2.0.0.dist-info/RECORD,,

leancontext-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

leancontext-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+leancontext = leancontext.cli:main

leancontext-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,190 @@
+                                 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.
+
+      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 2026 pankajniet
+
+   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.