Żądania asynchroniczne z żądaniami Pythona

Wypróbowałem próbkę dostarczoną w dokumentacji biblioteki żądań dla Pythona.

W przypadku async.map(rs)otrzymuję kody odpowiedzi, ale chcę uzyskać zawartość każdej żądanej strony. To na przykład nie działa:

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

Uwaga

Poniższa odpowiedź nie dotyczy żądań w wersji 0.13.0 +. Funkcjonalność asynchroniczna została przeniesiona do grequestów po napisaniu tego pytania. Jednakże, można po prostu zastąpić requestszgrequests dołu i powinno działać.

Pozostawiłem tę odpowiedź tak, jak ma odzwierciedlać pierwotne pytanie, które dotyczyło korzystania z żądań <v0.13.0.

Aby wykonać wiele zadań async.map asynchronicznie , musisz:

1. Zdefiniuj funkcję dla tego, co chcesz zrobić z każdym obiektem (Twoim zadaniem)
2. Dodaj tę funkcję jako punkt zaczepienia zdarzenia w swoim żądaniu
3. Wywołaj async.maplistę wszystkich żądań / działań

Przykład:

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)

asyncTeraz jest niezależnym modułem: grequests.

Zobacz tutaj: https://github.com/kennethreitz/grequests

I tam: Idealna metoda wysyłania wielu żądań HTTP przez Python?

instalacja:

$ pip install grequests

stosowanie:

zbuduj stos:

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)

wyślij stos

grequests.map(rs)

wynik wygląda jak

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

Wydaje się, że grequests nie ustawia ograniczenia dla jednoczesnych żądań, tj. gdy wiele żądań jest wysyłanych do tego samego serwera.

Przetestowałem zarówno prośby - przyszłość, jak i życzenia . Grequests jest szybszy, ale przynosi małpie łatanie i dodatkowe problemy z zależnościami. request-futures jest kilkakrotnie wolniejsze niż grequests. Postanowiłem napisać własne i po prostu opakować żądania w ThreadPoolExecutor i było to prawie tak szybkie jak grequests, ale bez zewnętrznych zależności.

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

może prośby o przyszłość to inny wybór.

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)

Zaleca się również w dokumencie biurowym . Jeśli nie chcesz angażować się w gevent, to dobrze.

Mam wiele problemów z większością opublikowanych odpowiedzi - albo korzystają z przestarzałych bibliotek, które zostały przeniesione z ograniczonymi funkcjami, albo zapewniają rozwiązanie ze zbyt dużą magią podczas wykonywania żądania, co utrudnia obsługę błędów. Jeśli nie należą do żadnej z powyższych kategorii, są bibliotekami innych firm lub są przestarzałe.

Niektóre z rozwiązań działają prawidłowo wyłącznie w przypadku żądań http, ale rozwiązania nie są odpowiednie dla innych rodzajów żądań, co jest śmieszne. W tym przypadku nie jest konieczne wysoce spersonalizowane rozwiązanie.

Samo użycie wbudowanej biblioteki Pythona asynciojest wystarczające do wykonywania asynchronicznych żądań dowolnego typu, a także zapewnia wystarczającą płynność do obsługi złożonych i specyficznych dla użytkownika błędów.

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

Jak to działa, jest proste. Tworzysz serię zadań, które chcesz wykonywać asynchronicznie, a następnie żądasz pętli, aby wykonać te zadania i zakończyć po zakończeniu. Brak dodatkowych bibliotek podlegających brakowi konserwacji, brak wymaganych funkcji.

Wiem, że to było od jakiegoś czasu zamknięte, ale pomyślałem, że może być przydatne wypromowanie innego rozwiązania asynchronicznego opartego na bibliotece żądań.

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

Dokumenty są tutaj: 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...

Jeśli chcesz używać asyncio, requests-asynczapewnia funkcjonalność async / await dla requests- https://github.com/encode/requests-async

Od jakiegoś czasu używam żądań Pythona do wywołań asynchronicznych przeciwko gist API github.

Na przykład zobacz kod tutaj:

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

Ten styl Pythona może nie jest najlepszym przykładem, ale zapewniam, że kod działa. Daj mi znać, jeśli jest to dla Ciebie mylące, a udokumentuję to.

Możesz użyć httpxdo tego.

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

jeśli potrzebujesz funkcjonalnej składni, biblioteka gamla otacza toget_async .

Wtedy możesz to zrobić

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

Plik 10 limit czasu w sekundach.

(zastrzeżenie: jestem jego autorem)

Próbowałem też kilku rzeczy przy użyciu metod asynchronicznych w Pythonie, ale miałem dużo więcej szczęścia, używając twisted do programowania asynchronicznego. Ma mniej problemów i jest dobrze udokumentowany. Oto link do czegoś podobnego do tego, co próbujesz w przekręconej.

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