Asynchrone Anforderungen mit Python-Anforderungen

Ich habe das Beispiel in der Dokumentation der Anforderungsbibliothek für Python ausprobiert .

Mit async.map(rs)erhalte ich die Antwortcodes, möchte aber den Inhalt jeder angeforderten Seite abrufen. Dies funktioniert beispielsweise nicht:

out = async.map(rs)
print out[0].content

Hinweis

Die folgende Antwort gilt nicht für Anfragen v0.13.0 +. Die asynchrone Funktionalität wurde nach dem Schreiben dieser Frage in Grequests verschoben . Allerdings konnte man nur ersetzen requestsmit grequestsunten und es sollte funktionieren.

Ich habe diese Antwort so belassen, wie sie ist, um die ursprüngliche Frage zu reflektieren, bei der es um die Verwendung von Anforderungen <v0.13.0 ging.

Um mehrere Aufgaben async.map asynchron auszuführen , müssen Sie:

1. Definieren Sie eine Funktion für das, was Sie mit jedem Objekt (Ihrer Aufgabe) tun möchten.
2. Fügen Sie diese Funktion als Ereignis-Hook in Ihre Anfrage ein
3. Rufen Sie async.mapeine Liste aller Anfragen / Aktionen auf

Beispiel:

from requests import async
# If using requests > v0.13.0, use
# from grequests import async

urls = [
    'http://python-requests.org',
    'http://httpbin.org',
    'http://python-guide.org',
    'http://kennethreitz.com'
]

# A simple task to do to each response object
def do_something(response):
    print response.url

# A list to hold our things to do via async
async_list = []

for u in urls:
    # The "hooks = {..." part is where you define what you want to do
    # 
    # Note the lack of parentheses following do_something, this is
    # because the response will be used as the first argument automatically
    action_item = async.get(u, hooks = {'response' : do_something})

    # Add the task to our list of things to do via async
    async_list.append(action_item)

# Do our list of things to do via async
async.map(async_list)

asyncist jetzt ein eigenständiges Modul : grequests.

Siehe hier: https://github.com/kennethreitz/grequests

Und da: Ideale Methode zum Senden mehrerer HTTP-Anfragen über Python?

Installation:

$ pip install grequests

Verwendung:

Bauen Sie einen Stapel:

import grequests

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

rs = (grequests.get(u) for u in urls)

Senden Sie den Stapel

grequests.map(rs)

Ergebnis sieht aus wie

[<Response [200]>, <Response [200]>, <Response [200]>, <Response [200]>, <Response [200]>]

Grequests scheinen keine Einschränkung für gleichzeitige Anforderungen festzulegen, dh wenn mehrere Anforderungen an denselben Server gesendet werden.

Ich habe sowohl Anfragen-Futures als auch Grequests getestet . Grequests sind schneller, bringen aber Affen-Patches und zusätzliche Probleme mit Abhängigkeiten mit sich. Anfragen-Futures sind um ein Vielfaches langsamer als Grequests. Ich habe beschlossen, meine eigenen und einfach verpackten Anfragen in ThreadPoolExecutor zu schreiben, und es war fast so schnell wie Grequests, aber ohne externe Abhängigkeiten.

import requests
import concurrent.futures

def get_urls():
    return ["url1","url2"]

def load_url(url, timeout):
    return requests.get(url, timeout = timeout)

with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:

    future_to_url = {executor.submit(load_url, url, 10): url for url in     get_urls()}
    for future in concurrent.futures.as_completed(future_to_url):
        url = future_to_url[future]
        try:
            data = future.result()
        except Exception as exc:
            resp_err = resp_err + 1
        else:
            resp_ok = resp_ok + 1

Vielleicht ist Anfragen-Futures eine andere Wahl.

from requests_futures.sessions import FuturesSession

session = FuturesSession()
# first request is started in background
future_one = session.get('http://httpbin.org/get')
# second requests is started immediately
future_two = session.get('http://httpbin.org/get?foo=bar')
# wait for the first request to complete, if it hasn't already
response_one = future_one.result()
print('response one status: {0}'.format(response_one.status_code))
print(response_one.content)
# wait for the second request to complete, if it hasn't already
response_two = future_two.result()
print('response two status: {0}'.format(response_two.status_code))
print(response_two.content)

Es wird auch in empfohlen Office - Dokument . Wenn Sie nicht gevent einbeziehen möchten, ist es eine gute.

Ich habe viele Probleme mit den meisten Antworten - sie verwenden entweder veraltete Bibliotheken, die mit eingeschränkten Funktionen portiert wurden, oder bieten eine Lösung mit zu viel Magie bei der Ausführung der Anforderung, was die Fehlerbehandlung erschwert. Wenn sie nicht in eine der oben genannten Kategorien fallen, sind sie Bibliotheken von Drittanbietern oder veraltet.

