Пример #1
1
def create_app(config=None):
    """Create an instance of the tentd flask application"""
    app = Flask("tentd")
    app.add_url_rule("/", "home", description)
    app.request_class = Request

    # Load the default configuration values
    import tentd.defaults as defaults

    app.config.from_object(defaults)

    # Load the user configuration values
    if isinstance(config, basestring):
        config = make_config(config)

    if not isinstance(config, dict):
        raise TypeError("Config argument must be a dict or string.")

    if config is not None:
        app.config.update(config)

    # Initialise the db for this app
    db.init_app(app)

    # Register the entity blueprints
    for blueprint in (entity, followers, posts):
        app.register_blueprint(blueprint, url_prefix=blueprint.prefix(app))

    return app
Пример #2
0
class app:
    """
    """

    controller_list = {}

    def __init__(self, name):
        self.app = Flask(name)
        self.app.debug = True
        self.app.secret_key = "this is a key"
        # app.run(host='0.0.0.0')

    def run(self, port):
        for k, v in self.controller_list.iteritems():
            print "Start Controller: %s" % (k)

        self.app.run(host="0.0.0.0", port=port)

    def add_controller(self, controller):
        self.controller_list[controller.name] = controller
        for k, v in controller.function_list.iteritems():
            route_path = "/" + controller.name + k
            if v.type == 1:
                route_path = "/" + controller.name + k + "/<path:url_var>"
            print "Reg function: %s" % (route_path)

            self.app.add_url_rule(route_path, None, v.func, **v.options)
Пример #3
0
	def create_app(self):
		app = Flask(__name__)
		app.config.from_object(config['unit_test'])
		app.add_url_rule('/test', view_func=test_route)
		app.add_url_rule('/', view_func=index)
		#print "app.view_functions: {}".format(app.view_functions)
		return app
Пример #4
0
    def test_url_invalid_object(self):
        app = Flask(__name__)
        app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x)
        field = fields.Url("foobar")

        with app.test_request_context("/"):
            self.assertRaises(MarshallingException, lambda: field.output("hey", None))
Пример #5
0
    def test_url_superclass_kwargs(self):
        app = Flask(__name__)
        app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x)
        field = fields.Url(absolute=True, attribute='hey')

        with app.test_request_context("/hey"):
            self.assertEquals("http://localhost/3", field.output("hey", Foo()))
Пример #6
0
    def test_url_absolute(self):
        app = Flask(__name__)
        app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x)
        field = fields.Url("foobar", absolute=True)

        with app.test_request_context("/"):
            self.assertEquals("http://localhost/3", field.output("hey", Foo()))
Пример #7
0
def start(application):
    """Start the web frontend"""

    # Make sure our views can access the main application
    global app
    app = application

    static_path = os.path.join(
        os.path.dirname(os.path.abspath(__file__)),
        '../static/'
    )

    config = app.get_config()

    frontend = Flask(__name__, static_folder=static_path)

    # Make sure we crash if there's some bug in the frontend code, this is so
    # we'll find the bugs
    frontend.config['PROPAGATE_EXCEPTIONS'] = True

    frontend.add_url_rule('/', view_func=MainView.as_view('index'))
    frontend.add_url_rule('/data.json', view_func=DataView.as_view('data'))

    # Set up the route for static files
    @frontend.route('/static/<path:filename>')
    def send_static(filename):
        return send_from_directory(static_path, filename)

    frontend.run(host='0.0.0.0', port=config.http_port)

    return frontend
Пример #8
0
class MethodViewLoginTestCase(unittest.TestCase):
    def setUp(self):
        self.app = Flask(__name__)
        self.login_manager = LoginManager()
        self.login_manager.init_app(self.app)
        self.login_manager._login_disabled = False

        class SecretEndpoint(MethodView):
            decorators = [
                login_required,
                fresh_login_required,
            ]

            def options(self):
                return u''

            def get(self):
                return u''

        self.app.add_url_rule('/secret',
                              view_func=SecretEndpoint.as_view('secret'))

    def test_options_call_exempt(self):
        with self.app.test_client() as c:
            result = c.open('/secret', method='OPTIONS')
            self.assertEqual(result.status_code, 200)
class PointOfInterestSearchEndpointTest(unittest.TestCase):

    def setUp(self):
        self._poi_service = Mock()
        self._poi_service.name_search = Mock(return_value=[])

        self._app = Flask(__name__)
        self._endpoint = PointOfInterestSearchEndpoint('test', self._poi_service)
        self._app.add_url_rule('/search', 'test.search', self._endpoint.get)
        self._app.add_url_rule('/<slug>', 'test.poi', self._endpoint.get)

    def test_making_search_passes_it_to_service(self):
        self._poi_service.search_name.return_value = []
        search_terms = "test search"
        self._make_search_request(search_terms)
        self._poi_service.search_name.assert_called_once_with(search_terms)

    def test_return_value_from_service_is_serialised_to_json(self):
        self._poi_service.search_name.return_value = [PointOfInterest(slug='test:test')]
        response = self._make_search_request("test")
        self.assertEquals('test:test', response['results'][0]['poi']['slug'])

    def _make_search_request(self, search_terms):
        with self._app.test_request_context(
            '/search?q={q}'.format(q=quote_plus(search_terms)), headers=[('Accept', 'application/json')]
        ):
            response = self._endpoint.get()
        return json.loads(response.data)
def test_instance_methods():
    class HelloWorldService:
        def get_value(self):
            return "test message 1"

    class HelloWorld:
        def from_injected_service(self, service: HelloWorldService):
            return service.get_value()

        def static_value(self):
            return "test message 2"

    app = Flask(__name__)
    hello_world = HelloWorld()
    app.add_url_rule('/from_injected_service', 'from_injected_service', hello_world.from_injected_service)
    app.add_url_rule('/static_value', 'static_value', hello_world.static_value)

    FlaskInjector(app=app)

    client = app.test_client()
    response = client.get('/from_injected_service')
    eq_(response.data.decode('utf-8'), "test message 1")

    response = client.get('/static_value')
    eq_(response.data.decode('utf-8'), "test message 2")
Пример #11
0
    def test_url_without_endpoint(self):
        app = Flask(__name__)
        app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x)
        field = fields.Url()

        with app.test_request_context("/hey"):
            self.assertEquals("/3", field.output("hey", Foo()))
Пример #12
0
    def test_url_without_endpoint_absolute_scheme(self):
        app = Flask(__name__)
        app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x)
        field = fields.Url(absolute=True, scheme='https')

        with app.test_request_context("/hey", base_url="http://localhost"):
            self.assertEquals("https://localhost/3", field.output("hey", Foo()))
Пример #13
0
    def create_app(self):
        
        class DefaultView(MethodView):
            '''Default route docstring'''
            def put(self):
                return "put on default route"
            def post(self):
                return "post on default route"
        
        class ScopedView(MethodView):
            '''Scoped route docstring'''
            scopes = ['default']
            decorators = [advertise('scopes')]
            def get(self):
                return "scoped route"

        app = Flask(__name__,static_folder=None)
        app.add_url_rule('/default',view_func=DefaultView.as_view('default'))
        app.add_url_rule('/scoped',view_func=ScopedView.as_view('scoped'))
        discoverer = Discoverer(app)

        self.expected_resources = {
            '/scoped': {
                'scopes':['default'],
                'description': 'Scoped route docstring',
                'methods': ['HEAD','OPTIONS','GET'],
            },
            '/default': {
                'description': 'Default route docstring',
                'methods': ['PUT','POST','OPTIONS'],
            },
        }
        return app
Пример #14
0
class FyPress():
    def __init__(self, config, manager=False):
        from flask.ext.babel import Babel
        from utils.mysql import FlaskFyMySQL

        self.prepared = False
        self.config = config
        self.app = Flask(
            __name__,
            template_folder=self.config.TEMPLATE_FOLDER,
            static_folder=self.config.STATIC_FOLDER
        )
        self.app.config.from_object(config)
        self.app.wsgi_app = ProxyFix(self.app.wsgi_app)
        self.babel = Babel(self.app)
        self.db    = FlaskFyMySQL(self.app)

        if not manager:
            self.prepare()

    def run(self, host='0.0.0.0', port=5000):
        if self.prepared == False:
            self.prepare()
        self.app.run(host=host, port=port, debug=self.config.DEBUG)

    def prepare(self):
        local.fp = self
        self.prepared = True

        @self.app.before_request
        def before_request():
            g.start = time.time()
            
        if self.config.DEBUG:
            @self.app.after_request
            def after_request(response):
                diff = time.time() - g.start
                if (response.response):
                    response.headers["Execution-Time"] = str(diff)
                return response

        self.app.add_url_rule(self.app.config['UPLOAD_DIRECTORY_URL']+'<filename>', 'FyPress.uploaded_file', build_only=True)
        self.app.wsgi_app = SharedDataMiddleware(self.app.wsgi_app, {self.app.config['UPLOAD_DIRECTORY_URL']: self.app.config['UPLOAD_DIRECTORY']})

        self.blueprint()

    def blueprint(self):
        ### Blueprints ###
        from user import user_blueprint
        from admin import admin_blueprint
        from public import public_blueprint

        ### Load Blueprints ###
        self.app.register_blueprint(user_blueprint)
        self.app.register_blueprint(admin_blueprint)
        self.app.register_blueprint(public_blueprint)

    @staticmethod
    def uploaded_file(filename):
        return send_from_directory(self.app.config['UPLOAD_DIRECTORY'], filename)
