Get the url for either a local or remote httpbin instance

Get the current time in UTC (timezone-aware)

Check if the specified request is cached Args: key: Check for a specific cache key request: Check for a matching requ

Initialize from request info and cache settings. Note on refreshing: `must-revalidate` isn't a standard request header, but is used here to

This method prepares and sends a request while automatically performing any necessary caching operations. This will be called by any other met

Delete all items from the cache

Get a thread-local database connection

Return the size of the database, in bytes. For an in-memory database, this will be an estimate based on page size.

Create a normalized cache key based on a request object Args: request: Request object to generate a cache key from ignored_parame

Initialize a LRUFileDict with common test parameters. Args: shared_cache_name: If provided, use this exact cache name (for multi-

Convert the CachedRequest back into a PreparedRequest

Create a CachedResponse based on an original Response or another CachedResponse object

Determine if we can reuse a cached response, or set headers for a conditional request if possible. Used after fetching a cached respo

Convert an expiration value in any supported format to an absolute datetime

Get absolute file paths to all cached responses

Update this cache with the contents of another cache

Create a placeholder type for a class that does not have dependencies installed. This allows delaying ImportErrors until init time, rather than at

Get cache values in sorted order; see :py:meth:`.SQLiteCache.sorted` for usage details

Simplified reader for cached content that emulates :py:meth:`urllib3.response.HTTPResponse.read()`, but does not need to read from a socket

Save a response to the cache Args: cache_key: Cache key for this response; will otherwise be generated based on request

Send a prepared request, with caching. See :py:meth:`requests.Session.send` for base parameters, and see :py:meth:`.request` for extra paramet

Count number of responses, optionally excluding expired

Normalize and remove ignored parameters from request URL, body, and headers. This is used for both: * Increasing cache hits by generating mor

Get the least recently used keys with a combined size >= total_size

Get the subset of non-None ``kwargs`` that are valid arguments for ``func``

Insert a large number of records within a single transaction Example: >>> d1 = SQLiteDict('test') >>> with d1.bulk_c

Create a normalized cache key from a request object

Deserialize a value, if a serializer is available. If deserialization fails (usually due to a value saved in an older requests-cache version)

Encode a value to bytes, if it hasn't already been

Serialize a value, if a serializer is available

Return a file size on disk, rounded up to fit the blocks on the file system

Decode a value from bytes, if hasn't already been. Note: ``PreparedRequest.body`` is always encoded in utf-8.

Determine whether a given cached response is "fresh enough" to satisfy the request, based on: * min-fresh * max-stale

Create a preconf serializer stage from a module name, if dependencies are installed. For JSON converters, force base64 encoding; cattrs defaults

Sort and filter request headers, and normalize minor variations in multi-value headers

Create or update a TTL index, and ignore and log any errors due to dropping a nonexistent index or attempting to overwrite without ```overwrit

Delete multiple keys from the cache, without raising errors for missing keys

Context manager for temporary disabling the cache .. warning:: This method is not thread-safe. Example: >>> s

Close the session and any open backend connections

Retrieve a response from the cache, if it exists Args: key: Cache key for the response default: Value to return if `k

For tests that use multiple tables, make index part of the table name

Get all unique cached URLs. Optionally takes keyword arguments for :py:meth:`.filter`.

Attempt an I/O operation, and either ignore errors or re-raise them as KeyErrors

Get responses from the cache, with optional filters for which responses to include: Args: valid: Include valid and unexpired resp

Get the currently defined TTL value in seconds, if any

Set a new expiration value to set on existing cache items Args: expire_after: New expiration value, **relative to the current tim

Update expiration + actions based on headers and other details from a new response. Used after receiving a new response, but before saving it

Send a request and cache the response, unless disabled by settings or headers. If applicable, also handle conditional requests.

Remove responses from the cache according one or more conditions. Args: keys: Remove responses with these cache keys

Get the internal cache object from the currently installed ``CachedSession`` (if any)

Convert an expiration value in any supported format to an expiration time in seconds

Initialize the database, if it hasn't already been

Initialize a serializer by name or instance

Create a serializer that uses ``pickle`` + ``itsdangerous`` to add a signature to responses on write, and validate that signature with a secret ke

Set decode_content, if the pipeline contains a CattrStage or compatible object

Translate keyword arguments into equivalent request headers

Update the given key with the current timestamp Raises: KeyError: If the key doesn't exist in the LRU index

Set content and reset raw response file pointer

Close any open backend connections

Close any active connections

Filter ignored parameters out of a URL

Convert a file size in bytes into a human-readable format

Parse cache directives and other settings from request or response headers

Check for a matching per-URL expiration, if any

Install the cache for all ``requests`` functions by monkey-patching :py:class:`requests.Session` Example: >>> requests_cache.instal

Returns whether the given content-type represents json

Normalize and filter a request body with serialized JSON data

Recreate cache keys for all previously cached responses

Reset raw response file pointer, and optionally update content