WIP Pyramid backend

example_a2.py

@@ -0,0 +1,139 @@
+# -*- coding: utf-8 -*-
+import json
+from http import HTTPStatus
+
+from pyramid.view import view_config
+from pyramid.config import Configurator
+from wsgiref.simple_server import make_server
+import time
+import yaml
+from beaker.middleware import SessionMiddleware
+
+import hapic
+from example import HelloResponseSchema, HelloPathSchema, HelloJsonSchema, \
+    ErrorResponseSchema, HelloQuerySchema
+from hapic.data import HapicData
+
+# hapic.global_exception_handler(UnAuthExc, StandardErrorSchema)
+# hapic.global_exception_handler(UnAuthExc2, StandardErrorSchema)
+# hapic.global_exception_handler(UnAuthExc3, StandardErrorSchema)
+# 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):
+    def boby(*args, **kwargs):
+        return f(*args, **kwargs)
+    return boby
+
+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,context,request,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
+        """
+        name = request.matchdict.get('name', None)
+        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'}
+
+    
+    # @view_config(renderer='json')
+    # @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, config):
+        config.add_route('hello', '/hello/{name}', request_method='GET')
+        #config.add_route('hello2', '/hello/{name}', request_method='POST')
+        #config.add_route('hello3', '/hello/{name}', request_method='GET')
+        config.add_view(self.hello, route_name='hello', renderer='json')
+        #config.add_view(self.hello2, route_name='hello2')
+        #config.add_view(self.hello3, route_name='hello3')
+
+
+with Configurator() as config:
+    controllers = Controllers()
+    controllers.bind(config)
+    config.include('pyramid_debugtoolbar')
+    app = config
+
+
+
+
+# time.sleep(1)
+# s = hapic.generate_doc(app)
+# ss = json.loads(json.dumps(s))
+# for path in ss['paths']:
+#     for method in ss['paths'][path]:
+#         for response_code in ss['paths'][path][method]['responses']:
+#             ss['paths'][path][method]['responses'][int(response_code)] = ss['paths'][path][method]['responses'][response_code]
+#             del ss['paths'][path][method]['responses'][int(response_code)]
+# print(yaml.dump(ss, default_flow_style=False))
+# time.sleep(1)
+
+hapic.set_context(hapic.ext.pyramid.PyramidContext())
+import pdb; pdb.set_trace()
+#print(json.dumps(hapic.generate_doc(app)))
+# app.run(host='localhost', port=8080, debug=True)
+server = make_server('0.0.0.0', 6543, app.make_wsgi_app())
+server.serve_forever()

example_a_pyramid.py

@@ -0,0 +1,174 @@
+# -*- coding: utf-8 -*-
+import json
+from http import HTTPStatus
+
+#import bottle
+from pyramid.config import Configurator
+from wsgiref.simple_server import make_server
+import time
+import yaml
+import uuid
+from beaker.middleware import SessionMiddleware
+
+import hapic
+from example import HelloResponseSchema, HelloPathSchema, HelloJsonSchema, \
+    ErrorResponseSchema, HelloQuerySchema
+from hapic.data import HapicData
+
+# hapic.global_exception_handler(UnAuthExc, StandardErrorSchema)
+# hapic.global_exception_handler(UnAuthExc2, StandardErrorSchema)
+# hapic.global_exception_handler(UnAuthExc3, StandardErrorSchema)
+# 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):
+    def boby(*args, **kwargs):
+        return f(*args, **kwargs)
+    return boby
+
+
+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, context, request, 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
+        """
+        name = request.matchdict.get('name', None)
+        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, context, request, hapic_data: HapicData):
+        name = request.matchdict.get('name', None)
+        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, context, request, hapic_data: HapicData):
+        name = request.matchdict.get('name', None)
+        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.config.include('pyramid_debugtoolbar')
+
+
+class PyramRoute(object):
+
+    def __init__(self, app, rule, method, callback, name, **options):
+        self.app = app
+        self.rule = rule
+        self.method = method
+        self.callback = callback
+        self.name = name
+
+        if not self.name:
+            self.name = str(uuid.uuid4())
+
+        with self.app.config as config:
+            config.add_route(self.name, self.rule, request_method=self.method)
+            config.add_view(
+                self.callback, route_name=self.name, renderer='json')
+        #import pdb; pdb.set_trace()
+
+
+class Pyramidapp(object):
+
+    def __init__(self):
+        self.config = Configurator()
+        self.routes = []
+
+    def route(self,
+              rule,
+              callback,
+              method='GET',
+              name=None,
+              **options):
+        r = PyramRoute(self, rule, method, callback, name, **options)
+        self.routes.append(r)
+
+    def run(self, host, port, debug):
+        server = make_server('0.0.0.0', port, self.config.make_wsgi_app())
+        server.serve_forever()
+
+
+app = Pyramidapp()
+
+controllers = Controllers()
+controllers.bind(app)
+
+
+# time.sleep(1)
+# s = hapic.generate_doc(app)
+# ss = json.loads(json.dumps(s))
+# for path in ss['paths']:
+#     for method in ss['paths'][path]:
+#         for response_code in ss['paths'][path][method]['responses']:
+#             ss['paths'][path][method]['responses'][int(response_code)] = ss['paths'][path][method]['responses'][response_code]
+#             del ss['paths'][path][method]['responses'][int(response_code)]
+# print(yaml.dump(ss, default_flow_style=False))
+# time.sleep(1)
+
+# hapic.set_context(hapic.ext.bottle.BottleContext())
+hapic.set_context(hapic.ext.pyramid.PyramidContext())
+#import pdb; pdb.set_trace()
+print(json.dumps(hapic.generate_doc(app)))
+app.run('localhost', 8080, True)
+#server = make_server('0.0.0.0', 8080, app.config.make_wsgi_app())
+# server.serve_forever()

