standin 0.2.0__tar.gz

standin-0.2.0/.gitignore

@@ -0,0 +1,14 @@
+__pycache__/
+*.pyc
+*.egg-info/
+build/
+dist/
+.pytest_cache/
+.hypothesis/
+.mypy_cache/
+.venv/
+venv/
+.env
+.DS_Store
+demo/.cache/
+demo/cassettes/

standin-0.2.0/ARCHITECTURE.md

@@ -0,0 +1,73 @@
+# Architecture
+
+`standin` is organized as a set of small, single-responsibility layers. The
+guiding rule: **the record/replay policy never knows which HTTP client it is
+sitting behind.** That keeps the decision logic tiny and testable, and makes new
+clients (or storage formats, matchers, redactors) additive rather than invasive.
+
+## Layers
+
+```
+                        use_cassette()          <- public API (core.py)
+                             │
+                             ▼
+        ┌───────────────  Engine  ───────────────┐   <- policy (engine.py)
+        │  record vs replay, ordering, misses     │
+        └───┬───────────┬───────────┬─────────────┘
+            │           │           │
+        Matcher     Redactor   CassetteStore        <- pluggable protocols
+        (matching)  (redaction) (storage)
+            │           │           │
+            ▼           ▼           ▼
+                     Cassette  ── Interaction / Recorded{Request,Response}
+                                        (models.py, _codec.py)
+            ▲
+            │  RawRequest / RawResponse  (transport-neutral)
+            │
+      ┌─────┴───────────────┐
+      │    Interceptor       │   <- transport glue (interceptors/)
+      │  HttpxInterceptor    │
+      └─────────────────────┘
+              │
+        httpx.HTTPTransport (patched once, inert until a cassette is open)
+```
+
+## Modules
+
+| Module | Responsibility |
+| --- | --- |
+| `models.py` | Data types. `RawRequest/RawResponse` (in-flight, bytes) vs `RecordedRequest/RecordedResponse/Interaction` (on disk). `Mode` enum. |
+| `_codec.py` | Body encode/decode + canonicalization for matching. |
+| `redaction.py` | `Redactor` protocol; `DefaultRedactor` (headers + secret patterns), `NullRedactor`. |
+| `matching.py` | `Matcher` protocol; `DefaultMatcher` (method/url/body, JSON-aware). |
+| `storage.py` | `CassetteStore` protocol; `JSONCassetteStore`. |
+| `cassette.py` | In-memory interactions + the ordered replay cursor. |
+| `config.py` | Wires the pieces; validates `mode`; picks the redactor. |
+| `engine.py` | The **policy**: replay-or-record, per `Mode`. Transport-neutral. |
+| `interceptors/` | Adapters from a concrete client to the engine. `HttpxInterceptor` today. |
+| `core.py` | `use_cassette` context manager: build config → engine → activate. |
+| `pytest_plugin.py` | `standin` fixture + `@pytest.mark.standin`. |
+
+## Data flow
+
+**Record** (cache miss): interceptor converts the client request to a
+`RawRequest` → engine calls `do_real` (the real network call) → response is
+redacted, encoded, appended to the cassette → returned to the client.
+
+**Replay** (cache hit): interceptor builds the `RawRequest` → engine matches it
+against an unplayed `Interaction` → decodes the stored response → returns it,
+**without any network call**.
+
+The active engine lives in a `ContextVar`, so recording is correct across threads
+and asyncio, and the httpx patch is completely inert whenever no cassette is open.
+
+## Extension points
+
+Every collaborator is a `Protocol`, so you can pass your own:
+
+- **Interceptor** — support another client (`requests`, `aiohttp`). The engine
+  is already transport-neutral; you only translate that client's request/response
+  to `RawRequest`/`RawResponse`.
+- **Matcher** — change when a live request equals a recording (e.g. semantic).
+- **Redactor** — change what gets scrubbed.
+- **CassetteStore** — change the on-disk format (YAML, a single archive, ...).

standin-0.2.0/CHANGELOG.md

