添加sanic 支持

Author: gusibi

api.yml

@@ -93,6 +93,16 @@ parameters:
     in: header
     required: true
     type: string
+  uid_in_path:
+    name: uid
+    in: path
+    required: true
+    type: string
+  name_in_query:
+    name: name
+    in: query
+    required: false
+    type: string
 securityDefinitions:
   OAuth2:
     type: oauth2
@@ -223,5 +233,18 @@ paths:
             $ref: '#/definitions/Error'
       parameters:
         - $ref: '#/parameters/AccessToken'
-      security: 
-        - OAuth2: [open]
+  /users/{uid}:
+    get:
+      summary: get current user info
+      responses:
+        200:
+          schema:
+            $ref: '#/definitions/User'
+          description: user info
+        default:
+          description: Unexpected error
+          schema:
+            $ref: '#/definitions/Error'
+      parameters:
+        - $ref: '#/parameters/uid_in_path'
+        - $ref: '#/parameters/name_in_query'

swagger_py_codegen/command.py

@@ -15,6 +15,7 @@
 from .flask import FlaskGenerator
 from .tornado import TornadoGenerator
 from .falcon import FalconGenerator
+from .sanic import SanicGenerator
 from .parser import Swagger
 from .base import Template
 
@@ -84,7 +85,7 @@ def print_version(ctx, param, value):
 @click.option('-j', '--jobs',
               default=4, help='Parallel jobs for processing.')
 @click.option('-tlp', '--templates',
-              default='flask', help='gen flask/tornado templates,default flask.')
+              default='flask', help='gen flask/tornado/falcon/sanic templates,default flask.')
 @click.option('--version', is_flag=True, callback=print_version,
               expose_value=False, is_eager=True,
               help='Show current version.')
