encadre 0.1.1__tar.gz

encadre-0.1.1/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.2
+Name: encadre
+Version: 0.1.1
+Summary: Encadre framework
+Author: Jean Schurger
+Author-email: jean@schurger.org
+License: GPLv3
+Requires-Dist: Flask
+Requires-Dist: fastjsonschema
+Requires-Dist: flask-cors
+Requires-Dist: decorator
+Requires-Dist: nose
+Requires-Dist: coverage
+Requires-Dist: flask_jwt_extended
+Dynamic: author
+Dynamic: author-email
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary

encadre-0.1.1/encadre/__init__.py

@@ -0,0 +1,80 @@
+import sys
+import configparser
+import traceback
+import logging
+import logging.config
+from encadre.controllers import Controller, load_controllers
+from encadre.framework import Framework, DumpRoutes
+from encadre.framework import framework_from_config, validate
+
+logger = logging.getLogger(__name__)
+
+
+class NotReady:
+    def __init__(self, diagnostic):
+        self.diagnostic = diagnostic
+
+    def __getattr__(self, attribute):
+        raise AttributeError("Cannot access %r: %s" %
+                             (attribute, self.diagnostic))
+
+    def __getitem__(self, item):
+        raise AttributeError("Cannot find %r: %s" % (item, self.diagnostic))
+
+    def __bool__(self):
+        return False
+
+
+request = cookies = NotReady("Encadre is not setup yet.")
+
+
+class Encadre():
+
+    config = {}
+
+    def __init__(self, config_filename):
+        self.application = getattr(self, 'application',
+                                   self.__class__.__name__.lower())
+        logger.debug("Starting encadre application '%s'." % self.application)
+        self.config_filename = config_filename
+        if self.config_filename:
+            self.config.update(self.read_config(self.config_filename))
+            try:
+                logging.config.fileConfig(self.config_filename)
+            except Exception:
+                print("You'd better configure logging in '%s':\n%s" %
+                      (self.config_filename, traceback.format_exc()))
+        setattr(sys.modules['encadre'], 'config', self.config)
+
+    def read_config(self, filename):
+        config = {self.__class__.__name__.lower(): {}}
+        p = configparser.ConfigParser()
+        p.read(filename)
+        for n, s in p.items():
+            if s:
+                config[n] = dict(s)
+        return config
+
+    def serve(self):
+        assert self.config, "Missing config."
+        f = framework_from_config(self.__class__.__name__.lower(), self.config)
+        f.setup_application(self)
+        load_controllers(f, self.application)
+        f.serve()
+
+    def dump_routes(self):
+        assert self.config, "Missing config."
+        f = DumpRoutes(self.__class__.__name__.lower(), self.config)
+        load_controllers(f, self.application)
+        print(f)
+
+    def get_wsgi_app(self):
+        config = self.read_config(self.config_filename)
+        assert config, "Missing config."
+        f = framework_from_config(self.__class__.__name__.lower(), config)
+        f.setup_application(self)
+        load_controllers(f, self.application)
+        return f.get_wsgi_app()
+
+
+__all__ = ['Encadre', 'Framework', 'Controller', 'validate']

encadre-0.1.1/encadre/controllers.py

