make async compatible for input_body and output_body only

aiopoc.py

+from sh import tail
+from asyncio import sleep
+from aiohttp import web
+
+
+async def handle(request):
+    response = web.StreamResponse(
+        status=200,
+        reason='OK',
+        headers={
+            'Content-Type': 'text/plain; charset=utf-8',
+        },
+    )
+
+    await response.prepare(request)
+    response.enable_chunked_encoding()
+
+    for line in tail("-f", "aiopocdata.txt", _iter=True):
+        await response.write(line.encode('utf-8'))
+        await sleep(0.1)
+
+    return response
+
+
+app = web.Application()
+app.add_routes([
+    web.get('/', handle)
+])
+
+
+web.run_app(app)

example/example_a_aiohttp.py

 
 from aiohttp import web
 from hapic import async as hapic
+from hapic import async as HapicData
 import marshmallow
 
 from hapic.ext.aiohttp.context import AiohttpContext
     )
 
 
+class HandleInputBody(marshmallow.Schema):
+    foo = marshmallow.fields.String(
+        required=True,
+    )
+
+
+class Handle2OutputBody(marshmallow.Schema):
+    data = marshmallow.fields.Dict(
+        required=True,
+    )
+
+
 class HandleOutputBody(marshmallow.Schema):
     sentence = marshmallow.fields.String(
         required=True,
     })
 
 
+@hapic.with_api_doc()
+@hapic.input_body(HandleInputBody())
+@hapic.output_body(Handle2OutputBody())
+async def handle2(request, hapic_data: HapicData):
+    data = hapic_data.body
+    return {
+        'data': data,
+    }
+
+
 async def do_login(request):
     data = await request.json()
     login = data['login']
     web.get('/n/', handle),
     web.get('/n/{name}', handle),
     web.post('/n/{name}', handle),
+    web.post('/b/', handle2),
     web.post('/login', do_login),
 ])
 

hapic/decorator.py

         self,
         func: 'typing.Callable[..., typing.Any]',
     ) -> 'typing.Callable[..., typing.Any]':
-        async def wrapper(*args, **kwargs) -> typing.Any:
+        # async def wrapper(*args, **kwargs) -> typing.Any:
+        def wrapper(*args, **kwargs) -> typing.Any:
             # Note: Design of before_wrapped_func can be to update kwargs
             # by reference here
-            replacement_response = await self.before_wrapped_func(args, kwargs)
+            replacement_response = self.before_wrapped_func(args, kwargs)
             if replacement_response:
                 return replacement_response
 
-            response = await self._execute_wrapped_function(func, args, kwargs)
+            response = self._execute_wrapped_function(func, args, kwargs)
             new_response = self.after_wrapped_function(response)
             return new_response
         return functools.update_wrapper(wrapper, func)
 
 
 # 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
+# (and ControllerWrapper.get_wrapper rewrite) to permit async compatibility.
+# Please re-think about code refact. TAG: REFACT_ASYNC
 class AsyncInputControllerWrapper(InputControllerWrapper):
+    def get_wrapper(
+        self,
+        func: 'typing.Callable[..., typing.Any]',
+    ) -> 'typing.Callable[..., 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 = await self.before_wrapped_func(args, kwargs)
+            if replacement_response:
+                return replacement_response
+
+            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)
+
     async def before_wrapped_func(
         self,
         func_args: typing.Tuple[typing.Any, ...],
         # 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(
+        request_parameters = self.get_request_parameters(
             func_args,
             func_kwargs,
         )
 
         try:
-            processed_data = self.get_processed_data(request_parameters)
+            processed_data = await 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(
+    async def get_processed_data(
         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
-        )
+        request_parameters: RequestParameters,
+    ) -> typing.Any:
+        parameters_data = await self.get_parameters_data(request_parameters)
+        processed_data = self.processor.process(parameters_data)
+        return processed_data
 
 
 class OutputControllerWrapper(InputOutputControllerWrapper):
     pass
 
 
+class AsyncOutputBodyControllerWrapper(OutputControllerWrapper):
+    def get_wrapper(
+        self,
+        func: 'typing.Callable[..., typing.Any]',
+    ) -> 'typing.Callable[..., typing.Any]':
+        # async 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)
+            if replacement_response:
+                return replacement_response
+
+            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)
+
+
 class OutputHeadersControllerWrapper(OutputControllerWrapper):
     pass
 
         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,
         return request_parameters.body_parameters
 
 
