Redis#

Redis cache backend. For usage details, see Backends: Redis.

`RedisCache`	Redis cache backend.
`RedisDict`	A dictionary-like interface for Redis operations.
`RedisHashDict`	A dictionary-like interface for operations on a single Redis hash

class requests_cache.backends.redis.RedisCache(namespace='http_cache', connection=None, serializer=None, ttl=True, ttl_offset=3600, **kwargs)[source]#

Bases: BaseCache

Redis cache backend.

Parameters:

namespace – Redis namespace
connection (Optional[Redis]) – Redis connection instance to use instead of creating a new one
ttl (bool) – Use Redis TTL to automatically delete expired items
ttl_offset (int) – Additional time to wait before deleting expired items, in seconds
kwargs – Additional keyword arguments for redis.client.Redis
serializer (Union[str, SerializerPipeline, Stage, None]) –

clear()#: Delete all items from the cache

close()#: Close any open backend connections

contains(key=None, request=None, url=None)#

Check if the specified request is cached

Parameters:

key (Optional[str]) – Check for a specific cache key
request (Union[Request, PreparedRequest, CachedRequest, None]) – Check for a matching request, according to current request matching settings
url (Optional[str]) – Check for a matching GET request with the specified URL

create_key(request, match_headers=None, **kwargs)#

Create a normalized cache key from a request object

Parameters:

request (Union[Request, PreparedRequest, CachedRequest]) –
match_headers (Optional[Iterable[str]]) –

Return type:

str

delete(*keys, expired=False, invalid=False, older_than=None, requests=None, urls=None)#

Remove responses from the cache according one or more conditions.

Parameters:

keys (str) – Remove responses with these cache keys
expired (bool) – Remove all expired responses
invalid (bool) – Remove all invalid responses (that can’t be deserialized with current settings)
older_than (Union[None, int, float, str, datetime, timedelta]) – Remove responses older than this value, relative to response.created_at
requests (Optional[Iterable[Union[Request, PreparedRequest, CachedRequest]]]) – Remove matching responses, according to current request matching settings
urls (Optional[Iterable[str]]) – Remove matching GET requests for the specified URL(s)

delete_url(url, method='GET', **kwargs)#

Parameters:

url (str) –
method (str) –

delete_urls(urls, method='GET', **kwargs)#

Parameters:

urls (Iterable[str]) –
method (str) –

filter(valid=True, expired=True, invalid=False, older_than=None)#

Get responses from the cache, with optional filters for which responses to include:

Parameters:

valid (bool) – Include valid and unexpired responses; set to False to get only expired/invalid/old responses
expired (bool) – Include expired responses
invalid (bool) – Include invalid responses (as an empty CachedResponse)
older_than (Union[None, int, float, str, datetime, timedelta]) – Get responses older than this value, relative to response.created_at

Return type:

Iterator[CachedResponse]

get_response(key, default=None)#

Retrieve a response from the cache, if it exists

Parameters:

key (str) – Cache key for the response
default – Value to return if key is not in the cache

Return type:

Optional[CachedResponse]

has_key(key)#

Parameters:: key (str) –
Return type:: bool

has_url(url, method='GET', **kwargs)#

Parameters:

url (str) –
method (str) –

Return type:

bool

keys(check_expiry=False)#

Parameters:: check_expiry (bool) –
Return type:: Iterator[str]

recreate_keys()#: Recreate cache keys for all previously cached responses

remove_expired_responses(expire_after=None)#

Parameters:: expire_after (Union[None, int, float, str, datetime, timedelta]) –

reset_expiration(expire_after=None)#

Set a new expiration value to set on existing cache items

Parameters:: expire_after (Union[None, int, float, str, datetime, timedelta]) – New expiration value, relative to the current time

response_count(check_expiry=False)#

Parameters:: check_expiry (bool) –
Return type:: int

save_response(response, cache_key=None, expires=None)#

Save a response to the cache

Parameters:

cache_key (Optional[str]) – Cache key for this response; will otherwise be generated based on request
response (Response) – Response to save
expires (Optional[datetime]) – Absolute expiration time for this response