Пример #15
0
def create_app():
    app = Flask(
        __name__.split('.')[0],
        template_folder='../templates',
        static_url_path=None,
        static_folder=None
    )

    env = Development
    if os.environ.get('APPLICATION_ENV', '') == 'Production':
        env = Production

    app.config.from_object(env)

    # Load config items into jinja settings
    for key, val in app.config.items():
        if key.startswith('JINJA'):
            setattr(app.jinja_env, key[6:].lower(), val)

    register_controllers(app)
    register_errorhandlers(app)
    register_extensions(app)

    app.static_folder = '../public/'
    app.add_url_rule(app.config['STATIC_URL_PATH'] + '/<path:filename>',
                     endpoint='static',
                     view_func=app.send_static_file
                     )

    signal.signal(signal.SIGUSR1, sig_handler)
    signal.signal(signal.SIGUSR2, sig_handler)

    return app
Пример #16
0
def make_oauth_wsgi(oauth, next_app, config=None):
    app = Flask(__name__, static_folder=None)
    app.config['PROPAGATE_EXCEPTIONS'] = True

    if config:
        app.config.update(config)
    else:
        app.config.from_envvar('OAUTH_SETTINGS')

    app.next_app = next_app
    oauth.init_app(app)
    app.add_url_rule('/login', endpoint=None, view_func=login)
    app.add_url_rule('/logout', endpoint=None, view_func=logout)
    app.add_url_rule('/login/oauth_callback', endpoint=None, view_func=authorized)
    app.add_url_rule(
        '/',
        endpoint=None, view_func=default_handler,
        methods=['GET', 'HEAD', 'POST', 'PUT', 'DELETE'],
    )
    app.add_url_rule(
        '/<path:any>',
        endpoint=None, view_func=default_handler,
        methods=['GET', 'HEAD', 'POST', 'PUT', 'DELETE'],

    )

    auth = get_auth_provider(oauth)
    if not auth._tokengetter:
        auth.tokengetter(get_oauth_token)

    app.wsgi_app = ProxyFix(app.wsgi_app)

    return app
Пример #17
0
def startAPIs(plugin_controller, model_controller, hostname, port):
    global _rest_controllers
    global _http_server
    _rest_controllers = [PluginControllerAPI(plugin_controller), ModelControllerAPI(model_controller)]

    app = Flask('APISController')

    _http_server = HTTPServer(WSGIContainer(app))
    while True:
        try:
            _http_server.listen(port, address=hostname)
            logger.getLogger().info(
                    "REST API server configured on %s" % str(
                        CONF.getApiRestfulConInfo()))
            break
        except socket.error as exception:
            if exception.errno == 98:
                # Port already in use
                # Let's try the next one
                port += 1
                if port > 65535:
                    raise Exception("No ports available!")
                CONF.setApiRestfulConInfoPort(port)
                CONF.saveConfig()
            else:
                raise exception

    routes = [r for c in _rest_controllers for r in c.getRoutes()]

    for route in routes:
        app.add_url_rule(route.path, view_func=route.view_func, methods=route.methods)

    logging.getLogger("tornado.access").addHandler(logger.getLogger(app))
    logging.getLogger("tornado.access").propagate = False
    threading.Thread(target=startServer).start()
Пример #18
0
def create_backend_app(service):
    from werkzeug.routing import Map

    # Create the backend_app
    backend_app = Flask(__name__)
    backend_app.debug = True
    backend_app.service = service

    # Reset view functions to reset the app
    backend_app.view_functions = {}
    backend_app.url_map = Map()
    backend_app.url_map.converters['regex'] = RegexConverter
    backend = BACKENDS[service]
    for url_path, handler in backend.flask_paths.items():
        if handler.__name__ == 'dispatch':
            endpoint = '{0}.dispatch'.format(handler.__self__.__name__)
        else:
            endpoint = None

        if endpoint in backend_app.view_functions:
            # HACK: Sometimes we map the same view to multiple url_paths. Flask
            # requries us to have different names.
            endpoint += "2"

        backend_app.add_url_rule(
            url_path,
            endpoint=endpoint,
            methods=HTTP_METHODS,
            view_func=convert_flask_to_httpretty_response(handler),
            strict_slashes=False,
        )

    backend_app.test_client_class = AWSTestHelper
    return backend_app
Пример #19
0
    def __init__(self, default_format, directory, *default_configs):
        app = Flask("configurator")
        view = ConfigView.as_view("config", default_format,
                                  directory, *default_configs)
        app.add_url_rule("/", view_func=view)

        self.app = app
Пример #20
0
def create_app(test_config=None):
    app = Flask(__name__, instance_relative_config = True)

    app.config.from_mapping(
        SECRET_KEY='dev',
        DATABASE=os.path.join(app.instance_path, 'grub.sqlite')
    )

    if test_config is None:
        # load the instance config, if it exists, when not testing
        app.config.from_pyfile('config.py', silent=True)
    else:
        # load the test config if passed in
        app.config.from_mapping(test_config)

    # ensure the instance folder exists
    try:
        os.makedirs(app.instance_path)
    except OSError:
        pass

    # Db
    from . import db
    db.init_app(app)

    # Orders
    from . import orders
    app.register_blueprint(orders.bp)
    app.add_url_rule('/', endpoint='index')

    # Orders
    from . import users
    app.register_blueprint(users.bp)

    return app
Пример #21
0
    def test_url_parameters(self):
        app = Flask(__name__)
        app.add_url_rule("/<foo>", "foobar", view_func=lambda x: x)
        field = fields.Url("foobar", attributes={'foo': 'hey'})

        with app.test_request_context("/"):
            self.assertEquals("/3", field.output("hey", Foo()))
Пример #22
0
 def setUp(self):
     app = Flask(__name__)
     app.debug = True
     toybox = ToyBox(app)
     app.add_url_rule("/test", view_func=DummyModelView.as_view("test"))
     app.add_url_rule("/test-base", view_func=DummyBaseModelView.as_view("test_base"))
     self.app = app.test_client()
Пример #23
0
def get_flask_application(core):
    application = Flask(__name__)
    application.debug = True
    for app in core.apps:
        for url, view in app.get_urls():
            application.add_url_rule(url, view.__class__.__name__, view(core))
    return application
Пример #24
0
def create_app(test_config=None):
    # create and configure the app
    app = Flask(__name__, instance_relative_config=True)
    app.config.from_mapping(
        SECRET_KEY='dev',
        DATABASE=os.path.join(app.instance_path, 'flaskr.sqlite')
    )

    if test_config is None:
        # load the instance config, if it exists, when not testing
        app.config.from_pyfile('config.py', silent=True)
    else:
        app.config.from_mapping(test_config)
    
    # ensure the isntance folder exists
    try:
        os.makedirs(app.instance_path)
    except OSError:
        pass
    
    @app.route('/hello')
    def hello():
        return 'Hello, World!'
    
    from . import db
    db.init_app(app)

    from . import auth
    app.register_blueprint(auth.bp)

    from . import blog
    app.register_blueprint(blog.bp)
    app.add_url_rule('/', endpoint='index')

    return app
Пример #25
0
def create_app(defer_init_app=False, freezer_kwargs=None):
    app = Flask(__name__)
    app.register_blueprint(admin_blueprint, url_prefix='/admin')
    if not freezer_kwargs:
        freezer_kwargs = {}
    if defer_init_app:
        freezer = Freezer(**freezer_kwargs)
    else:
        freezer = Freezer(app, **freezer_kwargs)

    @app.route('/')
    def index():
        return ('Main index ' +
                url_for('product', product_id='5', revision='b12ef20'))

    @app.route('/page/<name>/')
    def page(name):
        url_for('product', product_id='3')  # Pretend we’re adding a link
        url_for('product', product_id='4')  # Another link
        return u'Hello\xa0World! ' + name

    @app.route('/where_am_i/')
    def where_am_i():
        return (url_for('where_am_i') + ' ' +
                url_for('where_am_i', _external=True))

    @app.route('/robots.txt')
    def robots_txt():
        content = 'User-agent: *\nDisallow: /'
        return app.response_class(content, mimetype='text/plain')

    for asset in ("favicon.ico",):
        url = "/" + asset
        name = asset.replace(".", "_")
        _partial = partial(app.send_static_file, filename=asset)
        app.add_url_rule(url, name, _partial)

    @app.route('/product_<int:product_id>/')
    def product_route(product_id):
        return 'Product num %i' % product_id

    @app.route('/add/', methods=['POST'])
    def add_something(product_id):
        return 'This view should be ignored as it does not accept GET.'

    @freezer.register_generator
    def product_generator():
        # endpoint, values
        yield 'product', {'product_id': 0}
        yield 'page', {'name': 'foo'}
        # Just a `values` dict. The endpoint defaults to the name of the
        # generator function, just like with Flask views
        yield {'product_id': 1}
        # single string: url
        yield '/product_2/'

    if defer_init_app:
        freezer.init_app(app)

    return app, freezer
Пример #26
0
def startAPIs(plugin_manager, model_controller, mapper_manager, hostname=None, port=None):
    global _rest_controllers
    global _http_server
    _rest_controllers = [PluginControllerAPI(plugin_manager, mapper_manager), ModelControllerAPI(model_controller)]

    #TODO: some way to get defaults.. from config?
    if str(hostname) == "None":
        hostname = "localhost"
    if str(port) == "None":
        port = 9977

    if CONF.getApiRestfulConInfo() is None:
        CONF.setApiRestfulConInfo(hostname, port)

    app = Flask('APISController')

    _http_server = HTTPServer(WSGIContainer(app))
    _http_server.listen(port,address=hostname) 

    routes = [r for c in _rest_controllers for r in c.getRoutes()]

    for route in routes: 
        app.add_url_rule(route.path, view_func=route.view_func, methods=route.methods) 

    logging.getLogger("tornado.access").addHandler(logger.getLogger(app))
    logging.getLogger("tornado.access").propagate = False
    threading.Thread(target=startServer).start()
