Limiter/restreindre le taux de requêtes HTTP dans les requêtes Grequest

jetez un coup d'oeil à ceci pour les demandes automatiques: https://pypi.python.org/pypi/RequestsThrottler/0.2.2

vous pouvez définir à la fois un délai fixe entre chaque requête ou un nombre de requêtes pour envoyer un nombre fixe de secondes (ce qui est essentiellement la même chose):

import requests
from requests_throttler import BaseThrottler

request = requests.Request(method='GET', url='http://www.google.com')
reqs = [request for i in range(0, 5)]  # An example list of requests
with BaseThrottler(name='base-throttler', delay=1.5) as bt:
    throttled_requests = bt.multi_submit(reqs)

la fonction multi_submit renvoie une liste de ThrottledRequest (voir doc: lien à la fin).

vous pouvez alors l'accès à l'réponses:

for tr in throttled_requests:
    print tr.response

alternativement vous pouvez obtenir la même chose en spécifiant le nombre ou les requêtes à envoyer dans un temps déterminé (par exemple 15 requêtes toutes les 60 secondes):

import requests
from requests_throttler import BaseThrottler

request = requests.Request(method='GET', url='http://www.google.com')
reqs = [request for i in range(0, 5)]  # An example list of requests
with BaseThrottler(name='base-throttler', reqs_over_time=(15, 60)) as bt:
    throttled_requests = bt.multi_submit(reqs)

les deux solutions peuvent être mises en œuvre sans l'utilisation du with déclaration:

import requests
from requests_throttler import BaseThrottler

request = requests.Request(method='GET', url='http://www.google.com')
reqs = [request for i in range(0, 5)]  # An example list of requests
bt = BaseThrottler(name='base-throttler', delay=1.5)
bt.start()
throttled_requests = bt.multi_submit(reqs)
bt.shutdown()

Pour plus de détails: http://pythonhosted.org/RequestsThrottler/index.html

ne ressemble pas à il n'y a pas de mécanisme simple pour gérer cette compilation dans les requêtes ou le code de grequests. Le seul crochet qui semble être autour est pour les réponses.

voici un super travail hacky pour au moins prouver qu'il est possible - j'ai modifié les grequests pour garder une liste de l'heure à laquelle une demande a été émise et dormir la création de L'AsyncRequest jusqu'à ce que les demandes par seconde étaient inférieures au maximum.

class AsyncRequest(object):
    def __init__(self, method, url, **kwargs):
        print self,'init'
        waiting=True
        while waiting:
            if len([x for x in q if x > time.time()-15]) < 8:
                q.append(time.time())
                waiting=False
            else:
                print self,'snoozing'
                gevent.sleep(1)

vous pouvez utiliser les grequests.imap() pour regarder ce de manière interactive

import time
import rg

urls = [
        'http://www.heroku.com',
        'http://python-tablib.org',
        'http://httpbin.org',
        'http://python-requests.org',
        'http://kennethreitz.com',
        'http://www.cnn.com',
]

def print_url(r, *args, **kwargs):
        print(r.url),time.time()

hook_dict=dict(response=print_url)
rs = (rg.get(u, hooks=hook_dict) for u in urls)
for r in rg.imap(rs):
        print r

j'aimerais qu'il y ait une solution plus élégante, mais jusqu'à présent je n'en trouve pas. J'ai regardé dans les sessions et les adaptateurs. Peut-être que le poolmanager pourrait être augmenté à la place?

aussi, je ne mettrais pas ce code en production - la liste 'q' ne sera jamais tronquée et finira par devenir assez grande. En plus, je ne sais pas si ça marche comme annoncé. On dirait que c'est le cas quand je regarde la sortie de la console.

Ugh. Simplement en regardant ce code je peux dire qu'il est 3h du matin. Le temps de goto lit.

j'ai eu un problème similaire. Voici ma solution. Dans votre cas, je voudrais faire:

def worker():
    with rate_limit('slow.domain.com', 2):
        response = requests.get('https://slow.domain.com/path')
        text = response.text
    # Use `text`

en présumant que vous avez plusieurs domaines à partir desquels vous faites le tri, je mettrais en place un dictionnaire de mappage (domain, delay) donc vous n'atteignez pas vos limites de taux.

Ce code suppose que vous allez utiliser gevent et monkey patch.

from contextlib import contextmanager
from gevent.event import Event
from gevent.queue import Queue
from time import time


def rate_limit(resource, delay, _queues={}):
    """Delay use of `resource` until after `delay` seconds have passed.

    Example usage:

    def worker():
        with rate_limit('foo.bar.com', 1):
            response = requests.get('https://foo.bar.com/path')
            text = response.text
        # use `text`

    This will serialize and delay requests from multiple workers for resource
    'foo.bar.com' by 1 second.

    """

    if resource not in _queues:
        queue = Queue()
        gevent.spawn(_watch, queue)
        _queues[resource] = queue

    return _resource_manager(_queues[resource], delay)


def _watch(queue):
    "Watch `queue` and wake event listeners after delay."

    last = 0

    while True:
        event, delay = queue.get()

        now = time()

        if (now - last) < delay:
            gevent.sleep(delay - (now - last))

        event.set()   # Wake worker but keep control.
        event.clear()
        event.wait()  # Yield control until woken.

        last = time()


@contextmanager
def _resource_manager(queue, delay):
    "`with` statement support for `rate_limit`."

    event = Event()
    queue.put((event, delay))

    event.wait() # Wait for queue watcher to wake us.

    yield

    event.set()  # Wake queue watcher.