Cassetter

Rust-powered HTTP cassette recorder for Python tests. Safe by default.

Why?

VCR.py works, but has fundamental problems:

Unsafe by default - doesn't filter sensitive headers, tokens, or API keys
Unsafe YAML - uses yaml.load() with an unsafe loader that can execute arbitrary Python code from cassette files
Slow - pure Python YAML parsing, matching, and serialization
Fragile - relies on undocumented internals that break on minor version bumps
Poor readability - JSON bodies stored as escaped strings in YAML

cassetter fixes all of this with a Rust core (PyO3) for speed, safe-by-default security filtering, and secure YAML parsing.

Install

uv add cassetter

Quick start

With pytest (recommended)

Mark tests with @pytest.mark.vcr:

import httpx
import pytest

@pytest.mark.vcr
async def test_api_call():
    async with httpx.AsyncClient() as client:
        response = await client.get("https://api.example.com/users")
    assert response.status_code == 200

First run records real HTTP interactions. Subsequent runs replay from the cassette file - no network needed.

If you need direct access to the cassette (e.g. to inspect recorded interactions), request the fixture explicitly:

from cassetter import Cassette

@pytest.mark.vcr
async def test_with_cassette(cassette: Cassette):
    ...
    assert len(cassette.interactions) == 1
    assert cassette.interactions[0].request.method == "GET"

Recorded objects (HttpRequest, HttpResponse, HttpInteraction, Body, and the gRPC and WebSocket equivalents) are immutable value objects: they compare by value, and attribute assignment raises AttributeError. Use replace() to derive a modified copy:

recorded = cassette.interactions[0].request
probe = recorded.replace(uri="https://api.example.com/other")

assert probe != recorded
assert probe.method == recorded.method

To rewrite what gets recorded, use the before_record_request and before_record_response hooks, which receive mutable RawRequest and RawResponse dataclasses.

With the context manager

from cassetter import use_cassette

with use_cassette("tests/cassettes/my_test.yaml", record_mode="once"):
    async with httpx.AsyncClient() as client:
        response = await client.get("https://api.example.com/users")

With a reusable configuration

Cassetter holds the options shared by a group of cassettes, so they are declared once instead of on every call:

from cassetter import Cassetter

recorder = Cassetter(
    cassette_library_dir="tests/cassettes",
    record_mode="none",
    filter_headers=["x-gateway-apikey"],
    before_record_request=my_request_hook,
)

with recorder.use_cassette("openai.yaml"):
    ...

# override any option for a single cassette
with recorder.use_cassette("openai.yaml", record_mode="all"):
    ...

It takes every option use_cassette() takes, plus cassette_library_dir - the directory cassette names are resolved against. The object is frozen and callable, so recorder("openai.yaml") works too.

The vcr_config fixture accepts a Cassetter, so one object can configure both the pytest suite and direct use_cassette() calls:

@pytest.fixture(scope="module")
def vcr_config() -> Cassetter:
    return recorder

Record modes

Mode	Behavior
`none`	Replay only. Raises if no match found.
`once`	Record if cassette doesn't exist. Replay if it does.
`new_episodes`	Replay existing interactions. Record new ones.
`all`	Record everything, overwriting the cassette.
`rewrite`	Delete the cassette, then record everything.

Set via CLI: pytest --record-mode=none

Safe by default

Sensitive data is filtered at write time - cassettes never contain secrets. These headers are stripped automatically:

authorization, cookie, set-cookie, x-api-key, api-key, x-auth-token, proxy-authorization, www-authenticate, x-goog-api-key, x-amz-security-token

Query params like api_key, access_token, token, client_secret are replaced with [FILTERED].

JSON body fields like password, access_token, refresh_token, client_secret are scrubbed.

Filtering applies to every protocol: HTTP headers, query params, and bodies; gRPC request/response metadata and the json_debug payload; WebSocket handshake headers and text/JSON frame bodies. Binary protobuf bodies are stored as-is - they cannot be pattern-scrubbed.

Customize filtering:

from cassetter import use_cassette

with use_cassette(
    "cassette.yaml",
    filter_headers=["x-custom-secret"],
    body_scrub_patterns=["my_secret_field"],
    filter_replacement="***REDACTED***",
):
    ...

These add to the built-in lists rather than standing in for them, so naming one more header to scrub never starts recording the ones above.

Cassette format

Cassettes can be stored as YAML (default) or TOML. The format is detected by file extension (.yaml / .yml for YAML, .toml for TOML).

YAML (default)

JSON bodies are stored as structured YAML - not escaped strings:

