path: root/python-requests-async.spec

%global _empty_manifest_terminate_build 0
Name:		python-requests-async
Version:	0.6.2
Release:	1
Summary:	async-await support for `requests`.
License:	BSD
URL:		https://github.com/encode/requests-async
Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/4a/e7/afbe47fa17068c80a5e80d75e1e960a98a5cfefe3590108ba76d9560cefc/requests-async-0.6.2.tar.gz
BuildArch:	noarch


%description
# requests-async
Brings support for `async`/`await` syntax to Python's fabulous `requests` library.
<p>
<a href="https://travis-ci.org/encode/requests-async">
    <img src="https://travis-ci.org/encode/requests-async.svg?branch=master" alt="Build Status">
</a>
<a href="https://codecov.io/gh/encode/requests-async">
    <img src="https://codecov.io/gh/encode/requests-async/branch/master/graph/badge.svg" alt="Coverage">
</a>
<a href="https://pypi.org/project/requests-async/">
    <img src="https://badge.fury.io/py/requests-async.svg?cache0" alt="Package version">
</a>
</p>
## 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 requests
response = 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 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.
## 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 [`http3` package][http3] 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
[http3]: https://github.com/encode/http3

%package -n python3-requests-async
Summary:	async-await support for `requests`.
Provides:	python-requests-async
BuildRequires:	python3-devel
BuildRequires:	python3-setuptools
BuildRequires:	python3-pip
%description -n python3-requests-async
# requests-async
Brings support for `async`/`await` syntax to Python's fabulous `requests` library.
<p>
<a href="https://travis-ci.org/encode/requests-async">
    <img src="https://travis-ci.org/encode/requests-async.svg?branch=master" alt="Build Status">
</a>
<a href="https://codecov.io/gh/encode/requests-async">
    <img src="https://codecov.io/gh/encode/requests-async/branch/master/graph/badge.svg" alt="Coverage">
</a>
<a href="https://pypi.org/project/requests-async/">
    <img src="https://badge.fury.io/py/requests-async.svg?cache0" alt="Package version">
</a>
</p>
## 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 requests
response = 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 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.
## 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 [`http3` package][http3] 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
[http3]: https://github.com/encode/http3

%package help
Summary:	Development documents and examples for requests-async
Provides:	python3-requests-async-doc
%description help
# requests-async
Brings support for `async`/`await` syntax to Python's fabulous `requests` library.
<p>
<a href="https://travis-ci.org/encode/requests-async">
    <img src="https://travis-ci.org/encode/requests-async.svg?branch=master" alt="Build Status">
</a>
<a href="https://codecov.io/gh/encode/requests-async">
    <img src="https://codecov.io/gh/encode/requests-async/branch/master/graph/badge.svg" alt="Coverage">
</a>
<a href="https://pypi.org/project/requests-async/">
    <img src="https://badge.fury.io/py/requests-async.svg?cache0" alt="Package version">
</a>
</p>
## 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 requests
response = 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 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.
## 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 [`http3` package][http3] 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
[http3]: https://github.com/encode/http3

%prep
%autosetup -n requests-async-0.6.2

%build
%py3_build

%install
%py3_install
install -d -m755 %{buildroot}/%{_pkgdocdir}
if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
pushd %{buildroot}
if [ -d usr/lib ]; then
	find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/lib64 ]; then
	find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/bin ]; then
	find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/sbin ]; then
	find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
fi
touch doclist.lst
if [ -d usr/share/man ]; then
	find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
fi
popd
mv %{buildroot}/filelist.lst .
mv %{buildroot}/doclist.lst .

%files -n python3-requests-async -f filelist.lst
%dir %{python3_sitelib}/*

%files help -f doclist.lst
%{_docdir}/*

%changelog
* Fri Apr 21 2023 Python_Bot <Python_Bot@openeuler.org> - 0.6.2-1
- Package Spec generated