web-dev-qa-db-ja.com

GRequestsでのHTTPリクエストのレートの制限/調整

Python 2.7.3 with GRequests およびlxmlを使用して、さまざまなWebサイトから収集可能なカードの価格を収集し、それらを比較できるようにする小さなスクリプトを書いています。問題リクエストの数を制限しているWebサイトの1つであり、超過した場合はHTTPエラー429を返します。

指定した1秒あたりのリクエスト数を超えないように、GRequestesでリクエスト数を調整する方法はありますか？また、HTTP 429が発生した場合、しばらくしてからGRequestesを再試行するにはどうすればよいですか？

余談ですが、それらの制限は途方もなく低いです。 15秒あたり8リクエストのようなもの。価格の変更を待っているページを更新するだけで、ブラウザで何度も違反しました。

pythonhttppython-requeststhrottlingrate-limiting
24
Bartłomiej Siwek

私はこれを自分で考えなければならず、これについての情報はほとんどないようなので、自分の質問に答えようとしています。

アイデアは以下の通りです。 GRequestsで使用されるすべてのリクエストオブジェクトは、作成時にセッションオブジェクトをパラメータとして受け取ることができます。一方、Sessionオブジェクトには、リクエストを行うときに使用されるHTTPアダプタをマウントできます。独自のアダプターを作成することで、リクエストをインターセプトし、アプリケーションに最適な方法でリクエストをレート制限できます。私の場合、私は以下のコードで終わりました。

スロットルに使用されるオブジェクト：

DEFAULT_BURST_WINDOW = datetime.timedelta(seconds=5)
DEFAULT_WAIT_WINDOW = datetime.timedelta(seconds=15)


class BurstThrottle(object):
    max_hits = None
    hits = None
    burst_window = None
    total_window = None
    timestamp = None

    def __init__(self, max_hits, burst_window, wait_window):
        self.max_hits = max_hits
        self.hits = 0
        self.burst_window = burst_window
        self.total_window = burst_window + wait_window
        self.timestamp = datetime.datetime.min

    def throttle(self):
        now = datetime.datetime.utcnow()
        if now < self.timestamp + self.total_window:
            if (now < self.timestamp + self.burst_window) and (self.hits < self.max_hits):
                self.hits += 1
                return datetime.timedelta(0)
            else:
                return self.timestamp + self.total_window - now
        else:
            self.timestamp = now
            self.hits = 1
            return datetime.timedelta(0)

HTTPアダプター：

class MyHttpAdapter(requests.adapters.HTTPAdapter):
    throttle = None

    def __init__(self, pool_connections=requests.adapters.DEFAULT_POOLSIZE,
                 pool_maxsize=requests.adapters.DEFAULT_POOLSIZE, max_retries=requests.adapters.DEFAULT_RETRIES,
                 pool_block=requests.adapters.DEFAULT_POOLBLOCK, burst_window=DEFAULT_BURST_WINDOW,
                 wait_window=DEFAULT_WAIT_WINDOW):
        self.throttle = BurstThrottle(pool_maxsize, burst_window, wait_window)
        super(MyHttpAdapter, self).__init__(pool_connections=pool_connections, pool_maxsize=pool_maxsize,
                                            max_retries=max_retries, pool_block=pool_block)

    def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):
        request_successful = False
        response = None
        while not request_successful:
            wait_time = self.throttle.throttle()
            while wait_time > datetime.timedelta(0):
                gevent.sleep(wait_time.total_seconds(), ref=True)
                wait_time = self.throttle.throttle()

            response = super(MyHttpAdapter, self).send(request, stream=stream, timeout=timeout,
                                                       verify=verify, cert=cert, proxies=proxies)

            if response.status_code != 429:
                request_successful = True

        return response

セットアップ：

requests_adapter = adapter.MyHttpAdapter(
    pool_connections=__CONCURRENT_LIMIT__,
    pool_maxsize=__CONCURRENT_LIMIT__,
    max_retries=0,
    pool_block=False,
    burst_window=datetime.timedelta(seconds=5),
    wait_window=datetime.timedelta(seconds=20))

requests_session = requests.session()
requests_session.mount('http://', requests_adapter)
requests_session.mount('https://', requests_adapter)

unsent_requests = (grequests.get(url,
                                 hooks={'response': handle_response},
                                 session=requests_session) for url in urls)
grequests.map(unsent_requests, size=__CONCURRENT_LIMIT__)
28
Bartłomiej Siwek

自動リクエストのスロットリングについては、これを見てください： https://pypi.python.org/pypi/RequestsThrottler/0.2.2

各リクエスト間に一定の遅延を設定することも、一定の秒数で送信するリクエストの数を設定することもできます（これは基本的に同じことです）。

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)

ここで、関数multi_submitはThrottledRequestのリストを返します（最後のdoc：linkを参照）。

その後、応答にアクセスできます。

for tr in throttled_requests:
    print tr.response

または、一定の時間内に送信するリクエストの数またはリクエストを指定することで同じことを実現できます（たとえば、60秒ごとに15リクエスト）。

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)

両方のソリューションは、withステートメントを使用せずに実装できます。

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

詳細： http://pythonhosted.org/RequestsThrottler/index.html

9
se7entyse7en

このビルドをリクエストまたはgrequestsコードに処理するための簡単なメカニズムはないようです。周りにあるように見える唯一のフックは応答用です。

これは、少なくともそれが可能であることを証明するための非常にハッキーな回避策です-リクエストが発行された時間のリストを保持し、1秒あたりのリクエストが最大値を下回るまでAsyncRequestの作成をスリープするようにgrequestsを変更しました。

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)

これをインタラクティブに監視するには、grequests.imap（）を使用できます。

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

もっとエレガントな解決策があればいいのにと思っていますが、今のところ解決策はありません。セッションとアダプターを見て回った。代わりに、プールマネージャーを増やすことができますか？

また、私はこのコードを本番環境には入れません-'q'リストはトリミングされず、結局かなり大きくなります。さらに、実際に宣伝どおりに機能しているかどうかはわかりません。コンソールの出力を見ると、ちょうどそのように見えます。

ああ。このコードを見るだけで、午前3時だとわかります。寝る時間です。

1
synthesizerpatel

同様の問題がありました。これが私の解決策です。あなたの場合、私はします：

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

カリング元のドメインが複数あると想定して、辞書マッピングをセットアップします(domain, delay)したがって、レート制限に達しません。

このコードは、geventおよびmonkeyパッチを使用することを想定しています。

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.
1
GrantJ