def create_app(self) -> None: app.config.from_object('project.configs.TestingConfig') FlaskInjector(app=app, modules=[self.configure_injector], injector=app.config.get('injector')) return app
def create_app(additional_modules=None): """Initializes the Flask app.""" app = Flask(__name__) app.config.from_object('app.config') app.secret_key = app.config.get("SECRET_KEY") from . import ui_blueprint app.register_blueprint(ui_blueprint.bp) @app.errorhandler(MissingCurrencyException) def handle_invalid_usage(error): response = jsonify(error.to_dict()) response.status_code = error.http_status() return response @app.route('/api/v1/country/<country_code>/currency') def api_v1_currencies_for_country(country_code, data_querier: DataQuerier): """API v1 method for returning the 3-char currency codes associated with a given 2 char territory code.""" return jsonify(data_querier.get_currencies(country_code)) @app.route('/api/v1/currency/<base_currency_code>/amount/<int:base_amount>' ) def api_v1_currency_amount( base_currency_code, base_amount, currency_exchanger_source: InMemoryCachedCurrencyExchangers): """API v1 method for converting between currencies.""" requested_display_currency_code = request.args.get( 'display_currency_code') exchanger = currency_exchanger_source.get_exchanger_for_currency( base_currency_code) display_currency_code = requested_display_currency_code if requested_display_currency_code else base_currency_code display_amount = exchanger.convert_amount_to( amount_in_base_currency=base_amount, target_currency_code=display_currency_code) valid_for = int(exchanger.remaining_validity_period_in_seconds()) resp = jsonify({ "valid_for": valid_for, "base_currency_code": base_currency_code, "display_currency_code": display_currency_code, "base_amount": base_amount, "display_amount": display_amount }) resp.cache_control.max_age = valid_for return resp @app.route('/api/v1/currency/<currency_code>/country') def api_v1_countries_for_currency(currency_code, data_querier: DataQuerier): """API v1 method for returning the 2-char territory codes that use a given currency (identified by a 3 char code).""" return jsonify(data_querier.get_countries(currency_code)) injector_modules = create_injector_modules(app.logger, app.config.get("COUNTRY_DATA")) if isinstance(additional_modules, list): injector_modules = injector_modules + additional_modules FlaskInjector(app=app, modules=injector_modules) return app
def test_injections(): l = [1, 2, 3] counter = [0] def inc(): counter[0] += 1 def conf(binder): binder.bind(str, to="something") binder.bind(list, to=l) app = Flask(__name__) @app.route('/view1') def view1(content: str): inc() return render_template_string(content) class View2(View): @inject def __init__(self, *args, content: list, **kwargs): self.content = content super().__init__(*args, **kwargs) def dispatch_request(self): inc() return render_template_string('%s' % self.content) @app.before_request def br(c: list): inc() eq_(c, l) @app.before_first_request def bfr(c: list): inc() eq_(c, l) @app.after_request def ar(response_class, c: list): inc() eq_(c, l) return response_class @app.context_processor def cp(c: list): inc() eq_(c, l) return {} @app.teardown_request def tr(sender, exc=None, c: list = None): inc() eq_(c, l) app.add_url_rule('/view2', view_func=View2.as_view('view2')) FlaskInjector(app=app, modules=[conf]) with app.test_client() as c: response = c.get('/view1') eq_(response.get_data(as_text=True), "something") with app.test_client() as c: response = c.get('/view2') eq_(response.get_data(as_text=True), '%s' % (l, )) eq_(counter[0], 11)
app.json_encoder = ApiJSONEncoder api = Api(app=app) for handler in API_HANDLERS: api.add_resource(handler, handler.ENDPOINT) def configure(binder): db = DB(**app.config['PONY']) db.model.generate_mapping(create_tables=True) binder.bind(DB, to=db, scope=singleton) for service in SERVICES: binder.bind(service, scope=singleton) flask_injector = FlaskInjector(app=app, modules=[configure]) def create_logger(): import time logger = logging.getLogger(__name__) logger.setLevel(logging.ERROR) fh = logging.FileHandler( os.path.join(project_dir, "logs", f"{time.strftime('%H_%M_%b_%d_%Y')}.log")) fmt = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' formatter = logging.Formatter(fmt) fh.setFormatter(formatter) logger.addHandler(fh) return logger
def _init_components(self): def static_module(binder): # config binder.bind(Configuration, self.conf, scope=singleton) # db if self.conf.exist('SQLALCHEMY_DATABASE_URI'): binder.bind(SQLAlchemy, to=self.db, scope=singleton) # manually registered components for obj in self.components: if issubclass(obj, Component): self._component_registry[obj] = '' scope = singleton if obj.scope == 'singleton' else request binder.bind(obj, obj, scope) def scan_module(binder): for package in self.conf.get('COMPONENT') or []: try: self._logger.debug('>>> Scan components in %s', package) namespaces = scan_namespaces(package) for namespace in namespaces: try: module = import_string(namespace) class_names = [ m[0] for m in inspect.getmembers( module, inspect.isclass) if m[1].__module__ == module.__name__ ] valid_module = False for class_name in class_names: obj = getattr(module, class_name) if issubclass(obj, Controller): continue if issubclass(obj, Component): if obj.abstract is True: continue self._component_registry[obj] = '' valid_module = True scope = singleton if obj.scope == 'singleton' else request binder.bind(obj, obj, scope) self._logger.debug( 'Register component: %s', class_name) if not valid_module: del module except Exception as e: self._logger.exception( '!!! Failed to initialize modules in %s', namespace, e) sys.exit() except Exception: self._logger.debug('!!! No modules founded in %s', package) self.injector = FlaskInjector(app=self.app, modules=[static_module, scan_module]) # POST INIT for component, _ in self._component_registry.items(): obj = self.get_component(component) if isinstance(obj, ApplicationStateListener): order = obj.order if order is None: self.listeners.append(obj) else: self.listeners.insert(order, obj) if isinstance(obj, Filter): order = obj.order if order is None: self.filters.append(obj) else: self.filters.insert(order, obj)
def main(): FlaskInjector(app=app, modules=[GlobalFlask]) app.run(debug=True)
def make_client(self): self.injector = Injector([configure_test]) FlaskInjector(app=app, injector=self.injector) return app.test_client()
def create_app(): app = Flask(__name__) app.config['JWT_SECRET_KEY'] = 'super-secret' app.config['SQLALCHEMY_DATABASE_URI'] = \ 'sqlite:///' + os.path.join(basedir, 'data.db') app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True CORS(app) configureDatabase(app) jwt.init_app(app) sqlite_db.init_app(app) Migrate(app, sqlite_db) app.register_blueprint(account_controller) app.register_blueprint(start_controller) CORS(account_controller, max_age=30 * 86400) CORS(start_controller, max_age=30 * 86400) api = Api(app) app.url_map.strict_slashes = False login_manager = LoginManager() login_manager.session_protection = 'strong' login_manager.login_view = 'account_controller.login' login_manager.init_app(app) module_app = AppModule(app) FlaskInjector(app=app, modules=[module_app]) api.add_resource(ForumResource, '/questions/forum/', resource_class_kwargs={'database': module_app.db}) api.add_resource(ExternToolResource, '/questions/externtool/', resource_class_kwargs={'database': module_app.db}) api.add_resource(FileResource, '/resources/file/', resource_class_kwargs={'database': module_app.db}) api.add_resource(URLResource, '/resources/url/', resource_class_kwargs={'database': module_app.db}) api.add_resource(PageResource, '/resources/page/', resource_class_kwargs={'database': module_app.db}) api.add_resource(QuizResource, '/questions/quiz/', resource_class_kwargs={'database': module_app.db}) api.add_resource(WikiResource, '/questions/wiki/', resource_class_kwargs={'database': module_app.db}) api.add_resource(GlossarioResource, '/questions/glossario/', resource_class_kwargs={'database': module_app.db}) api.add_resource(ConditionResource, '/network/condition/', resource_class_kwargs={'database': module_app.db}) api.add_resource(ChatResource, '/questions/chat/', resource_class_kwargs={'database': module_app.db}) api.add_resource(LessonResource, '/questions/lesson/', resource_class_kwargs={'database': module_app.db}) api.add_resource(DatabaseResource, '/questions/database/', resource_class_kwargs={'database': module_app.db}) api.add_resource(ChoiceResource, '/questions/choice/', resource_class_kwargs={'database': module_app.db}) @login_manager.user_loader def load_user(user_id): return Usuario.query.get(int(user_id)) @app.errorhandler(Exception) def all_exception_handler(error): return jsonify({"message": "Ocorreu um problema.", "status": 500}), 500 return app
import nisse.routes from nisse.utils.configs import load_config from nisse.utils.logging import init_logging from nisse.services import UserService, TokenService from __version__ import __version__ application = Flask(__name__, instance_relative_config=True) load_config(application) init_logging(application) FlaskJSON(application) api = Api(application) nisse.routes.configure_api(api) nisse.routes.configure_oauth(application) # IoC config flask_injector = FlaskInjector(app=application, modules=[nisse.services.configure_container]) # initial create db = flask_injector.injector.get(SQLAlchemy) migrate = Migrate(application, db) application.logger.info('Version: ' + __version__) # create report path os.makedirs(os.path.join(application.instance_path, application.config["REPORT_PATH"]), exist_ok=True)
def get(self): dao: Dao = TestDao(self.t) r = dao.find() list = [ob.json() for ob in r] return jsonify(list), 200 if __name__ == '__main__': app = Flask(__name__) app.debug = True @app.route("/test") def test(t: Transaction): dao: Dao = TestDao(t) r = dao.find() list = [ob.json() for ob in r] return jsonify(list), 200 app.add_url_rule('/TestView', view_func=TesteView.as_view('TesteView'), methods=['GET']) FlaskInjector(app=app, modules=[Neo4jModule, Neo4jTransactionModule]) app.run()
from flask import Flask import connexion from flask_injector import FlaskInjector from Flask_projects.Encrypt_project.password_encryption.service import configure from connexion.resolver import RestyResolver # app = connexion.FlaskApp(__name__, port=4000, host='192.168.1.7',specification_dir='swagger/') app = connexion.FlaskApp(__name__, port=4000, specification_dir='swagger/') app.add_api('user_password.yaml', resolver=RestyResolver("api")) flask_injector = FlaskInjector(app=app.app) # , modules=[configure]
"""User service""" from flask import Flask, Request, request from flask_injector import FlaskInjector from flask_restful import Api from controller import User, UserList from service import UserService API_VERSION = 'v1' APP = Flask(__name__) API = Api(APP) API.add_resource(UserList, f'/{API_VERSION}/users/') API.add_resource(User, f'/{API_VERSION}/users/<uid>') def configure(binder): """Configures the injector""" binder.bind(UserService, to=UserService(), scope=request) binder.bind(Request, to=request, scope=request) FlaskInjector(app=APP, modules=[configure]) if __name__ == '__main__': APP.run(host='0.0.0.0', debug=True)
import getopt import sys from flask_injector import FlaskInjector from app import app from app.bindings import configure_database, configure_modules from instance import instance from instance.injectors import InstanceInjector FlaskInjector(app=app, modules=[configure_database, configure_modules]) InstanceInjector(instance=instance, modules=[configure_database, configure_modules]) def main(argv): try: opts, args = getopt.getopt(argv, "cp", ["db-create", "db-populate"]) except getopt.GetoptError: print('run.py [-c] [--db-create]') print('run.py [-p] [--db-populate]') sys.exit() for opt, arg in opts: if opt in ("-c", "--db-create"): instance.db_create() if opt in ("-p", "--db-populate"): instance.db_populate() app.run()
from flask import Flask from flask_injector import FlaskInjector from injector import singleton from app.main.services.membership_service import MembershipService app = Flask(__name__) from app.main.controllers.membership_controller import blueprint app.register_blueprint(blueprint) def configure_dependencies(binder): binder.bind(MembershipService, to=MembershipService, scope=singleton) FlaskInjector(app=app, modules=[configure_dependencies]) @app.route('/') def hello_world(): return 'Hello World!'
#! /usr/bin/env python3 import logging from os import chdir from os.path import abspath, dirname from flask_injector import FlaskInjector from app import app from app.dep_inject import WatchTheDoorModule from app.face_detector import Detector abs_path = abspath(__file__) dir = dirname(abs_path) chdir(dir) logging.basicConfig(format='%(asctime)s %(message)s') logging.root.setLevel(logging.WARN) inj = FlaskInjector(app=app, modules=[WatchTheDoorModule]) det = inj.injector.get(Detector) det.launch_detect_job() app.run(host='0.0.0.0', threaded=True)
@app.route('/') def route_file(): return app.send_static_file('index.html') @app.route('/<path:filename>') def send_app_files(filename): return send_from_directory(app.static_folder + '/', filename) @app.teardown_appcontext def shutdown_session(exception=None): db_session.remove() def configure(binder): binder.bind(SQLAlchemy, to=db_session, scope=singleton) def install_books(): init_db() member = Member('admin', 'admin@localhost') db_session.add(member) db_session.commit() FlaskInjector(app=app, modules=[configure], use_annotations=True) install_books()
# -*- coding: utf-8 -*- __author__ = 'Vincent Tertre' import sys import logging from flask_injector import FlaskInjector from server import Server from your_application import YourApplication def create_log_handler(): from configuration import logging_configuration formatter = logging.Formatter(logging_configuration[u'pattern']) handler = logging.StreamHandler(sys.stdout) handler.setFormatter(formatter) handler.setLevel(logging_configuration[u'level']) return handler log_handler = create_log_handler() root_logger = logging.getLogger() del root_logger.handlers[:] root_logger.setLevel(log_handler.level) root_logger.addHandler(log_handler) application = YourApplication() server = Server(application) FlaskInjector(app=server.flask, injector=application.injector)
def register_extensions(app): db.init_app(app) Migrate(app, db) injector = Injector([PaymentManagerModule(app)]) FlaskInjector(app=app, injector=injector)
def create_app(**kwargs): app = Flask(__name__) app.register_blueprint(blueprint, url_prefix=API_V1_PREFIX) FlaskInjector(app=app, modules=[configure_binding]) return app
from flask_injector import FlaskInjector from src.app.app import app from src.dependencies import compose_local, compose_deployed import awsgi def lambda_handler(event, context): FlaskInjector(app=app, modules=[compose_deployed()]) return awsgi.response(app, event, context) if __name__ == '__main__': FlaskInjector(app=app, modules=[compose_local()]) app.run(port=8080, debug=True)
@app.route("/stats") @REQUEST_TIME.time() def stats(storage: ViewsStorageBackend): with tracer.start_span("storage-query"): counts: dict[str, int] = storage.most_common(10) AVERAGE_TOP_HITS.set(sum(counts.values()) / len(counts) if counts else 0) TOP_PAGE.info({"top": max(counts, default="n/a", key=lambda x: counts[x])}) return counts @app.route("/test") @REQUEST_TIME.time() def test(): return """ <html> <head></head> <body><img src="/track"></body> </html> """ FlaskInjector(app=app, modules=[di.RedisModule()]) app.wsgi_app = DispatcherMiddleware(app.wsgi_app, {"/metrics": make_wsgi_app()}) if __name__ == "__main__": app.run(host="0.0.0.0", port=8000)
def lambda_handler(event, context): FlaskInjector(app=app, modules=[compose_deployed()]) return awsgi.response(app, event, context)
# app.py from flask import Flask from flask_injector import FlaskInjector import providers from resources.root_resource import blp as root_resource from resources.users_resource import blp as users_resource app = Flask(__name__) app.register_blueprint(root_resource) app.register_blueprint(users_resource) FlaskInjector(app=app, modules=[providers.RepositoriesModule]) if __name__ == '__main__': app.run(debug=True, port=5000)
""" CLI command to generate model for each station to predict station's availabilities """ from datetime import datetime import connexion from flask_injector import FlaskInjector from application.process.manager.CreateStationAvailabilityAlgorithmsManager import \ CreateStationAvailabilityAlgorithmsManager from config.services import configure from config.settings import DEBUG_MODE if __name__ == '__main__': APP = connexion.App(__name__) APP.debug = DEBUG_MODE INJECTOR = FlaskInjector(app=APP.app, modules=[configure]) MANAGER = INJECTOR.injector.get(CreateStationAvailabilityAlgorithmsManager) MANAGER.manage(datetime.strptime('2018-11-20 20:00:00', '%Y-%m-%d %H:%M:%S'), '5T')
def app(): app = lyrics_mixer.rest_api.app injector = Injector(AppModule(app, LyricsMixerStub())) FlaskInjector(app=app, injector=injector) return app
# Override with instance specific configs try: app.config.from_pyfile('config.py') except IOError: app.logger.warning( 'Could not find instance/config.py, environment only suitable for development.' ) register_blueprints(app) override_handlers(app) return app app = create_app() # Register dependencies FlaskInjector(app=app, modules=[DatabaseModule(app)]) # Box CLI Setup user_cli = AppGroup('user') app.cli.add_command(user_cli) @user_cli.command('create') @click.argument('name') def create_user(name): """TODO: Call `flask user create <name>` to create a user""" pass
from services.ElasticProvider import ElasticProvider import connexion from connexion.resolver import RestyResolver import logging # Set up logger logging.basicConfig(level=logging.INFO) ''' Injector is used bind a instance of ElasticProvider We bind the injected ElasticProvider to this initialised ElasticPpovider which which holds the server url ''' def configure(binder: Binder) -> Binder: binder.bind( ElasticProvider, to=ElasticProvider(host = os.environ.get('ELASTICSEARCH_URL',"http://localhost:9200")) ) #Redefine application as a connexion app. application = connexion.App(__name__, specification_dir='swagger/') # Setip RestyResolver and the OpenAPI docs application.add_api('elastic-crud-openapi.yaml', resolver=RestyResolver('api'), arguments={'title': 'ElasticSearch OpenAPI'}) #FlaskInjector Setup defined after configure FlaskInjector(app=application.app, modules=[configure]) if __name__ == '__main__': #Start the flask server on either a predefined port from the host machine or 2025 application.run(debug=False, \ #server='tornado', port=int(os.environ.get('PORT', 2025)))
def create_app(): app = Flask(__name__) app.config.from_object(app_config[os.getenv("ENV", "local")]) FlaskInjector(app, modules=[configure]) return app
import connexion from flask_injector import FlaskInjector from services.spellcheck_dictionary import SpellCheckDictionary from conf.settings import settings # inject the dictionary def configure(binder): binder.bind(SpellCheckDictionary, SpellCheckDictionary().fromUrl(settings["dictionary-url"])) # load the swagger definition app = connexion.App(__name__, specification_dir='./swagger/') app.add_api('swagger.yml') application = app.app FlaskInjector(app=app.app, modules=[configure]) if __name__ == '__main__': app.run(host='0.0.0.0', debug=True)
def create_app(name=__name__, init_mode=False, destroy_mode=False, worker_mode=False, testing_mode=False, skip_endpoint_mapping=False, **kwargs): """ Create the server istance for Flask application """ if PRODUCTION and testing_mode: log.exit("Unable to execute tests in production") ############################# # Initialize reading of all files mem.customizer = Customizer(testing_mode, PRODUCTION, init_mode) # FIXME: try to remove mem. from everywhere... ############################# # Add template dir for output in HTML from utilities import helpers tp = helpers.script_abspath(__file__, 'templates') kwargs['template_folder'] = tp ################################################# # Flask app instance ################################################# microservice = Flask(name, **kwargs) ############################## # Add commands to 'flask' binary if init_mode: microservice.config['INIT_MODE'] = init_mode skip_endpoint_mapping = True elif destroy_mode: microservice.config['DESTROY_MODE'] = destroy_mode skip_endpoint_mapping = True elif testing_mode: microservice.config['TESTING'] = testing_mode init_mode = True # microservice.config['INIT_MODE'] = init_mode elif worker_mode: skip_endpoint_mapping = True ############################## # Fix proxy wsgi for production calls microservice.wsgi_app = ProxyFix(microservice.wsgi_app) ############################## # Cors from restapi.protocols.cors import cors cors.init_app(microservice) log.verbose("FLASKING! Injected CORS") ############################## # Enabling our internal Flask customized response microservice.response_class = InternalResponse ############################## # Flask configuration from config file microservice.config.from_object(config) log.debug("Flask app configured") # log.pp(microservice.__dict__) ############################## if PRODUCTION: log.info("Production server mode is ON") # FIXME: random secrety key in production # # Check and use a random file a secret key. # install_secret_key(microservice) # # To enable exceptions printing inside uWSGI # # http://stackoverflow.com/a/17839750/2114395 # from werkzeug.debug import DebuggedApplication # app.wsgi_app = DebuggedApplication(app.wsgi_app, True) ############################## # Find services and try to connect to the ones available extensions = detector.init_services(app=microservice, worker_mode=worker_mode, project_init=init_mode, project_clean=destroy_mode) if worker_mode: microservice.extensions = extensions ############################## # Restful plugin if not skip_endpoint_mapping: # Triggering automatic mapping of REST endpoints current_endpoints = create_endpoints(farmer.EndpointsFarmer(Api)) # Restful init of the app current_endpoints.rest_api.init_app(microservice) ############################## # Injection! # Enabling "configuration modules" for services to be injected # IMPORTANT: Injector must be initialized AFTER mapping endpoints modules = detector.load_injector_modules() # AVOID warnings from Flask Injector warnings.filterwarnings("ignore") FlaskInjector(app=microservice, modules=modules) # otherwise... # Catch warnings from Flask Injector # try: # FlaskInjector(app=microservice, modules=modules) # except RuntimeWarning: # pass ############################## # Clean app routes ignore_verbs = {"HEAD", "OPTIONS"} for rule in microservice.url_map.iter_rules(): rulename = str(rule) # Skip rules that are only exposing schemas if '/schemas/' in rulename: continue endpoint = microservice.view_functions[rule.endpoint] if not hasattr(endpoint, 'view_class'): continue newmethods = ignore_verbs.copy() for verb in rule.methods - ignore_verbs: method = verb.lower() if method in mem.customizer._original_paths[rulename]: # remove from flask mapping # to allow 405 response newmethods.add(verb) else: log.verbose("Removed method %s.%s from mapping" % (rulename, verb)) rule.methods = newmethods # FIXME: SOLVE CELERY INJECTION # # Set global objects for celery workers # if worker_mode: # mem.services = internal_services ############################## # Logging responses @microservice.after_request def log_response(response): ############################### # NOTE: if it is an upload, # I must NOT consume request.data or request.json, # otherwise the content gets lost do_not_log_types = [ 'application/octet-stream', 'multipart/form-data', ] if request.mimetype in do_not_log_types: data = 'STREAM_UPLOAD' else: try: data = handle_log_output(request.data) # Limit the parameters string size, sometimes it's too big for k in data: try: if not isinstance(data[k], str): continue if len(data[k]) > MAX_CHAR_LEN: data[k] = data[k][:MAX_CHAR_LEN] + "..." except IndexError: pass except Exception as e: data = 'OTHER_UPLOAD' log.info("%s %s %s %s", request.method, request.url, data, response) return response ############################## # and the flask App is ready now: log.info("Boot completed") # return our flask app return microservice