Yêu cầu không đồng bộ với yêu cầu Python

Tôi đã thử mẫu được cung cấp trong tài liệu của thư viện yêu cầu cho python.

Với async.map(rs), tôi nhận được mã phản hồi, nhưng tôi muốn nhận nội dung của từng trang được yêu cầu. Điều này, ví dụ, không hoạt động:

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

Ghi chú

Câu trả lời dưới đây không áp dụng cho các yêu cầu v0.13.0 +. Các chức năng không đồng bộ đã được chuyển đến grequests sau khi câu hỏi này được viết. Tuy nhiên, bạn chỉ có thể thay thế requestsbằng grequestsbên dưới và nó sẽ hoạt động.

Tôi đã để lại câu trả lời này như là để phản ánh câu hỏi ban đầu về việc sử dụng các yêu cầu <v0.13.0.

Để thực hiện nhiều tác vụ async.map không đồng bộ, bạn phải:

1. Xác định hàm cho những gì bạn muốn làm với từng đối tượng (nhiệm vụ của bạn)
2. Thêm chức năng đó như một cái móc sự kiện trong yêu cầu của bạn
3. Gọi async.mapvào danh sách tất cả các yêu cầu / hành động

Thí dụ:

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)

asyncbây giờ là một mô-đun độc lập : grequests.

Xem tại đây: https://github.com/kennethreitz/grequests

Và ở đó: Phương pháp lý tưởng để gửi nhiều yêu cầu HTTP qua Python?

cài đặt:

$ pip install grequests

sử dụng:

xây dựng một ngăn xếp:

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)

gửi ngăn xếp

grequests.map(rs)

kết quả trông như

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

grequests dường như không đặt giới hạn cho các yêu cầu đồng thời, nghĩa là khi nhiều yêu cầu được gửi đến cùng một máy chủ.

Tôi đã thử nghiệm cả hai yêu cầu - tương lai và grequest . Grequests nhanh hơn nhưng mang lại bản vá khỉ và các vấn đề bổ sung với sự phụ thuộc. yêu cầu-tương lai chậm hơn nhiều lần so với grequest. Tôi đã quyết định viết các yêu cầu của riêng mình và đơn giản được gói vào ThreadPoolExecutor và nó gần như nhanh như các grequest, nhưng không có sự phụ thuộc bên ngoài.

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

có thể yêu cầu tương lai là một lựa chọn khác.

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)

Nó cũng được đề nghị trong tài liệu văn phòng . Nếu bạn không muốn liên quan đến gevent, thì đó là một điều tốt.

Tôi có rất nhiều vấn đề với hầu hết các câu trả lời được đăng - họ sử dụng các thư viện không dùng nữa với các tính năng hạn chế hoặc cung cấp giải pháp với quá nhiều phép thuật trong việc thực hiện yêu cầu, gây khó khăn cho việc xử lý lỗi. Nếu chúng không thuộc một trong các loại trên, chúng là thư viện của bên thứ 3 hoặc không dùng nữa.

Một số giải pháp hoạt động hoàn toàn trong các yêu cầu http, nhưng các giải pháp không phù hợp với bất kỳ loại yêu cầu nào khác, đó là lố bịch. Một giải pháp tùy biến cao là không cần thiết ở đây.

Chỉ cần sử dụng thư viện tích hợp python asynciolà đủ để thực hiện các yêu cầu không đồng bộ thuộc bất kỳ loại nào, cũng như cung cấp đủ tính trôi chảy để xử lý lỗi cụ thể và phức tạp.

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

Cách thức hoạt động rất đơn giản. Bạn đang tạo một loạt các tác vụ bạn muốn xảy ra không đồng bộ, sau đó yêu cầu một vòng lặp để thực thi các tác vụ đó và thoát khi hoàn thành. Không có thư viện bổ sung bị thiếu bảo trì, không thiếu chức năng cần thiết.

Tôi biết điều này đã bị đóng trong một thời gian, nhưng tôi nghĩ rằng nó có thể hữu ích để quảng bá một giải pháp async khác được xây dựng trên thư viện yêu cầu.

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

Các tài liệu ở đây: 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...

Nếu bạn muốn sử dụng asyncio, sau đó requests-asynccung cấp chức năng async / await cho requests- https://github.com/encode/requests-async

Tôi đã sử dụng các yêu cầu python cho các cuộc gọi không đồng bộ với API chính của github trong một thời gian.

Ví dụ, xem mã ở đây:

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

Kiểu trăn này có thể không phải là ví dụ rõ ràng nhất, nhưng tôi có thể đảm bảo với bạn rằng mã hoạt động. Hãy cho tôi biết nếu điều này gây nhầm lẫn với bạn và tôi sẽ ghi lại nó.

Bạn có thể sử dụng httpxcho điều đó.

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

nếu bạn muốn một cú pháp chức năng, gamla lib kết thúc điều này get_async.

Sau đó bạn có thể làm

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

Các 10là thời gian chờ trong vài giây.

(từ chối trách nhiệm: Tôi là tác giả của nó)

Tôi cũng đã thử một số thứ bằng cách sử dụng các phương thức không đồng bộ trong python, bao giờ tôi đã gặp may mắn hơn nhiều khi sử dụng xoắn cho lập trình không đồng bộ. Nó có ít vấn đề hơn và được ghi chép lại. Đây là một liên kết của một cái gì đó tương tự với những gì bạn đang cố gắng trong xoắn.

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