This work has been overtaken by the http3 project: https://www.encode.io/http3/
We now recommend using http3.AsyncClient() for async/await support with a requests-compatible API.
Note: Use ipython to try this from the console, since it supports await.
>>> import http3
>>> client = http3.AsyncClient()
>>> r = await client.get('https://www.example.org/')
>>> r.status_code
200
>>> r.text
'<!doctype html>\n<html>\n<head>\n<title>Example Domain</title>...'
Brings support for async/await syntax to Python's fabulous requests library.
$ pip install requests-async
Just use the standard requests API, but use await for making requests.
Note: Use ipython to try this from the console, since it supports await.
import requests_async as requests
response = await requests.get('https://example.org')
print(response.status_code)
print(response.text)
Or use explicit sessions, with an async context manager.
import requests_async as requests
async with requests.Session() as session:
response = await session.get('https://example.org')
print(response.status_code)
print(response.text)
The requests_async package subclasses requests, so you're getting all the
standard behavior and API you'd expect.
The iter_content() and iter_lines() methods are async iterators.
response = await requests.get('https://example.org', stream=True)
async for chunk in response.iter_content():
...
The method signatures remain the same as the standard requests API:
iter_content(chunk_size=1, decode_unicode=False)iter_lines(chunk_size=512, decode_unicode=False, delimiter=None)The methods will yield text if decode_unicode is set and the response includes
an encoding. Otherwise the methods will yield bytes.
You can also stream request bodies. To do this you should use an asynchronous generator that yields bytes.
async def stream_body():
...
response = await requests.post('https://example.org', data=stream_body())
In some situations, such as when you're testing a web application, you may not want to make actual outgoing network requests, but would prefer instead to mock out the endpoints.
You can do this using the ASGISession, which allows you to plug into
any ASGI application, instead of making actual network requests.
import requests_async
# Create a mock service, with Starlette, Responder, Quart, FastAPI, Bocadillo,
# or any other ASGI web framework.
mock_app = ...
if TESTING:
# Issue requests to the mocked application.
requests = requests_async.ASGISession(mock_app)
else:
# Make live network requests.
requests = requests_async.Session()
You can also use ASGISession as a test client for any ASGI application.
You'll probably want to install pytest and pytest-asyncio, or something
equivalent, to allow you to write async test cases.
from requests_async import ASGISession
from myproject import app
import pytest
@pytest.mark.asyncio
async def test_homepage():
client = ASGISession(app)
response = await client.get("/")
assert response.status_code == 200
http3 package both sync and async HTTP clients, with a requests-compatible API.aiohttp package provides an alternative client for making async HTTP requests.FAQs
async-await support for `requests`.
We found that requests-async demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
Security News
Socket researchers uncover a malicious npm package posing as a tool for detecting vulnerabilities in Etherium smart contracts.
Security News
Research
A supply chain attack on Rspack's npm packages injected cryptomining malware, potentially impacting thousands of developers.
Research
Security News
Socket researchers discovered a malware campaign on npm delivering the Skuld infostealer via typosquatted packages, exposing sensitive data.