Solicitudes asincrónicas con solicitudes de Python

Probé la muestra proporcionada en la documentación de la biblioteca de solicitudes para python.

Con async.map(rs), obtengo los códigos de respuesta, pero quiero obtener el contenido de cada página solicitada. Esto, por ejemplo, no funciona:

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

Nota

La siguiente respuesta no es aplicable a las solicitudes v0.13.0 +. La funcionalidad asincrónica se trasladó a grequests después de escribir esta pregunta. Sin embargo, podría reemplazar requestscon el grequestssiguiente y debería funcionar.

He dejado esta respuesta como para reflejar la pregunta original sobre el uso de solicitudes <v0.13.0.

Para realizar múltiples tareas de async.map forma asincrónica debes:

1. Defina una función para lo que desea hacer con cada objeto (su tarea)
2. Agregue esa función como un enlace de evento en su solicitud
3. Llame async.mapa una lista de todas las solicitudes / acciones

Ejemplo:

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)

asynces ahora un módulo independiente: grequests.

Ver aquí: https://github.com/kennethreitz/grequests

Y allí: ¿ Método ideal para enviar múltiples solicitudes HTTP a través de Python?

instalación:

$ pip install grequests

uso:

construir una pila:

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)

envía la pila

grequests.map(rs)

el resultado parece

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

grequests no parece establecer una limitación para las solicitudes concurrentes, es decir, cuando se envían varias solicitudes al mismo servidor.

Probé ambas solicitudes de futuros y grequests . Grequests es más rápido pero trae parches de mono y problemas adicionales con las dependencias. request-futuros es varias veces más lento que grequests. Decidí escribir mis propias solicitudes y simplemente envolverlas en ThreadPoolExecutor y fue casi tan rápido como grequests, pero sin dependencias externas.

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

tal vez las solicitudes de futuros es otra opción.

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)

También se recomienda en el documento de la oficina . Si no quieres involucrar a gevent, es bueno.

Tengo muchos problemas con la mayoría de las respuestas publicadas: o usan bibliotecas obsoletas que se han portado con funciones limitadas o proporcionan una solución con demasiada magia en la ejecución de la solicitud, lo que dificulta el manejo de errores. Si no entran en una de las categorías anteriores, son bibliotecas de terceros o están en desuso.

Algunas de las soluciones funcionan bien únicamente en solicitudes http, pero las soluciones se quedan cortas para cualquier otro tipo de solicitud, lo cual es ridículo. Aquí no es necesaria una solución altamente personalizada.

El simple uso de la biblioteca incorporada de Python asyncioes suficiente para realizar solicitudes asíncronas de cualquier tipo, además de proporcionar suficiente fluidez para el manejo de errores complejos y de casos de uso específicos.

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

El funcionamiento es simple. Está creando una serie de tareas que le gustaría que ocurrieran de forma asíncrona y luego solicita un ciclo para ejecutar esas tareas y salir al finalizar. No hay bibliotecas adicionales sujetas a falta de mantenimiento, no se requiere falta de funcionalidad.

Sé que esto ha estado cerrado por un tiempo, pero pensé que podría ser útil promover otra solución asíncrona construida en la biblioteca de solicitudes.

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

Los documentos están aquí: 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...

Si desea usar asyncio, requests-asyncproporciona la funcionalidad async / wait para requests: https://github.com/encode/requests-async

He estado usando solicitudes de python para llamadas asíncronas contra la API de Github durante algún tiempo.

Para ver un ejemplo, vea el código aquí:

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

Este estilo de python puede no ser el ejemplo más claro, pero puedo asegurarle que el código funciona. Avíseme si esto le resulta confuso y lo documentaré.

Puedes usar httpxpara eso.

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

si desea una sintaxis funcional, la gamla lib lo envuelve get_async.

Entonces puedes hacer

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

El 10es el tiempo de espera en segundos.

(descargo de responsabilidad: soy su autor)

También he intentado algunas cosas usando los métodos asincrónicos en Python, sin embargo, he tenido mucha mejor suerte usando Twisted para la programación asincrónica. Tiene menos problemas y está bien documentado. Aquí hay un enlace de algo similar a lo que está intentando retorcer.

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