def create_app(config={}):
    app = Flask("chassis")
    app.config.from_envvar("FLASK_CONFIG")
    app.config.update(config)

    #External
    sentry.init_app(app)
    api.init_app(app)
    cache.init_app(app)

    #Internal
    db.init_app(app)

    #API Endpoints
    api.add_resource(CatAPI, "/cats/<int:cat_id>")
    api.add_resource(TodoListAPI, "/todos")

    app.add_url_rule("/", view_func=show_todos)

    with app.app_context():
        db.create_all()

    #Debug tools
    if app.debug:
        DebugToolbarExtension(app)
        if app.config.get("PROFILE", False):
            app.wsgi_app = ProfilerMiddleware(app.wsgi_app,
                                              restrictions=[30],
                                              sort_by=("time", "cumulative"))

    return app
Пример #28
0
def create_app(defer_init_app=False, freezer_kwargs=None):
    app = Flask(__name__)
    app.register_blueprint(admin_blueprint, url_prefix="/admin")
    if not freezer_kwargs:
        freezer_kwargs = {}
    if defer_init_app:
        freezer = Freezer(**freezer_kwargs)
    else:
        freezer = Freezer(app, **freezer_kwargs)

    @app.route("/")
    def index():
        return "Main index " + url_for("product", product_id="5", revision="b12ef20")

    @app.route("/page/<name>/")
    def page(name):
        url_for("product", product_id="3")  # Pretend we’re adding a link
        url_for("product", product_id="4")  # Another link
        return u"Hello\xa0World! " + name

    @app.route("/where_am_i/")
    def where_am_i():
        return url_for("where_am_i") + " " + url_for("where_am_i", _external=True)

    @app.route("/robots.txt")
    def robots_txt():
        content = "User-agent: *\nDisallow: /"
        return app.response_class(content, mimetype="text/plain")

    for asset in ("favicon.ico",):
        url = "/" + asset
        name = asset.replace(".", "_")
        app.add_url_rule(url, name, partial(app.send_static_file, filename=asset))

    @app.route("/product_<int:product_id>/")
    def product(product_id):
        return "Product num %i" % product_id

    @freezer.register_generator
    def product():
        # endpoint, values
        yield "product", {"product_id": 0}
        # Just a `values` dict. The endpoint defaults to the name of the
        # generator function, just like with Flask views
        yield {"product_id": 1}
        # single string: url
        yield "/product_2/"

        yield "page", {"name": u"I løvë Unicode"}

    @app.errorhandler(404)
    def not_found(e):
        return "Page not found", 404

    freezer.error_handler_spec[None] = {404: "/404.html"}

    if defer_init_app:
        freezer.init_app(app)

    return app, freezer
Пример #29
0
class WebServer (threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.ioLoop = IOLoop.instance()
        self.app = Flask(__name__)
        self.app.add_url_rule(rule='/icnaas/api/v1.0/fmc_manager', methods=['POST'], view_func=self.groupMigration)

    #@self.app.route('/icnaas/api/v1.0/fmc_manager', methods=['POST'])
    def groupMigration(self):

        if not request.json or not 'mobility_prediction' in request.json:
            abort(400)

        print "Received Migration from MP_MIDDLEWARE"
        #print json.loads(request.data)

        mig = Migration()
        code = mig.processMigrationInfo(request.json)

        return jsonify({'result': code}), code
        #return jsonify({'result': 200}), 200

    def stop(self):
        self.ioLoop.stop()

    def run(self):
        http_server = HTTPServer(WSGIContainer(self.app))
        http_server.listen(5000)
        self.ioLoop.start()
Пример #30
0
def create_app():
    app = Flask(__name__)
    api = Api(app)
    app.config.from_object('config.default')
    app.config.from_envvar('APP_SETTINGS', silent=False)
    app.add_url_rule('/api/login', 'login', _get_token)
    from models.base import db
    db.init_app(app)
    from controllers.index import Index
    from controllers.user import UsersList, UserSingle
    from controllers.tasks import TaskSingle, Tasks, AssignTask
    from controllers.comments import Comments
    from controllers.reports import UserComments, TaskStats
    app.before_request(db_connect.before_request)
    app.after_request(db_connect.after_request)
    app.add_url_rule('/api/tasks/<int:task_id>/comments',
                     view_func=Comments.as_view(COMMENTS))
    api.add_resource(Index, '/api/index')
    api.add_resource(UsersList, '/api/users')
    api.add_resource(UserSingle, '/api/users/<int:user_id>')
    api.add_resource(Tasks, '/api/tasks')
    api.add_resource(TaskSingle, '/api/tasks/<int:task_id>')
    api.add_resource(AssignTask, '/api/assign_task')
    api.add_resource(UserComments, '/api/reports/user_comments')
    api.add_resource(TaskStats, '/api/reports/task_stats')
    return app
Пример #31
0
""" Программа использует flask и запускает веб-сервер. 
При запросе к этому серверу он возвращает содержимое файла index.html
Файл обрабатывается как шаблон. Он не находится! """
from flask import Flask, render_template


def index():
    """ функция обрабатывает шаблон index.html и возвращает получившийся документ"""
    return render_template('index.html')


app = Flask(__name__)

# создаём правило для URL '/':
app.add_url_rule('/', 'index', index)

# Запускаем веб-сервер:
app.run()
Пример #32
0
    def __init__(self,
                 app: flask.Flask,
                 config: typing.Dict[str, typing.Any],
                 login_name: str = 'authl.login',
                 login_path: str = '/login',
                 callback_name: str = 'authl.callback',
                 callback_path: str = '/cb',
                 tester_name: str = 'authl.test',
                 tester_path: str = None,
                 login_render_func: typing.Callable = None,
                 notify_render_func: typing.Callable = None,
                 session_auth_name: typing.Optional[str] = 'me',
                 force_https: bool = False,
                 stylesheet: typing.Union[str, typing.Callable] = None,
                 on_verified: typing.Callable = None,
                 make_permanent: bool = True,
                 state_storage: typing.Dict = None,
                 token_storage: tokens.TokenStore = None,
                 session_namespace='_authl',
                 ):
        # pylint:disable=too-many-arguments,too-many-locals,too-many-statements

        if state_storage is None:
            state_storage = typing.cast(typing.Dict, flask.session)

        self.authl = from_config(
            config,
            state_storage,
            token_storage)

        self._session = state_storage
        self.login_name = login_name
        self.callback_name = callback_name
        self.tester_name = tester_name
        self._tester_path = tester_path
        self._login_render_func = login_render_func
        self._notify_render_func = notify_render_func
        self._session_auth_name = session_auth_name
        self.force_https = force_https
        self._stylesheet = stylesheet
        self._on_verified = on_verified
        self.make_permanent = make_permanent
        self._prefill_key = session_namespace + '.prefill'

        for sfx in ['', '/', '/<path:redir>']:
            app.add_url_rule(login_path + sfx, login_name,
                             self._login_endpoint, methods=('GET', 'POST'))
        app.add_url_rule(callback_path + '/<hid>',
                         callback_name,
                         self._callback_endpoint,
                         methods=('GET', 'POST'))

        if tester_path:
            def find_service():
                from flask import request

                url = request.args.get('url')
                if not url:
                    return json.dumps(None)

                handler, _, canon_url = self.authl.get_handler_for_url(url)
                if handler:
                    return json.dumps({'name': handler.service_name,
                                       'url': canon_url})

                return json.dumps(None)
            app.add_url_rule(tester_path, tester_name, find_service)
Пример #33
0
"""
모델로더와 서빙 클래스를 Flask 프레임워크에 적용 
"""
import os
from flask import Flask, jsonify, request, Response
from aicentro.serving.serving_config import configure_error_handlers

context = os.getenv('AICENTRO_NOTEBOOK_CONTEXT_PATH', default='')

# Flask 객체 생성
app = Flask(__name__)
# Flask 객체에 URL Rule 정의
app.add_url_rule(
    '{0}/'.format(context),  # URL 패스 정의
    view_func=serving,  # 서빙 클래스 객체
    methods=['GET', 'POST']  # 서비스 가능 HTTP 메소드
)


# Error Handler 적용
# 에러에 따른 결과 포멧 변경 시 별도 함수 호출
def message_format(code, message):
    """
    에러 발생 시 리턴되는 Json 포멧 정의
    :param code: configure_error_hanlders 함수 호출 시 지정된 code 값
    :param message: error 발생 시 exception 의 메시지
    :return: dict: Json 으로 생성될 Dictionary
    """
    return {
        'error_code': code,
Пример #34
0
JUPITER_CONFIG_INI_PATH = '/jupiter/build/jupiter_config.ini'
APP_DIR = "/jupiter/build/app_specific_files/"
app = Flask(__name__)


def recv_task_assign_info():
    """
        Receive task assignment information from the workers
    """
    assign = request.args.get('assign')
    task_assign_summary.append(assign)
    log.debug("Task assign summary: " + json.dumps(task_assign_summary))
    return 'ok'


app.add_url_rule('/recv_task_assign_info', 'recv_task_assign_info',
                 recv_task_assign_info)


def recv_mapping():
    """
    From each droplet, the master receive the local mapping of the assigned task for that droplet, combine all of the information
    Write the global mapping to ``assignments`` variable and ``local/input_to_CIRCE.txt``

    Returns:
        str: ``ok`` if mapping is ready, ``not ok`` otherwise

    Raises:
        Exception:   when mapping is not ready
    """

    try:
Пример #35
0
        # 'production' is a magic string for bugsnag, rest are arbitrary
        release_stage=config.REALM.replace("prod", "production"),
        notify_release_stages=["production", "test"],
        use_ssl=True)
    handle_exceptions(app)

from filters import *
app.jinja_env.filters['status_class'] = status_class
app.jinja_env.filters['friendly_time'] = friendly_time
app.jinja_env.filters['friendly_size'] = friendly_size
app.jinja_env.filters['to_qs'] = to_qs
app.jinja_env.filters['approximate_time'] = approximate_time
app.jinja_env.filters['exact_time'] = exact_time
app.jinja_env.filters['short_date'] = short_date

app.add_url_rule('/', 'views.home')
app.add_url_rule('/<name>',
                 'views.bin',
                 methods=[
                     'GET', 'POST', 'DELETE', 'PUT', 'OPTIONS', 'HEAD',
                     'PATCH', 'TRACE'
                 ])

app.add_url_rule('/docs/<name>', 'views.docs')
app.add_url_rule('/api/v1/bins', 'api.bins', methods=['POST'])
app.add_url_rule('/api/v1/bins/<name>', 'api.bin', methods=['GET'])
app.add_url_rule('/api/v1/bins/<bin>/requests',
                 'api.requests',
                 methods=['GET'])
app.add_url_rule('/api/v1/bins/<bin>/requests/<name>',
                 'api.request',
Пример #36
0
import logging
from slack_logger import SlackHandler, SlackFormatter
from flask.logging import default_handler

app = Flask(__name__)
app.debug = True

root = logging.getLogger()

# def yashlogger(abc,level="asd"):
#     print(abc)

app.add_url_rule(
    '/gqlsecretpathhuehuehuehue',
    view_func=GraphQLView.as_view(
        'graphql',
        schema=schema,
        graphiql=True # for having the GraphiQL interface
    )
)
# Custom static data
@app.route('/app/<path:filename>')
def custom_static(filename):
    return send_from_directory("app-static", filename)

@app.route('/asdasdafgwgwrgregergerger')
def yash():
    pass

@app.route('/', methods=['GET'])
def home():
    return "<a href='app/index.html'>Hello there</h1></a>"
Пример #37
0
@app.route('/suma/<int:valor1>/<int:valor2>')
def suma(valor1, valor2):
    return 'La suma es: {0}'.format((valor1 + valor2))


@app.route('/perfil/<nombre>/<int:edad>')
def perfil(nombre, edad):
    return 'Tu nombre es: {0} y tu edad es: {1}'.format(nombre, edad)


@app.route('/lenguajes')
def lenguajes():
    data = {
        'hay_lenguajes': False,
        'lenguajes': ['PHP', 'Python', 'kotlin', 'Java']
    }
    return render_template('lenguajes.html', data=data)


@app.route('/datos')
def datos():
    print(request.args)
    a = request.args.get('valor1')
    b = int(request.args.get('valor2'))
    return 'Esto son los datos: {0}, {1}'.format(a, b + 15)


if __name__ == '__main__':
    app.add_url_rule('/', view_func=index)
    app.run(debug=True, port=5005)
Пример #38
0
    response.mimetype = 'text/xml'
    return response


@app.route('/robots.txt')
def robots():
    return send_from_directory(app.static_folder, "robots.txt")


# The "main" routes. 99% of requests will come in through these.
app.add_url_rule(
    "/update/1/<product>/<version>/<buildID>/<buildTarget>/<locale>/<channel>/update.xml",
    view_func=ClientRequestView.as_view("clientrequest1"),
    # Underlying code depends on osVersion being set. Since this route only
    # exists to support ancient queries, and all newer versions have osVersion
    # in them it's easier to set this here than make the all of the underlying
    # code support queries without it.
    defaults={
        "queryVersion": 2,
        "osVersion": ""
    },
)
app.add_url_rule(
    '/update/2/<product>/<version>/<buildID>/<buildTarget>/<locale>/<channel>/<osVersion>/update.xml',
    view_func=ClientRequestView.as_view('clientrequest2'),
    defaults={'queryVersion': 2},
)
app.add_url_rule(
    '/update/3/<product>/<version>/<buildID>/<buildTarget>/<locale>/<channel>/<osVersion>/<distribution>/<distVersion>/update.xml',
    view_func=ClientRequestView.as_view('clientrequest3'),
    defaults={'queryVersion': 3},
)
Пример #39
0
from flask_graphql import GraphQLView

from lime_comb_api.auth import jwt_validate
from lime_comb_api.schema import Mutation, Query

googleclouddebugger.enable()
googlecloudprofiler.start(
    service="lime-comb-api",
    service_version="0.0.0",
    # verbose is the logging level. 0-error, 1-warning, 2-info,
    # 3-debug. It defaults to 0 (error) if not set.
    verbose=3,
    # project_id must be set if not running on GCP.
    # project_id='lime-comb',
)

schema = graphene.Schema(query=Query)

view_func = GraphQLView.as_view(
    "graphql",
    schema=graphene.Schema(query=Query, mutation=Mutation),
    graphiql=True,
    # get_context=lambda: {"session": db_session},
)

app = Flask(__name__)
app.add_url_rule("/", view_func=jwt_validate(view_func))

if __name__ == "__main__":
    app.run(debug=True)
Пример #40
0
from flask import Flask

from toga_flask import TogaApp

from freedom import app as freedom

app = Flask(__name__, static_folder='../static')

app.add_url_rule('/', view_func=TogaApp.as_view("foo", app_module=freedom))


if __name__ == '__main__':
    app.run(port=8081, debug=True)
Пример #41
0
from flask import Flask
from schema import Query
from flask_graphql import GraphQLView
from graphene import Schema
import os


view_func = GraphQLView.as_view(
    'graphql', schema=Schema(query=Query), graphiql=True)

app = Flask(__name__)
app.add_url_rule('/graphql', view_func=view_func)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=os.environ.get('PORT', 5000))
Пример #42
0
    ]
}
allowed_url = 'https://d32e0zjclv95xl.cloudfront.net'
# allowed_url = 'http://localhost:4200' # TODO: change this to cloudfront