update(other)#

Update this cache with the contents of another cache

Parameters:: other (BaseCache) –

urls(**kwargs)#

Get all unique cached URLs. Optionally takes keyword arguments for filter().

Return type:: List[str]

values(check_expiry=False)#

Parameters:: check_expiry (bool) –
Return type:: Iterator[CachedResponse]

class requests_cache.backends.redis.RedisDict(namespace, collection_name=None, connection=None, serializer=<requests_cache.serializers.pipeline.SerializerPipeline object>, ttl=True, ttl_offset=3600, **kwargs)[source]#

Bases: BaseStorage

A dictionary-like interface for Redis operations.

Notes:

All keys will be encoded as bytes, and all values will be serialized
Supports TTL

Parameters:

namespace (str) –
collection_name (Optional[str]) –
serializer (Union[str, SerializerPipeline, Stage, None]) –
ttl (bool) –
ttl_offset (int) –

bulk_delete(keys)[source]#

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

Parameters:: keys (Iterable[str]) –

clear() → None. Remove all items from D.[source]#

close()[source]#: Close any open backend connections

deserialize(key, value)#

Deserialize a value, if a serializer is available.

If deserialization fails (usually due to a value saved in an older requests-cache version), None will be returned.

Parameters:: value (TypeVar(VT)) –

get(k[, d]) → D[k] if k in D, else d. d defaults to None.#

items() → a set-like object providing a view on D's items[source]#

keys() → a set-like object providing a view on D's keys[source]#

pop(k[, d]) → v, remove specified key and return the corresponding value.#: If key is not found, d is returned if given, otherwise KeyError is raised.

popitem() → (k, v), remove and return some (key, value) pair#: as a 2-tuple; but raise KeyError if D is empty.

serialize(value)#

Serialize a value, if a serializer is available

Parameters:: value (TypeVar(VT)) –

setdefault(k[, d]) → D.get(k,d), also set D[k]=d if k not in D#

update([E, ]**F) → None. Update D from mapping/iterable E and F.#: If E present and has a .keys() method, does: for k in E: D[k] = E[k] If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v In either case, this is followed by: for k, v in F.items(): D[k] = v

values() → an object providing a view on D's values[source]#

class requests_cache.backends.redis.RedisHashDict(namespace='http_cache', collection_name=None, connection=None, serializer=<requests_cache.serializers.pipeline.Stage object>, **kwargs)[source]#

Bases: BaseStorage

A dictionary-like interface for operations on a single Redis hash

Notes:

All keys will be encoded as bytes
Items will be stored in a hash named namespace:collection_name

Parameters:

namespace (str) –
collection_name (Optional[str]) –
serializer (Union[str, SerializerPipeline, Stage, None]) –

bulk_delete(keys)[source]#

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

Parameters:: keys (Iterable[str]) –

clear() → None. Remove all items from D.[source]#

close()#: Close any open backend connections

deserialize(key, value)#

Deserialize a value, if a serializer is available.

If deserialization fails (usually due to a value saved in an older requests-cache version), None will be returned.

Parameters:: value (TypeVar(VT)) –

get(k[, d]) → D[k] if k in D, else d. d defaults to None.#

items()[source]#: Get all (key, value) pairs in the hash

keys() → a set-like object providing a view on D's keys[source]#

pop(k[, d]) → v, remove specified key and return the corresponding value.#: If key is not found, d is returned if given, otherwise KeyError is raised.

popitem() → (k, v), remove and return some (key, value) pair#: as a 2-tuple; but raise KeyError if D is empty.

serialize(value)#

Serialize a value, if a serializer is available

Parameters:: value (TypeVar(VT)) –

setdefault(k[, d]) → D.get(k,d), also set D[k]=d if k not in D#

update([E, ]**F) → None. Update D from mapping/iterable E and F.#: If E present and has a .keys() method, does: for k in E: D[k] = E[k] If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v In either case, this is followed by: for k, v in F.items(): D[k] = v

values()[source]#: Get all values in the hash