initial code

.gitignore

@@ -0,0 +1,5 @@
+.idea
+*.pyc
+__pycache__
+*~
+/venv

example.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+import marshmallow
+
+
+class HelloResponseSchema(marshmallow.Schema):
+    sentence = marshmallow.fields.String(required=True)
+    name = marshmallow.fields.String(required=True)
+    color = marshmallow.fields.String(required=False)
+
+
+class HelloPathSchema(marshmallow.Schema):
+    name = marshmallow.fields.String(required=True)
+
+
+class HelloJsonSchema(marshmallow.Schema):
+    color = marshmallow.fields.String(required=True)

example_a.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+import bottle
+import hapic
+from example import HelloResponseSchema, HelloPathSchema, HelloJsonSchema
+from hapic.hapic import HapicData
+
+app = bottle.Bottle()
+
+
+def bob(f):
+    def boby(*args, **kwargs):
+        return f(*args, **kwargs)
+    return boby
+
+
+@hapic.with_api_doc()
+@hapic.ext.bottle.bottle_context()
+@hapic.input_path(HelloPathSchema())
+@hapic.output(HelloResponseSchema())
+def hello(name: str, hapic_data: HapicData):
+    return {
+        'sentence': 'Hello !',
+        'name': name,
+    }
+
+
+@hapic.with_api_doc()
+@hapic.ext.bottle.bottle_context()
+@hapic.input_path(HelloPathSchema())
+@hapic.input_body(HelloJsonSchema())
+@hapic.output(HelloResponseSchema())
+@bob
+def hello2(name: str, hapic_data: HapicData):
+    return {
+        'sentence': 'Hello !',
+        'name': name,
+        'color': hapic_data.body.get('color'),
+    }
+
+kwargs = {'validated_data': {'name': 'bob'}, 'name': 'bob'}
+
+
+@hapic.with_api_doc()
+@hapic.ext.bottle.bottle_context()
+@hapic.output(HelloResponseSchema())
+def hello3(name: str, hapic_data: HapicData):
+    return {
+        'sentence': 'Hello !',
+        'name': name,
+    }
+
+
+app.route('/hello/<name>', callback=hello)
+app.route('/hello2/<name>', callback=hello2, method='POST')
+app.route('/hello3/<name>', callback=hello3)
+
+hapic.generate_doc(app)
+app.run(host='localhost', port=8080, debug=True)

example_b.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+import bottle
+import hapic
+from example import HelloResponseSchema, HelloPathSchema, HelloJsonSchema
+from hapic.hapic import MarshmallowOutputProcessor, BottleContext, \
+    MarshmallowPathInputProcessor, MarshmallowJsonInputProcessor
+
+
+def bob(f):
+    def boby(*args, **kwargs):
+        return f
+    return boby
+
+
+@hapic.with_api_doc_bis()
+@bottle.route('/hello/<name>')
+@hapic.input(HelloPathSchema(), MarshmallowPathInputProcessor(), context=BottleContext())  # nopep8
+@hapic.output(HelloResponseSchema(), MarshmallowOutputProcessor())
+@bob
+def hello(name: str):
+    return "Hello {}!".format(name)
+
+
+@hapic.with_api_doc_bis()
+@bottle.route('/hello2/<name>')
+@hapic.input(HelloPathSchema(), MarshmallowPathInputProcessor(), context=BottleContext())  # nopep8
+@hapic.input(HelloJsonSchema(), MarshmallowJsonInputProcessor(), context=BottleContext())  # nopep8
+@hapic.output(HelloResponseSchema())
+@bob
+def hello2(name: str):
+    return "Hello {}!".format(name)
+
+
+@hapic.with_api_doc_bis()
+@bottle.route('/hello3/<name>')
+@hapic.output(HelloResponseSchema())
+def hello3(name: str):
+    return "Hello {}!".format(name)
+
+hapic.generate_doc()
+bottle.run(host='localhost', port=8080, debug=True)
+
+
+
+
+
+@bottle.route('/hello/<name>')
+@hapic.input_body(HelloPathSchema(), MarshmallowPathInputProcessor(), context=BottleContext())  # nopep8
+@hapic.input_header(HelloPathSchema(), MarshmallowPathInputProcessor(), context=BottleContext())  # nopep8
+@hapic.input_query(HelloPathSchema(), MarshmallowPathInputProcessor(), context=BottleContext())  # nopep8
+@hapic.input_path(HelloPathSchema(), MarshmallowPathInputProcessor(), context=BottleContext())  # nopep8
+@hapic.output(HelloResponseSchema(), MarshmallowOutputProcessor())
+def hello(name: str, hapic_data):
+    return "Hello {}!".format(name)
+
+
+@hapic.with_api_doc_bis()
+@bottle.route('/hello/<name>')
+@hapic.input(HelloPathSchema(), MarshmallowPathInputProcessor(), context=BottleContext())  # nopep8
+@hapic.output(HelloResponseSchema(), MarshmallowOutputProcessor())
+@bob
+def hello(name: str):
+    return "Hello {}!".format(name)