# Enable CORS
CORS(application,
     resources={r"/*": {
         "origins": config['ORIGINS']
     }},
     headers='Content-Type, X-Api-Key, Token',
     supports_credentials=True)

# add a rule for the index page. (Put here by AWS in the sample)
application.add_url_rule(
    '/', 'index',
    (lambda: header_text + say_hello() + instructions + footer_text))

# add a rule when the page is accessed with a name appended to the site
# URL. Put here by AWS in the sample
application.add_url_rule('/<username>', 'hello',
                         (lambda username: header_text + say_hello(username) +
                          home_link + footer_text))

##################################################################################################################
# The stuff I added begins here.

_default_context = None
_user_service = None

Пример #43
0
def create_app(handle, instance, reloader=None):
    check.inst_param(handle, 'handle', ExecutionTargetHandle)
    check.inst_param(instance, 'instance', DagsterInstance)
    check.opt_inst_param(reloader, 'reloader', Reloader)

    app = Flask('dagster-ui')
    sockets = Sockets(app)
    app.app_protocol = lambda environ_path_info: 'graphql-ws'

    schema = create_schema()
    subscription_server = DagsterSubscriptionServer(schema=schema)

    execution_manager = SubprocessExecutionManager(instance)

    warn_if_compute_logs_disabled()

    print('Loading repository...')
    context = DagsterGraphQLContext(
        handle=handle,
        instance=instance,
        execution_manager=execution_manager,
        reloader=reloader,
        version=__version__,
    )

    # Automatically initialize scheduler everytime Dagit loads
    scheduler_handle = context.scheduler_handle
    if scheduler_handle:
        handle = context.get_handle()

        python_path = sys.executable
        repository_path = handle.data.repository_yaml
        scheduler_handle.up(python_path, repository_path)

    app.add_url_rule(
        '/graphql',
        'graphql',
        DagsterGraphQLView.as_view(
            'graphql',
            schema=schema,
            graphiql=True,
            # XXX(freiksenet): Pass proper ws url
            graphiql_template=PLAYGROUND_TEMPLATE,
            executor=Executor(),
            context=context,
        ),
    )
    sockets.add_url_rule(
        '/graphql', 'graphql',
        dagster_graphql_subscription_view(subscription_server, context))

    app.add_url_rule(
        # should match the `build_local_download_url`
        '/download/<string:run_id>/<string:step_key>/<string:file_type>',
        'download_view',
        download_view(context),
    )

    # these routes are specifically for the Dagit UI and are not part of the graphql
    # API that we want other people to consume, so they're separate for now.
    # Also grabbing the magic global request args dict so that notebook_view is testable
    app.add_url_rule('/dagit/notebook', 'notebook',
                     lambda: notebook_view(request.args))

    app.add_url_rule('/static/<path:path>/<string:file>', 'static_view',
                     static_view)
    app.add_url_rule('/vendor/<path:path>/<string:file>', 'vendor_view',
                     vendor_view)
    app.add_url_rule('/<string:worker_name>.worker.js', 'worker_view',
                     worker_view)
    app.add_url_rule('/dagit_info', 'sanity_view', info_view)
    app.add_url_rule('/<path:_path>', 'index_catchall', index_view)
    app.add_url_rule('/', 'index', index_view, defaults={'_path': ''})

    CORS(app)

    return app
