Permintaan Asinkron dengan permintaan Python

Saya mencoba sampel yang disediakan dalam dokumentasi pustaka permintaan untuk python.

Dengan async.map(rs), saya mendapatkan kode respons, tetapi saya ingin mendapatkan konten dari setiap halaman yang diminta. Ini, misalnya, tidak berfungsi:

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

Catatan

Jawaban di bawah ini tidak berlaku untuk permintaan v0.13.0 +. Fungsionalitas tidak sinkron dipindahkan ke grequests setelah pertanyaan ini ditulis. Namun, Anda bisa saja menggantinya requestsdengangrequests bawah ini dan itu akan berfungsi.

Saya telah meninggalkan jawaban ini untuk mencerminkan pertanyaan awal yang tentang menggunakan permintaan <v0.13.0.

Untuk melakukan banyak tugas dengan async.map asinkron Anda harus:

1. Tetapkan fungsi untuk apa yang ingin Anda lakukan dengan setiap objek (tugas Anda)
2. Tambahkan fungsi itu sebagai pengait acara dalam permintaan Anda
3. Panggil async.mapdaftar semua permintaan / tindakan

Contoh:

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)

asyncsekarang modul independen: grequests.

Lihat di sini: https://github.com/kennethreitz/grequests

Dan di sana: Metode ideal untuk mengirim beberapa permintaan HTTP melalui Python?

instalasi:

$ pip install grequests

pemakaian:

membangun tumpukan:

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)

kirim tumpukan

grequests.map(rs)

hasilnya terlihat seperti

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

grequests tampaknya tidak menetapkan batasan untuk permintaan bersamaan, yaitu ketika beberapa permintaan dikirim ke server yang sama.

Saya menguji permintaan-futures dan grequest . Grequests lebih cepat tetapi membawa tambalan monyet dan masalah tambahan dengan dependensi. request-futures beberapa kali lebih lambat dari grequests. Saya memutuskan untuk menulis permintaan saya sendiri dan hanya membungkusnya ke dalam ThreadPoolExecutor dan itu hampir secepat grequest, tetapi tanpa ketergantungan eksternal.

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

mungkin permintaan-berjangka adalah pilihan lain.

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)

Juga direkomendasikan dalam dokumen kantor . Jika Anda tidak ingin melibatkan gevent, itu bagus.

Saya memiliki banyak masalah dengan sebagian besar jawaban yang diposting - mereka baik menggunakan perpustakaan yang sudah usang yang telah porting dengan fitur terbatas, atau memberikan solusi dengan sihir terlalu banyak pada pelaksanaan permintaan, sehingga sulit untuk menangani kesalahan. Jika mereka tidak termasuk dalam salah satu kategori di atas, itu adalah perpustakaan pihak ketiga atau sudah usang.

Beberapa solusi berfungsi dengan baik dalam permintaan http, tetapi solusi tersebut tidak memenuhi semua jenis permintaan lainnya, yang menggelikan. Solusi yang sangat khusus tidak diperlukan di sini.

Cukup menggunakan python built-in library asynciocukup untuk melakukan permintaan asinkronik dari jenis apa pun, serta memberikan fluiditas yang cukup untuk penanganan kesalahan kompleks dan usecase spesifik.

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

Cara kerjanya sederhana. Anda sedang membuat serangkaian tugas yang ingin Anda lakukan secara tidak sinkron, dan kemudian meminta loop untuk menjalankan tugas-tugas itu dan keluar setelah selesai. Tidak ada perpustakaan tambahan yang mengalami kekurangan pemeliharaan, tidak ada kekurangan fungsionalitas yang diperlukan.

Saya tahu ini telah ditutup untuk sementara waktu, tetapi saya pikir mungkin berguna untuk mempromosikan solusi async lain yang dibangun di pustaka permintaan.

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

Dokumen ada di sini: 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...

Jika Anda ingin menggunakan asyncio, maka sediakan requests-asyncfungsionalitas async / tunggu untuk requests- https://github.com/encode/requests-async

Saya telah menggunakan permintaan python untuk panggilan async terhadap API intisari github untuk beberapa waktu.

Sebagai contoh, lihat kode di sini:

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

Gaya python ini mungkin bukan contoh yang paling jelas, tetapi saya dapat meyakinkan Anda bahwa kodenya berfungsi. Beri tahu saya jika ini membingungkan Anda dan saya akan mendokumentasikannya.

Anda bisa menggunakannya httpxuntuk itu.

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

jika Anda ingin sintaks fungsional, gamla lib membungkusnya get_async.

Maka Anda bisa melakukannya

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

Ini 10adalah batas waktu dalam hitungan detik.

(penafian: saya penulisnya)

Saya juga mencoba beberapa hal menggunakan metode asynchronous di python, bagaimana pun saya memiliki keberuntungan yang lebih baik menggunakan twisted untuk pemrograman asynchronous. Ini memiliki lebih sedikit masalah dan didokumentasikan dengan baik. Berikut ini adalah tautan dari sesuatu yang serupa dengan apa yang Anda coba memutar.

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