Metadata-Version: 2.1
Name: requests-cache
Version: 0.9.3
Summary: A transparent persistent cache for the requests library
Home-page: https://github.com/reclosedev/requests-cache
License: BSD-2-Clause
Keywords: requests,cache,http,python-requests,web,performance,sqlite,redis,mongodb,gridfs,dynamodb
Author: Roman Haritonov
Maintainer: Jordan Cook
Requires-Python: >=3.7,<4.0
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Typing :: Typed
Provides-Extra: all
Provides-Extra: bson
Provides-Extra: docs
Provides-Extra: dynamodb
Provides-Extra: json
Provides-Extra: mongodb
Provides-Extra: redis
Provides-Extra: security
Provides-Extra: yaml
Requires-Dist: appdirs (>=1.4.4,<2.0.0)
Requires-Dist: attrs (>=21.2,<22.0)
Requires-Dist: boto3 (>=1.15,<2.0); extra == "dynamodb" or extra == "all"
Requires-Dist: botocore (>=1.18,<2.0); extra == "dynamodb" or extra == "all"
Requires-Dist: bson (>=0.5); extra == "bson"
Requires-Dist: cattrs (>=1.8,<2.0)
Requires-Dist: furo (>=2021.9.8); extra == "docs"
Requires-Dist: itsdangerous (>=2.0,<3.0); extra == "security" or extra == "all"
Requires-Dist: linkify-it-py (>=1.0.1,<2.0.0); extra == "docs"
Requires-Dist: myst-parser (>=0.15.1,<0.16.0); extra == "docs"
Requires-Dist: pymongo (>=3,<5); extra == "mongodb" or extra == "all"
Requires-Dist: pyyaml (>=5.4); extra == "yaml" or extra == "all"
Requires-Dist: redis (>=3,<5); extra == "redis" or extra == "all"
Requires-Dist: requests (>=2.22,<3.0)
Requires-Dist: sphinx (==4.3.0); extra == "docs"
Requires-Dist: sphinx-autodoc-typehints (>=1.11,<2.0); extra == "docs"
Requires-Dist: sphinx-automodapi (>=0.13,<0.15); extra == "docs"
Requires-Dist: sphinx-copybutton (>=0.3,<0.5); extra == "docs"
Requires-Dist: sphinx-inline-tabs (>=2022.1.2b11); (python_version >= "3.8") and (extra == "docs")
Requires-Dist: sphinx-notfound-page; extra == "docs"
Requires-Dist: sphinx-panels (>=0.6,<0.7); extra == "docs"
Requires-Dist: sphinxcontrib-apidoc (>=0.3,<0.4); extra == "docs"
Requires-Dist: ujson (>=4.0); extra == "json" or extra == "all"
Requires-Dist: url-normalize (>=1.4,<2.0)
Requires-Dist: urllib3 (>=1.25.5,<2.0.0)
Project-URL: Documentation, https://requests-cache.readthedocs.io
Project-URL: Repository, https://github.com/reclosedev/requests-cache
Description-Content-Type: text/markdown

