aiohttp support for input_path

example/example_a_aiohttp.py

+# coding: utf-8
+import json
+import yaml
+
+from aiohttp import web
+from hapic import async as hapic
+import marshmallow
+
+from hapic.ext.aiohttp.context import AiohttpContext
+
+
+class HandleInputPath(marshmallow.Schema):
+    name = marshmallow.fields.String(
+        required=False,
+        allow_none=True,
+    )
+
+
+class HandleOutputBody(marshmallow.Schema):
+    sentence = marshmallow.fields.String(
+        required=True,
+    )
+
+
+@hapic.with_api_doc()
+@hapic.input_path(HandleInputPath())
+# @hapic.output_body(HandleOutputBody())
+async def handle(request, hapic_data):
+    name = request.match_info.get('name', "Anonymous")
+    text = "Hello, " + name
+    return web.json_response({
+        'sentence': text,
+    })
+
+
+async def do_login(request):
+    data = await request.json()
+    login = data['login']
+    password = data['password']
+
+    return web.json_response({
+        'login': login,
+    })
+
+app = web.Application(debug=True)
+app.add_routes([
+    web.get('/n/', handle),
+    web.get('/n/{name}', handle),
+    web.post('/n/{name}', handle),
+    web.post('/login', do_login),
+])
+
+
+hapic.set_context(AiohttpContext(app))
+
+# print(yaml.dump(
+#     json.loads(json.dumps(hapic.generate_doc())),
+#     default_flow_style=False,
+# ))
+
+web.run_app(app)

hapic/async.py

+# -*- coding: utf-8 -*-
+from hapic.hapic import Hapic
+
+_hapic_default = Hapic(async=True)
+
+with_api_doc = _hapic_default.with_api_doc
+input_headers = _hapic_default.input_headers
+input_body = _hapic_default.input_body
+input_path = _hapic_default.input_path
+input_query = _hapic_default.input_query
+input_forms = _hapic_default.input_forms
+input_files = _hapic_default.input_files
+output_headers = _hapic_default.output_headers
+output_body = _hapic_default.output_body
+output_file = _hapic_default.output_file
+generate_doc = _hapic_default.generate_doc
+set_context = _hapic_default.set_context
+reset_context = _hapic_default.reset_context
+add_documentation_view = _hapic_default.add_documentation_view
+handle_exception = _hapic_default.handle_exception

hapic/decorator.py

         self,
         func: 'typing.Callable[..., typing.Any]',
     ) -> 'typing.Callable[..., typing.Any]':
-        def wrapper(*args, **kwargs) -> typing.Any:
+        async def wrapper(*args, **kwargs) -> typing.Any:
             # Note: Design of before_wrapped_func can be to update kwargs
             # by reference here
-            replacement_response = self.before_wrapped_func(args, kwargs)
+            replacement_response = await self.before_wrapped_func(args, kwargs)
             if replacement_response:
                 return replacement_response
 
-            response = self._execute_wrapped_function(func, args, kwargs)
+            response = await self._execute_wrapped_function(func, args, kwargs)
             new_response = self.after_wrapped_function(response)
             return new_response
         return functools.update_wrapper(wrapper, func)
         return error_response
 
 
