Асинхронні запити із запитами Python

Я спробував зразок, наданий в документації бібліотеки запитів на python.

З async.map(rs), я отримую коди відповідей, але хочу отримати вміст кожної запитуваної сторінки. Наприклад, це не працює:

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

Примітка

Відповідь нижче не стосується запитів v0.13.0 +. Після написання цього питання асинхронна функціональність була перенесена на найсильніші запити . Тим НЕ менше, ви могли б просто замінити requestsз grequestsнижче , і він повинен працювати.

Цю відповідь я залишив так, щоб відображати оригінальне запитання, яке стосувалося використання запитів <v0.13.0.

Для виконання декількох завдань з async.map асинхронним зв'язком потрібно:

1. Визначте функцію для того, що ви хочете робити з кожним об'єктом (ваше завдання)
2. Додайте цю функцію як гачок події у своєму запиті
3. Телефонуйте async.mapу списку всіх запитів / дій

Приклад:

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в даний час є незалежним модуль: grequests.

Дивіться тут: https://github.com/kennethreitz/grequests

І там: Ідеальний метод для надсилання декількох HTTP-запитів через Python?

установка:

$ pip install grequests

використання:

побудувати стек:

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)

відправити стек

grequests.map(rs)

результат виглядає так

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

здається, що грекести не встановлюють обмеження для одночасних запитів, тобто коли кілька запитів надсилаються на один і той же сервер.

Я перевіряв і запити, і ф'ючерси, і виграші . Grequests швидше, але приносить виправлення мавп та додаткові проблеми із залежностями. запити-ф'ючерси в кілька разів повільніше, ніж найсильніші. Я вирішив написати свої власні і просто загорнуті запити в ThreadPoolExecutor, і це було майже так само швидко, як гракети, але без зовнішніх залежностей.

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

можливо, запити-ф'ючерси - це інший вибір.

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)

Також рекомендується в офісному документі . Якщо ви не хочете залучати гевент, це добре.

У мене дуже багато проблем з більшістю опублікованих відповідей - вони або використовують застарілі бібліотеки, перенесені з обмеженими можливостями, або надають рішення з надто великою магією при виконанні запиту, що ускладнює обробку помилок. Якщо вони не належать до однієї з перерахованих вище категорій, вони є сторонніми бібліотеками або застарілими.

Деякі з рішень спрацьовують виключно в http-запитах, але рішення не відповідають будь-яким іншим запитам, що смішно. Тут не потрібні високомобільні рішення.

Просто використання вбудованої бібліотеки python asyncioє достатньою для виконання асинхронних запитів будь-якого типу, а також забезпечує достатню плинність для складних та корисних випадків обробки помилок.

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

Як це працює просто. Ви створюєте низку завдань, які хочете виконувати асинхронно, а потім просите цикл виконати ці завдання та вийти після завершення. Немає зайвих бібліотек, які не піддаються технічному обслуговуванню, відсутність функціональності.

Я знаю, що це було закрито на деякий час, але я подумав, що може бути корисним просувати ще одне рішення асинхронізації, побудоване на бібліотеці запитів.

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

Документи тут: 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...

Якщо ви хочете використовувати asyncio, тоді requests-asyncнадається функція async / await для requests- https://github.com/encode/requests-async

Я вже деякий час використовую запити python для викликів асинхронізації проти API суті github.

Для прикладу дивіться код тут:

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

Цей стиль пітона може бути не найяскравішим прикладом, але я можу запевнити, що код працює. Повідомте мене, якщо це вас бентежить, і я задокументую це.

Ви можете використовувати 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))

якщо ви хочете функціональний синтаксис, гамла- ліб обертає це get_async.

Тоді ви можете зробити

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

Час 10очікування в секундах.

(відмова від відповідальності: я її автор)

Я також спробував деякі речі, використовуючи асинхронні методи в python, як ніколи мені пощастило використовувати скручені для асинхронного програмування. У нього менше проблем і добре документовано. Ось посилання чогось схожого на те, що ви намагаєтесь крутити.

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