def create_app(config_file): # load config app.config.from_pyfile(config_file) from views.backgrounds import load_backgrounds load_backgrounds(app) # setup db from database import db db.init_app(app) # setup login login_manager.init_app(app) # login_manager.setup_app(app) from monkey.views import index_view, login_view for bp in [login_view, index_view]: app.register_blueprint(bp) # init all with app.app_context(): db.create_all() import api api.start_api([UserModel]) UserModel.initialize() return app
def create_app(): app = Flask(__name__) app.config['DEBUG'] = True app.config['SQLALCHEMY_DATABASE_URI'] = "sqlite:////Users/olivergoodman/Documents/github/app-blueprint/my_app/personal.db" db.init_app(app) app.register_blueprint(hello, url_prefix='') return app
def create_app(app): # config app app.config.from_object(os.environ["APP_SETTINGS"]) # initiate extensions db.init_app(app) ma.init_app(app) celery.init_app(app) jack_apns.init_app(app) # declare models import models # init app with app.app_context(): # db.reflect() # db.drop_all() db.create_all() app.register_blueprint(auth, url_prefix="/auth") app.register_blueprint(user, url_prefix="/user") app.register_blueprint(group, url_prefix="/group") app.register_blueprint(post, url_prefix="/post") app.register_blueprint(comment, url_prefix="/comment") app.register_blueprint(invite, url_prefix="/invite") app.register_blueprint(generic, url_prefix="/generic") app.register_blueprint(rule, url_prefix="/rule")
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) # use gzip compress response compress.init_app(app) # init database db.init_app(app) # init static resource # assets.init_app(app) # bundles = { # 'fullpage_css': Bundle( # 'css/base.css', # output='gen/base.css', # filters='cssmin'), # 'fullpage_js': Bundle( # 'js/base.js', # output='gen/base.js', # filters='jsmin'), # } # assets.register(bundles) from .api import api as api_blueprint app.register_blueprint(api_blueprint, url_prefix='/api') #solve the CORS problem(cross domain request) CORS(app, resources={r'/api/*': {"origins": "*"}}) return app
def create_app(config): app = Flask(__name__) app.config.from_object(config) # 載入 db model from db.common import * from db.user import * from db.store import * from db.discount import * db.init_app(app) # # 安裝 JSGlue # jsglue = JSGlue() # jsglue.init_app(app) # # Session Secret Key # app.secret_key = os.urandom(24).encode('hex') # print app.secret_key # # 擴充 url map # app.url_map.converters['regex'] = RegexConverter # # # 安裝 Session 強化擴充 # # sess = Session() # # sess.init_app(app) # # 載入 view # from app.web.client import client # from app.web.deposit import deposit # from app.web.donation import donation # # 註冊藍圖 # app.register_blueprint(client) # app.register_blueprint(deposit) # app.register_blueprint(donation) return app
def create_app(config): app = Flask(__name__) app.config.update(default_config) app.config.update(config) app.register_blueprint(api, url_prefix='/1.0') db.app = app db.init_app(app) @app.before_request def load_current_user(): g.user = (User.query.filter_by(email=session['email']).first() if 'email' in session else None) @app.route('/', methods=['GET']) def main(): """Default landing page.""" return render_template('index.html', authenticated=bool(g.user)) @app.route('/authenticate', methods=['POST']) def set_email(): """Verify via Persona. Upon success, create the user if it doesn't already exist and set the email for the user's session. """ data = browserid.verify(request.form['assertion'], '%s://%s' % ( app.config['PREFERRED_URL_SCHEME'], app.config['SERVER_NAME'])) email = data['email'] # Create user record. try: user = User.query.filter(User.email==email).one() except NoResultFound: user = User(email=email) db.session.add(user) db.session.commit() # Add self as contact. user.contacts.append(user) db.session.commit() session['email'] = user.email return jsonify({'message': 'okay'}) @app.route('/logout', methods=['GET', 'POST']) def logout(): """Log the user out.""" session.pop('email', None) return jsonify({'message': 'okay'}) @app.errorhandler(404) def page_not_found(error): return render_template('404.html') @app.errorhandler(500) def something_broke(error): return render_template('500.html') return app
def create_app(debug=False): def load_env(env_name, conf_name = None): """Load the specified key to config from env if exists""" if conf_name is None: conf_name = env_name app.config[conf_name] = os.environ.get(env_name, app.config.get(conf_name)) app = Flask(__name__) app.debug = debug app.config.from_object(os.environ.get('APP_CONFIG', 'config.DevelopmentConfig')) load_env('DATABASE_URL', 'SQLALCHEMY_DATABASE_URI') load_env('GCM_TOKEN') app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension') # Database creation db.init_app(app) with app.app_context(): db.create_all() # # Create the services # gcm = GCM(app.config['GCM_TOKEN']) authService = AuthenticationService(db) messageService = GCMMessengerService(db, gcm) locatorService = LocatorService(db, messageService) relayService = RelayService(db, messageService) # Easy method to get currentuser def current_user(): token = request.headers.get('Authorization') return authService.getUserFromAccessToken(token) # # Blueprints # authcheckBlueprint = authcheck_blueprint(authService, locatorService) locatorBlueprint = locator_blueprint(db, locatorService, current_user) relayBlueprint = relay_blueprint(db, relayService, current_user) refBlueprint = refactor_blueprint(db, authService, app, current_user) # Needs app for now as it has the apimanager... app.register_blueprint(locatorBlueprint) app.register_blueprint(relayBlueprint) app.register_blueprint(authcheckBlueprint) app.register_blueprint(refBlueprint) # Create admin interface admin.init_app(app, messageService, locatorService) # I'm a teapot. @app.route("/") def index(): abort(418) return app
def create_app(config_filename = 'cf'): app = Flask(__name__) app.config.from_object(__name__) app.config.from_pyfile('config.py', silent=False) db.init_app(app) # app.register_blueprint(bp) return app
def create_app(): '''Initialize Flask and SQLAlchemy contexts and register blueprints''' app = Flask(__name__) db.init_app(app) app.register_blueprint(root_app) app.register_blueprint(api_app) return app
def configure_database(app): """ Database configuration should be set here """ # uncomment for sqlalchemy support from database import db db.app = app db.init_app(app)
def create_app(): # set the project root directory as the static folder, you can set others. config_path = os.environ.get("APP_CONFIG_FILE", "config.py") print "loading config from ", config_path app.config.from_pyfile(config_path) with app.app_context(): db.init_app(app) create_model_tables() return app
def create_app(): app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/user_management.db' db.init_app(app) db.app = app from models import User, Group db.create_all() migrate.init_app(app,db) return app
def setUp(self): app.config.from_object('config.TestingConfig') self.client = app.test_client() db.init_app(app) with app.app_context(): db.create_all() user_datastore.create_user(email='test', password=encrypt_password('test')) db.session.commit()
def test_db(flask_app): uuid = str(uuid4()) flask_app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test-{}.db'.format(uuid) db.init_app(flask_app) with flask_app.app_context(): db.create_all() return db
def create_app(config=None): # init flask app app = Flask(__name__) app.config.from_pyfile('config.cfg', silent=True) if config is not None: app.config.from_pyfile(config, silent=True) db.init_app(app) app.register_blueprint(classes.bp, url_prefix = '/classes') return app
def configure_database(app): """ Database configuration should be set here """ from database import db db.app = app db.init_app(app) app.db = db return app
def create_app(): app = Flask(__name__) from database import db db.init_app(app) app.register_blueprint(HelloRouter.hello_router) app.register_blueprint(GoodByeRouter.goodbye_router) return app
def configure_database(app): """ Database configuration should be set here """ from database import db from flask_migrate import Migrate db.app = app db.init_app(app) Migrate(app, db)
def create_app(workdir): app = flask.Flask(__name__) db.init_app(app) oid.init_app(app) app.register_blueprint(frontend) configure_app(app, workdir) return app
def init_app(): app = Flask(__name__) app.config.from_pyfile('config.py') db.init_app(app) db.app = app app.debug = app.config['DEBUG'] init_logger(app) init_views(app) return app
def create_app(object_name, env="development"): """ An flask application factory, as explained here: http://flask.pocoo.org/docs/patterns/appfactories/ Arguments: object_name: the python path of the config object, e.g. appname.settings.ProdConfig env: The name of the current environment, e.g. prod or dev """ app = Flask(__name__) app.config.from_object(object_name) app.config['ENV'] = env #init the cache cache.init_app(app) #init SQLAlchemy db.init_app(app) # Initialize Flask-Babel babel = Babel(app) # Initialize Flask-Mail mail = Mail(app) # Initialize Flask-Migrate migrate = Migrate(app,db) @babel.localeselector def get_locale(): translations = [str(translation) for translation in babel.list_translations()] return request.accept_languages.best_match(translations) # Setup Flask-User db_adapter = SQLAlchemyAdapter(db, Users) # Select database adapter user_manager = UserManager(db_adapter, app, register_form = IceRegisterForm) # Init Flask-User and bind to app # register blueprints from controllers.main import main from controllers.customer import customer from controllers.email import email from controllers.schedule import schedule from controllers.kiosk import kiosk app.register_blueprint(main) app.register_blueprint(customer) app.register_blueprint(email) app.register_blueprint(schedule) app.register_blueprint(kiosk) return app
def create_app(config): app = Flask(__name__) app.config.from_object(config) db.init_app(app) csrf.init_app(app) crypt.init_app(app) login_manager.init_app(app) app.register_blueprint(user_blueprint) app.register_blueprint(list_blueprint,url_prefix='/lists') app.register_blueprint(item_blueprint,url_prefix='/items') return app
def init_app(config_file='config.py', is_register_api=True, is_register_view=True): app = Flask(__name__) app.config.from_pyfile(config_file) app.debug = app.config.get('DEBUG', True) db.app = app; db.init_app(app) if is_register_api: register_api(app) return app
def create_app(config): """ Given a configuration object, create a WSGI(Flask) app See `APP_CONFIG` in ../config.py for example configuration. """ app = Flask(__name__) app.config.update(config) register_blueprints(app) db.init_app(app) with app.app_context(): db.create_all() return app
def create_app(): app = Flask(__name__) # app.config['DEBUG'] = True # # app.config['SQLALCHEMY_DATABASE_URI'] = "sqlite:///" +__curdir__ + "/LP.db" app.config.from_pyfile('app.cfg') db.init_app(app) from ship import ship_bp app.register_blueprint(ship_bp) return app
def main(run_folders, users_file): db.init_app(app) logging.basicConfig(filename = 'NIPT_database_log', level=logging.DEBUG) db.create_all() NDBS = NiptDBSetup(db) NDBS.set_users(users_file) for folder in run_folders: BM = BatchMaker(db) BM.get_run_folder_info(folder) if BM.batch_id: BM.update_nipt_db(folder) else: logging.warning("Could not add to database from resultfile: %s" % path)
def main(flowcell_ids, users_file): db.init_app(app) logging.basicConfig(filename = 'NIPT_database_log', level=logging.DEBUG) db.create_all() NDBS = NiptDBSetup(db) NDBS.set_users(users_file) for flowcell_id in flowcell_ids: BM = BatchMaker(db) BM.parse_path(flowcell_id) BM.get_run_folder_info() if BM.batch_id: BM.update_nipt_db() else: logging.warning("Could not add to database from run: %s" % flowcell_id)
def configure_database(app): "Database configuration should be set here" # uncomment for sqlalchemy support from database import db db.app = app db.init_app(app) login_manager = LoginManager() login_manager.setup_app(app) @login_manager.user_loader def load_user(userid): user = User.query.get(userid) if user: return FLUserWrapper(user) else: return None pass
def create_app(config_override: Mapping = None) -> Flask: """Create the flask app for the debug server. Parameters: config_override: Dict containing custom configuration to apply after loading the normal config. Useful for testing. """ config_override = {} if config_override is None else config_override # TODO: Rename app, no longer used only for debugging app = Flask('stuffrdebugserver', instance_relative_config=True, static_url_path='', template_folder='static') app.config.from_object('config.default') app.config.from_envvar('STUFFR_SETTINGS') app.config.from_mapping(config_override) app.json_encoder = StuffrJSONEncoder logger.set_logger(app.logger) db.init_app(app) security = Security(app, user_store, confirm_register_form=StuffrRegisterForm) security.unauthorized_handler(api_unauthenticated_handler) Mail(app) # In debug mode Swagger documentation is served at root if not app.config['DEBUG']: def api_root_view(): """Provide a link to API documentation if root accessed.""" return error_response( 'TODO: Link to documentation here', HTTPStatus.NOT_FOUND) blueprint_api.add_url_rule('/', 'apiindex', api_root_view) app.register_blueprint(blueprint_simple, url_prefix='/simple') app.register_blueprint(blueprint_api, url_prefix='/api') def default404(e): """Default handler for 404.""" # TODO: Conditional JSON/HTML response (for simple mode) return error_response(e.description, HTTPStatus.NOT_FOUND) app.register_error_handler(HTTPStatus.NOT_FOUND, default404) # TODO: Make friendlier error message (40x or 50x?) app.add_url_rule('/', 'index', lambda: "You probably shouldn't be here") return app
def create_app(): app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db' app.config['SQLALCHEMY_ECHO'] = False app.config['DEBUG'] = True app.secret_key = 'DEVELOPMENT KEY CHANGE ME' # register all blueprints here #app.register_blueprint(examplemodule.bp) app.register_blueprint(core.bp) # start up sqlalchemny db.init_app(app) configure_login(app) configure_admin(app) return app
def register_extensions(app): db.init_app(app) login_manager.init_app(app)
api_instance.add_namespace(endpoint_api, path='/endpoint') api_instance.init_app(app) # Initialize the api TaskBase = celery.Task # Fiddle with celery because Flask needs to be able to work with celery, and without this bit celery doesn't have the correct app context. class ContextTask(TaskBase): abstract = True def __call__(self, *args, **kwargs): with app.app_context(): return TaskBase.__call__(self, *args, **kwargs) celery.Task = ContextTask # Set up database db.init_app(app) # Initialize the database with the app print("Resetting the database") db.drop_all( app=app) # Drop the table here, so we have a fresh start every time. db.create_all( app=app ) # If the database table doesn't already exist, then create it here. # Setup cache cache.init_app(app) if __name__ == '__main__': app.run(host='127.0.0.1', debug=True, port=80)
def create_app(): flask_app = Flask(__name__) configure_app(flask_app) with flask_app.app_context(): db.init_app(flask_app) return flask_app
from flask_sqlalchemy import SQLAlchemy from database import db from database.operations import save_to print ("loading data ...") app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///base.db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db.init_app(app) app.app_context().push() db.create_all() subunidades = get_subunidades() start = 0 for sub in subunidades[start:]: #s = Subunidade (sub) #save_to(s, db) docentes = get_docentes(sub["codigo"]) print (start, sub["codigo"]) start = start + 1
def register_database(app): """Register database.""" db.init_app(app)
from flask import Flask from routes.fileRoutes import fileApi from database import db import logging application = Flask(__name__) application.register_blueprint( fileApi, url_prefix="/file" ) ### Registers a blueprint. All /file requests will be routed to fileApi application.config[ 'SQLALCHEMY_DATABASE_URI'] = "sqlite:////tmp/fileStores.db" ## fileStore is SQLITE DB name application.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db.init_app(application) with application.app_context(): db.create_all() ##### Configure Logging ######## if __name__ != '__main__': gunicorn_logger = logging.getLogger('gunicorn.error') application.logger.handlers = gunicorn_logger.handlers application.logger.setLevel(gunicorn_logger.level) # Only for development server . will never executes when ran via gunicorn # if __name__ == "__main__": application.run()
def init_app(app): db.init_app(app) migrate.init_app(app, db) api.init_app(app)
import flask as f import flask_openid from database import db as d import database import bcrypt import re import steam.webapi import functools # noinspection PyUnresolvedReferences import configuration app = f.Flask(__name__) app.config.from_object("configuration.Config") d.init_app(app) steam_oid = flask_openid.OpenID(app) steam_api = steam.WebAPI(app.config["STEAM_API_KEY"]) @app.after_request def after_every_request(response): response.headers["Access-Control-Allow-Origin"] = "*" return response @app.route("/api/v1/user/register", methods=["POST"]) def api_v1_user_register(): f_data = f.request.form username = f_data.get("username") password = f_data.get("password") if username is None or password is None: return f.jsonify({
def main(): configure_app(app) db.init_app(app) app.register_blueprint(blueprint, url_prefix='/api') app.run(debug=config.FLASK_DEBUG)
def init_db(): db.init_app(app) dbPictures.init_app(app) db.app = app dbPictures.app = app
def init_app(app): db.init_app(app) flask_migrate.Migrate(app, db, directory='database/migrations')
def create_app(config_name='production'): """Create the app instance via Factory Method""" app = Flask(__name__) # Set the app config app.config.from_object(config[config_name]) app.config["SECURITY_I18N_DIRNAME"] = [ pkg_resources.resource_filename("flask_security", "translations"), "translations" ] app.secret_key = app.config['SECRET_KEY'] # setup autoreload jinja cache app.jinja_env.auto_reload = True # Init db db.init_app(app) # DebugToolbarExtension(app) # Init the Flask-Session via app object # flask_session.init_app(app) # Init the Flask-Login via app object # login_manager.init_app(app) # Setup Flask-Security flask_security.init_app( app, user_datastore) # register_form=ExtendedRegisterForm) # Init the Flask-Bable via app object flask_bable.init_app(app) # Init the Flask-bootstrap via app object flask_bootstrap.init_app(app) # Init the swgger via app object swagger.init_app(app) # Init the Flask-Restful via app object restful_api_bp = Blueprint('api_v1', __name__, url_prefix=app.config['API_PREFIX'] + '/v1') restful_api = Api(restful_api_bp) api_v1.api_setup(restful_api) app.register_blueprint(restful_api_bp) #函数模板 from common.helper.urlmanager import UrlManager app.add_template_global(UrlManager.makeup_static_url, 'makeup_static_url') app.add_template_global(UrlManager.makeup_image_url, 'makeup_image_url') from common.fields import str2json app.add_template_global(str2json, 'str2json') from common.date import Date app.add_template_global(Date.datetime_calculate, 'datetime_calculate') manage.reg_bp(app) @app.route('/') def index(): from flask_babelex import refresh refresh() return redirect(url_for('security.login')) @flask_bable.localeselector def get_local(): language = request.accept_languages.best_match(['zh', 'en']) language = 'zh_Hans_CN' if language == 'zh' else 'en' # Log.info(language) return language return app
def init_app(app): sess = Session() sess.init_app(app) db.init_app(app) flask_migrate.Migrate(app, db, directory='database/migrations')
def db(request, app): app.config['SQLALCHEMY_DATABASE_URI'] = TEST_DB test_db.init_app(app) test_db.create_all() yield test_db
def init_app(app): db.init_app(app)
def main(): ssl(app) db.init_app(app) app.run(ssl_context = ctx, host='0.0.0.0', port=8082)
def configure_database(app): "Database configuration should be set here" # uncomment for sqlalchemy support from database import db db.app = app db.init_app(app)
def init_db(flask_app): db.init_app(flask_app) db.create_all()
def init_app(app): app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['SQLALCHEMY_DATABASE_URI'] = DB_URI db.init_app(app)
def create_app(config_filename='config.py', config_override={}): """Factory function for flask application. Args: config_filename: path to python config file config_override: a dict with settings to use to override config from file; useful for writing very specific tests. """ app = Flask(__name__) # # Configuration handling # if config_filename: app.config.from_pyfile(config_filename) for key, value in config_override.items(): app.config[key] = value # ReCaptcha recaptcha.init_app(app) # Limiter limiter.init_app(app) # Scheduler if app.config.get('SCHEDULER_ENABLED', True): if scheduler.running: scheduler.shutdown() scheduler.init_app(app) scheduler.start() # Celery celery.init_app(app) from celery.security import setup_security setup_security() # # Error logging # if not app.debug: import logging from logging.handlers import RotatingFileHandler os.makedirs('logs', exist_ok=True) file_handler = RotatingFileHandler('logs/app.log', maxBytes=10 * 1024 * 1024, backupCount=5) file_handler.setLevel(logging.WARNING) root_logger = logging.getLogger() root_logger.addHandler(file_handler) # # Database creation # db.app = app db.init_app(app) db.create_all(bind='__all__') mode = app.config.get('BDB_MODE', 'c') bdb.open(app.config['BDB_DNA_TO_PROTEIN_PATH'], mode=mode) bdb_refseq.open(app.config['BDB_GENE_TO_ISOFORM_PATH'], mode=mode) if app.config['USE_LEVENSTHEIN_MYSQL_UDF']: with app.app_context(): for bind_key in ['bio', 'cms']: engine = get_engine(bind_key) engine.execute("DROP FUNCTION IF EXISTS levenshtein_ratio") engine.execute( "CREATE FUNCTION levenshtein_ratio RETURNS REAL SONAME 'levenshtein.so'" ) # # Configure Login Manager # from models import User from models import AnonymousUser login_manager.anonymous_user = AnonymousUser login_manager.user_loader(User.user_loader) login_manager.init_app(app) # # Configure mail service # mail.init_app(app) # # Register assets # assets = Environment(app) for name, bundle in bundles.items(): assets.register(name, bundle) # # Import views # # allow access to this app from views through module import sys sys.path.insert(0, '..') with app.app_context(): from website.views import views for view in views: view.register(app) # # Register functions for Jinja # import jinja2 base_dir = os.path.dirname(os.path.realpath(__file__)) template_loader = jinja2.ChoiceLoader([ app.jinja_loader, jinja2.FileSystemLoader(os.path.join(base_dir, 'static/js_templates')), ]) app.jinja_loader = template_loader from website.views.cms import substitute_variables from website.views.cms import thousand_separated_number from website.views.cms import ContentManagementSystem from jinja2_pluralize import pluralize import json # csrf adds hooks in before_request to validate token app.before_request(csrf.csrf_protect) app.jinja_env.trim_blocks = True app.jinja_env.lstrip_blocks = True jinja_globals = app.jinja_env.globals jinja_filters = app.jinja_env.filters app.dependency_manager = DependencyManager(app) jinja_globals['dependency'] = app.dependency_manager.get_dependency jinja_globals['system_menu'] = ContentManagementSystem._system_menu jinja_globals['system_setting'] = ContentManagementSystem._system_setting jinja_globals['inline_help'] = ContentManagementSystem._inline_help jinja_globals['text_entry'] = ContentManagementSystem._text_entry jinja_globals['t_sep'] = thousand_separated_number jinja_globals['csrf_token'] = csrf.new_csrf_token jinja_globals['is_debug_mode'] = app.debug jinja_filters['json'] = json.dumps jinja_filters['substitute_allowed_variables'] = substitute_variables jinja_filters['pluralize'] = pluralize return app
def configure_database(self): """ Database configuration should be set here """ db.init_app(self)
def create_app(name=__name__): app = Flask(name) app.config.from_object("config.DevelopmentConfig") db.init_app(app) return app
class ContextTask(TaskBase): abstract = True def __call__(self, *args, **kwargs): with app.app_context(): return TaskBase.__call__(self, *args, **kwargs) celery.Task = ContextTask return celery flask_app = Flask(__name__) flask_app.config.from_object(__name__ + '.CeleryConfig') db.init_app(flask_app) celery = make_celery(flask_app) @celery.task def event_listener(web3=None): # Load our block cursor from the event_tracker table. event_tracker = db_models.EventTracker.query.first() if not event_tracker: # No cursor found. Start from the beginning at block 0. event_tracker = db_models.EventTracker(last_read=0) db.session.add(event_tracker) db.session.commit() # Create an event handler and attempt to fetch events from the network. handler = EventHandler(web3=web3)
def load_test_app(): _test_app_ctx.push() db.init_app(_test_app) db.create_all()
def init_ext(app): db.init_app(app) commands.init_app(app)
def init_db(): db.init_app(app) db.app = app db.create_all()
def create_app(): app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = SQLALCHEMY_DATABASE_URI app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db.init_app(app) return app
def init_app(self, app, url_prefix='/api'): db.init_app(app) app.register_blueprint(blueprint, url_prefix=url_prefix)
def app(): app = create_app("config_test.py") with app.app_context(): db.init_app(app) db.create_all() yield app
def initialize_extensions(app): db.init_app(app) marshmallow.init_app(app) bcrypt.init_app(app) auth_token_db.init_app(app)