Solicitações assíncronas com solicitações Python

Eu tentei a amostra fornecida na documentação da biblioteca de solicitações para python.

Com async.map(rs), recebo os códigos de resposta, mas quero obter o conteúdo de cada página solicitada. Isso, por exemplo, não funciona:

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

Nota

A resposta abaixo não é aplicável aos pedidos v0.13.0 +. A funcionalidade assíncrona foi movida para grequests depois que essa pergunta foi escrita. No entanto, você pode simplesmente substituir requestspor grequestsabaixo e deve funcionar.

Eu deixei esta resposta como é para refletir a pergunta original que era sobre o uso de solicitações <v0.13.0.

Para executar várias tarefas de async.map forma assíncrona, é necessário:

1. Defina uma função para o que você deseja fazer com cada objeto (sua tarefa)
2. Adicione essa função como um gancho de evento em sua solicitação
3. Chame async.mapuma lista de todos os pedidos / ações

Exemplo:

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)

asyncagora é um módulo independente: grequests.

Veja aqui: https://github.com/kennethreitz/grequests

E aí: Método ideal para enviar várias solicitações HTTP através de Python?

instalação:

$ pip install grequests

uso:

construa uma pilha:

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)

envie a pilha

grequests.map(rs)

resultado parece

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

grequests não parecem definir uma limitação para solicitações simultâneas, ou seja, quando várias solicitações são enviadas para o mesmo servidor.

Eu testei os pedidos de futuros e grequests . O Grequests é mais rápido, mas traz o patch para macacos e problemas adicionais com as dependências. orders-futures é várias vezes mais lento que grequests. Decidi escrever minhas próprias solicitações e simplesmente encapsulá-las no ThreadPoolExecutor, e era quase tão rápido quanto as grequests, mas sem dependências 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

talvez pedidos-futuros seja outra opção.

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)

Também é recomendado no documento do escritório . Se você não quer envolver gevent, é uma boa.

Eu tenho muitos problemas com a maioria das respostas postadas - eles usam bibliotecas obsoletas que foram portadas com recursos limitados ou fornecem uma solução com muita mágica na execução da solicitação, dificultando a manipulação de erros. Se eles não se enquadram em uma das categorias acima, são bibliotecas de terceiros ou estão obsoletas.

Algumas das soluções funcionam bem puramente em solicitações http, mas as soluções ficam aquém de qualquer outro tipo de solicitação, o que é ridículo. Uma solução altamente personalizada não é necessária aqui.

Simplesmente usar a biblioteca asynciointerna python é suficiente para executar solicitações assíncronas de qualquer tipo, além de fornecer fluidez suficiente para manipulação de erros complexa e específica de uso do usuário.

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

Como funciona é simples. Você está criando uma série de tarefas que gostaria de ocorrer de forma assíncrona e solicitando um loop para executar essas tarefas e sair após a conclusão. Nenhuma biblioteca extra sujeita a falta de manutenção, não há funcionalidade necessária.

Sei que isso foi encerrado por um tempo, mas achei que poderia ser útil promover outra solução assíncrona criada na biblioteca de solicitações.

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

Os documentos estão aqui: 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 você deseja usar o assíncrono, requests-asyncfornece a funcionalidade assíncrona / aguardada para requests- https://github.com/encode/requests-async

Estou usando solicitações python para chamadas assíncronas contra a API gistub do github há algum tempo.

Para um exemplo, veja o código aqui:

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

Esse estilo de python pode não ser o exemplo mais claro, mas posso garantir que o código funciona. Deixe-me saber se isso é confuso para você e eu o documentarei.

Você pode usar httpxpara isso.

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 você quer uma sintaxe funcional, a gamla lib envolve isso get_async.

Então você pode fazer

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

O 10tempo limite é em segundos.

(aviso: sou o autor)

Eu também tentei algumas coisas usando os métodos assíncronos em python, como sempre tive uma sorte muito melhor usando o twisted para programação assíncrona. Tem menos problemas e está bem documentado. Aqui está um link de algo semelhante ao que você está tentando distorcer.

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