Service Client Framework powered by Python asyncio.

The easiest way to implement a client to work with a service REST API.

• Easy way to make request to service.
• AsyncIO implementation using aiohttp.
• Powerful plugin system.
• Useful plugins.
• Mock plugin in order to make tests.
• Opensource license: GNU LGPLv3

$ pip install aio-service-client

Service client framework is used to call HTTP service API's. So, you must define how to communicate with this service API defining its endpoint:

spec = {"get_users": {"path": "/user",
                      "method": "get"},
        "get_user_detail": {"path": "/user/{user_id}",
                            "method": "get"},
        "create_user": {"path": "/user",
                        "method": "post"},
        "update_user": {"path": "/user/{user_id}",
                        "method": "put"}}

Imagine you are using a Rest JSON API in order to manage users. So, your data must be sent as a JSON and response must be a JSON string. It mean you must serialize every request payload to a JSON, and parse every response as JSON. So, you only need to define JSON parser and serializer for your service:

service = ServiceClient(spec=spec,
                        plugins=[PathToken()],
                        base_path="http://example.com",
                        parser=json_decoder,
                        serializer=json_encoder)

So, you are ready to make request to service API:

resp = yield from service.call("get_users")
# it could be called directly
# resp = yield from service.get_users()

# if response is like:
# {"users": {"item": [{"userId": "12", "username": "foo"}, {"userId": "13", "username": "bar"}], "count": 2}
print("Count: %d" % resp.data['users']['count'])
for user in resp.data['users']['items']:
    print("User `%s`: %s" % (user['userId'], user['username']))

In order to send a payload you must use payload keyword on call:

resp = yield from service.call("create_user", payload={"username": "foobar"})
# it could be called directly
# resp = yield from service.create_user(payload={"username": "foobar"})

# it will make a request like:
# POST http://example.com/user
#
# {"username": "foobar"}

• Fix Mock and Loggers plugins work together.
• Added RawDataMock in order to allow to set mock data as string or byte-string directly on spec.
• Added JsonDataMock in order to allow to set mock json data as a dictionary or list on spec.

• Python 3.9 compatible.
• Update aiohttp.

• Pool plugin now add blocked_by_pool attribute to session containing elapsed time (seconds) on pool. It allows to log this time using log plugins.
• RateLimit plugin now add blocked_by_ratelimit attribute to session containing elapsed time (seconds) blocked by rate limit. It allows to log this time using log plugins.
• Tests improved.
• Added new exceptions: service_client.plugins.TooManyRequestsPendingError and service_client.plugins.TooMuchTimePendingError.
• Added decorator in order to help to build service clients. It allows to define a method using a request model but to call it using keywords to build request model which will be used to call method.

class RequestModel:
    def __init__(param_1=None):
        self.param_1 = param_1


class Service:

    @build_parameter_object
    async def method_1(request: RequestModel):
        return do_something(request)


serv = Service()
await serv.method_1(param_1=23)

• Improved Pool plugin. It now allows to set hard limit of pending requests, if it reach limit requests will fail raising RequestLimitError. In same way, it allows to set a timeout, in seconds, for pending requests and it will raise same exception.
• Added new RateLimit plugin. It is similar to Pool plugin but using a period parameter, in seconds, in order to limit number of request in this period.
• Improved error logging.
• Added new hook close in order to notify plugins that client is going to close.
• Removed compatibility with Python 3.4.

• Made compatible with aiohttp 2.0.x.

• Made compatible with aiohttp 1.0.x.
• Simplified factory code.

• Resolved problem with requests streamed.

• Added factories
• Added spec loaders

• Fix elapsed data on logs.

• Added new Pool plugin.
• Improved Elapsed plugin.
• Added new hook in order to allow plugins to override response methods.

• Fix response when using Timeout plugin.

• Added TrackingToken plugin. Token is added to session and to response.
• Added a log formatter.
• Removed tracking token stuff from log plugins.
• Improved log plugins. They avoid to print body if it is streamed or must be hidden.
• Improved session wrapper.

It allows to fill placeholders on path in order to build uri.

service = ServiceClient(spec={"endpoint1": {"method": "get",
                                            "path": "/endpoint/{placeholder1}/{placeholder2}"}},
                        plugins=[PathToken()],
                        base_path="http://example.com")

resp = yield from service.call("endpoint1", placeholder1=21, placeholder1="foo")
# It will make request:
# GET http://example.com/endpoint/21/foo

It allows to define default headers, endpoint headers and request headers.

service = ServiceClient(spec={"endpoint1": {"method": "get",
                                            "path": "/endpoint/foo/bar",
                                            "headers": {"X-fake-header": "header; data"}}},
                        plugins=[Headers(headers={"content-type": "application/json"})],
                        base_path="http://example.com")

resp = yield from service.call("endpoint1", headers={"X-other-fake-header": "foo"})
# It will make request:
# GET http://example.com/endpoint/foo/bar
# X-fake-header: header; data
# content-type: application/json
# X-other-fake-header: foo

It allows to define default timeout for service request, endpoint or request.

It adds elapsed time to response.

It allows to assign a token for each pair request/response in order to identify them.

It allows to use query parameters on request. They could be defined at service client, endpoint or request.

It allows to log request after serialize and response before parse.

It allows to log request before serialize and response after parse.

It allows to limit concurrent requests. Besides it allows to set a hard limit of pending requests and a timeout for blocked ones.

It allows to limit number of requests in a time period. Besides it allows to set a hard limit of pending requests and a timeout for blocked ones.