+# TODO BS 2018-07-23: This class is an async version of InputControllerWrapper
+# to permit async compatibility. Please re-think about code refact
+# TAG: REFACT_ASYNC
+class AsyncInputControllerWrapper(InputControllerWrapper):
+    async def before_wrapped_func(
+        self,
+        func_args: typing.Tuple[typing.Any, ...],
+        func_kwargs: typing.Dict[str, typing.Any],
+    ) -> typing.Any:
+        # Retrieve hapic_data instance or create new one
+        # hapic_data is given though decorators
+        # Important note here: func_kwargs is update by reference !
+        hapic_data = self.ensure_hapic_data(func_kwargs)
+        request_parameters = await self.get_request_parameters(
+            func_args,
+            func_kwargs,
+        )
+
+        try:
+            processed_data = self.get_processed_data(request_parameters)
+            self.update_hapic_data(hapic_data, processed_data)
+        except ProcessException:
+            error_response = self.get_error_response(request_parameters)
+            return error_response
+
+    async def get_request_parameters(
+        self,
+        func_args: typing.Tuple[typing.Any, ...],
+        func_kwargs: typing.Dict[str, typing.Any],
+    ) -> RequestParameters:
+        return await self.context.get_request_parameters(
+            *func_args,
+            **func_kwargs
+        )
+
+
 class OutputControllerWrapper(InputOutputControllerWrapper):
     def __init__(
         self,
         return request_parameters.path_parameters
 
 
+# TODO BS 2018-07-23: This class is an copy-patse of InputPathControllerWrapper
+# to permit async compatibility. Please re-think about code refact
+# TAG: REFACT_ASYNC
+class AsyncInputPathControllerWrapper(AsyncInputControllerWrapper):
+    def update_hapic_data(
+        self, hapic_data: HapicData,
+        processed_data: typing.Any,
+    ) -> None:
+        hapic_data.path = processed_data
+
+    def get_parameters_data(self, request_parameters: RequestParameters) -> dict:  # nopep8
+        return request_parameters.path_parameters
+
+
 class InputQueryControllerWrapper(InputControllerWrapper):
     def __init__(
         self,

hapic/ext/aiohttp/__init__.py

+# coding: utf-8

hapic/ext/aiohttp/context.py

+# coding: utf-8
+import asyncio
+import typing
+from http import HTTPStatus
+from json import JSONDecodeError
+
+from aiohttp.web_request import Request
+from multidict import MultiDict
+
+from hapic.context import BaseContext
+from hapic.context import RouteRepresentation
+from hapic.decorator import DecoratedController
+from hapic.exception import WorkflowException
+from hapic.processor import ProcessValidationError
+from hapic.processor import RequestParameters
+from aiohttp import web
+
+
+class AiohttpContext(BaseContext):
+    def __init__(
+        self,
+        app: web.Application,
+    ) -> None:
+        self._app = app
+
+    @property
+    def app(self) -> web.Application:
+        return self._app
+
+    async def get_request_parameters(
+        self,
+        *args,
+        **kwargs
+    ) -> RequestParameters:
+        try:
+            request = args[0]
+        except IndexError:
+            raise WorkflowException(
+                'Unable to get aiohttp request object',
+            )
+        request = typing.cast(Request, request)
+
+        path_parameters = dict(request.match_info)
+        query_parameters = MultiDict(request.query.items())
+
+        if request.can_read_body:
+            try:
+                # FIXME NOW: request.json() make
+                # request.content empty, do it ONLY if json headers
+                # body_parameters = await request.json()
+                # body_parameters = await request.content.read()
+                body_parameters = {}
+                pass
+            except JSONDecodeError:
+                # FIXME BS 2018-07-13: Raise an 400 error if header contain
+                # json type
+                body_parameters = {}
+        else:
+            body_parameters = {}
+
+        form_parameters_multi_dict_proxy = await request.post()
+        form_parameters = MultiDict(form_parameters_multi_dict_proxy.items())
+        header_parameters = dict(request.headers.items())
+
+        # TODO BS 2018-07-13: Manage files (see
+        # https://docs.aiohttp.org/en/stable/multipart.html)
+        files_parameters = dict()
+
+        return RequestParameters(
+            path_parameters=path_parameters,
+            query_parameters=query_parameters,
+            body_parameters=body_parameters,
+            form_parameters=form_parameters,
+            header_parameters=header_parameters,
+            files_parameters=files_parameters,
+        )
+
+    def get_response(
+        self,
+        response: str,
+        http_code: int,
+        mimetype: str = 'application/json',
+    ) -> typing.Any:
+        pass
+
+    def get_validation_error_response(
+        self,
+        error: ProcessValidationError,
+        http_code: HTTPStatus = HTTPStatus.BAD_REQUEST,
+    ) -> typing.Any:
+        pass
+
+    def find_route(
+        self,
+        decorated_controller: DecoratedController,
+    ) -> RouteRepresentation:
+        pass
+
+    def get_swagger_path(
+        self,
+        contextualised_rule: str,
+    ) -> str:
+        pass
+
+    def by_pass_output_wrapping(
+        self,
+        response: typing.Any,
+    ) -> bool:
+        pass
+
+    def add_view(
+        self,
+        route: str,
+        http_method: str,
+        view_func: typing.Callable[..., typing.Any],
+    ) -> None:
+        pass
+
+    def serve_directory(
+        self,
+        route_prefix: str,
+        directory_path: str,
+    ) -> None:
+        pass
+
+    def is_debug(
+        self,
+    ) -> bool:
+        pass
+
+    def handle_exception(
+        self,
+        exception_class: typing.Type[Exception],
+        http_code: int,
+    ) -> None:
+        pass
+
+    def handle_exceptions(
+        self,
+        exception_classes: typing.List[typing.Type[Exception]],
+        http_code: int,
+    ) -> None:
+        pass

hapic/hapic.py

 from hapic.decorator import InputBodyControllerWrapper
 from hapic.decorator import InputHeadersControllerWrapper
 from hapic.decorator import InputPathControllerWrapper
+from hapic.decorator import AsyncInputPathControllerWrapper
 from hapic.decorator import InputQueryControllerWrapper
 from hapic.decorator import InputFilesControllerWrapper
 from hapic.decorator import OutputBodyControllerWrapper
 
 
 class Hapic(object):
-    def __init__(self):
+    def __init__(
+        self,
+        async: bool = False,
+    ):
         self._buffer = DecorationBuffer()
         self._controllers = []  # type: typing.List[DecoratedController]
         self._context = None  # type: ContextInterface
         self._error_builder = None  # type: ErrorBuilderInterface
+        self._async = async
         self.doc_generator = DocGenerator()
 
         # This local function will be pass to different components
         processor.schema = schema
         context = context or self._context_getter
 
-        decoration = InputPathControllerWrapper(
-            context=context,
-            processor=processor,
-            error_http_code=error_http_code,
-            default_http_code=default_http_code,
+        decoration = self._get_input_path_controller_wrapper(
+            processor,
+            context,
+            error_http_code,
+            default_http_code,
         )
 
         def decorator(func):
             route,
             swaggerui_path,
         )
+
+    def _get_input_path_controller_wrapper(
+        self,
+        processor: ProcessorInterface,
+        context: ContextInterface,
+        error_http_code: HTTPStatus = HTTPStatus.BAD_REQUEST,
+        default_http_code: HTTPStatus = HTTPStatus.OK,
+    ) -> typing.Union[
+        InputPathControllerWrapper,
+        AsyncInputPathControllerWrapper,
+    ]:
+        if not self._async:
+            return InputPathControllerWrapper(
+                context=context,
+                processor=processor,
+                error_http_code=error_http_code,
+                default_http_code=default_http_code,
+            )
+        return AsyncInputPathControllerWrapper(
+            context=context,
+            processor=processor,
+            error_http_code=error_http_code,
+            default_http_code=default_http_code,
+        )