Пример #44
0
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# FACEBOOK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

import json
import os
import sys
import threading
import time
sys.path.insert(0, 'backend')
from states import NetworkStateService
from flask import Flask, Response, request

app = Flask(__name__, static_url_path='', static_folder='public')
app.add_url_rule('/', 'root', lambda: app.send_static_file('index.html'))

@app.route('/api/comments', methods=['GET', 'POST'])
def comments_handler():

    with open('database/comments.json', 'r') as file:
        comments = json.loads(file.read())

    if request.method == 'POST':
        newComment = request.form.to_dict()
        newComment['id'] = int(time.time() * 1000)
        comments.append(newComment)

        with open('database/comments.json', 'w') as file:
            file.write(json.dumps(comments, indent=4, separators=(',', ': ')))
Пример #45
0
import os
import logging.config

application = Flask(os.environ.get("APPLICATION_NAME"))
SETTINGS_FILE = os.environ.get("SETTINGS_FILE", "settings.local_settings")

application.config.from_object(SETTINGS_FILE)

with application.app_context():
    # this loads all the views with the app context
    # this is also helpful when the views import other
    # modules, this will load everything under the application
    # context and then one can use the current_app configuration
    # parameters
    from apis.urls import all_urls
    from scripts import ALL_CLI_COMMANDS

    for cli_name, cli_command in ALL_CLI_COMMANDS.items():
        application.cli.add_command(cli_command, name=cli_name)

# Adding all the url rules in the api application
for url, view, methods, _ in all_urls:
    application.add_url_rule(url, view_func=view, methods=methods)

logging.config.dictConfig(application.config["LOGGING"])

celery = Celery(application.name,
                broker=application.config['CELERY_BROKER_URL'])

celery.conf.update(application.config)
Пример #46
0
        return 'Nothing'


class StopAll(views.MethodView):

    def get(self):
        self.stop_all()
        return render_template("Switch.html")

    @staticmethod
    def stop_all():
        for cid in dev_ena:
            dev_ena[cid] = False
        app.add_url_rule('/login', view_func=Login.as_view(name='login'))
        print('stop_all')
        return 'Nothing'


app.add_url_rule('/login', view_func=Login.as_view(name='login'))
app.add_url_rule('/chem_a', view_func=ChemA.as_view(name='chem_a'))
app.add_url_rule('/chem_b', view_func=ChemB.as_view(name='chem_b'))
app.add_url_rule('/chem_wax', view_func=ChemWax.as_view(name='chem_wax'))
app.add_url_rule('/chem_wheel', view_func=ChemWheel.as_view(name='chem_wheel'))
app.add_url_rule('/l2_1', view_func=L21.as_view(name='l2_1'))
app.add_url_rule('/l2_2', view_func=L22.as_view(name='l2_2'))
app.add_url_rule('/wheel', view_func=Wheel.as_view(name='wheel'))
app.add_url_rule('/stop_all', view_func=StopAll.as_view(name='stop_all'))

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5010)
Пример #47
0
from flask import Flask


# Create Flask application object. That requires an arg for resolve the path.
app = Flask(__name__)


# Create a view function for root path. Decorate a python function with app.route()
@app.route('/')
def index():
    # It's a view function.
    return "<h2>Hello, FLASK!</h2>", 200
    # 200 is a status_code of response. It's not require


@app.route('/user/<name>')
def get_user(name):
    return "Welcome, {}".format(name), 200


def list_users():
    return "LIST OF USERS", 200
app.add_url_rule(rule='/user', endpoint='list_users', view_func=list_users)

# Run Flask web server. Debug mode on, port 8000.
if __name__ == '__main__':
    app.run(port=8000, debug=1)

# You can test typing that, "curl -X GET localhost:8000"
Пример #48
0
class FibonacciServer(object):

    MAX_ACCEPTABLE_NUMBER = 10000
    MAX_LOG_FILE_BYTES = 50 << 20  # 50 MB
    MAX_LOG_FILE_BACKUP = 9
    RUNTIME_LOG = 'runtime.log'

    def __init__(self, host='127.0.0.1', port=8080):
        self._host = host
        self._port = port
        self._app = Flask(__name__)
        self._init_logging()
        self._add_routes()
        self._fib = Fibonacci()

    def index(self):
        """Handles `GET /` request, this is required when deploy to heroku (it
        hits this uri to verify
        """
        msg = ('Welcome to Fibonacci Server!\n\n'
               'Currently only one API is supported:\n\n'
               'GET /v1/fib/:number\n')
        return msg, 200, {'Content-Type': 'text/plain; charset=utf-8'}

    def fib(self, version, number):
        """Handles the `GET /:version/fib/:number` request. Status goes to
        header, data goes to body in JSON.

        Status codes are:
            - 200 OK
            - 400 BAD REQUEST (invalid parameter)
            - 403 REQUEST ENTITY TOO LARGE (input number too large)
            - 500 INTERNAL SERVER ERROR (unknown exception)
            - 501 NOT IMPLEMENTED (not supported API)
        """
        if version != 'v1':
            return self._response(501)
        try:
            n = int(number)
        except ValueError:
            return self._response(400)
        if n < 0:
            return self._response(400)
        elif n > self.MAX_ACCEPTABLE_NUMBER:
            return self._response(413)

        try:
            seq = self._fib.sequence(n)
            return self._response(200, seq)
        except:
            return self._response(500)

    def run(self):
        self._app.run(host=self._host, port=self._port)

    def _init_logging(self):
        """Configure web log generated by werkzeug to use 'runtime.log'
        """
        handler = RotatingFileHandler(
            self.RUNTIME_LOG, maxBytes=self.MAX_LOG_FILE_BYTES,
            backupCount=self.MAX_LOG_FILE_BACKUP)
        logger = logging.getLogger('werkzeug')
        logger.addHandler(handler)
        logger.setLevel(logging.INFO)  # Turns off console log

    def _add_routes(self):
        self._app.add_url_rule('/', endpoint='index', view_func=self.index)
        self._app.add_url_rule('/<version>/fib/<number>', endpoint='fib', view_func=self.fib)

    def _response(self, status, data=None):
        data = data or []
        return Response(json.dumps(data), status=status,
                        mimetype='application/json')

    def _test_client(self):
        return self._app.test_client()