@@ -0,0 +1,135 @@
+import traceback
+import types
+import logging
+import unittest
+import pkg_resources
+from encadre.framework import Framework
+
+logger = logging.getLogger(__name__)
+
+
+class Controller():
+
+    version = 0
+
+    @classmethod
+    def setup(cls, framework, root):
+        methods = []
+        cls.framework = framework
+        ctrl_name = cls.__name__.lower()
+        version = ctrl_name.split('_')[-1]
+        if version.isdigit():
+            ctrl_name = ctrl_name[:-(len(version) + 1)]
+            version = int(version)
+        else:
+            version = framework.first_version
+
+        for name in [a for a in dir(cls) if a[0] != '_']:
+            attr = getattr(cls, name)
+            if isinstance(attr, types.FunctionType) and \
+               not name.startswith('test_'):
+                verbs = ''.join([c for c in name if c.isupper() or c == '_'
+                                 ]).lstrip('_').split('_')
+                if verbs != ['']:
+                    name = name[:name.find("_%s" % verbs[0])]
+                if name == 'index__':
+                    if root:
+                        if name == 'index__':
+                            framework.root_id = id(attr)
+                    else:
+                        root_id = getattr(framework, 'root_id', None)
+                        # Prevent inheritance of index__
+                        if root_id == id(attr):
+                            continue
+                methods.append(
+                    (name, attr,
+                     attr.__code__.co_varnames[1:attr.__code__.co_argcount],
+                     verbs if verbs != [''] else ['GET']))
+        framework.add_controller((cls, '__root__' if root else ctrl_name,
+                                  version), methods)
+
+
+def setup_controllers(cls, f, level=0):
+    if cls.__name__ != 'Controller':  # exclude abstract
+        cls.setup(f, root=level < 2)
+    for sub in cls.__subclasses__():
+        setup_controllers(sub, f, level + 1)
+
+
+def load_controllers(f, application):
+    for ep in pkg_resources.iter_entry_points('%s.controllers' % application):
+        try:
+            ep.load()
+        except ModuleNotFoundError:
+            logger.error("Error importing '%s': %s" % (
+                ep, traceback.format_exc()))
+    for ep in pkg_resources.iter_entry_points('encadre.controllers'):
+        try:
+            ep.load()
+        except ModuleNotFoundError:
+            logger.error("Error importing '%s': %s" % (
+                ep, traceback.format_exc()))
+    setup_controllers(Controller, f)
+
+
+class EncadreTestCase(unittest.TestCase):
+    def setUp(self):
+        self.framework._json = {}
+        self.framework._environ = {}
+        self.framework._headers = {}
+        self.framework._args = {}
+        self.framework._cookies = {}
+
+    def tearDown(self):
+        pass
+
+
+class TestFramework(Framework):
+    def request_json(self):
+        return self._json
+
+    def request_environ(self):
+
+        return self._environ
+
+    def request_headers(self):
+        return self._headers
+
+    def request_args(self):
+        return self._args
+
+    def get_cookie(self, key):
+        return self._cookies.get(key)
+
+    def set_cookie(self, key, value):  # pylint: disable=W0221
+        self._cookies[key] = value
+
+    def send_bytes(self, bytes_like, **kwargs):  # pylint: disable=W0613
+        return bytes_like.read()
+
+
+def get_controllers_tsts(app):
+    f = TestFramework(app.application, None)
+    load_controllers(f, app.application)
+
+    def missing_test(self):
+        raise Exception("Missing test")
+
+    for c in f.controllers:
+        for v in f.controllers[c]:
+            cls = f.controllers[c][v]['cls']
+            attributes = {}
+            for name in [a for a in dir(cls) if a[0] != '_']:
+                attr = getattr(cls, name)
+                if not name.startswith('test_'):
+                    attributes[name] = attr
+                if isinstance(attr, types.FunctionType) and \
+                   not name.startswith('test_'):
+                    test_name = 'test_%s' % name
+                    test_long_name = 'test_%s_%s' % (cls.__name__, name)
+                    test_fct = getattr(cls, test_name, missing_test)
+                    attributes[test_long_name] = test_fct
+            test_cls = type("Test%s" % cls.__name__,
+                            (getattr(cls, 'testcase_cls', EncadreTestCase), ),
+                            attributes)
+            yield (test_cls.__name__, test_cls)

encadre-0.1.1/encadre/framework.py

