requests cache

Résumé

Les demandes-cache sont un cache HTTP persistant qui fournit un moyen facile d'obtenir de meilleures performances avec la bibliothèque Python Demandes.

La documentation complète du projet peut être trouvée sur requêtes-cache.readthedocs.io.

Caractéristiques

• ? Facilité d'utilisation: Continuez à utiliser la bibliothèque requests que vous connaissez déjà. Ajoutez la mise en cache avec un remplacement sans rendez-vous pour requests requests.Session .
• Performance: Obtenez des temps de réponse inférieurs au milliseconde pour les réponses en cache. Lorsqu'ils expirent, vous gagnez toujours du temps avec des demandes conditionnelles.
• ? Persistance: fonctionne avec plusieurs backends de stockage, notamment SQLite, Redis, MongoDB et DynamoDB; ou enregistrer les réponses sous les fichiers JSON simples, YAML, et plus
• ? Expiration: utilisez le contrôle du cache et d'autres en-têtes HTTP standard, définissez votre propre horaire d'expiration, gardez votre cache sans encombre
• Personnalisation: fonctionne hors de la boîte avec une configuration nulle, mais avec un ensemble robuste de fonctionnalités pour configurer et étendre la bibliothèque en fonction de vos besoins
• ? Compatibilité: peut être combinée avec d'autres bibliothèques populaires en fonction des demandes

Start

Tout d'abord, installez avec PIP:

pip install requests-cache

Ensuite, utilisez des demandes_cache.cachedSession pour faire vos demandes. Il se comporte comme une demande normale, mais avec un comportement de mise en cache.

Pour illustrer, nous appellerons un point final qui ajoute un délai de 1 seconde, simulant un site Web lent ou limité par taux.

Cela prend 1 minute:

 import requests

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

Cela prend 1 seconde:

 import requests_cache

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

Avec la mise en cache, la réponse sera récupérée une fois, enregistrée sur demo_cache.sqlite , et les demandes ultérieures renverront la réponse mise en cache près d'instruction.

Radiation

Si vous ne souhaitez pas gérer un objet de session, ou si vous souhaitez simplement le tester rapidement dans votre application sans modifier de code, les demandes-cache peuvent également être installées à l'échelle mondiale et toutes les demandes seront mises en cache transparente:

 import requests
import requests_cache

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

En-têtes et expiration

Par défaut, les demandes-cache conserveront indéfiniment les réponses en cache. Dans la plupart des cas, vous voudrez utiliser l'une des deux stratégies suivantes pour équilibrer la fraîcheur et les performances du cache:

Définissez exactement combien de temps pour garder les réponses:

Utilisez le paramètre expire_after pour définir un temps d'expiration fixe pour toutes les nouvelles réponses:

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

Voir l'expiration pour plus de fonctionnalités et de paramètres.

Utilisez des en-têtes de contrôle du cache:

Utilisez le paramètre cache_control pour activer l'expiration automatique en fonction du Cache-Control et d'autres en-têtes HTTP standard envoyés par le serveur:

 from requests_cache import CachedSession

session = CachedSession ( 'demo_cache' , cache_control = True )

Voir les en-têtes de cache pour plus de détails.

Paramètres

Les paramètres par défaut fonctionnent bien pour la plupart des cas d'utilisation, mais il existe de nombreuses façons de personnaliser le comportement de mise en cache en cas de besoin. Voici un exemple rapide de certaines des options disponibles:

 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
)

Étapes suivantes

Pour en savoir plus sur ce que vous pouvez faire avec les demandes-cache, voir:

• Guide de l'utilisateur
• Exemples
• Référence de l'API
• Informations sur le projet