Пример #49
0
class FieldsTestCase(unittest.TestCase):
    
    def setUp(self):
        self.app = Flask(__name__)
        self.app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x)
        bp = Blueprint("foo", __name__, url_prefix="/foo")
        bp.add_url_rule("/<hey>", "foobar", view_func=lambda x: x)
        self.app.register_blueprint(bp)

    def test_decimal_trash(self):
        self.assertRaises(MarshallingException, lambda: fields.Float().output('a', {'a': 'Foo'}))

    def test_basic_dictionary(self):
        obj = {"foo": 3}
        field = fields.String()
        self.assertEquals(field.output("foo", obj), "3")

    def test_no_attribute(self):
        obj = {"bar": 3}
        field = fields.String()
        self.assertEquals(field.output("foo", obj), None)

    def test_date_field_invalid(self):
        obj = {"bar": 3}
        field = fields.DateTime()
        self.assertRaises(MarshallingException, lambda: field.output("bar", obj))

    def test_attribute(self):
        obj = {"bar": 3}
        field = fields.String(attribute="bar")
        self.assertEquals(field.output("foo", obj), "3")

    def test_formatting_field_none(self):
        obj = {}
        field = fields.FormattedString("/foo/{0[account_sid]}/{0[sid]}/")
        self.assertRaises(MarshallingException, lambda: field.output("foo", obj))

    def test_formatting_field_tuple(self):
        obj = (3, 4)
        field = fields.FormattedString("/foo/{0[account_sid]}/{0[sid]}/")
        self.assertRaises(MarshallingException, lambda: field.output("foo", obj))

    def test_formatting_field_dict(self):
        obj = {
            "sid": 3,
            "account_sid": 4,
        }
        field = fields.FormattedString("/foo/{account_sid}/{sid}/")
        self.assertEquals(field.output("foo", obj), "/foo/4/3/")

    def test_formatting_field(self):
        obj = Mock()
        obj.sid = 3
        obj.account_sid = 4
        field = fields.FormattedString("/foo/{account_sid}/{sid}/")
        self.assertEquals(field.output("foo", obj), "/foo/4/3/")

    def test_basic_field(self):
        obj = Mock()
        obj.foo = 3
        field = fields.Raw()
        self.assertEquals(field.output("foo", obj), 3)

    def test_raw_field(self):
        obj = Mock()
        obj.foo = 3
        field = fields.Raw()
        self.assertEquals(field.output("foo", obj), 3)

    def test_nested_raw_field(self):
        foo = Mock()
        bar = Mock()
        bar.value = 3
        foo.bar = bar
        field = fields.Raw()
        self.assertEquals(field.output("bar.value", foo), 3)

    def test_formatted_string_invalid_obj(self):
        field = fields.FormattedString("{hey}")
        self.assertRaises(MarshallingException, lambda: field.output("hey", None))

    def test_formatted_string(self):
        field = fields.FormattedString("{hey}")
        self.assertEquals("3", field.output("hey", Foo()))

    def test_string_with_attribute(self):
        field = fields.String(attribute="hey")
        self.assertEquals("3", field.output("foo", Foo()))

    def test_string_with_lambda(self):
        field = fields.String(attribute=lambda x: x.hey)
        self.assertEquals("3", field.output("foo", Foo()))

    def test_string_with_partial(self):

        def f(x, suffix):
            return "%s-%s" % (x.hey, suffix)

        p = partial(f, suffix="whatever")
        field = fields.String(attribute=p)
        self.assertEquals("3-whatever", field.output("foo", Foo()))

    def test_url_invalid_object(self):
        field = fields.Url("foobar")

        with self.app.test_request_context("/"):
            self.assertRaises(MarshallingException, lambda: field.output("hey", None))

    def test_url(self):
        field = fields.Url("foobar")

        with self.app.test_request_context("/"):
            self.assertEquals("/3", field.output("hey", Foo()))

    def test_url_absolute(self):
        field = fields.Url("foobar", absolute=True)

        with self.app.test_request_context("/"):
            self.assertEquals("http://localhost/3", field.output("hey", Foo()))

    def test_url_absolute_scheme(self):
        """Url.scheme should override current_request.scheme"""
        field = fields.Url("foobar", absolute=True, scheme='https')

        with self.app.test_request_context("/", base_url="http://localhost"):
            self.assertEquals("https://localhost/3", field.output("hey", Foo()))

    def test_url_without_endpoint_invalid_object(self):
        field = fields.Url()

        with self.app.test_request_context("/hey"):
            self.assertRaises(MarshallingException, lambda: field.output("hey", None))

    def test_url_without_endpoint(self):
        field = fields.Url()

        with self.app.test_request_context("/hey"):
            self.assertEquals("/3", field.output("hey", Foo()))

    def test_url_without_endpoint_absolute(self):
        field = fields.Url(absolute=True)

        with self.app.test_request_context("/hey"):
            self.assertEquals("http://localhost/3", field.output("hey", Foo()))

    def test_url_without_endpoint_absolute_scheme(self):
        field = fields.Url(absolute=True, scheme='https')

        with self.app.test_request_context("/hey", base_url="http://localhost"):
            self.assertEquals("https://localhost/3", field.output("hey", Foo()))

    def test_url_with_blueprint_invalid_object(self):
        field = fields.Url()

        with self.app.test_request_context("/foo/hey"):
            self.assertRaises(MarshallingException, lambda: field.output("hey", None))

    def test_url_with_blueprint(self):
        field = fields.Url()

        with self.app.test_request_context("/foo/hey"):
            self.assertEquals("/foo/3", field.output("hey", Foo()))

    def test_url_with_blueprint_absolute(self):
        field = fields.Url(absolute=True)

        with self.app.test_request_context("/foo/hey"):
            self.assertEquals("http://localhost/foo/3", field.output("hey", Foo()))

    def test_url_with_blueprint_absolute_scheme(self):
        field = fields.Url(absolute=True, scheme='https')

        with self.app.test_request_context("/foo/hey", base_url="http://localhost"):
            self.assertEquals("https://localhost/foo/3", field.output("hey", Foo()))

    def test_url_superclass_kwargs(self):
        field = fields.Url(absolute=True, attribute='hey')

        with self.app.test_request_context("/hey"):
            self.assertEquals("http://localhost/3", field.output("hey", Foo()))

    def test_int(self):
        field = fields.Integer()
        self.assertEquals(3, field.output("hey", {'hey': 3}))

    def test_int_default(self):
        field = fields.Integer(default=1)
        self.assertEquals(1, field.output("hey", {'hey': None}))

    def test_no_int(self):
        field = fields.Integer()
        self.assertEquals(0, field.output("hey", {'hey': None}))

    def test_int_decode_error(self):
        field = fields.Integer()
        self.assertRaises(MarshallingException, lambda: field.output("hey", {'hey': 'Explode please I am nowhere looking like an int'}))

    def test_float(self):
        field = fields.Float()
        self.assertEquals(3.0, field.output("hey", {'hey': 3.0}))

    def test_float_decode_error(self):
        field = fields.Float()
        self.assertRaises(MarshallingException, lambda: field.output("hey", {'hey': 'Explode!'}))

    PI_STR = u'3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612847564823378678316527120190914564856692346034861'
    PI = Decimal(PI_STR)

    def test_arbitrary(self):
        field = fields.Arbitrary()
        self.assertEquals(self.PI_STR, field.output("hey", {'hey': self.PI}))

    def test_fixed(self):
        field5 = fields.Fixed(5)
        field4 = fields.Fixed(4)

        self.assertEquals('3.14159', field5.output("hey", {'hey': self.PI}))
        self.assertEquals('3.1416', field4.output("hey", {'hey': self.PI}))
        self.assertEquals('3.0000', field4.output("hey", {'hey': '3'}))
        self.assertEquals('3.0000', field4.output("hey", {'hey': '03'}))
        self.assertEquals('3.0000', field4.output("hey", {'hey': '03.0'}))

    def test_zero_fixed(self):
        field = fields.Fixed()
        self.assertEquals('0.00000', field.output('hey', {'hey': 0}))

    def test_infinite_fixed(self):
        field = fields.Fixed()
        self.assertRaises(MarshallingException, lambda: field.output("hey", {'hey': '+inf'}))
        self.assertRaises(MarshallingException, lambda: field.output("hey", {'hey': '-inf'}))

    def test_advanced_fixed(self):
        field = fields.Fixed()
        self.assertRaises(MarshallingException, lambda: field.output("hey", {'hey': 'NaN'}))

    def test_fixed_with_attribute(self):
        field = fields.Fixed(4, attribute="bar")
        self.assertEquals('3.0000', field.output("foo", {'bar': '3'}))

    def test_string(self):
        field = fields.String()
        self.assertEquals("3", field.output("hey", Foo()))

    def test_string_no_value(self):
        field = fields.String()
        self.assertEquals(None, field.output("bar", Foo()))

    def test_string_none(self):
        field = fields.String()
        self.assertEquals(None, field.output("empty", {'empty': None}))

    def test_rfc822_date_field_without_offset(self):
        obj = {"bar": datetime(2011, 8, 22, 20, 58, 45)}
        field = fields.DateTime()
        self.assertEquals("Mon, 22 Aug 2011 20:58:45 -0000", field.output("bar", obj))

    def test_rfc822_date_field_with_offset(self):
        obj = {"bar": datetime(2011, 8, 22, 20, 58, 45, tzinfo=pytz.timezone('CET'))}
        field = fields.DateTime()
        self.assertEquals("Mon, 22 Aug 2011 19:58:45 -0000", field.output("bar", obj))

    def test_iso8601_date_field_without_offset(self):
        obj = {"bar": datetime(2011, 8, 22, 20, 58, 45)}
        field = fields.DateTime(dt_format='iso8601')
        self.assertEquals("2011-08-22T20:58:45", field.output("bar", obj))

    def test_iso8601_date_field_with_offset(self):
        obj = {"bar": datetime(2011, 8, 22, 20, 58, 45, tzinfo=pytz.timezone('CET'))}
        field = fields.DateTime(dt_format='iso8601')
        self.assertEquals("2011-08-22T20:58:45+01:00", field.output("bar", obj))

    def test_unsupported_datetime_format(self):
        obj = {"bar": datetime(2011, 8, 22, 20, 58, 45)}
        field = fields.DateTime(dt_format='raw')
        self.assertRaises(MarshallingException, lambda: field.output('bar', obj))

    def test_to_dict(self):
        obj = {"hey": 3}
        self.assertEquals(obj, fields.to_marshallable_type(obj))

    def test_to_dict_obj(self):
        obj = {"hey": 3}
        self.assertEquals(obj, fields.to_marshallable_type(Foo()))

    def test_to_dict_custom_marshal(self):
        obj = {"hey": 3}
        self.assertEquals(obj, fields.to_marshallable_type(Bar()))

    def test_get_value(self):
        self.assertEquals(3, fields.get_value("hey", {"hey": 3}))

    def test_get_value_no_value(self):
        self.assertEquals(None, fields.get_value("foo", {"hey": 3}))

    def test_get_value_obj(self):
        self.assertEquals(3, fields.get_value("hey", Foo()))

    def test_list(self):
        obj = {'list': ['a', 'b', 'c']}
        field = fields.List(fields.String)
        self.assertEquals(['a', 'b', 'c'], field.output('list', obj))

    def test_list_from_set(self):
        obj = {'list': set(['a', 'b', 'c'])}
        field = fields.List(fields.String)
        self.assertEquals(set(['a', 'b', 'c']), set(field.output('list', obj)))

    def test_list_from_object(self):
        class TestObject(object):
            def __init__(self, list):
                self.list = list
        obj = TestObject(['a', 'b', 'c'])
        field = fields.List(fields.String)
        self.assertEquals(['a', 'b', 'c'], field.output('list', obj))

    def test_list_with_attribute(self):
        class TestObject(object):
            def __init__(self, list):
                self.foo = list
        obj = TestObject(['a', 'b', 'c'])
        field = fields.List(fields.String, attribute='foo')
        self.assertEquals(['a', 'b', 'c'], field.output('list', obj))

    def test_list_with_scoped_attribute_on_dict_or_obj(self):
        class TestObject(object):
            def __init__(self, list_):
                self.bar = list_

        class TestEgg(object):
            def __init__(self, val):
                self.attrib = val

        eggs = [TestEgg(i) for i in ['a', 'b', 'c']]
        test_obj = TestObject(eggs)
        test_dict = {'bar': [{'attrib': 'a'}, {'attrib':'b'}, {'attrib':'c'}]}

        field = fields.List(fields.String(attribute='attrib'), attribute='bar')
        self.assertEquals(['a', 'b', 'c'], field.output('bar', test_obj))
        self.assertEquals(['a', 'b', 'c'], field.output('bar', test_dict))

    def test_null_list(self):
        class TestObject(object):
            def __init__(self, list):
                self.list = list
        obj = TestObject(None)
        field = fields.List(fields.String)
        self.assertEquals(None, field.output('list', obj))

    def test_indexable_object(self):
        class TestObject(object):
            def __init__(self, foo):
                self.foo = foo

            def __getitem__(self, n):
                if type(n) is int:
                    if n < 3:
                        return n
                    raise IndexError
                raise TypeError

        obj = TestObject("hi")
        field = fields.String(attribute="foo")
        self.assertEquals("hi", field.output("foo", obj))

    def test_list_from_dict_with_attribute(self):
        obj = {'list': [{'a': 1, 'b': 1}, {'a': 2, 'b': 1}, {'a': 3, 'b': 1}]}
        field = fields.List(fields.Integer(attribute='a'))
        self.assertEquals([1, 2, 3], field.output('list', obj))

    def test_list_of_nested(self):
        obj = {'list': [{'a': 1, 'b': 1}, {'a': 2, 'b': 1}, {'a': 3, 'b': 1}]}
        field = fields.List(fields.Nested({'a': fields.Integer}))
        self.assertEquals([OrderedDict([('a', 1)]), OrderedDict([('a', 2)]), OrderedDict([('a', 3)])],
                          field.output('list', obj))

    def test_nested_with_default(self):
        obj = None
        field = fields.Nested({'a': fields.Integer, 'b': fields.String}, default={})
        self.assertEquals({}, field.output('a', obj))

    def test_list_of_raw(self):
        obj = {'list': [{'a': 1, 'b': 1}, {'a': 2, 'b': 1}, {'a': 3, 'b': 1}]}
        field = fields.List(fields.Raw)
        self.assertEquals([OrderedDict([('a', 1), ('b', 1), ]),
                           OrderedDict([('a', 2), ('b', 1), ]),
                           OrderedDict([('a', 3), ('b', 1), ])],
                          field.output('list', obj))

        obj = {'list': [1, 2, 'a']}
        field = fields.List(fields.Raw)
        self.assertEquals([1, 2, 'a'], field.output('list', obj))