@@ -0,0 +1,186 @@
+import sys
+import logging
+import pkg_resources
+import traceback
+from decorator import decorator
+
+logger = logging.getLogger(__name__)
+ENI = Exception("Not implemented.")
+
+
+class Cookies():
+    def __init__(self, framework):
+        self.f = framework
+
+    def get(self, key):
+        return self.f.get_cookie(key)
+
+    def set(self, *args, **kwargs):
+        return self.f.set_cookie(*args, **kwargs)
+
+
+class Request():
+    def __init__(self, framework):
+        self.f = framework
+        self._json = None
+        self._environ = None
+        self._headers = None
+        self._args = None
+
+    def _get_json(self):
+        return self._json or self.f.request_json()
+
+    # Let unit tests set some json
+    def _set_json(self, json):
+        self._json = json
+
+    json = property(_get_json, _set_json)
+
+    def _get_environ(self):
+        return self._environ or self.f.request_environ()
+
+    # Let unit tests set environ
+    def _set_environ(self, environ):
+        self._environ = environ
+
+    environ = property(_get_environ, _set_environ)
+
+    def _get_headers(self):
+        return self._headers or self.f.request_headers()
+
+    # Let unit tests set environ
+    def _set_headers(self, headers):
+        self._headers = headers
+
+    headers = property(_get_headers, _set_headers)
+
+    def _get_args(self):
+        return self._args or self.f.request_args()
+
+    # Let unit tests set environ
+    def _set_args(self, args):
+        self._args = args
+
+    args = property(_get_args, _set_args)
+
+
+def validate(vargs):
+    def helper(func, *args, **kwargs):
+        if hasattr(args[0].framework, 'validate_query'):
+            args[0].framework.validate_query(vargs)
+        return func(*args, **kwargs)
+    return decorator(helper)
+
+
+class Framework():
+
+    request_class = Request
+    cookies_class = Cookies
+
+    def __init__(self, application, config):
+        self.application = application
+        self.config = config
+        self.first_version = int((self.config or {}).get(application, {}).get(
+            'first_version', '0'))
+        if self.first_version:
+            logger.debug("Config set 'first_version' to %s." %
+                         self.first_version)
+        self.versioning_use_prefix = (self.config or {}).get(
+            application, {}).get('versioning', 'headers').lower() == 'prefix'
+        if self.versioning_use_prefix:
+            logger.debug("Config set versioning to 'prefix' mode.")
+        self.routes = {}
+        self.controllers = {}
+        self.request = self.request_class(self)
+        setattr(sys.modules['encadre'], 'request', self.request)
+        self.cookies = self.cookies_class(self)
+        setattr(sys.modules['encadre'], 'cookies', self.cookies)
+
+    def add_controller(self, ctrl, methods):
+        ctrl_cls, ctrl_name, ctrl_version = ctrl
+        self.controllers.setdefault(ctrl_name, {})
+        self.controllers[ctrl_name][ctrl_version] = {
+            'doc': (ctrl_cls.__doc__ or '').strip(),
+            'cls': ctrl_cls,
+            'methods': {}}
+        for method_name, method, args, verbs in methods:
+            self.controllers[ctrl_name][ctrl_version]['methods'].setdefault(
+                method_name, {})
+            for verb in verbs:
+                self.controllers[ctrl_name][ctrl_version]['methods'][
+                    method_name][verb] = {
+                        'fct': method,
+                        'doc': (method.__doc__ or '').strip(),
+                        'args': args}
+
+    def setup_application(self, instance):
+        self.instance = instance
+        self.before_call_chain = []
+        if hasattr(instance, 'before_call'):
+            self.before_call_chain.append(self.instance_before_call)
+        self.after_call_chain = []
+        if hasattr(instance, 'after_call'):
+            self.after_call_chain.append(self.instance_after_call)
+        if hasattr(instance, 'validate_query'):
+            self.validate_query = instance.validate_query
+
+    def instance_before_call(self):
+        getattr(self.instance, 'before_call')()
+
+    def instance_after_call(self, response):
+        getattr(self.instance, 'after_call')()
+        return response
+
+    def not_implemented(self):
+        raise ENI
+
+    request_json = request_environ = request_headers = \
+        request_args = get_cookie = set_cookie = send_bytes = not_implemented
+
+    def format_exception(self, e):
+        ret = None
+        code = 500
+        logger.exception(traceback.format_exc())
+        if hasattr(self.instance, "format_exception"):
+            ret, code = self.instance.format_exception(e)
+        else:
+            ha = (self.config or {}).get(self.application, {}).get(
+                'on_exception', '').lower()
+            if ha == 'traceback':
+                ret = traceback.format_exc()
+            if ha == 'str':
+                ret = str(e)
+        if ret is None:
+            raise e
+        return ret, code
+
+
+class DumpRoutes(Framework):
+
+    def __repr__(self):
+        ret = []
+        for c in sorted(self.controllers):
+            ret.append("* Controller: %s" % (c))
+            for v in self.controllers[c]:
+                ret.append("** Version: %s: %s" %
+                           (v, self.controllers[c][v]['doc']))
+                for m in self.controllers[c][v]['methods']:
+                    for _v in self.controllers[c][v]['methods'][m]:
+                        ret.append(
+                            "- [%s] %s%s: %s" %
+                            (_v, m,
+                             self.controllers[c][v]['methods'][m][_v]['args'],
+                             self.controllers[c][v]['methods'][m][_v]['doc']))
+        return "\n".join(ret)
+
+
+def framework_from_config(application, config):
+    fw_name = (config.get(application) or {}).get('framework')
+    assert fw_name, "No framework configured."
+    for ep in pkg_resources.iter_entry_points('%s.frameworks' % application):
+        if ep.name == fw_name:
+            return ep.load()(application, config)
+    for ep in pkg_resources.iter_entry_points('encadre.frameworks'):
+        if ep.name == fw_name:
+            return ep.load()(application, config)
+    raise Exception("No framework available")

