Richieste asincrone con richieste Python

Ho provato l'esempio fornito nella documentazione della libreria delle richieste per Python.

Con async.map(rs), ottengo i codici di risposta, ma voglio ottenere il contenuto di ogni pagina richiesta. Questo, ad esempio, non funziona:

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

Nota

La risposta di seguito non è applicabile alle richieste v0.13.0 +. La funzionalità asincrona è stata spostata su grequest dopo che questa domanda è stata scritta. Tuttavia, potresti semplicemente sostituirlo requestscon grequestssotto e dovrebbe funzionare.

Ho lasciato questa risposta per riflettere la domanda originale che riguardava l'uso delle richieste <v0.13.0.

Per eseguire più attività in async.map modo asincrono è necessario:

1. Definisci una funzione per ciò che vuoi fare con ogni oggetto (il tuo compito)
2. Aggiungi quella funzione come hook di evento nella tua richiesta
3. Chiama async.mapun elenco di tutte le richieste / azioni

Esempio:

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)

asyncè ora un modulo indipendente: grequests.

Vedi qui: https://github.com/kennethreitz/grequests

E lì: metodo ideale per inviare più richieste HTTP su Python?

installazione:

$ pip install grequests

utilizzo:

costruire uno stack:

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)

invia lo stack

grequests.map(rs)

il risultato è simile

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

grequest non sembra impostare una limitazione per le richieste simultanee, vale a dire quando più richieste vengono inviate allo stesso server.

Ho testato sia richieste-future che richieste . Grequests è più veloce ma porta patch di scimmie e problemi aggiuntivi con dipendenze. request-futures è più volte più lento delle richieste. Ho deciso di scrivere le mie richieste e ho semplicemente spostato le richieste in ThreadPoolExecutor ed è stato veloce quasi quanto le richieste, ma senza dipendenze esterne.

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

forse il future di richieste è un'altra scelta.

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)

È inoltre raccomandato nel documento dell'ufficio . Se non vuoi coinvolgere gevent, è una buona idea.

Ho molti problemi con la maggior parte delle risposte pubblicate: usano librerie obsolete che sono state trasferite con funzionalità limitate o forniscono una soluzione con troppa magia sull'esecuzione della richiesta, rendendo difficile la gestione degli errori. Se non rientrano in una delle categorie di cui sopra, sono librerie di terze parti o obsolete.

Alcune delle soluzioni funzionano perfettamente solo nelle richieste http, ma le soluzioni non sono all'altezza di qualsiasi altro tipo di richiesta, il che è ridicolo. Una soluzione altamente personalizzata non è necessaria qui.

Il semplice utilizzo della libreria integrata di Python asyncioè sufficiente per eseguire richieste asincrone di qualsiasi tipo, oltre a fornire una fluidità sufficiente per la gestione di errori complessi e specifici.

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

Come funziona è semplice. Stai creando una serie di attività che desideri eseguire in modo asincrono, quindi chiedi a un loop di eseguire tali attività e uscire al termine. Nessuna libreria extra soggetta a mancanza di manutenzione, nessuna mancanza di funzionalità richiesta.

So che questo è stato chiuso per un po ', ma ho pensato che potesse essere utile promuovere un'altra soluzione asincrona costruita sulla libreria delle richieste.

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

I documenti sono qui: 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...

Se si desidera utilizzare asyncio, requests-asyncfornisce la funzionalità async / wait per requests- https://github.com/encode/requests-async

Sto usando le richieste di Python per le chiamate asincrone contro l'API gist di github da qualche tempo.

Per un esempio, vedi il codice qui:

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

Questo stile di Python potrebbe non essere l'esempio più chiaro, ma posso assicurarti che il codice funziona. Fammi sapere se questo ti confonde e lo documenterò.

Puoi usarlo httpxper quello.

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

se vuoi una sintassi funzionale, la gamla lib lo avvolge get_async.

Quindi puoi farlo

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

Il 10è il timeout in secondi.

(disclaimer: io sono il suo autore)

Ho anche provato alcune cose usando i metodi asincroni in Python, tuttavia ho avuto molta più fortuna usando il twisted per la programmazione asincrona. Ha meno problemi ed è ben documentato. Ecco un link di qualcosa di simile a quello che stai provando in contorto.

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