+# 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 AsyncInputBodyControllerWrapper(AsyncInputControllerWrapper):
+    def update_hapic_data(
+        self, hapic_data: HapicData,
+        processed_data: typing.Any,
+    ) -> None:
+        hapic_data.body = processed_data
+
+    async def get_parameters_data(self, request_parameters: RequestParameters) -> dict:  # nopep8
+        return await request_parameters.body_parameters
+
+
 class InputHeadersControllerWrapper(InputControllerWrapper):
     def update_hapic_data(
         self, hapic_data: HapicData,

hapic/ext/aiohttp/context.py

 from json import JSONDecodeError
 
 from aiohttp.web_request import Request
+from aiohttp.web_response import Response
 from multidict import MultiDict
 
 from hapic.context import BaseContext
 from aiohttp import web
 
 
+class AiohttpRequestParameters(object):
+    def __init__(
+        self,
+        request: Request,
+    ) -> None:
+        self._request = request
+        self._parsed_body = None
+
+    @property
+    async def body_parameters(self) -> dict:
+        if self._parsed_body is None:
+            content_type = self.header_parameters.get('Content-Type')
+            is_json = content_type == 'application/json'
+
+            if is_json:
+                self._parsed_body = await self._request.json()
+            else:
+                self._parsed_body = await self._request.post()
+
+        return self._parsed_body
+
+    @property
+    def path_parameters(self):
+        return dict(self._request.match_info)
+
+    @property
+    def query_parameters(self):
+        return MultiDict(self._request.query.items())
+
+    @property
+    def form_parameters(self):
+        # TODO BS 2018-07-24: There is misunderstanding around body/form/json
+        return self.body_parameters
+
+    @property
+    def header_parameters(self):
+        return dict(self._request.headers.items())
+
+    @property
+    def files_parameters(self):
+        # TODO BS 2018-07-24: To do
+        raise NotImplementedError('todo')
+
+
 class AiohttpContext(BaseContext):
     def __init__(
         self,
     def app(self) -> web.Application:
         return self._app
 
-    async def get_request_parameters(
+    def get_request_parameters(
         self,
         *args,
         **kwargs
                 '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,
-        )
+        return AiohttpRequestParameters(request)
 
     def get_response(
         self,
         http_code: int,
         mimetype: str = 'application/json',
     ) -> typing.Any:
-        pass
+        return Response(
+            body=response,
+            status=http_code,
+            content_type=mimetype,
+        )
 
     def get_validation_error_response(
         self,
         error: ProcessValidationError,
         http_code: HTTPStatus = HTTPStatus.BAD_REQUEST,
     ) -> typing.Any:
-        pass
+        # TODO BS 2018-07-24: To do
+        raise NotImplementedError('todo')
 
     def find_route(
         self,

hapic/hapic.py

 from hapic.decorator import ControllerReference
 from hapic.decorator import ExceptionHandlerControllerWrapper
 from hapic.decorator import InputBodyControllerWrapper
+from hapic.decorator import AsyncInputBodyControllerWrapper
 from hapic.decorator import InputHeadersControllerWrapper
 from hapic.decorator import InputPathControllerWrapper
-from hapic.decorator import AsyncInputPathControllerWrapper
 from hapic.decorator import InputQueryControllerWrapper
-from hapic.decorator import AsyncInputQueryControllerWrapper
 from hapic.decorator import InputFilesControllerWrapper
 from hapic.decorator import OutputBodyControllerWrapper
+from hapic.decorator import AsyncOutputBodyControllerWrapper
 from hapic.decorator import OutputHeadersControllerWrapper
 from hapic.decorator import OutputFileControllerWrapper
 from hapic.description import InputBodyDescription
         processor = processor or MarshmallowOutputProcessor()
         processor.schema = schema
         context = context or self._context_getter
-        decoration = OutputBodyControllerWrapper(
-            context=context,
-            processor=processor,
-            error_http_code=error_http_code,
-            default_http_code=default_http_code,
-        )
+
+        if self._async:
+            decoration = AsyncOutputBodyControllerWrapper(
+                context=context,
+                processor=processor,
+                error_http_code=error_http_code,
+                default_http_code=default_http_code,
+            )
+        else:
+            decoration = OutputBodyControllerWrapper(
+                context=context,
+                processor=processor,
+                error_http_code=error_http_code,
+                default_http_code=default_http_code,
+            )
 
         def decorator(func):
             self._buffer.output_body = OutputBodyDescription(decoration)
         processor.schema = schema
         context = context or self._context_getter
 
-        decoration = self._get_input_path_controller_wrapper(
+        decoration = InputPathControllerWrapper(
             context=context,
             processor=processor,
             error_http_code=error_http_code,
         processor.schema = schema
         context = context or self._context_getter
 
-        decoration = self._get_input_query_controller_wrapper(
+        decoration = InputQueryControllerWrapper(
             context=context,
             processor=processor,
             error_http_code=error_http_code,
         processor.schema = schema
         context = context or self._context_getter
 
-        decoration = InputBodyControllerWrapper(
-            context=context,
-            processor=processor,
-            error_http_code=error_http_code,
-            default_http_code=default_http_code,
-        )
+        if self._async:
+            decoration = AsyncInputBodyControllerWrapper(
+                context=context,
+                processor=processor,
+                error_http_code=error_http_code,
+                default_http_code=default_http_code,
+            )
+        else:
+            decoration = InputBodyControllerWrapper(
+                context=context,
+                processor=processor,
+                error_http_code=error_http_code,
+                default_http_code=default_http_code,
+            )
 
         def decorator(func):
             self._buffer.input_body = InputBodyDescription(decoration)
             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,
-        )
-
-    def _get_input_query_controller_wrapper(
-        self,
-        processor: ProcessorInterface,
-        context: ContextInterface,
-        error_http_code: HTTPStatus = HTTPStatus.BAD_REQUEST,
-        default_http_code: HTTPStatus = HTTPStatus.OK,
-        as_list: typing.List[str]=None,
-    ) -> typing.Union[
-        InputQueryControllerWrapper,
-        AsyncInputQueryControllerWrapper,
-    ]:
-        if not self._async:
-            return InputQueryControllerWrapper(
-                context=context,
-                processor=processor,
-                error_http_code=error_http_code,
-                default_http_code=default_http_code,
-                as_list=as_list,
-            )
-        return AsyncInputQueryControllerWrapper(
-            context=context,
-            processor=processor,
-            error_http_code=error_http_code,
-            default_http_code=default_http_code,
-            as_list=as_list,
-        )