encadre-0.1.1/encadre.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.2
+Name: encadre
+Version: 0.1.1
+Summary: Encadre framework
+Author: Jean Schurger
+Author-email: jean@schurger.org
+License: GPLv3
+Requires-Dist: Flask
+Requires-Dist: fastjsonschema
+Requires-Dist: flask-cors
+Requires-Dist: decorator
+Requires-Dist: nose
+Requires-Dist: coverage
+Requires-Dist: flask_jwt_extended
+Dynamic: author
+Dynamic: author-email
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary

encadre-0.1.1/encadre.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+setup.cfg
+setup.py
+encadre/__init__.py
+encadre/controllers.py
+encadre/framework.py
+encadre.egg-info/PKG-INFO
+encadre.egg-info/SOURCES.txt
+encadre.egg-info/dependency_links.txt
+encadre.egg-info/entry_points.txt
+encadre.egg-info/requires.txt
+encadre.egg-info/top_level.txt
+encadre_flask/__init__.py
+encadre_flask/test.py

encadre-0.1.1/encadre.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

encadre-0.1.1/encadre.egg-info/entry_points.txt

@@ -0,0 +1,9 @@
+[console_scripts]
+encadre-test-app-dump-routes = encadre_test_app:dump_routes
+encadre-test-app-serve = encadre_test_app:serve
+
+[encadre.frameworks]
+flask = encadre_flask:FlaskFramework
+
+[encadre_test_app.controllers]
+test_controllers = encadre_test_controllers

encadre-0.1.1/encadre.egg-info/requires.txt

@@ -0,0 +1,7 @@
+Flask
+fastjsonschema
+flask-cors
+decorator
+nose
+coverage
+flask_jwt_extended

encadre-0.1.1/encadre.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+encadre
+encadre_flask

encadre-0.1.1/encadre_flask/__init__.py

