DynamoDB#

DynamoDB is a NoSQL document database hosted on Amazon Web Services. In terms of features and use cases, it is roughly comparable to MongoDB and other NoSQL databases. It is an especially good fit for serverless applications running on AWS Lambda.

Warning

DynamoDB binary item sizes are limited to 400KB. If you need to cache larger responses, consider using a different backend.

Creating Tables#

Tables will be automatically created if they don’t already exist. This is convienient if you just want to quickly test out DynamoDB as a cache backend, but in a production environment you will likely want to create the tables yourself, for example with CloudFormation or Terraform. Here are the details you’ll need:

Tables: two tables, named responses and redirects
Partition key (aka namespace): namespace
Range key (aka sort key): key
Attributes: namespace (string) and key (string)

Connection Options#

The DynamoDB backend accepts any keyword arguments for boto3.session.Session.resource():

>>> backend = DynamoDbCache(region_name='us-west-2')
>>> session = CachedSession('http_cache', backend=backend)

API Reference#

`DynamoDbCache`	DynamoDB cache backend
`DynamoDbDict`	A dictionary-like interface for DynamoDB key-value store

class requests_cache.backends.dynamodb.DynamoDbCache(table_name='http_cache', connection=None, **kwargs)[source]#

Bases: requests_cache.backends.base.BaseCache

DynamoDB cache backend

Parameters

table_name (str) – DynamoDB table name
namespace – Name of DynamoDB hash map
connection (Optional[ServiceResource]) – DynamoDB Resource object to use instead of creating a new one
kwargs – Additional keyword arguments for resource()

bulk_delete(keys)#

Remove multiple responses and their associated redirects from the cache

Parameters: keys (Iterable[str]) –

clear()#: Delete all items from the cache

create_key(request=None, **kwargs)#

Create a normalized cache key from a request object

Parameters: request (Union[Request, PreparedRequest, CachedRequest, None]) –
Return type: str

delete(key)#

Delete a response or redirect from the cache, as well any associated redirect history

Parameters: key (str) –

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

Delete a cached response for the specified request

Parameters

url (str) –
method (str) –

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

Delete all cached responses for the specified requests

Parameters

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

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)#

Returns True if key is in the cache

Parameters: key (str) –
Return type: bool

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

Returns True if the specified request is cached

Parameters

url (str) –
method (str) –

Return type

bool

keys(check_expiry=False)#

Get all cache keys for redirects and valid responses combined

Return type: Iterator[str]

remove_expired_responses(expire_after=None)#

Remove expired and invalid responses from the cache, optionally with revalidation

Parameters: expire_after (Union[None, int, float, str, datetime, timedelta]) – A new expiration time used to revalidate the cache

response_count(check_expiry=False)#

Get the number of responses in the cache, excluding invalid (unusable) responses. Can also optionally exclude expired responses.

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 (Union[Response, CachedResponse]) – 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) –

property urls#

Get all URLs currently in the cache (excluding redirects)

Return type: Iterator[str]

values(check_expiry=False)#

Get all valid response objects from the cache

Return type: Iterator[CachedResponse]

class requests_cache.backends.dynamodb.DynamoDbDict(table_name, namespace='http_cache', connection=None, read_capacity_units=1, write_capacity_units=1, **kwargs)[source]#

Bases: requests_cache.backends.base.BaseStorage

A dictionary-like interface for DynamoDB key-value store

Notes:

The actual table name on the Dynamodb server will be namespace:table_name
In order to deal with how DynamoDB stores data, all values are serialized.

Parameters

table_name – DynamoDB table name
namespace – Name of DynamoDB hash map
connection – DynamoDB Resource object to use instead of creating a new one
kwargs – Additional keyword arguments for resource()

bulk_delete(keys)[source]#

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

Parameters: keys (Iterable[str]) –

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

composite_key(key)[source]#

Parameters: key (str) –
Return type: Dict[str, str]

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#

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

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.

property serializer#

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#