hapic/__init__.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+# from hapic.hapic import Hapic
+
+# _hapic_default = Hapic()
+#
+# with_api_doc = _hapic_default.with_api_doc
+# with_api_doc_bis = _hapic_default.with_api_doc_bis
+# generate_doc = _hapic_default.generate_doc
+
+from hapic.hapic import with_api_doc
+from hapic.hapic import with_api_doc_bis
+from hapic.hapic import generate_doc
+from hapic.hapic import output
+from hapic.hapic import input_body
+from hapic.hapic import input_query
+from hapic.hapic import input_path
+from hapic.hapic import input_headers
+from hapic.hapic import BottleContext
+from hapic.hapic import set_fake_default_context
+
+
+class FakeSetContext(object):
+    def bottle_context(self):
+        hapic.set_fake_default_context(BottleContext())
+        def decorator(func):
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+            return wrapper
+        return decorator
+
+
+class FakeExt(object):
+    bottle = FakeSetContext()
+
+
+ext = FakeExt()

hapic/hapic.py

@@ -0,0 +1,332 @@
+# -*- coding: utf-8 -*-
+import json
+import typing
+
+import functools
+
+import bottle
+
+# TODO: Gérer les erreurs de schema
+# TODO: Gérer les cas ou c'est une liste la réponse (items, item_nb)
+
+
+# CHANGE
+flatten = lambda l: [item for sublist in l for item in sublist]
+
+
+_waiting = {}
+_endpoints = {}
+_default_global_context = None
+
+
+def set_fake_default_context(context):
+    global _default_global_context
+    _default_global_context = context
+
+
+def _register(func):
+    assert func not in _endpoints
+    global _waiting
+
+    _endpoints[func] = _waiting
+    _waiting = {}
+
+
+def with_api_doc():
+    def decorator(func):
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        _register(wrapper)
+        return wrapper
+
+    return decorator
+
+
+def with_api_doc_bis():
+    def decorator(func):
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        _register(func)
+        return wrapper
+
+    return decorator
+
+
+def generate_doc(app=None):
+    # TODO @Damien bottle specific code !
+    app = app or bottle.default_app()
+
+    route_by_callbacks = []
+    routes = flatten(app.router.dyna_routes.values())
+    for path, path_regex, route, func_ in routes:
+        route_by_callbacks.append(route.callback)
+
+    for func, descriptions in _endpoints.items():
+        routes = flatten(app.router.dyna_routes.values())
+        for path, path_regex, route, func_ in routes:
+            if route.callback == func:
+                print(route.method, path, descriptions)
+                continue
+
+
+class RequestParameters(object):
+    def __init__(
+        self,
+        path_parameters,
+        query_parameters,
+        body_parameters,
+        form_parameters,
+        header_parameters,
+    ):
+        self.path_parameters = path_parameters
+        self.query_parameters = query_parameters
+        self.body_parameters = body_parameters
+        self.form_parameters = form_parameters
+        self.header_parameters = header_parameters
+
+
+class ContextInterface(object):
+    def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
+        raise NotImplementedError()
+
+    def get_response(
+        self,
+        response: dict,
+        http_code: int,
+    ):
+        raise NotImplementedError()
+
+
+class BottleContext(ContextInterface):
+    def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
+        return RequestParameters(
+            path_parameters=bottle.request.url_args,
+            query_parameters=bottle.request.params,
+            body_parameters=bottle.request.json,
+            form_parameters={},  # TODO
+            header_parameters={},  # TODO
+        )
+
+    def get_response(
+        self,
+        response: dict,
+        http_code: int,
+    ) -> bottle.HTTPResponse:
+        return bottle.HTTPResponse(
+            body=json.dumps(response),
+            headers=[
+                ('Content-Type', 'application/json'),
+            ],
+            status=http_code,
+        )
+
+
+class OutputProcessorInterface(object):
+    def __init__(self):
+        self.schema = None
+
+    def process(self, value):
+        raise NotImplementedError
+
+
+class InputProcessorInterface(object):
+    def __init__(self):
+        self.schema = None
+
+    def process(self, request_context: RequestParameters):
+        raise NotImplementedError
+
+
+class MarshmallowOutputProcessor(OutputProcessorInterface):
+    def process(self, data: typing.Any):
+        return self.schema.dump(data).data
+
+
+class MarshmallowInputProcessor(OutputProcessorInterface):
+    def process(self, data: dict):
+        return self.schema.load(data).data
+
+
+# class MarshmallowPathInputProcessor(OutputProcessorInterface):
+#     def process(self, request_context: RequestParameters):
+#         return self.schema.load(request_context.path_parameters).data
+#
+#
+# class MarshmallowQueryInputProcessor(OutputProcessorInterface):
+#     def process(self, request_context: RequestParameters):
+#         return self.schema.load(request_context.query_parameters).data
+#
+#
+# class MarshmallowJsonInputProcessor(OutputProcessorInterface):
+#     def process(self, request_context: RequestParameters):
+#         return self.schema.load(request_context.json_parameters).data
+
+
+# class MarshmallowFormInputProcessor(OutputProcessorInterface):
+#     def process(self, request_context: RequestParameters):
+#         return self.schema.load(xxx).data
+#
+#
+# class MarshmallowHeaderInputProcessor(OutputProcessorInterface):
+#     def process(self, request_context: RequestParameters):
+#         return self.schema.load(xxx).data
+
+
+class HapicData(object):
+    def __init__(self):
+        self.body = {}
+        self.path = {}
+        self.query = {}
+        self.headers = {}
+
+
+# TODO: Il faut un output_body et un output_header
+def output(
+    schema,
+    processor: OutputProcessorInterface=None,
+    context: ContextInterface=None,
+    default_http_code=200,
+    default_error_code=500,
+):
+    processor = processor or MarshmallowOutputProcessor()
+    processor.schema = schema
+    context = context or _default_global_context
+
+    def decorator(func):
+        # @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            raw_response = func(*args, **kwargs)
+            processed_response = processor.process(raw_response)
+            prepared_response = context.get_response(
+                processed_response,
+                default_http_code,
+            )
+            return prepared_response
+
+        _waiting['output'] = schema
+
+        return wrapper
+    return decorator
+
+
+# TODO: raccourcis 'input' tout court ?
+def input_body(
+    schema,
+    processor: InputProcessorInterface=None,
+    context: ContextInterface=None,
+    error_http_code=400,
+):
+    processor = processor or MarshmallowInputProcessor()
+    processor.schema = schema
+    context = context or _default_global_context
+
+    def decorator(func):
+
+        # @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            updated_kwargs = {'hapic_data': HapicData()}
+            updated_kwargs.update(kwargs)
+            hapic_data = updated_kwargs['hapic_data']
+
+            request_parameters = context.get_request_parameters(*args, **updated_kwargs)
+            hapic_data.body = processor.process(request_parameters.body_parameters)
+
+            return func(*args, **updated_kwargs)
+
+        _waiting.setdefault('input', []).append(schema)
+
+        return wrapper
+    return decorator
+
+
+def input_path(
+    schema,
+    processor: InputProcessorInterface=None,
+    context: ContextInterface=None,
+    error_http_code=400,
+):
+    processor = processor or MarshmallowInputProcessor()
+    processor.schema = schema
+    context = context or _default_global_context
+
+    def decorator(func):
+
+        # @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            updated_kwargs = {'hapic_data': HapicData()}
+            updated_kwargs.update(kwargs)
+            hapic_data = updated_kwargs['hapic_data']
+
+            request_parameters = context.get_request_parameters(*args, **updated_kwargs)
+            hapic_data.path = processor.process(request_parameters.path_parameters)
+
+            return func(*args, **updated_kwargs)
+
+        _waiting.setdefault('input', []).append(schema)
+
+        return wrapper
+    return decorator
+
+
+def input_query(
+    schema,
+    processor: InputProcessorInterface=None,
+    context: ContextInterface=None,
+    error_http_code=400,
+):
+    processor = processor or MarshmallowInputProcessor()
+    processor.schema = schema
+    context = context or _default_global_context
+
+    def decorator(func):
+
+        # @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            updated_kwargs = {'hapic_data': HapicData()}
+            updated_kwargs.update(kwargs)
+            hapic_data = updated_kwargs['hapic_data']
+
+            request_parameters = context.get_request_parameters(*args, **updated_kwargs)
+            hapic_data.query = processor.process(request_parameters.query_parameters)
+
+            return func(*args, **updated_kwargs)
+
+        _waiting.setdefault('input', []).append(schema)
+
+        return wrapper
+    return decorator
+
+
+def input_headers(
+    schema,
+    processor: InputProcessorInterface,
+    context: ContextInterface=None,
+    error_http_code=400,
+):
+    processor = processor or MarshmallowInputProcessor()
+    processor.schema = schema
+    context = context or _default_global_context
+
+    def decorator(func):
+
+        # @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            updated_kwargs = {'hapic_data': HapicData()}
+            updated_kwargs.update(kwargs)
+            hapic_data = updated_kwargs['hapic_data']
+
+            request_parameters = context.get_request_parameters(*args, **updated_kwargs)
+            hapic_data.headers = processor.process(request_parameters.header_parameters)
+
+            return func(*args, **updated_kwargs)
+
+        _waiting.setdefault('input', []).append(schema)
+
+        return wrapper
+    return decorator

requirements.txt

@@ -0,0 +1,2 @@
+bottle==0.12.13
+marshmallow==2.13.6