def _load_extensions(app):
from extensions import db
from extensions import migrate
db.init_app(app)
migrate.init_app(app, db)
_load_extension_sentry(app)
def configure_extensions(app):
# I18N
babel.init_app(app)
# Database
db.init_app(app)
# CouchDB
couchdbmanager.setup(app)
couchdbmanager.sync(app)
# Login
login_manager.init_app(app)
login_manager.login_view = "authentification.login"
# Roles
principal.init_app(app)
# Mail
mail.init_app(app)
# Plugins list global
plugin_manager.init_plugin_manager(app.root_path + "/plugins", app)
plugin_manager.activate_plugins()
plugin_manager.setup_plugins()
def create_app():
app = Flask(__name__)
app.config['SECRET_KEY'] = '11eeo9_rCa0a@a#roCr/'
ENV = 'prod'
if ENV == 'dev':
app.debug = True
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@localhost/portfolio'
else:
app.debug = False
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgres://*****:*****@ec2-3-228-114-251.compute-1.amazonaws.com:5432/d9f0l50lh8a8ai'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
extensions.bootstrap.init_app(app)
app.register_blueprint(main)
db.init_app(app)
with app.app_context():
db.create_all()
return app
def create_app():
app = Flask(__name__)
app.config.from_object('config')
# Create modules
app.register_blueprint(indexModule)
app.register_blueprint(themeModule)
app.register_blueprint(groupModule)
app.register_blueprint(relationModule)
app.register_blueprint(constructionModule)
app.register_blueprint(adminModule)
app.register_blueprint(mymapModule)
# Enable the toolbar?
app.config['DEBUG_TB_ENABLED'] = app.debug
# Should intercept redirects?
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = True
# Enable the profiler on all requests, default to false
app.config['DEBUG_TB_PROFILER_ENABLED'] = True
# Enable the template editor, default to false
app.config['DEBUG_TB_TEMPLATE_EDITOR_ENABLED'] = True
# debug toolbar
# toolbar = DebugToolbarExtension(app)
# Create database
db.init_app(app)
with app.test_request_context():
db.create_all()
return app
def init_extensions(app):
db.init_app(app)
db.app = app
db.metadata.naming_convention = {
"ix": 'ix_%(column_0_label)s',
"uq": "uq_%(table_name)s_%(column_0_name)s",
"ck": "ck_%(table_name)s_%(column_0_name)s",
"fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
"pk": "pk_%(table_name)s"
}
# set constraint naming convention to sensible default, per
# http://docs.sqlalchemy.org/en/rel_0_9/core/constraints.html#configuring-constraint-naming-conventions
assets.init_app(app)
assets.app = app
babel.init_app(app)
cache.init_app(app)
csrf.init_app(app)
mail.init_app(app)
login_manager.init_app(app)
store.init_app(app)
rest.init_app(app,
flask_sqlalchemy_db=db,
preprocessors=restless_preprocessors)
rest.app = app
if app.config.get('DEBUG'):
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
def register_extensions(app):
# Flask-SQLAlchemy
db.init_app(app)
db.app = app
# Flask-Redis
# rd.init_app(app)
# Flask-Migrate
# migrate.init_app(app, db)
# Flask-Mail
mail.init_app(app)
# Flask-Cache
# cache.init_app(app)
# Flask-Login
from models import AnonymousUser
login_manager.session_protection = 'basic'
login_manager.login_view = 'blog.articles'
login_manager.login_message = 'please login first~'
login_manager.anonymous_user = AnonymousUser
login_manager.init_app(app)
def register_extensions(app):
"""
扩展实例化
:param app:
:return:
"""
db.init_app(app)
moment.init_app(app)
migrate.init_app(app=app, db=db)
cache.init_app(app)
login_manager.init_app(app)
# 登录过滤保护
login_manager.exempt_views((user_bp, demo_bp, audio_bp, img_api_bp, ocr_api_bp))
session.init_app(app)
csrf.init_app(app)
# csrf过滤保护
csrf.exempt_views((demo_bp, audio_bp, img_api_bp, ocr_api_bp))
# 定时任务 解决FLASK DEBUG模式定时任务执行两次
if os.environ.get('FLASK_DEBUG', '0') == '0':
scheduler.init_app(app)
scheduler.start()
elif os.environ.get('WERKZEUG_RUN_MAIN') == 'true':
scheduler.init_app(app)
scheduler.start()
def configure_extensions(app):
db.init_app(app)
migrate.init_app(app, db, directory="_migrations", render_as_batch=True)
CORS(app)
def create_app(settings_overrides=None):
app = Flask(__name__)
# Using Cross-origin resource sharing to allow
# the ajax call from another domain since
# SimpleHTTPServer runs on port 8000 and this
# application runs on port 5000
cors = CORS(app)
app.config['CORS_HEADERS'] = 'Content-Type'
configure_settings(app, settings_overrides)
# Initialise database
db.init_app(app)
configure_blueprints(app)
with app.app_context():
db.create_all()
# Initialising the data in the database
# this should not be needed in a real system
# since the data would be fed in as a result or
# real events taking place.
# However for the sake of this task we need data to work with
# so will keeo this here.
if not Shop.query.count():
load_shops('shops.csv')
if not Product.query.count():
load_products('products.csv')
if not Tag.query.count():
load_tags('tags.csv')
if not Tagging.query.count():
load_taggings('taggings.csv')
return app
def create_app(config_obj='intersentia.config.DevelopmentConfig'):
"""
Returns an app Flask object configurated with the given config_obj.
"""
# TODO: avoid hardcoded paths.
app = Flask(__name__,
static_folder='../static/dist',
template_folder='../static/public')
app.config.from_object(config_obj)
from extensions import db
from extensions import migrate
# TODO: command to create database and context db_models.
# understand the concept of session and scoped_session.
# Create makemigrations and migrate.
db.init_app(app)
migrate.init_app(app, db=db, render_as_batch=True)
from v1.blueprint import api_bp
app.register_blueprint(api_bp, url_prefix='/api')
from flask_cors import CORS
CORS(app)
return app
def create_app(settings_folder):
# App
app = Flask(__name__)
app.config.from_pyfile(
os.path.join('..', 'settings', 'common.py'), silent=False)
# os.path.join(settings_folder, 'common.py'), silent=False)
app.config.from_pyfile(
os.path.join(settings_folder, 'local_settings.py'), silent=False)
CORS(app, resources={r"*": {"origins": "*"}})
# DB
db.init_app(app)
# Signer/Verifier
sv.config(priv_key_path=os.path.join(settings_folder, 'key'),
priv_key_password=app.config['PRIVATE_KEY_PASSWORD'])
# API
api.init_app(app)
app.register_blueprint(apidoc.apidoc)
api.app = app
# Social
init_social_models(app)
# Mail
api.mail = Mail(app)
return app
def init_extensions(app):
# Init database
from extensions import db
db.init_app(app)
# Init migration
from extensions import migrate
migrate.init_app(app, db)
# Init bcrypt
from extensions import bcrypt
bcrypt.init_app(app)
# Init Login manager
from extensions import login_mgr
login_mgr.login_view = 'auth.login'
login_mgr.init_app(app)
# Init mail
from extensions import mail
mail.init_app(app)
# Init jwt
from extensions import jwt
jwt.init_app(app)
def register_extensions(app):
# ..config
config.init_app(app)
# ..bcrypt
bcrypt.init_app(app)
# ..db
db.init_app(app)
# ..csrf
csrf_protect.init_app(app)
# ...login_manager
login_manager.init_app(app)
login_manager.login_view = 'accounts.login'
login_manager.login_message = None
@login_manager.user_loader
def load_user(user_id):
from accounts.models import User
return User.get_by_id(user_id)
# ..migrate
migrate.init_app(app, db)
# ..webpack
if not app.config['MIGRATION_MODE']:
webpack.init_app(app)
# ...
return None
def make_application():
app = Flask(__name__, instance_relative_config=True)
app.config.from_pyfile("config.py")
logging.basicConfig(level=app.config["LOGGER_LEVEL"], format=app.config["LOGGER_FORMAT"])
# Setup sqlalchemy
db.init_app(app)
@app.after_request
def after_request(response):
try:
db.session.commit()
except Exception:
db.session.rollback()
abort(500)
return response
# blueprints
from views import docs
app.register_blueprint(docs, url_prefix="/docs")
# Config jinjia global variables
app.jinja_env.filters["error_class"] = filters.error_class
app.jinja_env.filters["error_text"] = filters.error_text
app.jinja_env.filters["dateformat"] = filters.dateformat
app.jinja_env.filters["empty"] = filters.empty
app.jinja_env.globals["static"] = lambda filename: url_for("static", filename=filename)
return app
def configure_extensions(app):
db.app = app
celery.init_app(app)
db.init_app(app)
mail.init_app(app)
cache.init_app(app)
celery.init_app(app)
def create_app(config=None):
"""Return a Flask application according to application factory design pattern function.
Create app object. Configure it. Initialize Flask extensions. Register Blueprints.
:type config: dict
:param config: Additional configuration that'll override default values
"""
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db' # sqlite://<nohostname>/<path>
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.config.from_pyfile('secret.py', silent=True)
if config is not None:
app.config.update(config)
misaka.init_app(app)
login_manager.init_app(app)
db.init_app(app)
app.register_blueprint(login)
app.register_blueprint(static_pages)
app.register_blueprint(blog, url_prefix='/blog')
app.register_blueprint(simple_routes)
app.register_blueprint(tags_api, url_prefix='/blog')
return app
def register_extensions(app):
db.init_app(app)
migrate = Migrate(app, db)
jwt.init_app(app)
configure_uploads(app, image_set)
patch_request_class(app, 10 * 1024 * 1024)
cache.init_app(app)
limiter.init_app(app)
@jwt.token_in_blocklist_loader
def check_if_token_in_blacklist(jwt_header, jwt_payload):
jti = jwt_payload['jti']
return jti in black_list
@app.before_request
def before_request():
print('\n=============BEFORE REQUEST===============\n')
print(cache.cache._cache.keys())
print('\n==========================================\n')
@app.after_request
def after_request(response):
print('\n============AFTER REQUEST=================\n')
print(cache.cache._cache.keys())
print('\n==========================================\n')
return response
@limiter.request_filter
def ip_whitelist():
return request.remote_addr == '127.0.0.1'
def create_app():
app = Flask(__name__)
# get config from config.py
app.config.from_object(DevConfig)
db.init_app(app)
views_app(app)
return app
def configure_extensions(app):
"""
初始化插件
"""
db.init_app(app)
admin.init_app(app)
def configure_extensions(app):
""" Configure app extension. """
# flask SQLAlchemy
db.init_app(app)
db.create_all(app=app)
# CSRF Protection
csrf.init_app(app)
@csrf.error_handler
def csrf_error(reason):
raise CsrfTokenError()
# mail.init_app(app)
# flask OAuthlib
oauth.init_app(app)
# Login Manger
login_manager.init_app(app)
# Interface for anonymous users
class AnonymousUserMixin(_AnonymousUserMixin):
username = '******'
firstName = ''
lastName = ''
email = ''
role = Role.GUEST
is_admin = False
login_manager.login_view = 'auth.post_login'
login_manager.session_protection = "strong"
login_manager.anonymous_user = AnonymousUserMixin
def configure_extensions(app):
from extensions import cache, db, mail, Login
# initialize mail
mail = mail.init_app(app)
# initialize cache
cache = cache.init_app(app)
# initialize database
db.init_app(app)
app.logger.info("Database initialized.")
db.app = app
db.metadata.bind = db.get_engine(app)
db.metadata.reflect()
app.logger.info("Database tables reflected.")
from models import User
db.create_all(bind=['users'])
# login
Login.manager.setup_app(app)
@Login.manager.user_loader
def load_user(userid):
return User.query.get(userid)
@Login.manager.token_loader
def load_token(token):
return User.query.filter(User.passkey == token).first()
def create_app():
# Create the Flask's instance.
app = Flask(__name__,
static_folder="../dist/static",
template_folder="../dist")
# Set the project's config.
app.config.from_object(ProdConfig)
# Register blueprint
app.register_blueprint(user)
app.register_blueprint(article)
app.register_blueprint(catalog)
# Init the extensions' app
db.init_app(app)
cors.init_app(app)
jwt.init_app(app)
# swagger.init_app(app)
# Page jump
@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def catch_all(path):
return render_template("index.html")
return app
def register_extensions(app):
db.init_app(app)
bootstrap.init_app(app)
moment.init_app(app)
whooshee.init_app(app)
loginmanager.init_app(app)
mail.init_app(app)
def register_extensions(app):
db.init_app(app)
blueprint = Blueprint('api', __name__, url_prefix='/api')
api.init_app(blueprint)
app.register_blueprint(blueprint)
cors.init_app(app)
def register_extensions(app):
db.init_app(app)
migrate = Migrate(app, db)
jwt.init_app(app)
mail.init_app(app)
cache.init_app(app)
limiter.init_app(app)
def create_app(debug=False):
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///capstone360.db'
app.config['SECRET_KEY'] = '06ca1f7f68edd3eb7209a5fca2cc6ca0'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.config['CAS_SERVER'] = 'https://auth.cecs.pdx.edu/cas/login'
app.config['CAS_AFTER_LOGIN'] = '******'
app.config['CAS_AFTER_LOGOUT'] = 'logout'
app.jinja_env.trim_blocks = True
app.jinja_env.lstrip_blocks = True
if not debug:
os.environ['CAPSTONE_SETTINGS'] = '/etc/capstone.prod.cfg'
app.config.from_envvar('CAPSTONE_SETTINGS')
else:
app.config['DEBUG'] = True
app.app_context().push()
db.init_app(app)
db.Model.metadata.reflect(db.engine)
# CAS LOGIN
cas.init_app(app)
register_routes(app)
return app
def create_app(config_name=None):
if config_name is None:
config_name = 'default'
app = Flask(__name__)
app.config.from_object(config[config_name])
# db
db.app = app
db.init_app(app)
# login
login_manager.init_app(app)
# blueprints
for bp in blueprints:
app.register_blueprint(bp)
#bootstrap
Bootstrap(app)
#scheduler
scheduler = APScheduler()
scheduler.init_app(app)
scheduler.start()
app.scheduler = ScheduleHelper(scheduler)
logging.basicConfig()
handle_errors(app)
handle_date(app)
return app
def init_extensions(app):
db.init_app(app)
db.app = app
db.metadata.naming_convention = {
"ix": 'ix_%(column_0_label)s',
"uq": "uq_%(table_name)s_%(column_0_name)s",
"ck": "ck_%(table_name)s_%(column_0_name)s",
"fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
"pk": "pk_%(table_name)s"
}
# set constraint naming convention to sensible default, per
# http://docs.sqlalchemy.org/en/rel_0_9/core/constraints.html#configuring-constraint-naming-conventions
assets.init_app(app)
assets.app = app
babel.init_app(app)
cache.init_app(app)
csrf.init_app(app)
mail.init_app(app)
login_manager.init_app(app)
rq.init_app(app)
app.rq = rq
store.init_app(app)
rest.init_app(app, flask_sqlalchemy_db=db,
preprocessors=restless_preprocessors)
rest.app = app
limiter.init_app(app)
for handler in app.logger.handlers:
limiter.logger.addHandler(handler)
if app.config.get('DEBUG'):
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
app.debug = True
def register_extensions(db, app):
"""Register Flask extensions."""
db.init_app(app)
with app.app_context():
db.create_all()
return None
def create_app():
# name is a pre-defined python variable which is set to the name of the module in which it is used
# the flask object implements a WSGI application - once it is created it acts as a central repository
# for view functions, url rules, template config, etc
# should be created in main module or __init__.py of your package
app = Flask(__name__)
app.config['MONGODB_SETTINGS'] = {
'db': 'kart_db',
'host': '172.21.0.2',
'port': 27017,
'authentication_source': 'admin',
'username': '******',
'password': '******'
}
#print('cf: ' + str(dir(config_filename)))
#app.config.from_object('settings')
app.config.from_envvar('FLASK_MODULE_SETTINGS')
#app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+mysqlconnector://root:[email protected]:3306/mange_takk_db'
#app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# initialize extensions so that extension knows the name of the application object
api.init_app(app)
cors.init_app(app)
# right now all cross origin requests are allowed - need to change this config
# src: https://stackoverflow.com/questions/26980713/solve-cross-origin-resource-sharing-with-flask
# cors = CORS(app, resources={r"/api/*": {"origins": "*"}})
db.init_app(app)
jwt.init_app(app)
return app
def create_app(config_filename=None):
app = Flask(__name__, instance_relative_config=True)
if app.config.from_pyfile("settings.conf", silent=True):
print "Settings loaded from local instance"
if app.config.from_envvar("RSVP_CONF", silent=True):
print "Settings loaded from ENVVAR"
if app.config["DEBUG"]:
app.debug = True
log_formatter = logging.Formatter("%(asctime)s [%(levelname)s] %(message)s")
root_logger = logging.getLogger("werkzeug")
if app.config["DEBUG"]:
root_logger.setLevel(logging.DEBUG)
file_handler = logging.FileHandler("{}/{}".format(app.config["LOGDIR"], "rsvp.log"))
file_handler.setFormatter(log_formatter)
root_logger.addHandler(file_handler)
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_formatter)
root_logger.addHandler(console_handler)
from extensions import db
import models
db.init_app(app)
models.create_all(app)
from views import views_bp
app.register_blueprint(views_bp)
return app
def register_extensions(app):
db.init_app(app)
migrate = Migrate(app, db)
jwt.init_app(app)
configure_uploads(app, image_set)
patch_request_class(app, 10 * 1024 * 1024)
cache.init_app(app)
limiter.init_app(app)
@jwt.token_in_blacklist_loader
def check_if_token_in_blacklist(decrypted_token):
jti = decrypted_token['jti']
return jti in black_list
@app.before_request
def before_request():
print('\n==================== BEFORE REQUEST ====================\n')
print(cache.cache._cache.keys())
print('\n=======================================================\n')
@app.after_request
def after_request(response):
print('\n==================== AFTER REQUEST ====================\n')
print(cache.cache._cache.keys())
print('\n=======================================================\n')
return response
def create_app(settings_folder):
# App
app = Flask(__name__)
app.config.from_pyfile(
os.path.join('..', 'settings', 'common.py'), silent=False)
# os.path.join(settings_folder, 'common.py'), silent=False)
app.config.from_pyfile(
os.path.join(settings_folder, 'local_settings.py'), silent=False)
CORS(app, resources={r"*": {"origins": "*"}})
# DB
db.init_app(app)
# Signer/Verifier
sv.config(pub_key_path=os.path.join(settings_folder, 'keypub'))
# API
api.init_app(app)
app.register_blueprint(apidoc.apidoc)
api.app = app
# Mail
api.mail = Mail(app)
api.urltoken = URLSafeTimedSerializer(app.config['SECRET_KEY'])
return app
def extensions(app_instance):
"""
Register 0 or more extensions (mutates the app passed in).
:param app: Flask application instance
:return: None
"""
# debug_toolbar.init_app(app)
# mail.init_app(app_instance)
# csrf.init_app(app_instance)
db.init_app(app_instance)
login_manager.init_app(app_instance)
# app.config.update({
# 'RESTFUL_JSON':{
# 'cls':CustomJSONEncoder
# }
# })
# app.json_encoder = CustomJSONEncoder
# flask_restful.representations.json.settings["cls"] = CustomJSONEncoder
# metaData = MetaData()
# engine = create_engine(app_instance.config['SQLALCHEMY_DATABASE_URI'], pool_recycle=3600, pool_size=20, max_overflow=-1)
# metaData.bind = engine
# engine.echo = False
#
#
# session_factory = sessionmaker(bind=engine, autoflush=False)
# session = flask_scoped_session(session_factory, app_instance)
return app_instance
def create_app(config_filename):
"""
Creates the app instance
:param config_filename: Set configuration file
:return: app
"""
# Initiate the app
app = Flask(__name__)
# Point to the configuration file
app.config.from_pyfile(config_filename)
# Create our database
db.init_app(app)
# Import our blueprints
from blueprints.admin.views import admin
# Register our blueprints
app.register_blueprint(admin)
# Give the run.py file our app
return app
def create_app(settings_folder):
# App
app = Flask(__name__)
app.config.from_pyfile(os.path.join("..", "settings", "common.py"), silent=False)
# os.path.join(settings_folder, 'common.py'), silent=False)
app.config.from_pyfile(os.path.join(settings_folder, "local_settings.py"), silent=False)
CORS(app, resources={r"*": {"origins": "*"}})
# DB
db.init_app(app)
# Signer/Verifier
sv.config(pub_key_path=os.path.join(settings_folder, "keypub"))
# API
api.init_app(app)
app.register_blueprint(apidoc.apidoc)
api.app = app
# Mail
api.mail = Mail(app)
api.urltoken = URLSafeTimedSerializer(app.config["SECRET_KEY"])
return app
def register_extensions(app):
db.init_app(app)
moment.init_app(app)
csrf.init_app(app)
bootstrap.init_app(app)
login_manager.init_app(app)
avatars.init_app(app)
def create_app(config_class=Config):
"""
Returns the flask application instance
Parameters
----------
config_class: class
Returns
-------
app: object
"""
app = Flask(__name__)
app.config.from_object(Config)
db.init_app(app)
migrate = Migrate(app, db)
from views import blog
from views import contact
from views import main
from views import portfolio
from views import sitemap
from api.search import search_blueprint
app.register_blueprint(blog.blog_blueprint)
app.register_blueprint(contact.contact_blueprint)
app.register_blueprint(main.main_blueprint)
app.register_blueprint(portfolio.portfolio_blueprint)
app.register_blueprint(sitemap.sitemap_blueprint)
app.register_blueprint(search_blueprint, url_prefix="/api")
return app
def create_app(config):
flask_app = Flask(__name__)
flask_app.config.from_object(config)
flask_app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(flask_app)
return flask_app
def register_extensions(app_obj):
app_obj.app_context().push()
app_obj.register_blueprint(home_controller, url_prefix="/")
app_obj.register_blueprint(user_controller, url_prefix="/api/users")
app_obj.register_blueprint(project_controller, url_prefix="/api/projects")
db.init_app(app_obj)
db.create_all()
def configure_extensions(app):
db.app = app
db.init_app(app)
mail.init_app(app)
cache.init_app(app)
celery.conf.update(app.config)
rd.init_app(app)
def configure_extensions(app):
"""This function configures all extensions used in app."""
db.init_app(app)
with app.app_context():
db.create_all()
db.session.commit()
def create_app():
app = Flask("foo")
app.config.from_object(ConfigDev)
db.init_app(app)
register_blueprints(app)
return app
def register_extensions(app):
assets.init_app(app)
bcrypt.init_app(app)
cache.init_app(app)
db.init_app(app)
login_manager.init_app(app)
debug_toolbar.init_app(app)
migrate.init_app(app, db)
return None
def register_extensions(app):
db.init_app(app)
bcrypt.init_app(app)
lm.init_app(app)
lm.login_view = 'auth.login'
toolbar.init_app(app)
mail.init_app(app)
migrate.init_app(app, db)
return None
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
db.init_app(app)
# Register the blueprints
from appblueprint.views import externalmodule
app.register_blueprint(externalmodule, url_prefix='/externalmodule')
return app
def configure_extensions(app):
login_manager = LoginManager()
login_manager.init_app(app)
@login_manager.user_loader
def load_user(id):
return User.query.filter_by(id=id).first()
db.init_app(app)
bcrypt.init_app(app)
def create_app():
app = Flask(__name__)
app.config.from_object('utopia.settings')
db.init_app(app)
app.register_blueprint(index)
return app
def configure_extensions(app):
# setup SQLAlchemy
db.init_app(app)
# db.drop_all(app=app)
db.create_all(app=app)
from dummy_data import create_test_data
# create_test_data(app)
mail.init_app(app)
bcrypt.init_app(app)
def create_app(config=None):
app = Flask(__name__)
app.config.from_object(DevConfig)
if config is not None:
app.config.from_object(config)
db.init_app(app)
register_blueprints(app)
return app
def create_app():
app_init = Flask(__name__)
app_init.config.from_object('config')
db.init_app(app_init)
db.app = app_init
bootstrap.init_app(app_init)
migrate.init_app(app_init, db)
if app_init.config['DEBUG'] is True:
app_init.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
debug_toolbar.init_app(app_init)
return app_init
def register_extensions(app):
cache.init_app(app)
db.init_app(app)
admin.init_app(app)
register_admin_views(admin)
user_datastore = MongoEngineUserDatastore(db, User, Role)
security = Security(app, user_datastore, confirm_register_form=ExtendedRegisterForm)
mail.init_app(app)
debug_toolbar.init_app(app)
return None
def configure_extensions(app):
db.init_app(app)
login_manager.init_app(app)
@app.after_request
def after_request(response):
try:
db.session.commit()
except Exception,e:
db.session.rollback()
abort(500)
return response
def create_app(config):
app = Flask(__name__)
app.config.from_pyfile(config)
configure_urls(app)
db.init_app(app)
configure_identity(app)
configure_before_handlers(app)
configure_errorhandlers(app)
return app
def configure_extensions(app):
# flask-mongoengine
db.init_app(app)
app.session_interface = MongoEngineSessionInterface(db)
# flask-mail
mail.init_app(app)
# flask-babel
babel.init_app(app)
# Bcrypt for hashing passwords
bcrypt.init_app(app)
# the Gravatar service
gravatar.init_app(app)
# Markdown
md.init_app(app)
# Caching
cache.init_app(app)
# Debug Toolbar
if app.debug:
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
@babel.localeselector
def get_locale():
"""
Get the current request locale.
returns String
"""
if not hasattr(g, 'lang'):
g.lang = 'en'
accept_languages = app.config.get('ACCEPT_LANGUAGES')
return g.lang or request.accept_languages.best_match(accept_languages)
# flask-login
login_manager.login_view = 'frontend.login'
login_manager.refresh_view = 'frontend.reauth'
@login_manager.user_loader
def load_user(user_id):
return User.objects(id=user_id).first()
login_manager.setup_app(app)
def config_app(app, config):
logger.info('Setting up application...')
app.config.from_pyfile(config)
db.init_app(app)
oid.init_app(app)
login_manager.init_app(app)
@app.after_request
def after_request(response):
try:
db.session.commit()
except Exception:
db.session.rollback()
abort(500)
return response
def create_app(config=None):
app = Flask(__name__)
if config is None:
if getenv('PROD') == '1':
config = ProdConfig
else:
config = DevConfig
app.config.from_object(config)
cache.init_app(app, config=config.CACHE_CONFIG)
db.init_app(app)
register_blueprints(app)
return app
def configure_extensions(app):
# 初始化一些扩展
db.init_app(app)
mdb.init_app(app)
db_config = app.config.get('MONGODB_SETTINGS')
db_config = dict([(k.lower(), v) for k, v in db_config.items() if v])
db_name = db_config.pop('db')
mdb.register_connection(db_name, db_name, **db_config)
dbs = Servers.query.distinct(Servers.db_res)
for res_db in dbs:
s = Servers.query.filter(Servers.db_res == res_db, Servers.ip!='127.0.0.1').first()
if s:
host = s.ip
db_config.update({'host': host, 'username': s.username, 'password': s.password})
mdb.register_connection(res_db, res_db, **db_config)
def create_app(config=None):
app = Flask('scaffold', instance_relative_config=True)
if config is not None:
app.config.from_object(config)
init_logger(app)
logger.info('starting %s' % app.name)
db.init_app(app)
cors.init_app(app)
celery.config_from_object(app.config)
login_manager.init_app(app)
api.init_app(app)
init_api(api, app)
logger.info('started %s' % app.name)
return app
def configure_extensions(app):
# flask-sqlalchemy
db.init_app(app)
# Sentry
if app.config['SENTRY_DSN']:
sentry.init(app, dsn=app.config['SENTRY_DSN'])
# flask-login
login_manager.login_view = 'frontend.login'
login_manager.refresh_view = 'frontend.login'
login_manager.anonymous_user = Anonymous
@login_manager.user_loader
def load_user(id):
return User.query.get(id)
login_manager.setup_app(app)
