use an attribute to identify controller

.gitignore

 *~
 /venv
 .cache
+*.egg-info

example_a.py

 import bottle
 import time
 import yaml
+from beaker.middleware import SessionMiddleware
 
 import hapic
 from example import HelloResponseSchema, HelloPathSchema, HelloJsonSchema, \
     ErrorResponseSchema, HelloQuerySchema
 from hapic.data import HapicData
 
-app = bottle.Bottle()
 # hapic.global_exception_handler(UnAuthExc, StandardErrorSchema)
 # hapic.global_exception_handler(UnAuthExc2, StandardErrorSchema)
 # hapic.global_exception_handler(UnAuthExc3, StandardErrorSchema)
-bottle.default_app.push(app)
-hapic.set_context(hapic.ext.bottle.bottle_context)
+# bottle.default_app.push(app)
+
+# session_opts = {
+#     'session.type': 'file',
+#     'session.data_dir': '/tmp',
+#     'session.cookie_expires': 3600,
+#     'session.auto': True
+# }
+# session_middleware = SessionMiddleware(
+#     app,
+#     session_opts,
+#     environ_key='beaker.session',
+#     key='beaker.session.id',
+# )
+# app = session_middleware.wrap_app
 
 
 def bob(f):
     return boby
 
 
-@hapic.with_api_doc()
-# @hapic.ext.bottle.bottle_context()
-@hapic.handle_exception(ZeroDivisionError, http_code=HTTPStatus.BAD_REQUEST)
-@hapic.input_path(HelloPathSchema())
-@hapic.input_query(HelloQuerySchema())
-@hapic.output_body(HelloResponseSchema())
-def hello(name: str, hapic_data: HapicData):
-    """
-    my endpoint hello
-    ---
-    get:
-        description: my description
-        parameters:
-            - in: "path"
-              description: "hello"
-              name: "name"
-              type: "string"
-        responses:
-            200:
-                description: A pet to be returned
-                schema: HelloResponseSchema
-    """
-    if name == 'zero':
-        raise ZeroDivisionError('Don\'t call him zero !')
-
-    return {
-        'sentence': 'Hello !',
-        'name': name,
-    }
-
-
-@hapic.with_api_doc()
-# @hapic.ext.bottle.bottle_context()
-# @hapic.error_schema(ErrorResponseSchema())
-@hapic.input_path(HelloPathSchema())
-@hapic.input_body(HelloJsonSchema())
-@hapic.output_body(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.error_schema(ErrorResponseSchema())
-@hapic.input_path(HelloPathSchema())
-@hapic.output_body(HelloResponseSchema())
-def hello3(name: str):
-    return {
-        'sentence': 'Hello !',
-        'name': name,
-    }
-
-
-app.route('/hello/<name>', callback=hello)
-app.route('/hello/<name>', callback=hello2, method='POST')
-app.route('/hello3/<name>', callback=hello3)
+class Controllers(object):
+    @hapic.with_api_doc()
+    # @hapic.ext.bottle.bottle_context()
+    @hapic.handle_exception(ZeroDivisionError, http_code=HTTPStatus.BAD_REQUEST)
+    @hapic.input_path(HelloPathSchema())
+    @hapic.input_query(HelloQuerySchema())
+    @hapic.output_body(HelloResponseSchema())
+    def hello(self, name: str, hapic_data: HapicData):
+        """
+        my endpoint hello
+        ---
+        get:
+            description: my description
+            parameters:
+                - in: "path"
+                  description: "hello"
+                  name: "name"
+                  type: "string"
+            responses:
+                200:
+                    description: A pet to be returned
+                    schema: HelloResponseSchema
+        """
+        if name == 'zero':
+            raise ZeroDivisionError('Don\'t call him zero !')
+
+        return {
+            'sentence': 'Hello !',
+            'name': name,
+        }
+
+    @hapic.with_api_doc()
+    # @hapic.ext.bottle.bottle_context()
+    # @hapic.error_schema(ErrorResponseSchema())
+    @hapic.input_path(HelloPathSchema())
+    @hapic.input_body(HelloJsonSchema())
+    @hapic.output_body(HelloResponseSchema())
+    @bob
+    def hello2(self, 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.error_schema(ErrorResponseSchema())
+    @hapic.input_path(HelloPathSchema())
+    @hapic.output_body(HelloResponseSchema())
+    def hello3(self, name: str):
+        return {
+            'sentence': 'Hello !',
+            'name': name,
+        }
+
+    def bind(self, app):
+        app.route('/hello/<name>', callback=self.hello)
+        app.route('/hello/<name>', callback=self.hello2, method='POST')
+        app.route('/hello3/<name>', callback=self.hello3)
+
+app = bottle.Bottle()
+
+controllers = Controllers()
+controllers.bind(app)
+
 
 # time.sleep(1)
 # s = hapic.generate_doc(app)
 # print(yaml.dump(ss, default_flow_style=False))
 # time.sleep(1)
 
-print(json.dumps(hapic.generate_doc()))
+hapic.set_context(hapic.ext.bottle.bottle_context)
+print(json.dumps(hapic.generate_doc(app)))
 
 app.run(host='localhost', port=8080, debug=True)

hapic/decorator.py

 from hapic.processor import ProcessorInterface
 from hapic.processor import RequestParameters
 
+# TODO: Ensure usage of DECORATION_ATTRIBUTE_NAME is documented and
+# var names correctly choose.
+DECORATION_ATTRIBUTE_NAME = '_hapic_decoration_token'
+
 
 class ControllerWrapper(object):
     def before_wrapped_func(
 class DecoratedController(object):
     def __init__(
         self,
-        reference: 'typing.Callable[..., typing.Any]',
+        token: str,
         description: ControllerDescription,
     ) -> None:
-        self._reference = reference
+        self._token = token
         self._description = description
 
     @property
-    def reference(self) -> 'typing.Callable[..., typing.Any]':
-        return self._reference
+    def token(self) -> str:
+        return self._token
 
     @property
     def description(self) -> ControllerDescription:

hapic/doc.py

 from apispec import APISpec, Path
 from apispec.ext.marshmallow.swagger import schema2jsonschema
 
-from hapic.decorator import DecoratedController
-
+from hapic.decorator import DecoratedController, DECORATION_ATTRIBUTE_NAME
 
 # Bottle regular expression to locate url parameters
 from hapic.description import ControllerDescription
 BOTTLE_RE_PATH_URL = re.compile(r'<(?:[^:<>]+:)?([^<>]+)>')
 
 
-def bottle_route_for_view(reference, app):
+def bottle_route_for_view(token, app):
     for route in app.routes:
-        if route.callback == reference:
+        route_token = getattr(
+            route.callback,
+            DECORATION_ATTRIBUTE_NAME,
+            None,
+        )
+        if route_token == token:
             return route
     # TODO: specialize exception
     raise Exception('Not found')
         # with app.test_request_context():
         paths = {}
         for controller in controllers:
-            bottle_route = bottle_route_for_view(controller.reference, app)
+            bottle_route = bottle_route_for_view(controller.token, app)
             swagger_path = BOTTLE_RE_PATH_URL.sub(r'{\1}', bottle_route.rule)
 
             operations = bottle_generate_operations(

hapic/hapic.py

 # -*- coding: utf-8 -*-
 import typing
+import uuid
 from http import HTTPStatus
 import functools
 
 import marshmallow
 
 from hapic.buffer import DecorationBuffer
-from hapic.context import ContextInterface, BottleContext
-from hapic.decorator import DecoratedController
+from hapic.context import ContextInterface
+from hapic.decorator import DecoratedController, DECORATION_ATTRIBUTE_NAME
 from hapic.decorator import ExceptionHandlerControllerWrapper
 from hapic.decorator import InputBodyControllerWrapper
 from hapic.decorator import InputHeadersControllerWrapper
 from hapic.decorator import InputQueryControllerWrapper
 from hapic.decorator import OutputBodyControllerWrapper
 from hapic.decorator import OutputHeadersControllerWrapper
-from hapic.description import InputBodyDescription, ErrorDescription
+from hapic.description import InputBodyDescription
+from hapic.description import ErrorDescription
 from hapic.description import InputFormsDescription
 from hapic.description import InputHeadersDescription
 from hapic.description import InputPathDescription
         def decorator(func):
 
             # FIXME: casse ou casse pas le bis ?
-            # @functools.wraps(func)
+            @functools.wraps(func)
             def wrapper(*args, **kwargs):
                 return func(*args, **kwargs)
 
+            token = uuid.uuid4().hex
+            setattr(wrapper, DECORATION_ATTRIBUTE_NAME, token)
             description = self._buffer.get_description()
+
             decorated_controller = DecoratedController(
-                reference=wrapper,
+                token=token,
                 description=description,
             )
             self._buffer.clear()