Disable the cache by restoring the original :py:class:`requests.Session`

After revalidation, update the cached response's expiration and headers

Convert redirect history, if any; avoid recursion by not copying redirects of redirects

Create a default table if one does not already exist

Enable TTL, if not already enabled

Make space in the cache to fit the given number of bytes, if needed. This starts deleting the least recently used entries first.

Check request method as well as method override headers

Log details on any failed checks for cache read or write

Delete multiple keys from the cache, without raising errors for missing keys. This is a naive, generic implementation that subclasses should

Get the first non-``None`` value in a list of values

Create a copy of this pipeline and its stage objects

Handle Binary objects from a custom serializer

Get a formatted datetime string in the local time zone

Create a CachedRequest based on an original request object

Get a resolved cache path

Get a response with randomized content

Display some info about your own resources on GitHub

Initialize a backend from a name, class, or instance

Get all ``(key, value)`` pairs in the hash

Create a new task to draw the next line on the bar chart

Normalize and filter a request body if possible, depending on Content-Type

Normalize and filter urlencoded params from either a URL or request body with form data

If the ``files`` param is present, patch the form boundary used to separate multipart uploads. ``requests`` does not provide a way to pass a custo

Redact any ignored parameters (potentially containing sensitive info) from a cached request

Convert responses to a VCR cassette dict

Save a value (file size), and update access time and total cache size

Compare cookies between the current request and cached request for Vary: Cookie

Read and copy raw response data, and then restore response object to its previous state. This is necessary so streaming responses behave consisten

Decode response body into a human-readable format, if possible

A more efficient implementation of deleting expired responses in SQL

Re-encode response body if saved as JSON or text (via ``decode_content=True``). This has no effect for a binary response body.

Estimate the current size of the database based on page count * size

Get SQL parameter marks for a sequence-based query

Use either the provided file extension, or get the serializer's default extension

Get a resolved path for a SQLite database file (or memory URI)

Handle a request error based on settings: * Default behavior: re-raise the error * stale-if-error: Ignore the error and and return the

Log which specific headers specified by Vary did not match

Merge Vary headers with user-configured match_headers to build a complete set of headers for the secondary cache key.

Attempt to parse an HTTP (RFC 5322-compatible) timestamp

Remove any redirects that no longer point to an existing response

A more efficient implementation of removing invalid redirects in SQL

Handle a stale cached response by attempting to resend the request and cache a fresh response

Send a non-blocking request to refresh a cached response

Split a cache directive into a `(key, value)` pair, or `(key, True)` if value-only

Rebuild the LRU index from files on disk

Check response headers for expiration and other cache directives

If needed, get validation headers based on a cached response. Revalidation may be triggered by a stale response, request headers, or cached re

Determine if a URL matches a pattern Args: url: URL to test. Its base URL (without protocol) will be used. pattern: Glob pattern

If the cached response contains Vary, check that the specified request headers match

Assert that the given datetimes are approximately ``target_delta`` seconds apart

Delete multiple keys from the cache. Does not raise errors for missing keys.

Delete multiple items from the cache, without raising errors for any missing items. Supports deleting by either key or by value.

Check some information on cached requests

Split an iterable into chunks of a max size

Clean up temporary build + documentation files

Create a CachedHTTPResponse based on a cached response

Constructor with some additional steps: * Handle some deprecated argument names * Ignore invalid settings, for easier initialization

Get a 504: Not Cached error response, for use with only-if-cached option

Return the time offset to use for expiration, if either min-fresh or max-stale is set

Get only the headers we should match against as a list of ``k=v`` strings, given an optional include list.

Get a requests-mock Adapter with some URLs mocked by default