@@ -0,0 +1,168 @@
+import sys
+import re
+import logging
+from flask import Flask, request, send_file, abort
+from flask_cors import CORS
+from flask_jwt_extended import JWTManager
+from encadre import Framework
+
+logger = logging.getLogger(__name__)
+
+
+class FlaskFramework(Framework):
+    def __init__(self, application, config):
+        Framework.__init__(self, application, config)
+        self.versions = {}
+        self._endpoints = set()
+        self.application = application
+        self.flask_app = Flask(application)
+        self.flask_app.url_map.strict_slashes = False
+        self.flask_app.register_error_handler(404, self.handle_exception)
+        for k, v in (self.config.get('flask') or {}).items():
+            _v = v
+            if v.lower() == 'false':
+                _v = False
+            if v.lower() == 'true':
+                _v = True
+            if v.isdigit():
+                _v = int(v)
+            self.flask_app.config[k.upper()] = _v
+        if not (self.config.get('flask') or {}).get('external_cors'):
+            logger.debug("We handle CORS.")
+            CORS(self.flask_app)
+        else:
+            logger.debug("CORS must be handheld upstream.")
+        if (self.config.get('flask') or {}).get('JWT_SECRET_KEY'.lower()):
+            self.jwt_manager = JWTManager(self.flask_app)
+
+    def setup_application(self, instance):
+        Framework.setup_application(self, instance)
+        for fct in self.before_call_chain:
+            self.flask_app.before_request(fct)
+        for fct in self.after_call_chain:
+            self.flask_app.after_request(fct)
+        self.flask_app.after_request(self._set_cookies)
+
+    def _add_method(self, ctrl_name, method_name):
+        def accessor(**args):
+            import flask
+            v = None
+            if self.versioning_use_prefix:
+                v = flask.request.environ.get('PATH_INFO').lstrip('/').split(
+                    '/')[0]
+                logger.debug("Got version '%s' from URL." % v)
+            else:
+                # flask handle case and underscores
+                h = 'X-%s-Version' % self.application
+                v = flask.request.headers.get(h)
+                logger.debug("Got version '%s' from header '%s'." % (v, h))
+            if v and not v.isdigit():
+                flask.abort(405)
+            v = int(v) if v else sys.maxsize
+            v = v if v in self.controllers[ctrl_name] else max(
+                self.controllers[ctrl_name].keys())
+            verb = flask.request.environ['REQUEST_METHOD']
+            cls = self.controllers[ctrl_name][v]['cls']
+            try:
+                m = self.controllers[ctrl_name][v]['methods'][method_name][
+                    verb]['fct'].__name__
+            except KeyError:
+                logger.error("Cannot found method for: controller: '%s', "
+                             "method: '%s', version: '%s', verb: '%s'" %
+                             (ctrl_name, method_name, v, verb))
+                flask.abort(405)
+            self._cookies = []
+            try:
+                ret = getattr(cls(), m)(**args)
+            except Exception as e:
+                ret = self.handle_exception(e)
+            return ret
+
+        setattr(self, '_m_%s_%s' % (ctrl_name, method_name), accessor)
+
+    def handle_exception(self, e):
+        message, code = self.format_exception(e)
+        if not message:
+            abort(code)
+        return message, code
+
+    def _mk_endpoint(self, ctrl_name, method_name, args, version):
+        ep = "/%s/%s%s" % (ctrl_name.lower(),
+                           method_name if method_name != 'index__' else '',
+                           ('/' + '/'.join(['<%s>' % a
+                                            for a in args]) if args else ''))
+        return '/%s%s' % (version, ep) if version else ep
+
+    def _setup_routes(self):
+        """ Add routes to flask """
+        endpoints = {}
+        methods = {}
+        for c in sorted(self.controllers):
+            for v in self.controllers[c]:
+                for m in self.controllers[c][v]['methods']:
+                    for _v in self.controllers[c][v]['methods'][m]:
+                        fct = self.controllers[c][v]['methods'][m][_v]['fct']
+                        args = self.controllers[c][v]['methods'][m][_v]['args']
+                        e = self._mk_endpoint(
+                            c,
+                            m,
+                            args,
+                            version=v if self.versioning_use_prefix else None)
+                        endpoints.setdefault(e, set())
+                        if isinstance(fct.__defaults__, tuple):
+                            url = re.search(r'^(.*[\\\/])', e).group()
+                            endpoints.setdefault(url, set())
+                            endpoints[url].add(_v)
+                            methods[url] = (c, m)
+                        endpoints[e].add(_v)
+                        methods[e] = (c, m)
+        for e, verbs in endpoints.items():
+            self._add_method(*methods[e])
+            logger.debug("Adding endpoint: '%s' allowing with verbs: '%s'." %
+                         (e, verbs))
+            route = e
+            if route.startswith('/__root__'):
+                route = e.replace('/__root__', '', 1)
+            self.flask_app.add_url_rule(route,
+                                        route,
+                                        getattr(self, '_m_%s_%s' % methods[e]),
+                                        methods=verbs)
+
+    def serve(self):
+        self._setup_routes()
+        self.flask_app.run(
+            host=self.flask_app.config.get('HOST', '0.0.0.0'),
+            port=self.flask_app.config.get('PORT', 5001),
+            debug=self.flask_app.config.get('DEBUG', True),
+            threaded=self.flask_app.config.get('THREADED', False),
+        )
+
+    def get_wsgi_app(self):
+        self._setup_routes()
+        return self.flask_app
+
+    def _set_cookies(self, response):
+        for args, kwargs in getattr(self, '_cookies', {}):
+            response.set_cookie(*args, **kwargs)
+        return response
+
+    def request_json(self):
+        return request.json
+
+    def request_environ(self):
+        return request.environ
+
+    def request_headers(self):
+        return request.headers
+
+    def request_args(self):
+        return request.args
+
+    def get_cookie(self, key):
+        return request.cookies.get(key)
+
+    def set_cookie(self, *args, **kwargs):
+        self._cookies.append((args, kwargs))
+
+    def send_bytes(self, bytes_like, **kwargs):
+        return send_file(bytes_like, **kwargs)

