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