Metadata-Version: 2.1
Name: aio-request
Version: 0.1.14
Summary: Various strategies for sending requests
Home-page: https://github.com/Pliner/aio-request
Author: Yury Pliner
Author-email: yury.pliner@gmail.com
License: MIT
Description: # aio-request
        
        This library simplifies an interaction between microservices:
        1. Allows sending requests using various strategies
        1. Propagates a deadline and a priority of requests
        1. Exposes client/server metrics
        
        Example:
        ```python
        import aiohttp
        import aio_request
        
        async with aiohttp.ClientSession() as client_session:
            client = aio_request.setup(
                transport=aio_request.AioHttpTransport(client_session),
                endpoint="http://endpoint:8080/",
            )
            response_ctx = client.request(
                aio_request.get("thing"),
                deadline=aio_request.Deadline.from_timeout(5)
            )
            async with response_ctx as response:
                pass  # process response here
        ```
        
        # Request strategies 
        The following strategies are supported:
        1. Single attempt. Only one attempt is sent.
        1. Sequential. Attempts are sent sequentially with delays between them.
        1. Parallel. Attempts are sent in parallel one by one with delays between them.
        
        Attempts count and delays are configurable.
        
        Example:
        ```python
        import aiohttp
        import aio_request
        
        async with aiohttp.ClientSession() as client_session:
            client = aio_request.setup(
                transport=aio_request.AioHttpTransport(client_session),
                endpoint="http://endpoint:8080/",
            )
            response_ctx = client.request(
                aio_request.get("thing"),
                deadline=aio_request.Deadline.from_timeout(5),
                strategy=aio_request.parallel_strategy(
                    attempts_count=3,
                    delays_provider=aio_request.linear_delays(min_delay_seconds=0.1, delay_multiplier=0.1)
                )
            )
            async with response_ctx as response:
                pass  # process response here
        ```
        
        # Deadline & priority propagation
        
        To enable it for the server side a middleware should be configured:
        ```python
        import aiohttp.web
        import aio_request
        
        app = aiohttp.web.Application(middlewares=[aio_request.aiohttp_middleware_factory()])
        ```
        
        # Expose client/server metrics
        
        To enable client metrics a metrics provider should be passed to the transport:
        ```python
        import aiohttp
        import aio_request
        
        async with aiohttp.ClientSession() as client_session:
            client = aio_request.setup(
                transport=aio_request.AioHttpTransport(
                    client_session,
                    metrics_provider=aio_request.PROMETHEUS_METRICS_PROVIDER
                ),
                endpoint="http://endpoint:8080/",
            )
        ```
        
        It is an example of how it should be done for aiohttp and prometheus.
        
        To enable client metrics a metrics provider should be passed to the middleware:
        ```python
        import aiohttp.web
        import aio_request
        
        app = aiohttp.web.Application(
            middlewares=[
                aio_request.aiohttp_middleware_factory(
                    metrics_provider=aio_request.PROMETHEUS_METRICS_PROVIDER
                )
            ]
        )
        ```
        
        # Circuit breaker
        
        ```python
        import aiohttp
        import aio_request
        
        async with aiohttp.ClientSession() as client_session:
            client = aio_request.setup_v2(
                transport=aio_request.AioHttpTransport(client_session),
                endpoint="http://endpoint:8080/",
                circuit_breaker=aio_request.DefaultCircuitBreaker[str, int](
                    break_duration=1.0,
                    sampling_duration=1.0,
                    minimum_throughput=2,
                    failure_threshold=0.5,
                ),
            )
        ```
        
        In the case of requests count >= minimum throughput(>=2) in sampling period(1 second) the circuit breaker will open
        if failed requests count/total requests count >= failure threshold(50%).
        
        ## v0.1.14 (2021-08-18)
        
        * [Keys should be materialized if dict is changed in loop](https://github.com/Pliner/aio-request/pull/66)
        
        ## v0.1.13 (2021-08-15)
        
        * [Circuit breaker](https://github.com/Pliner/aio-request/pull/65)
        
        ## v0.1.12 (2021-07-21)
        
        * [Basic repr implementation](https://github.com/Pliner/aio-request/commit/adaa4888c3d372fa65f3dd5eb6113ab68f46de24)
        
        ## v0.1.11 (2021-07-21)
        
        * Fix Request.update_headers, add Request.extend_headers [#59](https://github.com/Pliner/aio-request/pull/59)
        
        ## v0.1.10 (2021-07-20)
        
        * Add Response.is_json property to check whether content-type is json compatible [#58](https://github.com/Pliner/aio-request/pull/58)
        * Tracing support [#54](https://github.com/Pliner/aio-request/pull/54), 
        * [Configuration](https://github.com/Pliner/aio-request/commit/f0e1904f4d87daf7c242a834168c0f1b25dd86d5) of a new pipeline
        
Platform: macOS
Platform: POSIX
Platform: Windows
Classifier: License :: OSI Approved :: MIT License
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Operating System :: OS Independent
Classifier: Environment :: Web Environment
Classifier: Development Status :: 5 - Production/Stable
Classifier: Framework :: AsyncIO
Classifier: Typing :: Typed
Requires-Python: >=3.8
Description-Content-Type: text/markdown