@@ -0,0 +1,37 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/), and the project adheres to
+[Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+## [0.2.0] - 2026-09-05
+
+### Added
+- `standin` command-line tool: `list`, `show`, `stats`, and `scrub` (re-run
+  secret redaction over an existing cassette).
+- `FuzzyMatcher`: match method/url exactly but allow the request body to differ
+  up to a similarity threshold, so a reworded/reformatted prompt still replays.
+  A semantic/embedding matcher plugs in the same way (implement `matches`).
+- Runnable examples for OpenAI and LangChain under `examples/`.
+
+### Changed
+- The `Matcher` protocol is now a single `matches(live, stored)` predicate
+  (exact and fuzzy strategies share the cassette lookup). `DefaultMatcher` keeps
+  its `live_key`/`stored_key` helpers.
+
+## [0.1.0] - 2026-09-05
+
+### Added
+- `use_cassette` context manager and a `standin` pytest fixture / marker.
+- Provider-agnostic record & replay via an httpx transport interceptor
+  (OpenAI, Anthropic, Gemini, Mistral, Cohere, litellm, LangChain, LlamaIndex).
+- Streaming (SSE) record and replay.
+- Automatic redaction of auth headers and secret tokens in cassettes.
+- VCR-style modes: `once`, `none`, `all`, `new_episodes`; `STANDIN_MODE` override.
+- JSON-body-aware matching; ordered replay for repeated calls (agent loops).
+- Pluggable `Matcher`, `Redactor`, and `CassetteStore` protocols.
+
+[Unreleased]: https://github.com/eeshsaxena/standin/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/eeshsaxena/standin/releases/tag/v0.1.0

standin-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eesh Saxena
+
+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.

standin-0.2.0/PKG-INFO

@@ -0,0 +1,182 @@
+Metadata-Version: 2.5
+Name: standin
+Version: 0.2.0
+Summary: A stand-in for the real LLM in your tests. Record LLM API calls once, replay them forever: fast, free, deterministic, offline.
+Project-URL: Homepage, https://github.com/eeshsaxena/standin
+Project-URL: Source, https://github.com/eeshsaxena/standin
+Project-URL: Issues, https://github.com/eeshsaxena/standin/issues
+Project-URL: Changelog, https://github.com/eeshsaxena/standin/blob/main/CHANGELOG.md
+Author-email: Eesh Saxena <eeshsaxena@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ai,anthropic,cassette,deterministic,llm,mock,openai,pytest,record,replay,testing,vcr
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.23
+Provides-Extra: dev
+Requires-Dist: anthropic>=0.30; extra == 'dev'
+Requires-Dist: hypothesis>=6; extra == 'dev'
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: openai>=1.0; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# standin
+
+**A stand-in for the real LLM in your tests.** Record your LLM API calls once, then replay them forever: fast, free, deterministic, and fully offline. One line, any provider.
+
+<p align="center"><img src="demo/standin.gif" alt="standin: record LLM calls once, replay them instantly and offline" width="820"></p>
+
+```python
+import standin
+
+with standin.use_cassette("tests/cassettes/summary.json"):
+    reply = client.chat.completions.create(model="gpt-4o", messages=[...])
+# First run: hits the real API and records it.
+# Every run after: replayed from disk. No network, no cost, same answer.
+```
+
+Your LLM tests are slow, flaky, and cost money because they hit real APIs. `standin` makes them **deterministic and offline** by recording the real HTTP calls once and replaying them after, with the things LLM devs actually need: **streaming**, **tool-calls**, **secret redaction**, and **body-aware matching**.
+
+---
+
+## Why not just VCR.py?
+
+VCR.py is great, but it's a general HTTP tool. `standin` is built for LLMs:
+
+- **Provider-agnostic, zero wiring.** It hooks `httpx` under the hood, so it works with **OpenAI, Anthropic, Gemini, Mistral, Cohere, litellm, LangChain, LlamaIndex** — anything that sends over httpx. No per-SDK adapters.
+- **Streaming just works.** Server-sent event (SSE) responses are recorded and replayed intact.
+- **Safe to commit.** API keys in headers and secret-looking tokens in bodies are **redacted automatically**, so cassettes can live in a public repo.
+- **Body-aware matching.** Requests match on normalized JSON, so key ordering and formatting noise don't break replays. Repeated identical calls (agent loops) replay in order.
+- **One-line pytest fixture**, with sane auto-named cassettes.
+- **Clean, typed, extensible core** (see [ARCHITECTURE.md](ARCHITECTURE.md)) — swap the matcher, redactor, or storage backend.
+
+## Install
+
+```bash
+pip install standin
+```
+
+Python 3.9+ and `httpx` (already a dependency of the major LLM SDKs).
+
+## Quickstart
+
+### With pytest (recommended)
+
+```python
+import pytest
+
+@pytest.mark.standin          # cassette auto-named tests/cassettes/test_summarize.json
+def test_summarize(standin):
+    out = summarize("war and peace")     # your code that calls an LLM
+    assert "Napoleon" in out
+```
+
+First run records against the real API; every run after replays from the cassette. Commit the cassette and teammates (and CI) run the test with **no keys and no network**.
+
+### Anywhere (context manager)
+
+```python
+import standin
+from openai import OpenAI
+
+client = OpenAI()
+with standin.use_cassette("tests/cassettes/haiku.json"):
+    resp = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[{"role": "user", "content": "haiku about testing"}],
+    )
+```
+
+## Modes
+
+| Mode | Behavior |
+| --- | --- |
+| `once` (default) | Replay if the cassette exists, otherwise record it. |
+| `none` | Replay only. **Errors on any unrecorded call** — use this in CI. |
+| `all` | Always re-record, ignoring existing interactions. |
+| `new_episodes` | Replay what's recorded, record anything new (great for agent loops). |
+
+**In CI**, force replay-only for the whole run so a stray live call fails loudly:
+
+```bash
+STANDIN_MODE=none pytest
+```
+
+## What a cassette looks like
+
+Plain, reviewable JSON, secrets already stripped:
+
+```json
+{
+  "version": 1,
+  "recorded_with": "standin",
+  "interactions": [
+    {
+      "request": {
+        "method": "POST",
+        "url": "https://api.openai.com/v1/chat/completions",
+        "headers": { "authorization": "[REDACTED]" },
+        "body": { "json": { "model": "gpt-4o-mini", "messages": [ ] } }
+      },
+      "response": { "status_code": 200, "body": { "json": { "choices": [ ] } } }
+    }
+  ]
+}
+```
+
+## Extending it
+
+Everything is a small protocol you can replace (see [ARCHITECTURE.md](ARCHITECTURE.md)):
+
+```python
+standin.use_cassette(path, matcher=MyMatcher(), redactor=MyRedactor(), store=MyStore())
+```
+
+- **Matcher** — decide when a live request equals a recorded one. Ships with
+  `DefaultMatcher` (exact) and `FuzzyMatcher` (body may drift up to a similarity
+  threshold, so a reworded prompt still replays):
+
+  ```python
+  from standin import use_cassette, FuzzyMatcher, DefaultRedactor
+  with use_cassette(path, matcher=FuzzyMatcher(DefaultRedactor(), threshold=0.9)):
+      ...
+  ```
+- **Redactor** — control what gets scrubbed before writing.
+- **CassetteStore** — change the on-disk format.
+
+## Command line
+
+```bash
+standin list  tests/cassettes/summary.json     # one line per interaction
+standin show  tests/cassettes/summary.json 0   # full request/response
+standin stats tests/cassettes/summary.json     # counts by method/status
+standin scrub tests/cassettes/summary.json     # re-run secret redaction in place
+```
+
+## Roadmap
+
+- Embedding-based semantic matching (a `Matcher` you drop in; `FuzzyMatcher`
+  already covers string-similarity drift today).
+- `requests` / `aiohttp` interceptors (the engine is already transport-neutral).
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Run the suite with `pytest`, lint with `ruff`, type-check with `mypy`.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

standin-0.2.0/README.md

@@ -0,0 +1,146 @@
+# standin
+
+**A stand-in for the real LLM in your tests.** Record your LLM API calls once, then replay them forever: fast, free, deterministic, and fully offline. One line, any provider.
+
+<p align="center"><img src="demo/standin.gif" alt="standin: record LLM calls once, replay them instantly and offline" width="820"></p>
+
+```python
+import standin
+
+with standin.use_cassette("tests/cassettes/summary.json"):
+    reply = client.chat.completions.create(model="gpt-4o", messages=[...])
+# First run: hits the real API and records it.
+# Every run after: replayed from disk. No network, no cost, same answer.
+```
+
+Your LLM tests are slow, flaky, and cost money because they hit real APIs. `standin` makes them **deterministic and offline** by recording the real HTTP calls once and replaying them after, with the things LLM devs actually need: **streaming**, **tool-calls**, **secret redaction**, and **body-aware matching**.
+
+---
+
+## Why not just VCR.py?
+
+VCR.py is great, but it's a general HTTP tool. `standin` is built for LLMs:
+
+- **Provider-agnostic, zero wiring.** It hooks `httpx` under the hood, so it works with **OpenAI, Anthropic, Gemini, Mistral, Cohere, litellm, LangChain, LlamaIndex** — anything that sends over httpx. No per-SDK adapters.
+- **Streaming just works.** Server-sent event (SSE) responses are recorded and replayed intact.
+- **Safe to commit.** API keys in headers and secret-looking tokens in bodies are **redacted automatically**, so cassettes can live in a public repo.
+- **Body-aware matching.** Requests match on normalized JSON, so key ordering and formatting noise don't break replays. Repeated identical calls (agent loops) replay in order.
+- **One-line pytest fixture**, with sane auto-named cassettes.
+- **Clean, typed, extensible core** (see [ARCHITECTURE.md](ARCHITECTURE.md)) — swap the matcher, redactor, or storage backend.
+
+## Install
+
+```bash
+pip install standin
+```
+
+Python 3.9+ and `httpx` (already a dependency of the major LLM SDKs).
+
+## Quickstart
+
+### With pytest (recommended)
+
+```python
+import pytest
+
+@pytest.mark.standin          # cassette auto-named tests/cassettes/test_summarize.json
+def test_summarize(standin):
+    out = summarize("war and peace")     # your code that calls an LLM
+    assert "Napoleon" in out
+```
+
+First run records against the real API; every run after replays from the cassette. Commit the cassette and teammates (and CI) run the test with **no keys and no network**.
+
+### Anywhere (context manager)
+
+```python
+import standin
+from openai import OpenAI
+
+client = OpenAI()
+with standin.use_cassette("tests/cassettes/haiku.json"):
+    resp = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[{"role": "user", "content": "haiku about testing"}],
+    )
+```
+
+## Modes
+
+| Mode | Behavior |
+| --- | --- |
+| `once` (default) | Replay if the cassette exists, otherwise record it. |
+| `none` | Replay only. **Errors on any unrecorded call** — use this in CI. |
+| `all` | Always re-record, ignoring existing interactions. |
+| `new_episodes` | Replay what's recorded, record anything new (great for agent loops). |
+
+**In CI**, force replay-only for the whole run so a stray live call fails loudly:
+
+```bash
+STANDIN_MODE=none pytest
+```
+
+## What a cassette looks like
+
+Plain, reviewable JSON, secrets already stripped:
+
+```json
+{
+  "version": 1,
+  "recorded_with": "standin",
+  "interactions": [
+    {
+      "request": {
+        "method": "POST",
+        "url": "https://api.openai.com/v1/chat/completions",
+        "headers": { "authorization": "[REDACTED]" },
+        "body": { "json": { "model": "gpt-4o-mini", "messages": [ ] } }
+      },
+      "response": { "status_code": 200, "body": { "json": { "choices": [ ] } } }
+    }
+  ]
+}
+```
+
+## Extending it
+
+Everything is a small protocol you can replace (see [ARCHITECTURE.md](ARCHITECTURE.md)):
+
+```python
+standin.use_cassette(path, matcher=MyMatcher(), redactor=MyRedactor(), store=MyStore())
+```
+
+- **Matcher** — decide when a live request equals a recorded one. Ships with
+  `DefaultMatcher` (exact) and `FuzzyMatcher` (body may drift up to a similarity
+  threshold, so a reworded prompt still replays):
+
+  ```python
+  from standin import use_cassette, FuzzyMatcher, DefaultRedactor
+  with use_cassette(path, matcher=FuzzyMatcher(DefaultRedactor(), threshold=0.9)):
+      ...
+  ```
+- **Redactor** — control what gets scrubbed before writing.
+- **CassetteStore** — change the on-disk format.
+
+## Command line
+
+```bash
+standin list  tests/cassettes/summary.json     # one line per interaction
+standin show  tests/cassettes/summary.json 0   # full request/response
+standin stats tests/cassettes/summary.json     # counts by method/status
+standin scrub tests/cassettes/summary.json     # re-run secret redaction in place
+```
+
+## Roadmap
+
+- Embedding-based semantic matching (a `Matcher` you drop in; `FuzzyMatcher`
+  already covers string-similarity drift today).
+- `requests` / `aiohttp` interceptors (the engine is already transport-neutral).
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Run the suite with `pytest`, lint with `ruff`, type-check with `mypy`.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

standin-0.2.0/demo/README.md

@@ -0,0 +1,44 @@
+# Demo
+
+Two ways to see `standin` work, both keyless and offline (a local server stands
+in for the OpenAI API with realistic latency).
+
+## The one-liner (used for the README GIF)
+
+```bash
+python demo/demo.py
+```
+
+Records 5 model calls once (~8s), then replays them from the cassette (~0.03s):
+
+```
+  1st run   real API calls, recording     8.07s   $$$
+  every run replayed from cassette        0.029s   $0.00  offline
+  => 281x faster, deterministic, no network, no keys.
+```
+
+## The pytest example (the real workflow)
+
+```bash
+pytest demo/test_summary.py -p standin.pytest_plugin -q   # first run records
+pytest demo/test_summary.py -p standin.pytest_plugin -q   # replays, offline
+```
+
+(The `-p` flag isn't needed once `standin` is `pip install`ed — the plugin loads
+automatically.)
+
+## Regenerating the GIF
+
+The GIF is produced from [`demo.tape`](demo.tape) with
+[VHS](https://github.com/charmbracelet/vhs):
+
+```bash
+vhs demo/demo.tape        # writes demo/standin.gif
+```
+
+No VHS? Record with [asciinema](https://asciinema.org) instead:
+
+```bash
+asciinema rec -c "python demo/demo.py" demo/standin.cast
+# then: agg demo/standin.cast demo/standin.gif
+```

standin-0.2.0/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "standin"
+version = "0.2.0"
+description = "A stand-in for the real LLM in your tests. Record LLM API calls once, replay them forever: fast, free, deterministic, offline."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{ name = "Eesh Saxena", email = "eeshsaxena@gmail.com" }]
+keywords = ["llm", "testing", "pytest", "openai", "anthropic", "vcr", "cassette", "record", "replay", "mock", "ai", "deterministic", "agents"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Framework :: Pytest",
+    "Topic :: Software Development :: Testing",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Typing :: Typed",
+]
+dependencies = ["httpx>=0.23"]
+
+[project.optional-dependencies]
+dev = ["pytest>=7", "ruff>=0.5", "mypy>=1.8", "openai>=1.0", "anthropic>=0.30", "hypothesis>=6"]
+
+[project.urls]
+Homepage = "https://github.com/eeshsaxena/standin"
+Source = "https://github.com/eeshsaxena/standin"
+Issues = "https://github.com/eeshsaxena/standin/issues"
+Changelog = "https://github.com/eeshsaxena/standin/blob/main/CHANGELOG.md"
+
+[project.entry-points.pytest11]
+standin = "standin.pytest_plugin"
+
+[project.scripts]
+standin = "standin.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["standin"]
+
+[tool.hatch.build.targets.sdist]
+include = ["standin", "tests", "README.md", "LICENSE", "ARCHITECTURE.md", "CHANGELOG.md"]
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "C4"]
+ignore = ["E501"]
+
+[tool.mypy]
+python_version = "3.10"
+ignore_missing_imports = true
+warn_redundant_casts = true
+no_implicit_optional = true

standin-0.2.0/standin/__init__.py

@@ -0,0 +1,42 @@
+"""standin — a stand-in for the real LLM in your tests.
+
+Record real LLM API calls once, then replay them forever: fast, free, offline,
+and deterministic. Provider-agnostic (hooks httpx), streaming and tool-calls
+supported, secrets redacted so cassettes are safe to commit.
+
+    import standin
+
+    with standin.use_cassette("tests/cassettes/summary.json"):
+        resp = openai_client.chat.completions.create(...)   # recorded once, replayed after
+
+Architecture (see ARCHITECTURE.md): a transport-neutral policy **engine** sits
+behind pluggable **interceptors** (httpx today), **matchers**, **redactors**,
+and **stores**, so behavior is easy to reason about and extend.
+"""
+from .config import Config
+from .core import use_cassette
+from .exceptions import CannotReplay, CassetteError, ConfigError, StandinError
+from .matching import DefaultMatcher, FuzzyMatcher, Matcher
+from .models import Mode
+from .redaction import DefaultRedactor, NullRedactor, Redactor
+from .storage import CassetteStore, JSONCassetteStore
+
+__version__ = "0.2.0"
+__all__ = [
+    "use_cassette",
+    "Config",
+    "Mode",
+    "StandinError",
+    "CannotReplay",
+    "CassetteError",
+    "ConfigError",
+    "Redactor",
+    "DefaultRedactor",
+    "NullRedactor",
+    "Matcher",
+    "DefaultMatcher",
+    "FuzzyMatcher",
+    "CassetteStore",
+    "JSONCassetteStore",
+    "__version__",
+]