hypercache-kv 0.1.0__tar.gz

hypercache_kv-0.1.0/LICENSE

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2026 Hyper Cache
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Note: this license applies to the SDK source code in this repository only.
+The Hyper Cache codec algorithm — which runs only inside Cloudflare Workers
+as compiled WebAssembly and is accessed via HTTP — is proprietary, patent-
+pending, and not licensed under MIT. This SDK is a thin HTTP wrapper and
+contains zero codec algorithm code.

hypercache_kv-0.1.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: hypercache-kv
+Version: 0.1.0
+Summary: Skip repeated LLM calls, skip GPU prefill, prove what happened — a thin client for the Hyper Cache API.
+Author-email: Hyper Cache <contact@hypercache.ai>
+License: MIT
+Project-URL: homepage, https://hypercache.ai
+Project-URL: documentation, https://hypercache.ai/docs
+Project-URL: repository, https://github.com/Hyper-Cache/hypercache-kv
+Project-URL: issues, https://github.com/Hyper-Cache/hypercache-kv/issues
+Keywords: ai,ml,llm,cache,fingerprint,audit,inference
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: numpy
+Requires-Dist: numpy>=1.20; extra == "numpy"
+Provides-Extra: torch
+Requires-Dist: torch>=2.0; extra == "torch"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: numpy>=1.20; extra == "test"
+Dynamic: license-file
+
+# hypercache (Python SDK)
+
+Thin client for the [Hyper Cache](https://hypercache.ai) API. Zero runtime dependencies (stdlib only).
+
+Hyper Cache is one thing on Cloudflare: a small fast server-locked codec that gives any input a tamper-evident 90-byte ID, plus a content-addressed cache and chain. **This SDK is a thin HTTP wrapper** — the codec algorithm runs only inside our WASM binary on Cloudflare, never on your machine.
+
+## Three gains, one primitive
+
+```python
+from hypercache.workflows import Pipeline
+
+with Pipeline("my_pipeline") as p:
+    # Skip repeated LLM calls — same input next time, cached response back
+    answer, was_hit = p.cached(
+        label="gpt_call",
+        input_bytes=prompt.encode("utf-8"),
+        compute=lambda: call_openai(prompt),
+    )
+
+    # Prove what happened — every step gets a verifiable fingerprint
+    p.record("output", answer.encode("utf-8"))
+
+print(f"{p.report.n_hits} hits / {p.report.n_misses} misses")
+audit_chain = p.report.export_audit()
+```
+
+One template, three gains: skip repeated work (cache), prove what happened (chain), stats for your dashboard (report).
+
+## Install
+
+```bash
+pip install hypercache-kv
+export HYPERCACHE_KEY=hck_...
+```
+
+Get a key at [hypercache.ai](https://hypercache.ai).
+
+## The three gains in detail
+
+**1. Skip repeated LLM calls.** Same prompt → cached response in milliseconds. Measured 7.6× faster on cache hit against real Phi-3-mini calls.
+
+```python
+from hypercache.workflows import cached_completion
+
+text, was_hit = cached_completion(
+    prompt="Translate to French: Hello",
+    compute=lambda p: call_openai(p),
+)
+```
+
+Or wrap your OpenAI / Anthropic client directly:
+
+```python
+from openai import OpenAI
+from hypercache.workflows import wrap_openai
+
+client = wrap_openai(OpenAI())
+resp = client.chat.completions.create(model="gpt-4o-mini", messages=[...])
+```
+
+**2. Skip repeated GPU prefill.** For self-hosted inference (vLLM, llama-cpp, SGLang, TRT-LLM) with reused system prompts or RAG contexts. Measured 21.8× faster than cold prefill on Phi-3-mini at 1199 tokens. See [docs/02_skip_gpu_prefill.md](../../docs/02_skip_gpu_prefill.md).
+
+**3. Prove what happened.** Every fingerprint chains algebraically to the prior one. The chain is mathematically verifiable, server-locked against forgery, and exportable for compliance.
+
+```python
+from hypercache.workflows import audit_chain
+
+with audit_chain() as chain:
+    r1 = chain.fingerprint(input_bytes)
+    r2 = chain.fingerprint(model_output)
+    r3 = chain.fingerprint(reviewer_note)
+```
+
+## Low-level API
+
+```python
+import hypercache
+
+result = hypercache.cache_lookup(b"some input bytes")
+if result.hit:
+    print(result.value)
+else:
+    hypercache.cache_put(result.fingerprint_hex, b"my expensive output", ttl=3600)
+
+results = hypercache.cache_lookup_batch([b"in 1", b"in 2", b"in 3"])
+
+fp = hypercache.fingerprint(b"any bytes")
+print(fp.record_hex)
+```
+
+## What's open / what's closed
+
+- **Open (this SDK):** thin HTTP wrappers + workflow templates. MIT licensed.
+- **Closed:** the codec algorithm itself runs only inside our WASM binary on Cloudflare. You interact with it via HTTP.
+
+The separation is intentional: the codec's mathematical integrity (forgery resistance for audit, byte-precision for caching) requires that the algorithm cannot be replicated or modified by anyone, including customers. This SDK contains zero codec code; PRs that try to add codec algorithm code locally will be closed.
+
+## License
+
+MIT. See [LICENSE](./LICENSE).

hypercache_kv-0.1.0/README.md

@@ -0,0 +1,100 @@
+# hypercache (Python SDK)
+
+Thin client for the [Hyper Cache](https://hypercache.ai) API. Zero runtime dependencies (stdlib only).
+
+Hyper Cache is one thing on Cloudflare: a small fast server-locked codec that gives any input a tamper-evident 90-byte ID, plus a content-addressed cache and chain. **This SDK is a thin HTTP wrapper** — the codec algorithm runs only inside our WASM binary on Cloudflare, never on your machine.
+
+## Three gains, one primitive
+
+```python
+from hypercache.workflows import Pipeline
+
+with Pipeline("my_pipeline") as p:
+    # Skip repeated LLM calls — same input next time, cached response back
+    answer, was_hit = p.cached(
+        label="gpt_call",
+        input_bytes=prompt.encode("utf-8"),
+        compute=lambda: call_openai(prompt),
+    )
+
+    # Prove what happened — every step gets a verifiable fingerprint
+    p.record("output", answer.encode("utf-8"))
+
+print(f"{p.report.n_hits} hits / {p.report.n_misses} misses")
+audit_chain = p.report.export_audit()
+```
+
+One template, three gains: skip repeated work (cache), prove what happened (chain), stats for your dashboard (report).
+
+## Install
+
+```bash
+pip install hypercache-kv
+export HYPERCACHE_KEY=hck_...
+```
+
+Get a key at [hypercache.ai](https://hypercache.ai).
+
+## The three gains in detail
+
+**1. Skip repeated LLM calls.** Same prompt → cached response in milliseconds. Measured 7.6× faster on cache hit against real Phi-3-mini calls.
+
+```python
+from hypercache.workflows import cached_completion
+
+text, was_hit = cached_completion(
+    prompt="Translate to French: Hello",
+    compute=lambda p: call_openai(p),
+)
+```
+
+Or wrap your OpenAI / Anthropic client directly:
+
+```python
+from openai import OpenAI
+from hypercache.workflows import wrap_openai
+
+client = wrap_openai(OpenAI())
+resp = client.chat.completions.create(model="gpt-4o-mini", messages=[...])
+```
+
+**2. Skip repeated GPU prefill.** For self-hosted inference (vLLM, llama-cpp, SGLang, TRT-LLM) with reused system prompts or RAG contexts. Measured 21.8× faster than cold prefill on Phi-3-mini at 1199 tokens. See [docs/02_skip_gpu_prefill.md](../../docs/02_skip_gpu_prefill.md).
+
+**3. Prove what happened.** Every fingerprint chains algebraically to the prior one. The chain is mathematically verifiable, server-locked against forgery, and exportable for compliance.
+
+```python
+from hypercache.workflows import audit_chain
+
+with audit_chain() as chain:
+    r1 = chain.fingerprint(input_bytes)
+    r2 = chain.fingerprint(model_output)
+    r3 = chain.fingerprint(reviewer_note)
+```
+
+## Low-level API
+
+```python
+import hypercache
+
+result = hypercache.cache_lookup(b"some input bytes")
+if result.hit:
+    print(result.value)
+else:
+    hypercache.cache_put(result.fingerprint_hex, b"my expensive output", ttl=3600)
+
+results = hypercache.cache_lookup_batch([b"in 1", b"in 2", b"in 3"])
+
+fp = hypercache.fingerprint(b"any bytes")
+print(fp.record_hex)
+```
+
+## What's open / what's closed
+
+- **Open (this SDK):** thin HTTP wrappers + workflow templates. MIT licensed.
+- **Closed:** the codec algorithm itself runs only inside our WASM binary on Cloudflare. You interact with it via HTTP.
+
+The separation is intentional: the codec's mathematical integrity (forgery resistance for audit, byte-precision for caching) requires that the algorithm cannot be replicated or modified by anyone, including customers. This SDK contains zero codec code; PRs that try to add codec algorithm code locally will be closed.
+
+## License
+
+MIT. See [LICENSE](./LICENSE).

hypercache_kv-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hypercache-kv"
+version = "0.1.0"
+description = "Skip repeated LLM calls, skip GPU prefill, prove what happened — a thin client for the Hyper Cache API."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Hyper Cache", email = "contact@hypercache.ai" }]
+keywords = ["ai", "ml", "llm", "cache", "fingerprint", "audit", "inference"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+# Zero runtime dependencies — stdlib only.
+
+[project.optional-dependencies]
+numpy = ["numpy>=1.20"]
+torch = ["torch>=2.0"]
+test = ["pytest>=7", "numpy>=1.20"]
+
+[project.urls]
+homepage = "https://hypercache.ai"
+documentation = "https://hypercache.ai/docs"
+repository = "https://github.com/Hyper-Cache/hypercache-kv"
+issues = "https://github.com/Hyper-Cache/hypercache-kv/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

hypercache_kv-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+