Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/encode/requests-async
async-await support for `requests`. ✨ 🍰 ✨
https://github.com/encode/requests-async
Last synced: about 2 months ago
JSON representation
async-await support for `requests`. ✨ 🍰 ✨
- Host: GitHub
- URL: https://github.com/encode/requests-async
- Owner: encode
- License: other
- Archived: true
- Created: 2019-03-20T17:28:58.000Z (over 5 years ago)
- Default Branch: master
- Last Pushed: 2019-07-22T21:40:29.000Z (about 5 years ago)
- Last Synced: 2024-07-26T23:21:06.931Z (about 2 months ago)
- Language: Python
- Homepage:
- Size: 95.7 KB
- Stars: 936
- Watchers: 25
- Forks: 36
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE.md
Awesome Lists containing this project
README
**This work has been overtaken by the `httpx` project:** https://github.com/encode/httpx
We now recommend using `httpx.AsyncClient()` for async/await support with a requests-compatible API.
**Note**: Use `ipython` to try this from the console, since it supports `await`.
```python
>>> import httpx
>>> client = httpx.AsyncClient()
>>> r = await client.get('https://www.example.org/')
>>> r.status_code
200
>>> r.text
'\n\n\nExample Domain...'
```---
# requests-async
Brings support for `async`/`await` syntax to Python's fabulous `requests` library.
## Requirements
* Python 3.6+
## Installation
```shell
$ pip install requests-async
```## Usage
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`.
```python
import requests_async as requestsresponse = await requests.get('https://example.org')
print(response.status_code)
print(response.text)
```Or use explicit sessions, with an async context manager.
```python
import requests_async as requestsasync 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.## Streaming responses & requests
The `iter_content()` and `iter_lines()` methods are async iterators.
```python
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.```python
async def stream_body():
...response = await requests.post('https://example.org', data=stream_body())
```## Mock Requests
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.```python
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()
```## Test Client
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.```python
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
```## Alternatives
* The [`httpx` package][httpx] both sync and async HTTP clients, with a requests-compatible API.
* The [`aiohttp` package][aiohttp] provides an alternative client for making async HTTP requests.[issues]: https://github.com/encode/requests-async/issues
[aiohttp]: https://docs.aiohttp.org/en/stable/client.html
[httpx]: https://github.com/encode/httpx