@@ -99,6 +100,8 @@ def generate(destination, swagger_doc, force=False, package=None,
         generator = TornadoGenerator(swagger)
     elif templates == 'falcon':
         generator = FalconGenerator(swagger)
+    elif templates == 'sanic':
+        generator = SanicGenerator(swagger)
     else:
         generator = FlaskGenerator(swagger)
     generator.with_spec = specification

swagger_py_codegen/sanic.py

@@ -0,0 +1,234 @@
+from __future__ import absolute_import
+import re
+from collections import OrderedDict
+
+from .base import Code, CodeGenerator
+from .jsonschema import Schema, SchemaGenerator, build_default
+
+SUPPORT_METHODS = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head']
+
+
+class Router(Code):
+
+    template = 'sanic/routers.tpl'
+    dest_template = '%(package)s/%(module)s/routes.py'
+    override = True
+
+
+class View(Code):
+
+    template = 'sanic/view.tpl'
+    dest_template = '%(package)s/%(module)s/api/%(view)s.py'
+    override = False
+
+
+class Specification(Code):
+
+    template = 'sanic/specification.tpl'
+    dest_template = '%(package)s/static/%(module)s/swagger.json'
+    override = True
+
+
+class Validator(Code):
+
+    template = 'sanic/validators.tpl'
+    dest_template = '%(package)s/%(module)s/validators.py'
+    override = True
+
+
+class Api(Code):
+
+    template = 'sanic/api.tpl'
+    dest_template = '%(package)s/%(module)s/api/__init__.py'
+
+
+class Blueprint(Code):
+
+    template = 'sanic/blueprint.tpl'
+    dest_template = '%(package)s/%(module)s/__init__.py'
+
+
+class App(Code):
+
+    template = 'sanic/app.tpl'
+    dest_template = '%(package)s/__init__.py'
+
+
+class Requirements(Code):
+
+    template = 'sanic/requirements.tpl'
+    dest_template = 'requirements.txt'
+
+
+class UIIndex(Code):
+
+    template = 'ui/index.html'
+    dest_template = '%(package)s/static/swagger-ui/index.html'
+
+
+def _swagger_to_sanic_url(url, swagger_path_node):
+    types = {
+        'integer': 'int',
+        'long': 'int',
+        'float': 'float',
+        'double': 'float'
+    }
+    node = swagger_path_node
+    params = re.findall(r'\{([^\}]+?)\}', url)
+    url = re.sub(r'{(.*?)}', '<\\1>', url)
+
+    def _type(parameters):
+        for p in parameters:
+            if p.get('in') != 'path':
+                continue
+            t = p.get('type', 'string')
+            if t in types:
+                yield '<%s>' % p['name'], '<%s:%s>' % (types[t], p['name'])
+
+    for old, new in _type(node.get('parameters', [])):
+        url = url.replace(old, new)
+
+    for k in SUPPORT_METHODS:
+        if k in node:
+            for old, new in _type(node[k].get('parameters', [])):
+                url = url.replace(old, new)
+
+    return url, params
+
+
+def _remove_characters(text, deletechars):
+    return text.translate({ord(x): None for x in deletechars})
+
+
+def _path_to_endpoint(swagger_path):
+    return _remove_characters(
+        swagger_path.strip('/').replace('/', '_').replace('-', '_'),
+        '{}')
+
+
+def _path_to_resource_name(swagger_path):
+    return _remove_characters(swagger_path.title(), '{}/_-')
+
+
+def _location(swagger_location):
+    location_map = {
+        'body': 'json',
+        'header': 'headers',
+        'formData': 'form',
+        'query': 'args'
+    }
+    return location_map.get(swagger_location)
+
+
+class SanicGenerator(CodeGenerator):
+
+    dependencies = [SchemaGenerator]
+
+    def __init__(self, swagger):
+        super(SanicGenerator, self).__init__(swagger)
+        self.with_spec = False
+        self.with_ui = False
+
+    def _dependence_callback(self, code):
+        if not isinstance(code, Schema):
+            return code
+        schemas = code
+        # schemas default key likes `('/some/path/{param}', 'method')`
+        # use sanic endpoint to replace default validator's key,
+        # example: `('some_path_param', 'method')`
+        validators = OrderedDict()
+        for k, v in schemas.data['validators'].items():
+            locations = {_location(loc): val for loc, val in v.items()}
+            validators[(_path_to_endpoint(k[0]), k[1])] = locations
+
+        # filters
+        filters = OrderedDict()
+        for k, v in schemas.data['filters'].items():
+            filters[(_path_to_endpoint(k[0]), k[1])] = v
+
+        # scopes
+        scopes = OrderedDict()
+        for k, v in schemas.data['scopes'].items():
+            scopes[(_path_to_endpoint(k[0]), k[1])] = v
+
+        schemas.data['validators'] = validators
+        schemas.data['filters'] = filters
+        schemas.data['scopes'] = scopes
+        self.schemas = schemas
+        self.validators = validators
+        self.filters = filters
+        return schemas
+
+    def _process_data(self):
+
+        views = []  # [{'endpoint':, 'name':, url: '', params: [], methods: {'get': {'requests': [], 'response'}}}, ..]
+
+        for paths, data in self.swagger.search(['paths', '*']):
+            swagger_path = paths[-1]
+            url, params = _swagger_to_sanic_url(swagger_path, data)
+            endpoint = _path_to_endpoint(swagger_path)
+            name = _path_to_resource_name(swagger_path)
+
+            methods = OrderedDict()
+            for method in SUPPORT_METHODS:
+                if method not in data:
+                    continue
+                methods[method] = {}
+                validator = self.validators.get((endpoint, method.upper()))
+                if validator:
+                    methods[method]['requests'] = list(validator.keys())
+
+                for status, res_data in data[method].get('responses', {}).items():
+                    if isinstance(status, int) or status.isdigit():
+                        example = res_data.get('examples', {}).get('application/json')
+
+                        if not example:
+                            example = build_default(res_data.get('schema'))
+                        response = example, int(status), build_default(res_data.get('headers'))
+                        methods[method]['response'] = response
+                        break
+
+            views.append(dict(
+                url=url,
+                params=params,
+                endpoint=endpoint,
+                methods=methods,
+                name=name
+            ))
+
+        return views
+
+    def _get_oauth_scopes(self):
+        for path, scopes in self.swagger.search(('securityDefinitions', '*', 'scopes')):
+            return scopes
+        return None
+
+    def _process(self):
+        views = self._process_data()
+        yield Router(dict(views=views))
+        for view in views:
+            yield View(view, dist_env=dict(view=view['endpoint']))
+        if self.with_spec:
+            try:
+                import simplejson as json
+            except ImportError:
+                import json
+            swagger = {}
+            swagger.update(self.swagger.origin_data)
+            swagger.pop('host', None)
+            swagger.pop('schemes', None)
+            yield Specification(dict(swagger=json.dumps(swagger, indent=2)))
+
+        yield Validator()
+
+        yield Api()
+
+        yield Blueprint(dict(scopes_supported=self.swagger.scopes_supported,
+                             blueprint=self.swagger.module_name))
+        yield App(dict(blueprint=self.swagger.module_name,
+                       base_path=self.swagger.base_path))
+
+        yield Requirements()
+
+        if self.with_ui:
+            yield UIIndex(dict(spec_path='/static/%s/swagger.json' % self.swagger.module_name))

swagger_py_codegen/templates/sanic/api.tpl

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, print_function
+
+import inspect
+
+from sanic.views import HTTPMethodView
+
+from ..validators import request_validate, response_filter
+
+before_decorators = [request_validate]
+after_decorators = [response_filter]
+
+methods = ['get', 'put', 'post', 'delete']
+
+
+def add_before_decorators(model_class):
+    for name, m in inspect.getmembers(model_class, inspect.isfunction):
+        if name in methods:
+            for dec in before_decorators:
+                m = dec(m)
+            setattr(model_class, name, m)
+
+
+def add_after_decorators(model_class):
+    for name, m in inspect.getmembers(model_class, inspect.isfunction):
+        if name in methods:
+            for dec in after_decorators:
+                setattr(model_class, name, dec)
+
+
+class APIMetaclass(type):
+    """
+    Metaclass of the Model.
+    """
+    def __init__(cls, name, bases, attrs):
+        super(APIMetaclass, cls).__init__(name, bases, attrs)
+        add_before_decorators(cls)
+        # add_after_decorators(cls)
+
+
+class Resource(HTTPMethodView, metaclass=APIMetaclass):
+
+
+    pass

swagger_py_codegen/templates/sanic/app.tpl

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+from sanic import Sanic
+
+import {{ blueprint }}
+
+
+def create_app():
+    app = Sanic(__name__)
+    app.register_blueprint(
+        {{ blueprint }}.bp,
+        url_prefix='{{ base_path }}')
+    return app
+
+
+app = create_app()
+
+
+if __name__ == '__main__':
+    app.run(host="0.0.0.0", port=8000)

swagger_py_codegen/templates/sanic/blueprint.tpl

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+from sanic import Blueprint
+
+from .routes import routes
+from .validators import security
+
+
+@security.scopes_loader
+def current_scopes():
+    return {{ scopes_supported }}
+
+bp = Blueprint('{{ blueprint }}', __name__)
+
+for route in routes:
+    route.pop('endpoint', None)
+    bp.add_route(route.pop('resource'), *route.pop('urls'), **route)

swagger_py_codegen/templates/sanic/requirements.tpl

@@ -0,0 +1,4 @@
+sanic
+jsonschema
+ujson
+uwsgi