Пример #50
0
from database.base import db_session, Base, engine
from flask import Flask
from flask_graphql import GraphQLView
from schema import schema
from schema_triangle import SerializeTriangle
from flask_cors import CORS

Base.metadata.create_all(engine)
app = Flask(__name__)
CORS(app)

app.add_url_rule('/graphql',
                 view_func=GraphQLView.as_view(
                     'graphql',
                     schema=schema,
                     graphiql=True,
                     middleware=[SerializeTriangle()]))


@app.teardown_appcontext
def shutdown_session(exception=None):
    db_session.remove()


if __name__ == '__main__':
    app.run(threaded=True, debug=True)
Пример #51
0
        tmp = ''.join(random.choice(src_str) for _ in xrange(24))
        f.write('\n#Auto-generated secret key\nSECRET_KEY = """' + tmp +
                '"""\n')
        app.config["SECRET_KEY"] = tmp
#Make a dictionary of queues of stuff that remotes need to do
queues = dict()
#Make a dictionary of clients
live_clients = dict()
#Global variable to hold the current client
app.config['current_client'] = None

#Make a new static endpoint so that the path gets set goodly
app.static_url_path = app.config.get("URL_PREFIX", "") + '/static'
app.static_folder = 'static'
app.add_url_rule(app.static_url_path + '/<path:filename>',
                 endpoint='static',
                 view_func=app.send_static_file)

#Make the database handler
db = SQLAlchemy(app)
db.create_all()

#Make a dictionary to hold handlers for glacier
handlers = dict()
for region in glacier.regions():
    handlers[region.name] = None

#Has the current config been validated?
validated_glacier = False
validated_db = False
Пример #52
0
from flask import Flask, request, url_for, abort, jsonify

from router import app_routes

# INITIALIZATION
app = Flask(__name__)
app.config.from_object(__name__)

# CONFIGURATION
# Load default configuration and override config from an environment variable
app.config.update(
    dict(DATABASE=os.path.join(app.root_path, 'nft.db'),
         DEBUG=True,
         SECRET_KEY='development_key'))
app.config.from_envvar('FLASK_SETTINGS', silent=True)
app.config.from_pyfile('config.cfg', silent=True)

# ROUTES
for route in app_routes:
    options_and_url = re.split(',\s|\s', route[0])
    route[2].methods = options_and_url[0:-1]
    app.add_url_rule(options_and_url[-1],
                     route[1],
                     route[2],
                     methods=options_and_url[0:-1])

# MAIN
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8000)
Пример #53
0
from flask import Flask
from . import db

db.does_table_exists()

app = Flask(__name__)

from . import views
app.register_blueprint(views.bp)
app.add_url_rule('/create/note', endpoint='create')
app.add_url_rule('/notes', endpoint='get_notes')
app.add_url_rule('/notes/<int:id>', endpoint='get_a_note')
app.add_url_rule('/update/note/<int:id>', endpoint='update')
app.add_url_rule('/delete/note/<int:id>', endpoint='delete')
Пример #54
0
import sys
from flask import Flask
import function_method
from flask_cors import *

app = Flask(__name__,
            static_folder='static',
            template_folder="templates")
CORS(app, supports_credentials=True)
app.add_url_rule('/', view_func=function_method.index, methods=["GET"])  # 跳转首页
app.add_url_rule('/api/get_board_count', view_func=function_method.get_board_count, methods=["GET"])  # 获取板卡数量
app.add_url_rule('/api/get_board_status', view_func=function_method.get_board_status, methods=["GET"])  # 获取板卡状态
app.add_url_rule('/api/start_data_receiving', view_func=function_method.start_data_receiving, methods=["GET"])  # 开启接收数据
app.add_url_rule('/api/stop_data_receiving', view_func=function_method.stop_data_receiving, methods=["GET"])  # 停止接收数据
app.add_url_rule('/api/close_Unload_library', view_func=function_method.close_Unload_library, methods=["GET"])  # 释放资源

