diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-lowhaio.spec | 490 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 492 insertions, 0 deletions
@@ -0,0 +1 @@ +/lowhaio-0.0.88.tar.gz diff --git a/python-lowhaio.spec b/python-lowhaio.spec new file mode 100644 index 0000000..4a59e1e --- /dev/null +++ b/python-lowhaio.spec @@ -0,0 +1,490 @@ +%global _empty_manifest_terminate_build 0 +Name: python-lowhaio +Version: 0.0.88 +Release: 1 +Summary: Lightweight Python asyncio HTTP client +License: MIT License +URL: https://github.com/michalc/lowhaio +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/83/8a/8bf4f87bd6a0c4384448881a97cd1860f122e1585f937916fe03b7920d52/lowhaio-0.0.88.tar.gz +BuildArch: noarch + +Requires: python3-aiodnsresolver + +%description +# lowhaio [](https://circleci.com/gh/michalc/lowhaio) [](https://codeclimate.com/github/michalc/lowhaio/test_coverage) + +A lightweight Python asyncio HTTP/1.1 client. No additional tasks are created; all code is in a single module; and other than the standard library only a single dependency is required, [aiodnsresolver](https://github.com/michalc/aiodnsresolver) + +Lowhaio has a deliberately limited scope: it includes just enough code to be a useful HTTP client and allow more complex behaviour to be added on top if required. + +Connections are DNS-aware, in that they are only re-used if they match a current A record for the domain. + + +## Installation + +```bash +pip install lowhaio +``` + + +## Usage + +The API is streaming-first: for both request and response bodies, asynchronous iterators are used. + +```python +import asyncio +from lowhaio import Pool + +async def main(): + request, close = Pool() + + async def request_body(): + yield b'a' + yield b'bc' + + code, headers, response_body = await request( + b'POST', 'https://postman-echo.com/post', + headers=((b'content-length', b'3'), (b'content-type', b'text/plain'),), + body=request_body, + ) + async for chunk in response_body: + print(chunk) + + await close() + +loop = asyncio.get_event_loop() +loop.run_until_complete(main()) +``` + +However, there are helper functions `streamed` and `buffered` when this isn't required or possible. + +```python +import asyncio +from lowhaio import Pool, streamed, buffered + +async def main(): + request, close = Pool() + + request_body = streamed(b'abc') + + code, headers, response_body = await request( + b'POST', 'https://postman-echo.com/post', + headers=((b'content-length', b'3'), (b'content-type', b'text/plain'),), + body=request_body, + ) + print(await buffered(response_body)) + + await close() + +loop = asyncio.get_event_loop() +loop.run_until_complete(main()) +``` + + +## Headers + +The only header automatically added to requests is the `host` header, which is the idna/punycode-encoded domain name from the requested URL. + + +## Exceptions + +Exceptions are usually subclasses of `HttpError`. If a lower-level exception caused this, it is set in the `__cause__` attribute of the `HttpError`. Specifically, before any data is sent `HttpConnectionError` is raised, and after data is sent, `HttpDataError` is raised. This difference is to make it possible to know if non-idempotent requests can be retried. + +However, `asyncio.CancelledError` and exceptions that do not directive from `Exception`, such as `SystemExit`, are allowed to bubble up. + + +## Custom SSL context + +Lowhaio can be used with an custom SSL context through through the `get_ssl_context` parameter to `Pool`. For example, to use the certifi CA bundle, you can install it by + +```bash +pip install certifi +``` + +and use it as below. + +```python +import asyncio +import ssl + +import certifi +from lowhaio import Pool, buffered, streamed + +async def main(): + request, close = Pool( + get_ssl_context=lambda: ssl.create_default_context(cafile=certifi.where()), + ) + + request_body = streamed(b'abc') + + code, headers, response_body = await request( + b'POST', 'https://postman-echo.com/post', + headers=((b'content-length', b'3'), (b'content-type', b'text/plain'),), + body=request_body, + ) + print(await buffered(response_body)) + + await close() + +loop = asyncio.get_event_loop() +loop.run_until_complete(main()) +``` + + +## Scope + +The scope of the core functions is restricted to: + +- (TLS) connection opening, closing and pooling; +- passing and receiving HTTP headers and streaming bodies; +- decoding chunked responses; +- raising exceptions on timeouts. + +This is to make the core behaviour useful to a reasonable range of uses, but to _not_ include what can be added by layer(s) on top. Specifically not included: + +- following redirects, implemented by [lowhaio-redirect](https://github.com/michalc/lowhaio-redirect); +- retrying failed requests, implemented by [lowhaio-retry](https://github.com/michalc/lowhaio-retry); +- encoding chunked requests, implemented by [lowhaio-chunked](https://github.com/michalc/lowhaio-chunked); +- authentication, such as AWS Signature Version 4 implemented by [lowhaio-aws-sigv4](https://github.com/michalc/lowhaio-aws-sigv4), or AWS Signature Version 4 with unsigned payload implemented by [lowhaio-aws-sigv4-unsigned-payload](https://github.com/michalc/lowhaio-aws-sigv4-unsigned-payload); +- compressing/decompressing requests/responses; +- cookies. + + + + +%package -n python3-lowhaio +Summary: Lightweight Python asyncio HTTP client +Provides: python-lowhaio +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-lowhaio +# lowhaio [](https://circleci.com/gh/michalc/lowhaio) [](https://codeclimate.com/github/michalc/lowhaio/test_coverage) + +A lightweight Python asyncio HTTP/1.1 client. No additional tasks are created; all code is in a single module; and other than the standard library only a single dependency is required, [aiodnsresolver](https://github.com/michalc/aiodnsresolver) + +Lowhaio has a deliberately limited scope: it includes just enough code to be a useful HTTP client and allow more complex behaviour to be added on top if required. + +Connections are DNS-aware, in that they are only re-used if they match a current A record for the domain. + + +## Installation + +```bash +pip install lowhaio +``` + + +## Usage + +The API is streaming-first: for both request and response bodies, asynchronous iterators are used. + +```python +import asyncio +from lowhaio import Pool + +async def main(): + request, close = Pool() + + async def request_body(): + yield b'a' + yield b'bc' + + code, headers, response_body = await request( + b'POST', 'https://postman-echo.com/post', + headers=((b'content-length', b'3'), (b'content-type', b'text/plain'),), + body=request_body, + ) + async for chunk in response_body: + print(chunk) + + await close() + +loop = asyncio.get_event_loop() +loop.run_until_complete(main()) +``` + +However, there are helper functions `streamed` and `buffered` when this isn't required or possible. + +```python +import asyncio +from lowhaio import Pool, streamed, buffered + +async def main(): + request, close = Pool() + + request_body = streamed(b'abc') + + code, headers, response_body = await request( + b'POST', 'https://postman-echo.com/post', + headers=((b'content-length', b'3'), (b'content-type', b'text/plain'),), + body=request_body, + ) + print(await buffered(response_body)) + + await close() + +loop = asyncio.get_event_loop() +loop.run_until_complete(main()) +``` + + +## Headers + +The only header automatically added to requests is the `host` header, which is the idna/punycode-encoded domain name from the requested URL. + + +## Exceptions + +Exceptions are usually subclasses of `HttpError`. If a lower-level exception caused this, it is set in the `__cause__` attribute of the `HttpError`. Specifically, before any data is sent `HttpConnectionError` is raised, and after data is sent, `HttpDataError` is raised. This difference is to make it possible to know if non-idempotent requests can be retried. + +However, `asyncio.CancelledError` and exceptions that do not directive from `Exception`, such as `SystemExit`, are allowed to bubble up. + + +## Custom SSL context + +Lowhaio can be used with an custom SSL context through through the `get_ssl_context` parameter to `Pool`. For example, to use the certifi CA bundle, you can install it by + +```bash +pip install certifi +``` + +and use it as below. + +```python +import asyncio +import ssl + +import certifi +from lowhaio import Pool, buffered, streamed + +async def main(): + request, close = Pool( + get_ssl_context=lambda: ssl.create_default_context(cafile=certifi.where()), + ) + + request_body = streamed(b'abc') + + code, headers, response_body = await request( + b'POST', 'https://postman-echo.com/post', + headers=((b'content-length', b'3'), (b'content-type', b'text/plain'),), + body=request_body, + ) + print(await buffered(response_body)) + + await close() + +loop = asyncio.get_event_loop() +loop.run_until_complete(main()) +``` + + +## Scope + +The scope of the core functions is restricted to: + +- (TLS) connection opening, closing and pooling; +- passing and receiving HTTP headers and streaming bodies; +- decoding chunked responses; +- raising exceptions on timeouts. + +This is to make the core behaviour useful to a reasonable range of uses, but to _not_ include what can be added by layer(s) on top. Specifically not included: + +- following redirects, implemented by [lowhaio-redirect](https://github.com/michalc/lowhaio-redirect); +- retrying failed requests, implemented by [lowhaio-retry](https://github.com/michalc/lowhaio-retry); +- encoding chunked requests, implemented by [lowhaio-chunked](https://github.com/michalc/lowhaio-chunked); +- authentication, such as AWS Signature Version 4 implemented by [lowhaio-aws-sigv4](https://github.com/michalc/lowhaio-aws-sigv4), or AWS Signature Version 4 with unsigned payload implemented by [lowhaio-aws-sigv4-unsigned-payload](https://github.com/michalc/lowhaio-aws-sigv4-unsigned-payload); +- compressing/decompressing requests/responses; +- cookies. + + + + +%package help +Summary: Development documents and examples for lowhaio +Provides: python3-lowhaio-doc +%description help +# lowhaio [](https://circleci.com/gh/michalc/lowhaio) [](https://codeclimate.com/github/michalc/lowhaio/test_coverage) + +A lightweight Python asyncio HTTP/1.1 client. No additional tasks are created; all code is in a single module; and other than the standard library only a single dependency is required, [aiodnsresolver](https://github.com/michalc/aiodnsresolver) + +Lowhaio has a deliberately limited scope: it includes just enough code to be a useful HTTP client and allow more complex behaviour to be added on top if required. + +Connections are DNS-aware, in that they are only re-used if they match a current A record for the domain. + + +## Installation + +```bash +pip install lowhaio +``` + + +## Usage + +The API is streaming-first: for both request and response bodies, asynchronous iterators are used. + +```python +import asyncio +from lowhaio import Pool + +async def main(): + request, close = Pool() + + async def request_body(): + yield b'a' + yield b'bc' + + code, headers, response_body = await request( + b'POST', 'https://postman-echo.com/post', + headers=((b'content-length', b'3'), (b'content-type', b'text/plain'),), + body=request_body, + ) + async for chunk in response_body: + print(chunk) + + await close() + +loop = asyncio.get_event_loop() +loop.run_until_complete(main()) +``` + +However, there are helper functions `streamed` and `buffered` when this isn't required or possible. + +```python +import asyncio +from lowhaio import Pool, streamed, buffered + +async def main(): + request, close = Pool() + + request_body = streamed(b'abc') + + code, headers, response_body = await request( + b'POST', 'https://postman-echo.com/post', + headers=((b'content-length', b'3'), (b'content-type', b'text/plain'),), + body=request_body, + ) + print(await buffered(response_body)) + + await close() + +loop = asyncio.get_event_loop() +loop.run_until_complete(main()) +``` + + +## Headers + +The only header automatically added to requests is the `host` header, which is the idna/punycode-encoded domain name from the requested URL. + + +## Exceptions + +Exceptions are usually subclasses of `HttpError`. If a lower-level exception caused this, it is set in the `__cause__` attribute of the `HttpError`. Specifically, before any data is sent `HttpConnectionError` is raised, and after data is sent, `HttpDataError` is raised. This difference is to make it possible to know if non-idempotent requests can be retried. + +However, `asyncio.CancelledError` and exceptions that do not directive from `Exception`, such as `SystemExit`, are allowed to bubble up. + + +## Custom SSL context + +Lowhaio can be used with an custom SSL context through through the `get_ssl_context` parameter to `Pool`. For example, to use the certifi CA bundle, you can install it by + +```bash +pip install certifi +``` + +and use it as below. + +```python +import asyncio +import ssl + +import certifi +from lowhaio import Pool, buffered, streamed + +async def main(): + request, close = Pool( + get_ssl_context=lambda: ssl.create_default_context(cafile=certifi.where()), + ) + + request_body = streamed(b'abc') + + code, headers, response_body = await request( + b'POST', 'https://postman-echo.com/post', + headers=((b'content-length', b'3'), (b'content-type', b'text/plain'),), + body=request_body, + ) + print(await buffered(response_body)) + + await close() + +loop = asyncio.get_event_loop() +loop.run_until_complete(main()) +``` + + +## Scope + +The scope of the core functions is restricted to: + +- (TLS) connection opening, closing and pooling; +- passing and receiving HTTP headers and streaming bodies; +- decoding chunked responses; +- raising exceptions on timeouts. + +This is to make the core behaviour useful to a reasonable range of uses, but to _not_ include what can be added by layer(s) on top. Specifically not included: + +- following redirects, implemented by [lowhaio-redirect](https://github.com/michalc/lowhaio-redirect); +- retrying failed requests, implemented by [lowhaio-retry](https://github.com/michalc/lowhaio-retry); +- encoding chunked requests, implemented by [lowhaio-chunked](https://github.com/michalc/lowhaio-chunked); +- authentication, such as AWS Signature Version 4 implemented by [lowhaio-aws-sigv4](https://github.com/michalc/lowhaio-aws-sigv4), or AWS Signature Version 4 with unsigned payload implemented by [lowhaio-aws-sigv4-unsigned-payload](https://github.com/michalc/lowhaio-aws-sigv4-unsigned-payload); +- compressing/decompressing requests/responses; +- cookies. + + + + +%prep +%autosetup -n lowhaio-0.0.88 + +%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-lowhaio -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Wed May 10 2023 Python_Bot <Python_Bot@openeuler.org> - 0.0.88-1 +- Package Spec generated @@ -0,0 +1 @@ +c30952dadccc05c2d47f22c044e055a5 lowhaio-0.0.88.tar.gz |