hapic/ext/__init__.py

@@ -1,2 +1,2 @@
 # -*- coding: utf-8 -*-
-from hapic.ext import bottle
+from hapic.ext import bottle, pyramid

hapic/ext/bottle/context.py

@@ -14,7 +14,7 @@ class BottleContext(ContextInterface):
     def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
         return RequestParameters(
             path_parameters=bottle.request.url_args,
-            query_parameters=bottle.request.params,
+            query_parameters=bottle.request.params, ## query?
             body_parameters=bottle.request.json,
             form_parameters=bottle.request.forms,
             header_parameters=bottle.request.headers,

hapic/ext/pyramid/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+from hapic.ext.pyramid.context import PyramidContext

hapic/ext/pyramid/context.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+import json
+import typing
+from http import HTTPStatus
+
+from pyramid.request import Request
+from pyramid.response import Response
+
+
+from hapic.context import ContextInterface
+from hapic.exception import OutputValidationException
+from hapic.processor import RequestParameters, ProcessValidationError
+
+
+class PyramidContext(ContextInterface):
+    def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
+        req = args[-1]  # TODO : Check
+        assert isinstance(req, Request)
+        # TODO : move this code to check_json
+        # same idea as in : https://bottlepy.org/docs/dev/_modules/bottle.html#BaseRequest.json
+        if req.body and req.content_type in ('application/json', 'application/json-rpc'):
+            json_body = req.json_body
+            # TODO : raise exception if not correct , return 400 if uncorrect instead ?
+        else:
+            json_body = None
+
+        return RequestParameters(
+            path_parameters=req.matchdict,
+            query_parameters=req.GET,
+            body_parameters=json_body,
+            form_parameters=req.POST,
+            header_parameters=req.headers,
+        )
+
+    def get_response(
+        self,
+        response: dict,
+        http_code: int,
+    ) -> Response:
+        return Response(
+            body=json.dumps(response),
+            headers=[
+                ('Content-Type', 'application/json'),
+            ],
+            status=http_code,
+        )
+
+    def get_validation_error_response(
+        self,
+        error: ProcessValidationError,
+        http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
+    ) -> typing.Any:
+        # TODO BS 20171010: Manage error schemas, see #4
+        from hapic.hapic import _default_global_error_schema
+        unmarshall = _default_global_error_schema.dump(error)
+        if unmarshall.errors:
+            raise OutputValidationException(
+                'Validation error during dump of error response: {}'.format(
+                    str(unmarshall.errors)
+                )
+            )
+
+        return Response(
+            body=json.dumps(unmarshall.data),
+            headers=[
+                ('Content-Type', 'application/json'),
+            ],
+            status=int(http_code),
+        )