diff options
| author | CoprDistGit <infra@openeuler.org> | 2023-03-09 16:24:34 +0000 |
|---|---|---|
| committer | CoprDistGit <infra@openeuler.org> | 2023-03-09 16:24:34 +0000 |
| commit | d8f4f92ee3570c4cb33053a9dfca1841e2d4d977 (patch) | |
| tree | 6f0c9e0e3dcebb38077a9629788e8c008c5c5222 | |
| parent | 58eaeb254fb3381d0ab93376c28c2c2781c43893 (diff) | |
automatic import of python-requests-cache
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-requests-cache.spec | 550 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 552 insertions, 0 deletions
@@ -0,0 +1 @@ +/requests_cache-1.0.0.tar.gz diff --git a/python-requests-cache.spec b/python-requests-cache.spec new file mode 100644 index 0000000..7ca3e01 --- /dev/null +++ b/python-requests-cache.spec @@ -0,0 +1,550 @@ +%global _empty_manifest_terminate_build 0 +Name: python-requests-cache +Version: 1.0.0 +Release: 1 +Summary: A persistent cache for python requests +License: BSD-2-Clause +URL: https://github.com/requests-cache/requests-cache +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/ae/36/2d19b9c2442cb73c4a9a3a9c2916cc1709077ed3f78d8c7270f9ae5273ca/requests_cache-1.0.0.tar.gz +BuildArch: noarch + +Requires: python3-requests +Requires: python3-urllib3 +Requires: python3-attrs +Requires: python3-cattrs +Requires: python3-platformdirs +Requires: python3-url-normalize +Requires: python3-boto3 +Requires: python3-botocore +Requires: python3-pymongo +Requires: python3-redis +Requires: python3-bson +Requires: python3-itsdangerous +Requires: python3-pyyaml +Requires: python3-ujson +Requires: python3-furo +Requires: python3-linkify-it-py +Requires: python3-myst-parser +Requires: python3-sphinx +Requires: python3-sphinx-autodoc-typehints +Requires: python3-sphinx-automodapi +Requires: python3-sphinx-copybutton +Requires: python3-sphinx-design +Requires: python3-sphinx-notfound-page +Requires: python3-sphinxcontrib-apidoc +Requires: python3-sphinxext-opengraph + +%description +[](https://requests-cache.readthedocs.io) + +[](https://github.com/requests-cache/requests-cache/actions/workflows/build.yml) +[](https://codecov.io/gh/requests-cache/requests-cache) +[](https://requests-cache.readthedocs.io/en/stable/) +[](https://www.codeshelter.co/) + +[](https://pypi.org/project/requests-cache) +[](https://anaconda.org/conda-forge/requests-cache) +[](https://pypi.org/project/requests-cache) +[](https://pypi.org/project/requests-cache) + +## Summary +**requests-cache** is a persistent HTTP cache that provides an easy way to get better +performance with the python [requests](https://requests.readthedocs.io/) 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 transparent 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 +* 🕗 **Expiration:** Use + [Cache-Control](https://requests-cache.readthedocs.io/en/stable/user_guide/headers.html#cache-control) + and other standard HTTP headers, define your own expiration schedule, keep your cache clutter-free + with backends that natively support TTL, or any combination of strategies +* ⚙️ **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 +* 🧩 **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://requests.readthedocs.io/en/latest/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('https://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('https://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('https://httpbin.org/delay/1') +``` + +### Headers and Expiration +By default, requests-cache will keep cached responses indefinitely. In most cases, you will want to +use one of the two following strategies to balance cache freshness and performance: + +**Define exactly how long to keep responses:** + +Use the `expire_after` parameter to set a fixed expiration time for all responses: +```python +from requests_cache import CachedSession +from datetime import timedelta + +# Keep responses for 360 seconds +session = CachedSession('demo_cache', expire_after=360) + +# Or use timedelta objects to specify other units of time +session = CachedSession('demo_cache', expire_after=timedelta(hours=1)) +``` +See [Expiration](https://requests-cache.readthedocs.io/en/stable/user_guide/expiration.html) for +more features and settings. + +**Use Cache-Control headers:** + +Use the `cache_control` parameter to enable automatic expiration based on `Cache-Control` and other +standard HTTP headers sent by the server: +```python +from requests_cache import CachedSession + +session = CachedSession('demo_cache', cache_control=True) +``` +See [Cache Headers](https://requests-cache.readthedocs.io/en/stable/user_guide/headers.html) +for more details. + + +### Settings +The default settings work well for most use cases, but there are plenty of ways to customize +caching behavior when needed. Here is a quick example of some of the options available: +```python +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 response headers for expiration, if available + expire_after=timedelta(days=1), # Otherwise expire responses after one day + allowable_codes=[200, 400], # Cache 400 responses as a solemn reminder of your failures + allowable_methods=['GET', 'POST'], # Cache whatever HTTP methods you want + ignored_parameters=['api_key'], # Don't match this request param, and redact if from the cache + match_headers=['Accept-Language'], # Cache a different response per language + 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) +* [Examples](https://requests-cache.readthedocs.io/en/stable/examples.html) +* [API Reference](https://requests-cache.readthedocs.io/en/stable/reference.html) +* [Project Info](https://requests-cache.readthedocs.io/en/stable/project_info.html) +<!-- END-RTD-IGNORE --> + + +%package -n python3-requests-cache +Summary: A persistent cache for python requests +Provides: python-requests-cache +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-requests-cache +[](https://requests-cache.readthedocs.io) + +[](https://github.com/requests-cache/requests-cache/actions/workflows/build.yml) +[](https://codecov.io/gh/requests-cache/requests-cache) +[](https://requests-cache.readthedocs.io/en/stable/) +[](https://www.codeshelter.co/) + +[](https://pypi.org/project/requests-cache) +[](https://anaconda.org/conda-forge/requests-cache) +[](https://pypi.org/project/requests-cache) +[](https://pypi.org/project/requests-cache) + +## Summary +**requests-cache** is a persistent HTTP cache that provides an easy way to get better +performance with the python [requests](https://requests.readthedocs.io/) 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 transparent 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 +* 🕗 **Expiration:** Use + [Cache-Control](https://requests-cache.readthedocs.io/en/stable/user_guide/headers.html#cache-control) + and other standard HTTP headers, define your own expiration schedule, keep your cache clutter-free + with backends that natively support TTL, or any combination of strategies +* ⚙️ **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 +* 🧩 **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://requests.readthedocs.io/en/latest/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('https://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('https://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('https://httpbin.org/delay/1') +``` + +### Headers and Expiration +By default, requests-cache will keep cached responses indefinitely. In most cases, you will want to +use one of the two following strategies to balance cache freshness and performance: + +**Define exactly how long to keep responses:** + +Use the `expire_after` parameter to set a fixed expiration time for all responses: +```python +from requests_cache import CachedSession +from datetime import timedelta + +# Keep responses for 360 seconds +session = CachedSession('demo_cache', expire_after=360) + +# Or use timedelta objects to specify other units of time +session = CachedSession('demo_cache', expire_after=timedelta(hours=1)) +``` +See [Expiration](https://requests-cache.readthedocs.io/en/stable/user_guide/expiration.html) for +more features and settings. + +**Use Cache-Control headers:** + +Use the `cache_control` parameter to enable automatic expiration based on `Cache-Control` and other +standard HTTP headers sent by the server: +```python +from requests_cache import CachedSession + +session = CachedSession('demo_cache', cache_control=True) +``` +See [Cache Headers](https://requests-cache.readthedocs.io/en/stable/user_guide/headers.html) +for more details. + + +### Settings +The default settings work well for most use cases, but there are plenty of ways to customize +caching behavior when needed. Here is a quick example of some of the options available: +```python +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 response headers for expiration, if available + expire_after=timedelta(days=1), # Otherwise expire responses after one day + allowable_codes=[200, 400], # Cache 400 responses as a solemn reminder of your failures + allowable_methods=['GET', 'POST'], # Cache whatever HTTP methods you want + ignored_parameters=['api_key'], # Don't match this request param, and redact if from the cache + match_headers=['Accept-Language'], # Cache a different response per language + 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) +* [Examples](https://requests-cache.readthedocs.io/en/stable/examples.html) +* [API Reference](https://requests-cache.readthedocs.io/en/stable/reference.html) +* [Project Info](https://requests-cache.readthedocs.io/en/stable/project_info.html) +<!-- END-RTD-IGNORE --> + + +%package help +Summary: Development documents and examples for requests-cache +Provides: python3-requests-cache-doc +%description help +[](https://requests-cache.readthedocs.io) + +[](https://github.com/requests-cache/requests-cache/actions/workflows/build.yml) +[](https://codecov.io/gh/requests-cache/requests-cache) +[](https://requests-cache.readthedocs.io/en/stable/) +[](https://www.codeshelter.co/) + +[](https://pypi.org/project/requests-cache) +[](https://anaconda.org/conda-forge/requests-cache) +[](https://pypi.org/project/requests-cache) +[](https://pypi.org/project/requests-cache) + +## Summary +**requests-cache** is a persistent HTTP cache that provides an easy way to get better +performance with the python [requests](https://requests.readthedocs.io/) 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 transparent 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 +* 🕗 **Expiration:** Use + [Cache-Control](https://requests-cache.readthedocs.io/en/stable/user_guide/headers.html#cache-control) + and other standard HTTP headers, define your own expiration schedule, keep your cache clutter-free + with backends that natively support TTL, or any combination of strategies +* ⚙️ **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 +* 🧩 **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://requests.readthedocs.io/en/latest/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('https://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('https://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('https://httpbin.org/delay/1') +``` + +### Headers and Expiration +By default, requests-cache will keep cached responses indefinitely. In most cases, you will want to +use one of the two following strategies to balance cache freshness and performance: + +**Define exactly how long to keep responses:** + +Use the `expire_after` parameter to set a fixed expiration time for all responses: +```python +from requests_cache import CachedSession +from datetime import timedelta + +# Keep responses for 360 seconds +session = CachedSession('demo_cache', expire_after=360) + +# Or use timedelta objects to specify other units of time +session = CachedSession('demo_cache', expire_after=timedelta(hours=1)) +``` +See [Expiration](https://requests-cache.readthedocs.io/en/stable/user_guide/expiration.html) for +more features and settings. + +**Use Cache-Control headers:** + +Use the `cache_control` parameter to enable automatic expiration based on `Cache-Control` and other +standard HTTP headers sent by the server: +```python +from requests_cache import CachedSession + +session = CachedSession('demo_cache', cache_control=True) +``` +See [Cache Headers](https://requests-cache.readthedocs.io/en/stable/user_guide/headers.html) +for more details. + + +### Settings +The default settings work well for most use cases, but there are plenty of ways to customize +caching behavior when needed. Here is a quick example of some of the options available: +```python +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 response headers for expiration, if available + expire_after=timedelta(days=1), # Otherwise expire responses after one day + allowable_codes=[200, 400], # Cache 400 responses as a solemn reminder of your failures + allowable_methods=['GET', 'POST'], # Cache whatever HTTP methods you want + ignored_parameters=['api_key'], # Don't match this request param, and redact if from the cache + match_headers=['Accept-Language'], # Cache a different response per language + 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) +* [Examples](https://requests-cache.readthedocs.io/en/stable/examples.html) +* [API Reference](https://requests-cache.readthedocs.io/en/stable/reference.html) +* [Project Info](https://requests-cache.readthedocs.io/en/stable/project_info.html) +<!-- END-RTD-IGNORE --> + + +%prep +%autosetup -n requests-cache-1.0.0 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-requests-cache -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Thu Mar 09 2023 Python_Bot <Python_Bot@openeuler.org> - 1.0.0-1 +- Package Spec generated @@ -0,0 +1 @@ +0f20a10212e48b303d520d28709d9da5 requests_cache-1.0.0.tar.gz |