encadre-0.1.1/encadre_flask/test.py

@@ -0,0 +1,25 @@
+import unittest
+from encadre import Encadre
+from encadre.framework import framework_from_config
+from encadre.controllers import load_controllers
+
+
+class EncadreFlask(Encadre):
+
+    application = 'encadre_test_app'
+
+    def __init__(self):
+        Encadre.__init__(self, None)
+        self.framework = framework_from_config(self.application,
+                                               {self.application:
+                                                {'framework': 'flask'}})
+        load_controllers(self.framework, self.application)
+
+
+class TestEncadreFlask(unittest.TestCase):
+
+    def setUp(self):
+        self.encadre = EncadreFlask()
+
+    def test_setup_routes(self):
+        self.encadre.framework._setup_routes()

encadre-0.1.1/setup.cfg

@@ -0,0 +1,8 @@
+[nosetests]
+verbosity = 3
+with-doctest = 1
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

encadre-0.1.1/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup
+
+console_scripts = """
+encadre-test-app-serve = encadre_test_app:serve
+encadre-test-app-dump-routes = encadre_test_app:dump_routes
+"""
+
+setup(name='encadre',
+      version='0.1.1',
+      description="Encadre framework",
+      author="Jean Schurger",
+      author_email='jean@schurger.org',
+      packages=['encadre', 'encadre_flask'],
+      install_requires=['Flask', 'fastjsonschema', 'flask-cors',
+                        'decorator', 'nose', 'coverage', 'flask_jwt_extended'],
+      entry_points={
+          'console_scripts': console_scripts,
+          'encadre.frameworks':
+          ['flask = encadre_flask:FlaskFramework'],
+          'encadre_test_app.controllers':
+          ['test_controllers = encadre_test_controllers']
+      },
+      license='GPLv3')