Einige der Lösungen funktionieren nur in http-Anfragen, aber die Lösungen sind für jede andere Art von Anfrage nicht geeignet, was lächerlich ist. Eine hochgradig kundenspezifische Lösung ist hier nicht erforderlich.

Die einfache Verwendung der in Python integrierten Bibliothek asyncioreicht aus, um asynchrone Anforderungen jeglicher Art auszuführen und eine ausreichende Fluidität für die komplexe und benutzerspezifische Fehlerbehandlung bereitzustellen.

import asyncio

loop = asyncio.get_event_loop()

def do_thing(params):
    async def get_rpc_info_and_do_chores(id):
        # do things
        response = perform_grpc_call(id)
        do_chores(response)

    async def get_httpapi_info_and_do_chores(id):
        # do things
        response = requests.get(URL)
        do_chores(response)

    async_tasks = []
    for element in list(params.list_of_things):
       async_tasks.append(loop.create_task(get_chan_info_and_do_chores(id)))
       async_tasks.append(loop.create_task(get_httpapi_info_and_do_chores(ch_id)))

    loop.run_until_complete(asyncio.gather(*async_tasks))

Wie es funktioniert ist einfach. Sie erstellen eine Reihe von Aufgaben, die asynchron ausgeführt werden sollen, und fordern dann eine Schleife auf, diese Aufgaben auszuführen und nach Abschluss zu beenden. Keine zusätzlichen Bibliotheken, die nicht gewartet werden müssen, keine mangelnde Funktionalität erforderlich.

Ich weiß, dass dies für eine Weile geschlossen wurde, aber ich dachte, es könnte nützlich sein, eine andere asynchrone Lösung zu bewerben, die auf der Anforderungsbibliothek basiert.

list_of_requests = ['http://moop.com', 'http://doop.com', ...]

from simple_requests import Requests
for response in Requests().swarm(list_of_requests):
    print response.content

Die Dokumente finden Sie hier: http://pythonhosted.org/simple-requests/

threads=list()

for requestURI in requests:
    t = Thread(target=self.openURL, args=(requestURI,))
    t.start()
    threads.append(t)

for thread in threads:
    thread.join()

...

def openURL(self, requestURI):
    o = urllib2.urlopen(requestURI, timeout = 600)
    o...

Wenn Sie asyncio verwenden möchten, requests-asyncbietet es async / await-Funktionen für requests- https://github.com/encode/requests-async

Ich verwende seit einiger Zeit Python-Anforderungen für asynchrone Aufrufe für die Gistub-API.

Ein Beispiel finden Sie im Code hier:

https://github.com/davidthewatson/flasgist/blob/master/views.py#L60-72

Dieser Python-Stil ist vielleicht nicht das klarste Beispiel, aber ich kann Ihnen versichern, dass der Code funktioniert. Lassen Sie mich wissen, wenn dies für Sie verwirrend ist, und ich werde es dokumentieren.

Es ist ein weiteres Paket mit dem Namen fgrequests verfügbar .

Es ist eine Alternative zu Grequests. Es ist schneller als grequests. Der Grund dafür fgrequestsist, dass Threading für gleichzeitige Anforderungen verwendet wird. Sie können Ihr eigenes Parallelitätslimit entsprechend der Leistung Ihres Systems festlegen. Es hat auch eine gute Dokumentation. Bietet auch fast alle Funktionen der Python- requestsBibliothek.

Ich hoffe, Ihnen wird das in beiden (features & speed)Szenarien gefallen .

Sie können dafür verwenden httpx.

import httpx

async def get_async(url):
    async with httpx.AsyncClient() as client:
        return await client.get(url)

urls = ["http://google.com", "http://wikipedia.org"]

# Note that you need an async context to use `await`.
await asyncio.gather(*map(get_async, urls))

Wenn Sie eine funktionale Syntax wünschen, wird diese von der Gamla Lib umschlossen get_async.

Dann können Sie tun

await gamla.map(gamla.get_async(10), ["http://google.com", "http://wikipedia.org"])

Das 10ist das Timeout in Sekunden.

(Haftungsausschluss: Ich bin sein Autor)

Ich habe auch einige Dinge mit den asynchronen Methoden in Python ausprobiert, aber ich hatte viel mehr Glück mit Twisted für die asynchrone Programmierung. Es hat weniger Probleme und ist gut dokumentiert. Hier ist ein Link von etwas ähnlichem zu dem, was Sie in verdreht versuchen.

http://pythonquirks.blogspot.com/2011/04/twisted-asynchronous-http-request.html