version: 1
interactions:
  - request:
      method: POST
      uri: https://api.openai.com/v1/chat/completions
      headers:
        content-type:
          - application/json
      body:
        type: json
        content:
          model: gpt-4o
          messages:
            - role: user
              content: Hello!
    response:
      status: 200
      headers:
        content-type:
          - application/json
      body:
        type: json
        content:
          id: chatcmpl-abc123
          choices:
            - message:
                role: assistant
                content: Hi there!
    recorded_at: '2026-02-20T10:30:01Z'

TOML

Use .toml extension for TOML cassettes. Body content is stored as a JSON string since TOML cannot represent null values or heterogeneous arrays:

with use_cassette("cassette.toml"):
    ...

TOML loads ~2.8x faster than YAML and produces ~12% smaller files (saves are slower).

Request matching

Default: match on method + URI. Configurable:

from cassetter import use_cassette

with use_cassette(
    "cassette.yaml",
    match_on=["method", "uri", "json_body"],
    ignore_json_paths=["request_id", "timestamp"],
):
    ...

Available matchers: method, uri, headers, body, json_body.

Supported libraries

Library	Protocol	Interception method
httpx	HTTP	`AsyncBaseTransport` / `BaseTransport`
httpx2	HTTP	`AsyncBaseTransport` / `BaseTransport`
aiohttp	HTTP	Session `_request` patch
requests	HTTP	Session `send` patch
urllib3	HTTP	`HTTPConnectionPool.urlopen` patch
pyreqwest-impersonate	HTTP	`Client` method patches
grpcio	gRPC	`grpc.aio.Channel` wrapper
websockets	WebSocket	`websockets.connect` patch

By default, interceptors are auto-detected based on which libraries are installed. To limit interception to specific libraries:

with use_cassette("cassette.yaml", intercept=["httpx", "aiohttp"]):
    ...

Concurrency

Multiple cassettes can run concurrently in the same process - each use_cassette context gets its own isolated cassette via contextvars.ContextVar. This works out of the box with asyncio.gather, anyio.create_task_group, and any framework that creates async tasks (e.g. Pydantic Evals with max_concurrency > 1).

async def task_a():
    with use_cassette("cassettes/a.yaml", record_mode="none"):
        async with httpx.AsyncClient() as client:
            return await client.get("https://api.example.com/data")

async def task_b():
    with use_cassette("cassettes/b.yaml", record_mode="none"):
        async with httpx.AsyncClient() as client:
            return await client.get("https://api.example.com/data")

# Each task uses its own cassette - no cross-contamination
results = await asyncio.gather(task_a(), task_b())

Nested cassettes work too - the inner cassette overrides the outer, and the outer is restored when the inner exits.

Threads

For ThreadPoolExecutor, each thread has its own context by default (no cassette). To propagate the current cassette into a thread, use contextvars.copy_context():

with use_cassette("cassette.yaml", record_mode="none"):
    ctx = contextvars.copy_context()

    def work():
        with httpx.Client() as client:
            return client.get("https://api.example.com/data")

    with ThreadPoolExecutor() as pool:
        future = pool.submit(ctx.run, work)
        result = future.result()

Without copy_context(), threads see no active cassette and requests pass through to the real server.

gRPC support

Install the gRPC extra:

uv add "cassetter[grpc]"

Record and replay gRPC calls by adding "grpc" to the interceptor list:

with use_cassette("cassette.yaml", intercept=["grpc"]):
    channel = grpc.aio.insecure_channel("localhost:50051")
    stub = my_service_pb2_grpc.MyServiceStub(channel)
    response = await stub.Echo(my_service_pb2.EchoRequest(message="hello"))

All four gRPC call patterns are supported: unary-unary, server streaming, client streaming, and bidirectional streaming. Request and response bodies are stored as binary in the cassette, with an optional json_debug section for human-readable protobuf representation (when google.protobuf is available):

grpc_interactions:
  - request:
      method: /mypackage.MyService/Echo
      metadata: {}
      body:
        type: binary
        content: 0a0568656c6c6f
    response:
      status_code: 0
      status_message: OK
      metadata: {}
      body:
        type: binary
        content: 0a0568656c6c6f
    json_debug:
      request:
        message: hello
      response:
        message: hello

Streaming responses use length-prefixed binary encoding - multiple response chunks are stored in a single body field and decoded back into individual messages on replay.

WebSocket support

Install the WebSocket extra:

uv add "cassetter[websockets]"

Record and replay WebSocket connections:

with use_cassette("cassette.yaml", intercept=["websockets"]):
    async with websockets.connect("wss://ws.example.com/stream") as ws:
        await ws.send('{"subscribe": "ticker"}')
        data = await ws.recv()

WebSocket interactions record each frame with direction, type, and timing offset:

ws_interactions:
  - uri: wss://ws.example.com/stream
    headers: {}
    frames:
      - direction: send
        frame_type: text
        body:
          type: text
          content: '{"subscribe": "ticker"}'
        offset_ms: 0
      - direction: recv
        frame_type: text
        body:
          type: json
          content:
            price: 42.5
        offset_ms: 120

On replay, recv() returns recorded frames in order without a real connection, then raises ConnectionClosedOK when they're exhausted (like a real connection at end-of-stream). send() is a no-op. Both text and binary frames are supported, and both async with websockets.connect(...) and ws = await websockets.connect(...) work.

Streaming / SSE support

SSE (Server-Sent Events) responses - used by OpenAI, Anthropic, Groq, and other LLM APIs for streaming - work out of the box. The full response body is recorded as readable text in the cassette:

response:
  status: 200
  headers:
    content-type:
      - text/event-stream
  body:
    type: text
    content: |+
      data: {"id":"chatcmpl-abc","choices":[{"delta":{"role":"assistant"}}]}

      data: {"id":"chatcmpl-abc","choices":[{"delta":{"content":"Hello"}}]}

      data: [DONE]

On replay, the buffered body is returned to the client SDK, which parses SSE events from it. This matches how VCR.py handles streaming - chunk boundaries aren't preserved, but SSE parsers split on \n\n boundaries regardless of how bytes are delivered.

Request filtering

Ignore hosts

Bypass the cassette entirely for requests to specific hosts. Matched requests pass through to the real server - no recording, no replay:

with use_cassette(
    "cassette.yaml",
    ignore_hosts=["*.googleapis.com", "accounts.google.com"],
):
    ...

Patterns use fnmatch syntax (* matches any sequence of characters). Combine with ignore_localhost for full control:

with use_cassette(
    "cassette.yaml",
    ignore_localhost=True,
    ignore_hosts=["*.googleapis.com"],
):
    ...

Before record request hook

Use a callback that runs before each request is recorded or replayed. Return the (possibly modified) RawRequest. Raise SkipRecording to let the request pass through live:

from cassetter import RawRequest, SkipRecording, use_cassette

def my_hook(request: RawRequest) -> RawRequest:
    if not request.uri.startswith("https://api.mycompany.com"):
        raise SkipRecording
    # Strip auth header before recording
    request.headers.pop("authorization", None)
    return request

with use_cassette("cassette.yaml", before_record_request=my_hook):
    ...

Before record response hook

Modify or discard responses before they are recorded. Return the (possibly modified) RawResponse. Raise SkipRecording to skip recording the interaction:

from cassetter import RawResponse, SkipRecording, use_cassette

def my_hook(response: RawResponse) -> RawResponse:
    if response.status >= 500:
        raise SkipRecording  # don't record server errors
    # Strip a volatile header
    response.headers.pop("x-request-id", None)
    return response

with use_cassette("cassette.yaml", before_record_response=my_hook):
    ...

Both hooks work with the pytest plugin via vcr_config:

@pytest.fixture(scope="module")
def vcr_config():
    return {
        "ignore_hosts": ["*.googleapis.com"],
    }

Cassette expiry

Force re-recording when cassettes get stale:

with use_cassette("cassette.yaml", max_age="30d", on_expiry="rerecord"):
    ...

max_age accepts durations like "24h", "7d", "4w". on_expiry controls the behavior:

Action	Behavior
`warn`	Emit a warning (default)
`fail`	Raise `CassetteExpiredError`
`rerecord`	Delete and re-record the cassette

Also configurable via pytest:

[tool.pytest.ini_options]
vcr_max_age = "30d"
vcr_on_expiry = "warn"

Or per-test:

@pytest.mark.vcr(max_age="7d", on_expiry="fail")
async def test_fresh_data():
    ...

Orphan detection

Find cassette files that no test uses:

pytest --vcr-check-orphans=tests/cassettes/

Performance

Cassetter's Rust core is faster than vcrpy (compared against vcrpy with libyaml, its fastest configuration). Matching is the number a test suite actually feels - it runs once per request, while load and save run once per test:

                    cassetter    vcrpy        speedup
  10 interactions
  load              205 us       471 us       2.3x
  match             0.9 us       12.6 us      13.7x
  save              252 us       456 us       1.8x

  1000 interactions
  load              18.1 ms      52.8 ms      2.9x
  match             0.8 us       1.22 ms      1573.7x
  save              6.5 ms       42.5 ms      6.5x

Match cost is constant in cassette size: the method+URI index is built once and cached on the cassette, and matching runs against the interactions Rust already owns rather than copying them across the FFI boundary per request. vcrpy's linear scan is why its match column grows with N and cassetter's does not.