[![](docs/_static/requests-cache-logo-header.png)](https://requests-cache.readthedocs.io)

[![Build](https://github.com/reclosedev/requests-cache/actions/workflows/build.yml/badge.svg)](https://github.com/reclosedev/requests-cache/actions/workflows/build.yml)
[![Codecov](https://codecov.io/gh/reclosedev/requests-cache/branch/master/graph/badge.svg?token=FnybzVWbt2)](https://codecov.io/gh/reclosedev/requests-cache)
[![Documentation](https://img.shields.io/readthedocs/requests-cache/stable)](https://requests-cache.readthedocs.io/en/stable/)
[![Code Shelter](https://www.codeshelter.co/static/badges/badge-flat.svg)](https://www.codeshelter.co/)

[![PyPI](https://img.shields.io/pypi/v/requests-cache?color=blue)](https://pypi.org/project/requests-cache)
[![Conda](https://img.shields.io/conda/vn/conda-forge/requests-cache?color=blue)](https://anaconda.org/conda-forge/requests-cache)
[![PyPI - Python Versions](https://img.shields.io/pypi/pyversions/requests-cache)](https://pypi.org/project/requests-cache)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/requests-cache?color=blue)](https://pypi.org/project/requests-cache)

## Summary
**requests-cache** is a transparent, persistent cache that provides an easy way to get better
performance with the python [requests](http://python-requests.org) library.

<!-- RTD-IGNORE -->
Complete project documentation can be found at [requests-cache.readthedocs.io](https://requests-cache.readthedocs.io).
<!-- END-RTD-IGNORE -->

## Features
* 🍰 **Ease of use:** Keep using the `requests` library you're already familiar with. Add caching
  with a [drop-in replacement](https://requests-cache.readthedocs.io/en/stable/user_guide/general.html#sessions)
  for `requests.Session`, or
  [install globally](https://requests-cache.readthedocs.io/en/stable/user_guide/general.html#patching)
  to add caching to all `requests` functions.
* 🚀 **Performance:** Get sub-millisecond response times for cached responses. When they expire, you
  still save time with
  [conditional requests](https://requests-cache.readthedocs.io/en/stable/user_guide/headers.html#conditional-requests).
* 💾 **Persistence:** Works with several
  [storage backends](https://requests-cache.readthedocs.io/en/stable/user_guide/backends.html)
  including SQLite, Redis, MongoDB, and DynamoDB; or save responses as plain JSON files, YAML,
  and more
* ⚙️ **Customization:** Works out of the box with zero config, but with a robust set of features for
  configuring and extending the library to suit your needs
* 🕗 **Expiration:** Keep your cache fresh using
  [Cache-Control](https://requests-cache.readthedocs.io/en/stable/user_guide/headers.html#cache-control),
  eagerly cache everything for long-term storage, use
  [URL patterns](https://requests-cache.readthedocs.io/en/stable/user_guide/expiration.html#expiration-with-url-patterns)
  for selective caching, or any combination of strategies
* ✔️ **Compatibility:** Can be combined with other popular
  [libraries based on requests](https://requests-cache.readthedocs.io/en/stable/user_guide/compatibility.html)

## Quickstart
First, install with pip:
```bash
pip install requests-cache
```

Then, use [requests_cache.CachedSession](https://requests-cache.readthedocs.io/en/stable/session.html)
to make your requests. It behaves like a normal
[requests.Session](https://docs.python-requests.org/en/master/user/advanced/#session-objects),
but with caching behavior.

To illustrate, we'll call an endpoint that adds a delay of 1 second, simulating a slow or
rate-limited website.

**This takes 1 minute:**
```python
import requests

session = requests.Session()
for i in range(60):
    session.get('http://httpbin.org/delay/1')
```

**This takes 1 second:**
```python
import requests_cache

session = requests_cache.CachedSession('demo_cache')
for i in range(60):
    session.get('http://httpbin.org/delay/1')
```

With caching, the response will be fetched once, saved to `demo_cache.sqlite`, and subsequent
requests will return the cached response near-instantly.

**Patching:**

If you don't want to manage a session object, or just want to quickly test it out in your
application without modifying any code, requests-cache can also be installed globally, and all
requests will be transparently cached:
```python
import requests
import requests_cache

requests_cache.install_cache('demo_cache')
requests.get('http://httpbin.org/delay/1')
```

**Configuration:**

A quick example of some of the options available:
```python
# fmt: off
from datetime import timedelta
from requests_cache import CachedSession

session = CachedSession(
    'demo_cache',
    use_cache_dir=True,                # Save files in the default user cache dir
    cache_control=True,                # Use Cache-Control headers for expiration, if available
    expire_after=timedelta(days=1),    # Otherwise expire responses after one day
    allowable_methods=['GET', 'POST'], # Cache POST requests to avoid sending the same data twice
    allowable_codes=[200, 400],        # Cache 400 responses as a solemn reminder of your failures
    ignored_parameters=['api_key'],    # Don't match this param or save it in the cache
    match_headers=True,                # Match all request headers
    stale_if_error=True,               # In case of request errors, use stale cache data if possible
)
```

<!-- RTD-IGNORE -->
## Next Steps
To find out more about what you can do with requests-cache, see:

* [User Guide](https://requests-cache.readthedocs.io/en/stable/user_guide.html)
* [API Reference](https://requests-cache.readthedocs.io/en/stable/reference.html)
* [Project Info](https://requests-cache.readthedocs.io/en/stable/project_info.html)
* A working example at Real Python:
  [Caching External API Requests](https://realpython.com/blog/python/caching-external-api-requests)
* More examples in the
  [examples/](https://github.com/reclosedev/requests-cache/tree/master/examples) folder
<!-- END-RTD-IGNORE -->