if __name__ == '__main__':
    host = "0.0.0.0"
    port = 5000

    if sys.argv[1:]:  # 192.168.4.100:8000
        try:
            host, port = sys.argv[1:][0].split(":")
            try:
                functionname, pattern = sys.argv[1:][1].split("=")
                try:
                    import ast

                    pattern = ast.literal_eval(pattern)
                except Exception as e:
                    print('debug参数格式有误错误信息为{},\n'
Пример #55
0
        input_pdb_string = server_job_manager.status.submitted().pdb_string
        rq_job = Job.create(
            create_metrics_from_pdb,
            [input_pdb_string],
            connection=REDIS_CONNECTION,
        )
        rq_job_handle = JOB_QUEUE.enqueue_job(rq_job)
        server_job_manager.rq_job_handle = rq_job_handle
        return message_dict["tag"], server_job_manager
    else:
        raise ValueError(f'Unexpected job type: {message_dict["tag"]}')


app.add_url_rule(
    "/graphql",
    view_func=GraphQLView.as_view(
        "graphql",
        schema=schema,
        graphiql=True  # for having the GraphiQL interface
    ),
)


@app.teardown_appcontext
def shutdown_session(exception=None):
    big_structure_db_session.remove()
    designs_db_session.remove()


__version__ = "0.1.0"
Пример #56
0
jwt = JWTManager(app)
LOGGER.info("Initialzed JSON web token")


from fkart.controllers import export_api_list, PKG_DIR

#for c_name in export_api_list:
#    print(c_name.__name__)

# Initialzing apis from controllers
for api in export_api_list:
    # in-case export list contains direct urls
    # if hasattr(api, "url"):
        # api_url = getattr(api, "url")
    #else:
    api_url = api.__name__.lower().split("api")[0]
    api_name = api.__name__.lower()
    api_url_temp = ""
    for i in api_url.split('_'):
        api_url_temp += i
    api_url = api_url_temp
    del(api_url_temp)
    #print("API URL:"+api_url)
    #print('API NAME:'+api_name)
    # for removing '/' from beginning if present
    # if api_url[0] == "/":
        # api_url = api_url[1:]
    view = api.as_view("%s" % api_name)
    app.add_url_rule("/"+(api_url), view_func=view)
LOGGER.info("Added APIs to be used")
Пример #57
0
# flask.app.Flask.add_url_rule
from flask import Flask

app = Flask(__name__)


def index():
    return 'Hi'


# 데코레이터 없이 함수를 선언

app.add_url_rule('/index', view_func=index, methods=['GET'])
# add_url_rule이라는 메서드로 리소스를 추가한다.
# rule, endpoint, view function 순서로 넣어주어야 하지만 지정해서 넣어줄 수도 있음. 메소드도 설정 가능

app.run(debug=True)
Пример #58
0
class CogCompTimeDemoService:
    def __init__(self):
        self.app = Flask(__name__)
        CORS(self.app)
        self.backend = CogCompTimeBackend()

    @staticmethod
    def handle_root(path):
        if path == "" or path is None:
            path = "index.html"
        return send_from_directory('./frontend', path)

    @staticmethod
    def handle_index():
        return send_from_directory('./frontend', 'index.html')

    def tokenized_to_origin_span(self, text, token_list):
        text = text.replace("\n", "")
        token_span = []
        pointer = 0
        for token in token_list:
            while True:
                if token[0] == text[pointer]:
                    start = pointer
                    end = start + len(token) - 1
                    pointer = end + 1
                    break
                else:
                    pointer += 1
            token_span.append([start, end])
        return token_span

    def handle_request(self):
        args = request.get_json()
        text = args['text']
        order = self.backend.build_graph(text)
        return {
            "result": order,
        }

    def handle_uiuc_request(self):
        form = json.loads(request.data)
        stories = form['oneie']['en']['json']
        story_jsons = {}
        for s in stories:
            if len(stories[s]) == 0:
                continue
            if s not in story_jsons:
                story_jsons[s] = []
            ls = [x.strip() for x in stories[s].split("\n")]
            for lls in ls:
                try:
                    obj = json.loads(lls)
                    story_jsons[s].append(obj)
                except:
                    continue
        event_lines = [
            x.strip() for x in form['coref']['event.cs'].split("\n")
        ]
        temporal_content = process_kairos(story_jsons, event_lines)
        form['temporal_relation']['en'][
            'temporal_relation.cs'] = temporal_content
        return form

    def handle_json_request(self):
        args = request.get_json()
        tokens = args["tokens"]
        sent_ends = args["sentences"]["sentenceEndPositions"]
        sentences = []
        sentence = []
        for i, token in enumerate(tokens):
            sentence.append(token)
            if i + 1 in sent_ends:
                sentences.append(sentence)
                sentence = []
        views = args["views"]
        event_view = None
        event_view_id = None
        for i, view in enumerate(views):
            if view["viewName"] == "Event_extraction":
                event_view = view
                event_view_id = i
                break
        if event_view is None:
            return args
        event_triggers = []
        con_id_to_json_id = {}
        for i, constituent in enumerate(
                event_view["viewData"][0]['constituents']):
            start = constituent["start"]
            if "properties" in constituent:
                key = (constituent['properties']['sentence_id'], start)
                if key[0] > 0:
                    key = (key[0], start - sent_ends[key[0] - 1])
                event_triggers.append(key)
                if key not in con_id_to_json_id:
                    con_id_to_json_id[key] = []
                con_id_to_json_id[key].append(i)
        event_triggers = list(set(event_triggers))
        formatted_events = []
        for event in event_triggers:
            formatted_events.append(event)
        single_verb_map, relation_map = self.backend.build_graph_with_events(
            sentences, formatted_events, dct="2020-10-01")
        for back_id in single_verb_map:
            trigger_key = formatted_events[back_id]
            update_ids = con_id_to_json_id[trigger_key]
            for uid in update_ids:
                args["views"][event_view_id]["viewData"][0]["constituents"][
                    uid]["properties"]["duration"] = int(
                        single_verb_map[back_id][1])
        for back_id_pair in relation_map:
            source = back_id_pair[0]
            dest = back_id_pair[1]
            for s_uid in con_id_to_json_id[formatted_events[source]]:
                for d_uid in con_id_to_json_id[formatted_events[dest]]:
                    args["views"][event_view_id]["viewData"][0][
                        "relations"].append({
                            "relationName":
                            relation_map[back_id_pair][0],
                            "srcConstituent":
                            s_uid,
                            "targetConstituent":
                            d_uid,
                            "properties": {
                                "distance": int(relation_map[back_id_pair][1])
                            }
                        })

        return args

    def handle_json_request_no_gurobi(self):
        args = request.get_json()
        tokens = args["tokens"]
        sent_ends = args["sentences"]["sentenceEndPositions"]
        sentences = []
        sentence = []
        for i, token in enumerate(tokens):
            sentence.append(token)
            if i + 1 in sent_ends:
                sentences.append(sentence)
                sentence = []
        views = args["views"]
        event_view = None
        event_view_id = None
        for i, view in enumerate(views):
            if view["viewName"] == "Event_extraction":
                event_view = view
                event_view_id = i
                break
        if event_view is None:
            return args
        event_triggers = []
        con_id_to_json_id = {}
        for i, constituent in enumerate(
                event_view["viewData"][0]['constituents']):
            start = constituent["start"]
            if "properties" in constituent:
                key = (constituent['properties']['sentence_id'], start)
                if key[0] > 0:
                    key = (key[0], start - sent_ends[key[0] - 1])
                event_triggers.append(key)
                if key not in con_id_to_json_id:
                    con_id_to_json_id[key] = []
                con_id_to_json_id[key].append(i)
        event_triggers = list(set(event_triggers))
        formatted_events = []
        for event in event_triggers:
            formatted_events.append(event)
        single_verb_map, relation_map = self.backend.build_graph_with_events_no_gurobi(
            sentences, formatted_events, dct="2020-10-01")
        for back_id in single_verb_map:
            trigger_key = formatted_events[back_id]
            update_ids = con_id_to_json_id[trigger_key]
            for uid in update_ids:
                args["views"][event_view_id]["viewData"][0]["constituents"][
                    uid]["properties"]["duration"] = int(
                        single_verb_map[back_id][1])
                args["views"][event_view_id]["viewData"][0]["constituents"][
                    uid]["properties"][
                        "duration_minute_prob"] = single_verb_map[back_id][2]
                args["views"][event_view_id]["viewData"][0]["constituents"][
                    uid]["properties"]["duration_hour_prob"] = single_verb_map[
                        back_id][3]
                args["views"][event_view_id]["viewData"][0]["constituents"][
                    uid]["properties"]["duration_day_prob"] = single_verb_map[
                        back_id][4]
                args["views"][event_view_id]["viewData"][0]["constituents"][
                    uid]["properties"]["duration_week_prob"] = single_verb_map[
                        back_id][5]
                args["views"][event_view_id]["viewData"][0]["constituents"][
                    uid]["properties"][
                        "duration_month_prob"] = single_verb_map[back_id][6]
                args["views"][event_view_id]["viewData"][0]["constituents"][
                    uid]["properties"]["duration_year_prob"] = single_verb_map[
                        back_id][7]
                args["views"][event_view_id]["viewData"][0]["constituents"][
                    uid]["properties"][
                        "duration_decade_prob"] = single_verb_map[back_id][8]

        for back_id_pair in relation_map:
            source = back_id_pair[0]
            dest = back_id_pair[1]
            for s_uid in con_id_to_json_id[formatted_events[source]]:
                for d_uid in con_id_to_json_id[formatted_events[dest]]:
                    args["views"][event_view_id]["viewData"][0][
                        "relations"].append({
                            "relationName":
                            relation_map[back_id_pair][0],
                            "srcConstituent":
                            s_uid,
                            "targetConstituent":
                            d_uid,
                            "properties": {
                                "distance": int(relation_map[back_id_pair][1])
                            }
                        })

        return args

    def start(self, localhost=False, port=80, ssl=False):
        self.app.add_url_rule("/", "", self.handle_index)
        self.app.add_url_rule("/<path:path>", "<path:path>", self.handle_root)
        self.app.add_url_rule("/request",
                              "request",
                              self.handle_request,
                              methods=['POST', 'GET'])
        self.app.add_url_rule("/request_temporal_json",
                              "request_temporal_json",
                              self.handle_json_request,
                              methods=['POST', 'GET'])
        self.app.add_url_rule("/annotate",
                              "annotate",
                              self.handle_json_request,
                              methods=['POST', 'GET'])
        self.app.add_url_rule("/annotate_no_gurobi",
                              "annotate_no_gurobi",
                              self.handle_json_request_no_gurobi,
                              methods=['POST', 'GET'])
        self.app.add_url_rule("/request_uiuc_temporal",
                              "request_uiuc_temporal",
                              self.handle_uiuc_request,
                              methods=['POST', 'GET'])
        if ssl:
            if localhost:
                if port == 0:
                    self.app.run(ssl_context='adhoc')
                else:
                    self.app.run(ssl_context='adhoc', port=port)
            else:
                self.app.run(host='0.0.0.0', port=port, ssl_context='adhoc')
        else:
            if localhost:
                if port == 0:
                    self.app.run()
                else:
                    self.app.run(port=port)
            else:
                self.app.run(host='0.0.0.0', port=port)
Пример #59
0
    return str(params)


# 方法视图
class GetView(MethodView):

    @filter_params(get=get_field)
    def get(self, params=None):
        return str(params)

    @filter_params(post=post_field, response='html')
    def post(self, params=None):
        return str(params)


# 标准视图demo
class BaseView(View):

    @filter_params(get=get_field, post=post_field, response='html')
    def dispatch_request(self, params=None):
        return str(params)


app.add_url_rule('/getview', view_func=GetView.as_view('getview'))
app.add_url_rule('/baseview', view_func=BaseView.as_view('baseview'))


if __name__ == "__main__":
    app.run()

Пример #60
0
load_dotenv(dotenv_path, verbose=True)

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = str(engine.url)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
alchemy_app = SQLAlchemy(app)

CORS(app)

app.config['BASIC_AUTH_USERNAME'] = os.environ['BASIC_AUTH_USER_NAME']
app.config['BASIC_AUTH_PASSWORD'] = os.environ['BASIC_AUTH_PASSWORD']
basic_auth = BasicAuth(app)

if os.environ["ENV"] != 'production':
    app.debug = True
    app.add_url_rule('/api', view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=True,
                                                           context={'session': db_session}))
else:
    app.debug = False
    app.add_url_rule('/api', view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=False,
                                                           context={'session': db_session}))

    app.add_url_rule('/sandbox', view_func=GraphQLView.as_view('sandbox', schema=schema, graphiql=True,
                                                               context={'session': db_session}))


class RegexConverter(BaseConverter):
    def __init__(self, url_map, *items):
        super(RegexConverter, self).__init__(url_map)
        self.regex = items[0]