Absolute timings are machine dependent; the speedup ratios are the portable part. Load speedup also depends on cassette shape: many small interactions (as above) is the hardest case for the parser, while cassettes with large bodies (e.g. LLM/SSE responses) load proportionally faster.

TOML cassettes (.toml) load ~2.8x faster than YAML and produce ~12% smaller files (at the cost of slower saves):

  1000 interactions
                      YAML         TOML
  save                10.7 ms      18.0 ms
  load                53 ms        18.6 ms
  size                768 KB       675 KB

Run uv run python benchmarks/bench.py and uv run python benchmarks/bench_formats.py to reproduce.

YAML safety

vcrpy uses yaml.load() with an unsafe loader (CLoader/Loader) that can execute arbitrary Python via !!python/object tags. A malicious cassette file could run code when loaded.

cassetter parses YAML in Rust with serde-saphyr - no Python object construction, no unsafe code, panic-free on malformed input, and hard budgets against alias-expansion attacks (billion laughs). Only data types are supported.

Migrating from pytest-recording / VCR.py

cassetter is designed as a drop-in replacement. Most projects can migrate with minimal changes.

Cassette files

Existing VCR cassettes work as-is - cassetter reads both VCR format and its own format. On the next re-record, cassettes are written in cassetter's format with structured JSON bodies instead of escaped strings.

To bulk-convert existing cassettes to a different format, use the CLI:

# Convert a single file
cassetter convert cassette.yaml cassette.toml

# Convert all cassettes in a directory (in-place, changing extension)
cassetter convert tests/cassettes/ toml

# Rewrite in-place keeping the same format (VCR -> cassetter migration)
cassetter convert tests/cassettes/ yaml --force

# Convert to a separate output directory
cassetter convert tests/cassettes/ output/ --to toml

Conversion applies the default security filtering (headers, query params, body fields), so secrets recorded by VCR.py are removed on the way through. Pass --no-scrub to skip it.

pytest plugin

cassetter uses the same @pytest.mark.vcr marker, vcr_config fixture, and --record-mode CLI flag. Key differences:

pytest-recording / VCR.py	cassetter	Notes
`vcr` fixture	`cassette` fixture	`vcr` is available as an alias
`vcr.VCR(...)`	`Cassetter(...)`	Same idea, same `cassette_library_dir`
`vcr_cassette_dir` fixture	`vcr_cassette_dir` fixture	Same name, same behavior
`filter_query_parameters`	`filter_query_parameters`	Same name
`decode_compressed_response`	(automatic)	Always decompresses - no config needed
`before_record_response`	`before_record_response`	Same name, same behavior
`filter_post_data_parameters`	`body_scrub_patterns`	Regex-based instead of parameter-name-based
`before_record_request`	`before_record_request`	Same name, same behavior
`before_playback_response`	(not supported)	VCR hook to modify/filter responses during playback
`allow_playback_repeats`	(not supported)	VCR can replay the same interaction multiple times
`record_on_exception`	(not supported)	VCR can skip saving when the test raises
Custom matchers	`uri_normalizer`	Callable applied to both recorded and incoming URIs before matching; covers region/account normalization
`@pytest.mark.block_network`	(not supported)
`--disable-recording`	(not supported)

Development

Requires Rust toolchain and Python 3.10+.

git clone https://github.com/Kludex/cassetter.git
cd cassetter
uv sync
uv run maturin develop
uv run pytest

Development Status
- 3 - Alpha
Framework
- Pytest
Intended Audience
- Developers
Programming Language
- Python :: 3
- Rust
Topic
- Software Development :: Testing

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

cassetter-0.10.0.tar.gz (75.0 kB view details)

Uploaded Aug 10, 2026 Source

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

cassetter-0.10.0-cp314-cp314t-win_amd64.whl (2.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.14tWindows x86-64

cassetter-0.10.0-cp314-cp314t-musllinux_1_2_x86_64.whl (2.3 MB view details)

Uploaded Aug 10, 2026 CPython 3.14tmusllinux: musl 1.2+ x86-64

cassetter-0.10.0-cp314-cp314t-musllinux_1_2_aarch64.whl (2.1 MB view details)

Uploaded Aug 10, 2026 CPython 3.14tmusllinux: musl 1.2+ ARM64

cassetter-0.10.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.14tmanylinux: glibc 2.17+ x86-64

cassetter-0.10.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (1.9 MB view details)

Uploaded Aug 10, 2026 CPython 3.14tmanylinux: glibc 2.17+ ARM64

cassetter-0.10.0-cp314-cp314t-macosx_11_0_arm64.whl (1.8 MB view details)

Uploaded Aug 10, 2026 CPython 3.14tmacOS 11.0+ ARM64

cassetter-0.10.0-cp314-cp314t-macosx_10_12_x86_64.whl (2.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.14tmacOS 10.12+ x86-64

cassetter-0.10.0-cp314-cp314-win_amd64.whl (2.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.14Windows x86-64

cassetter-0.10.0-cp314-cp314-musllinux_1_2_x86_64.whl (2.3 MB view details)

Uploaded Aug 10, 2026 CPython 3.14musllinux: musl 1.2+ x86-64

cassetter-0.10.0-cp314-cp314-musllinux_1_2_aarch64.whl (2.1 MB view details)

Uploaded Aug 10, 2026 CPython 3.14musllinux: musl 1.2+ ARM64

cassetter-0.10.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.1 MB view details)

Uploaded Aug 10, 2026 CPython 3.14manylinux: glibc 2.17+ x86-64

cassetter-0.10.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (1.9 MB view details)

Uploaded Aug 10, 2026 CPython 3.14manylinux: glibc 2.17+ ARM64

cassetter-0.10.0-cp314-cp314-macosx_11_0_arm64.whl (1.8 MB view details)

Uploaded Aug 10, 2026 CPython 3.14macOS 11.0+ ARM64

cassetter-0.10.0-cp314-cp314-macosx_10_12_x86_64.whl (2.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.14macOS 10.12+ x86-64

cassetter-0.10.0-cp313-cp313-win_amd64.whl (2.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.13Windows x86-64

cassetter-0.10.0-cp313-cp313-musllinux_1_2_x86_64.whl (2.3 MB view details)

Uploaded Aug 10, 2026 CPython 3.13musllinux: musl 1.2+ x86-64

cassetter-0.10.0-cp313-cp313-musllinux_1_2_aarch64.whl (2.1 MB view details)

Uploaded Aug 10, 2026 CPython 3.13musllinux: musl 1.2+ ARM64

cassetter-0.10.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.1 MB view details)

Uploaded Aug 10, 2026 CPython 3.13manylinux: glibc 2.17+ x86-64

cassetter-0.10.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (1.9 MB view details)

Uploaded Aug 10, 2026 CPython 3.13manylinux: glibc 2.17+ ARM64

cassetter-0.10.0-cp313-cp313-macosx_11_0_arm64.whl (1.8 MB view details)

Uploaded Aug 10, 2026 CPython 3.13macOS 11.0+ ARM64

cassetter-0.10.0-cp313-cp313-macosx_10_12_x86_64.whl (2.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.13macOS 10.12+ x86-64

cassetter-0.10.0-cp312-cp312-win_amd64.whl (2.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.12Windows x86-64

cassetter-0.10.0-cp312-cp312-musllinux_1_2_x86_64.whl (2.3 MB view details)

Uploaded Aug 10, 2026 CPython 3.12musllinux: musl 1.2+ x86-64

cassetter-0.10.0-cp312-cp312-musllinux_1_2_aarch64.whl (2.1 MB view details)

Uploaded Aug 10, 2026 CPython 3.12musllinux: musl 1.2+ ARM64

cassetter-0.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.1 MB view details)

Uploaded Aug 10, 2026 CPython 3.12manylinux: glibc 2.17+ x86-64

cassetter-0.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (1.9 MB view details)

Uploaded Aug 10, 2026 CPython 3.12manylinux: glibc 2.17+ ARM64

cassetter-0.10.0-cp312-cp312-macosx_11_0_arm64.whl (1.8 MB view details)

Uploaded Aug 10, 2026 CPython 3.12macOS 11.0+ ARM64

cassetter-0.10.0-cp312-cp312-macosx_10_12_x86_64.whl (2.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.12macOS 10.12+ x86-64

cassetter-0.10.0-cp311-cp311-win_amd64.whl (2.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.11Windows x86-64

cassetter-0.10.0-cp311-cp311-musllinux_1_2_x86_64.whl (2.3 MB view details)

Uploaded Aug 10, 2026 CPython 3.11musllinux: musl 1.2+ x86-64

cassetter-0.10.0-cp311-cp311-musllinux_1_2_aarch64.whl (2.1 MB view details)

Uploaded Aug 10, 2026 CPython 3.11musllinux: musl 1.2+ ARM64

cassetter-0.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.1 MB view details)

Uploaded Aug 10, 2026 CPython 3.11manylinux: glibc 2.17+ x86-64

cassetter-0.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (1.9 MB view details)

Uploaded Aug 10, 2026 CPython 3.11manylinux: glibc 2.17+ ARM64

cassetter-0.10.0-cp311-cp311-macosx_11_0_arm64.whl (1.8 MB view details)

Uploaded Aug 10, 2026 CPython 3.11macOS 11.0+ ARM64

cassetter-0.10.0-cp311-cp311-macosx_10_12_x86_64.whl (2.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.11macOS 10.12+ x86-64

cassetter-0.10.0-cp310-cp310-win_amd64.whl (2.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.10Windows x86-64

cassetter-0.10.0-cp310-cp310-musllinux_1_2_x86_64.whl (2.3 MB view details)

Uploaded Aug 10, 2026 CPython 3.10musllinux: musl 1.2+ x86-64

cassetter-0.10.0-cp310-cp310-musllinux_1_2_aarch64.whl (2.1 MB view details)

Uploaded Aug 10, 2026 CPython 3.10musllinux: musl 1.2+ ARM64

cassetter-0.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.1 MB view details)

Uploaded Aug 10, 2026 CPython 3.10manylinux: glibc 2.17+ x86-64

cassetter-0.10.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (1.9 MB view details)

Uploaded Aug 10, 2026 CPython 3.10manylinux: glibc 2.17+ ARM64

cassetter-0.10.0-cp310-cp310-macosx_11_0_arm64.whl (1.8 MB view details)

Uploaded Aug 10, 2026 CPython 3.10macOS 11.0+ ARM64

cassetter-0.10.0-cp310-cp310-macosx_10_12_x86_64.whl (2.0 MB view details)

Uploaded Aug 10, 2026 CPython 3.10macOS 10.12+ x86-64

File details

Details for the file cassetter-0.10.0.tar.gz.

File metadata

Download URL: cassetter-0.10.0.tar.gz
Upload date: Aug 10, 2026
Size: 75.0 kB
Tags: Source
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/7.0.0 CPython/3.13.14

File hashes

Hashes for cassetter-0.10.0.tar.gz
Algorithm	Hash digest
SHA256	`0be6cda0ac553a93afef7cccdee28953c33f7ea0c4e817f19aadfb5f9d322afb`
MD5	`ad238335a3c7c6b58cdcc8ec45673e9b`
BLAKE2b-256	`f7df80da70ef20164336bf07175327d21fa06080f66ae0be418ff9340b1690a8`

Algorithm	Hash digest
SHA256	`e85d83a558bd6a55761e97c5ab595c575acc78ae52a76369b99b9fc9596d6847`
MD5	`17d321a4a5ffc2bff71279c91160a34d`
BLAKE2b-256	`4afc792e3fdfd7019a117b5c731bf096ffd77bd6e492032efa2f2a53bb08f6c2`

Algorithm	Hash digest
SHA256	`5230452109ed78959a853d2267bae3a63c9f2ca66d98aa77fb4c3f2250a75e9c`
MD5	`68dbf6b2723741c4b902bffe62ce2b94`
BLAKE2b-256	`a92537434840253fbbe9b9dfce1c5aec2100dd32eb5b238fabe8977cd6a9bba2`

Algorithm	Hash digest
SHA256	`1f8e447b490fc18039ad522d0921c7c75e52584ea44117ae6deaaff0ea1b1083`
MD5	`d890a5fc272bd927570623d0a077804d`
BLAKE2b-256	`aec7921aeea0914bd4c497ead8e5dc6b4412fb36d6bfd8e1fb2a273dc42c1d85`

Algorithm	Hash digest
SHA256	`69aaaeca4dbc716e7efcfaf98923043135e25dac6f4dd0a48e2c3f2560342456`
MD5	`b8adb8963888086a6ccbd5901c6278cc`
BLAKE2b-256	`cb3c8d7ac30d8d3c539a4038280d9449bcc6db1c72545395943b3b4ff6b1c7d9`

Algorithm	Hash digest
SHA256	`1dbdffd03093d6096cdd828eb145d5ae504d96955e562921d521d6b3bd00119b`
MD5	`0f0db25a3645f606f6936124db3a39de`
BLAKE2b-256	`cc4032ff46fee3c1b9ee4c52b21c2800be020319bafe4ed7fb02ed8001580c81`

Algorithm	Hash digest
SHA256	`3cd0b2ed9a94102109597423fd952345a26c8d2c245c7c81317b4b545983feb9`
MD5	`ba3dea8be893539289a2a2a6f29e2838`
BLAKE2b-256	`f9339d7d0d83cb2541dd626d72aeff3c7339941577cee3e278c26496ddea5270`

Algorithm	Hash digest
SHA256	`7fe58c8d0c8a51bdbc6f6ad544d981863c0fbba1186397faf5d7dde72f888478`
MD5	`7e699de8f81700708177821d897c0de2`
BLAKE2b-256	`e28d6d36253fb99c3e4bcfdba5380e6bd892e456e969a45c82173a6ee0584b81`

Algorithm	Hash digest
SHA256	`e4702dac7308704a849721b11666ccfcb17a24b482a3c5e96c4f53d4b206c29d`
MD5	`147e9e9092dde33eac705ec73f82c8c4`
BLAKE2b-256	`5ce6dab29c06a1fc21baa3e8c70fb7770cb3181ebf357cdfb4154c0a41ae0974`

Algorithm	Hash digest
SHA256	`112cb7dc1a24a8057c3e4ad9c84584af78e3fc6c1d07e5dea167e8ac31232a8e`
MD5	`ce9ff6d3b1c380bb075aeee5b98f2b34`
BLAKE2b-256	`68d3dd2205b26cdece5eab14046bb0015f0117334a89b5a8bacb76fb25414f5d`

Algorithm	Hash digest
SHA256	`472322f4e99fa3236a6dfd7e8fbc0a7d6df43efb1a4e6ae2c01b31e7326a128d`
MD5	`e29bbc5539c68802a498ddfa492e2bd7`
BLAKE2b-256	`fe378e9c37db3abc4cb2f747bcc6c06f36adddf413c2531aec04c08a83055372`

Algorithm	Hash digest
SHA256	`de8fb20b2fb08fe494ce8a332787c91ace9f8241f7f0b12d8cb194371afb902d`
MD5	`60577d03795bb5dac826adae2a8a8869`
BLAKE2b-256	`84b9eaf3e8bfea780ba615ff431081e6b6687a42730cd566202400241d4d338e`

Algorithm	Hash digest
SHA256	`12be22ee2e24bb98e96b5f14f39dae0d49236d71d093fe93a7c12ee08ca3591d`
MD5	`44c6e05668cb9bb21d9298a393b08e86`
BLAKE2b-256	`a18c1227c8526af5166456faca70eb9961237d4bb8b652595ebcd2b5e9cd4296`

Algorithm	Hash digest
SHA256	`138a560d0f74a1c2b43f88f75cfcfb3dcedac41050c84c550bbe9216614c6eda`
MD5	`2f99369fa4fcc13dff0596e88b243b99`
BLAKE2b-256	`5c8d7ccd7079e3136e48e7c826ff4356c86fe1702bf4369181b6ecebf6ad9556`

Algorithm	Hash digest
SHA256	`f485213fce809b90a2f15e16bc5f50617cd8e36fd2713732491391ccb9a5bed4`
MD5	`75a7df4ef9d4da192dbb67454ef3d3b6`
BLAKE2b-256	`ebe19fdb4a0e6867ebb11747193451009c5b238e61f823c1b1f612d188f59975`

Algorithm	Hash digest
SHA256	`880dbc397bae217d33628a407cfc087f5399c9fab4a65a0d4b7ccd9145ab8238`
MD5	`7c9aa56014015c234d66f168f95be863`
BLAKE2b-256	`8c8f427ef5d06f5ac17847f1da3959f69e12bf084a5b61a8782496d9c826afec`

Algorithm	Hash digest
SHA256	`09263f3968699ead344e2f3abf58c2a9385c4fb26d14f6b8a7745dd60a281cc3`
MD5	`b54916de008ce122ccc78636f7b91c66`
BLAKE2b-256	`ee775d0dae0c0d971e3bad24f2e95eb4e4c6c0f839e333bf69fbe13e054fac92`

Algorithm	Hash digest
SHA256	`af570fe2e7c304f894b50b5c7202df23e094c607bfe99a9fcdc16f4a72b2e76e`
MD5	`585d624e6ab65c1c1f767c9932bbb022`
BLAKE2b-256	`def7f0a4975b99102224879094e1904692fc496cc06b8979fd2d5c69b9bc8ca8`

Algorithm	Hash digest
SHA256	`6425d876f11ea4fb73c5d733ed6b5649a3111f2e9ad01ebf2401c5221259b2eb`
MD5	`1ca86b1186ee6bc289cffe1391b6704b`
BLAKE2b-256	`c97dcbc7f99b63239916c90b19eb64879c74f0351e8cc7a2cd45618d585cb1df`

Algorithm	Hash digest
SHA256	`e87ab9d87ad149f5dcbba9caf7051c17358bcf29ed365a38b24c9c6391431ae4`
MD5	`4bd8313e772d80e83d8edaa1e64ec480`
BLAKE2b-256	`70589f17faf5636b579d783eb02af0ac2c065fb1391ecc74a5b471a0464a041c`

Algorithm	Hash digest
SHA256	`5631f9566c7f3fdef7959957895775264a5b43ebf5010678f8efc07e12f9335b`
MD5	`177f72d55e83f7e86f3a3ea7ab5f112b`
BLAKE2b-256	`f082d53c88a15f0a0ae72d4990c9de2eb12ec4a0fffd1f65a4ead3928dec977b`

cassetter 0.10.0

Cassetter

Why?

Install

Quick start

With pytest (recommended)

With the context manager

With a reusable configuration

Record modes

Safe by default

Cassette format

YAML (default)

TOML

Request matching

Supported libraries

Concurrency

Threads

gRPC support

WebSocket support

Streaming / SSE support

Request filtering

Ignore hosts

Before record request hook

Before record response hook

Cassette expiry

Orphan detection

Performance

YAML safety

Migrating from pytest-recording / VCR.py

Cassette files

pytest plugin

Development

Project links

Key dates

1 maintainer

Credits

GitHub Statistics

License expression

Requires

Provides Extra

Classifiers

Download files

Source Distribution

Built Distributions

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

Algorithm	Hash digest
SHA256	`085bcbcb07d99b9c9ad2d1664d34c3787faa649daff1987a10ea3f1b5e687b7a`
MD5	`7e5b78d8b9b2e5e03c799bc702c5aaf5`
BLAKE2b-256	`f2c2d09ead53ece6a57c623056a3b86484120d95dd536e3f7d746061866b0b11`

Algorithm	Hash digest
SHA256	`edcf7421923a67ae39f1b54ec7b59e90a950b613a6ceab7b8f8fcdc8cbc808cd`
MD5	`3bafeee6b7da85fdb399b30b77699cac`
BLAKE2b-256	`0ac6dd2acc0e8d1f748f6bf58fa0b4d90f033ae1c58f77c1471d9d2ebdf2cde1`

Algorithm	Hash digest
SHA256	`c1e6c7095dacaa73971a5a178af7c5985e7aee2ddeb79ef019745f9231f34606`
MD5	`6dfad905ba5b0c152bfb3b43251dc46c`
BLAKE2b-256	`e877f1b26b2aa4b992eb1ed6f9f369b5a5909b5902f0fe59c0e323ea288c7f87`

Algorithm	Hash digest
SHA256	`7c390e7768147791b1231b16e6d48b19dd50cb8d9a6bad7394d4a8bea55c0ae2`
MD5	`49118a416bffd80fbda1e29f11275f61`
BLAKE2b-256	`fc98091d0b1321cb6679cefbe158d775d60d28523d633dd05883b0c43ca67603`

Algorithm	Hash digest
SHA256	`28d896f97394ace6507018bb26939e666cb97f499a6368bd0e36c1d667406037`
MD5	`373c57b3b4f68beba4817de5e3bcdbaa`
BLAKE2b-256	`392fbce5ab25b8b5a130ab24a173400729f080684e0cd7378c882e3124999ad7`

Algorithm	Hash digest
SHA256	`e6845a57d15815a77a0a8f8e01141623fac0a3d8feb2313794426a8b43cd6485`
MD5	`b67d149c7a1e437b6a2226a3439bd6a0`
BLAKE2b-256	`8ea7a60c3ffffad6ffb740cbc4ff4f22b765cf03f3433a41aa454dd180f7455b`

Algorithm	Hash digest
SHA256	`2a95761021ea9bf60dd47b1724e4624b97d329b6898c1495c9dc496e691a68a5`
MD5	`44b9319cc02c4b3253935ea28aa646c1`
BLAKE2b-256	`cf6ba794c94a8deb68cfca50723cca21c80de48a57cd617638f5c5fdbff3cb6a`

Algorithm	Hash digest
SHA256	`b6fc4817c57e025a69c81f84dcd17a32156b01d1ab44e773cbe6ed30fc0f5f43`
MD5	`b3c7ad2baba1fce467280f2c441c92f1`
BLAKE2b-256	`1f74e89e199f1ed6f08641d155b0d48ae6b2948e6c2362b4920d319a49a913ac`

Algorithm	Hash digest
SHA256	`3d97cecd208d2113746b5ce6755543f3e7fe50d526d7b99304052fdcc3803455`
MD5	`e26d8b9b9c9484bc3138e83739563574`
BLAKE2b-256	`399dedf543287765389094d4788a40481746fc672e5782e1cd0075f4620f2927`

Algorithm	Hash digest
SHA256	`d3f3a5461fc0450cb329bff377ee86be1c2c6d192ec602c368f7b356d9038906`
MD5	`fa0b33bf344ccc3c8d6971f3099a9951`
BLAKE2b-256	`0e4581691f2e290c297a947ad89b45d53f29d775a8229d879544836006d4ace3`