def create_app(config_name):
# app
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
# database
db.init_app(app)
db.app = app
migrate.init_app(app, db)
# cache
from app.cache import CachingConfig, cache
app.config.from_object(CachingConfig)
cache.init_app(app)
# 国际化
babel.init_app(app)
# flask-admin
admin.init_app(app)
admin.name = app.config.get("APP_NAME")
# flask-user
from app.models import User
from app.flask_user_custom import FlaskUserConfig
app.config.from_object(FlaskUserConfig) # 添加 FlaskUserConfig 配置
app.config["USER_APP_NAME"] = app.config.get("APP_NAME")
user_manager.init_app(app, db, User)
# toolbar
# toolbar.init_app(app)
# jinja2 env
from app.jinja2_env import init_jinja2_env
init_jinja2_env(app)
# views
from app.views import views
app.register_blueprint(views)
# error pages
# from app.errors import init_errors_page
# init_errors_page(app)
amdin_index_view.init_errors_page(app)
# apis
from app.apis import api
app.register_blueprint(api, url_prefix="/api/v1_0")
from app.flask_restless_custom import api_manager
api_manager.init_app(app, flask_sqlalchemy_db=db)
api_manager.app = app
# 慢查询日志
from app.database import init_app
init_app(app)
return app
def create_app(config_object=config.Config):
app = Flask(__name__, root_path=config_object.APP_PATH)
with app.app_context():
app.config.from_object(config_object)
log_file_path = Path(app.config['LOG_PATH'])
log_file_path.mkdir(parents=True, exist_ok=True)
handler = logging.FileHandler(Path(log_file_path,
app.config['LOG_FILENAME']),
encoding='utf-8')
handler.setFormatter(logging.Formatter(app.config['LOG_FORMAT']))
app.logger.setLevel(app.config['LOG_LEVEL'])
app.logger.addHandler(handler)
app.jinja_env.auto_reload = True
app.register_blueprint(home)
app.register_blueprint(history_graph)
app.register_error_handler(UserNotFoundException, user_not_found)
app.register_error_handler(ValidationError, validation_error)
app.register_error_handler(HTTPException, http_exception)
app.register_error_handler(Exception, internal_server_error)
cache.init_app(app)
return app
def register_plugin(app):
from app.models.base import db
from app.cache import cache
db.init_app(app)
cache.init_app(app,app.config['CACHE_CONFIG'])
with app.app_context():
db.create_all()
pass
def create_app(config="app.config.Config"):
app = Flask(__name__)
# Set Config
app.config.from_object(config)
with app.app_context():
# Create Database(if it doesn't created)
url = create_database()
# Set MySQL's charset to utf8mb4 forcely
app.config["SQLALCHEMY_DATABASE_URI"] = str(url)
# Set Redis Session
app.session_interface = redis.RedisSessionInterface()
# Register Database
db.init_app(app)
# Create DB Session & Engine (if db is not defined, create db too.)
db.create_all()
# Set ReCaptcha
if is_setup():
app.config["RECAPTCHA_SITE_KEY"] = get_config("recaptcha_site_key")
app.config["RECAPTCHA_SECRET_KEY"] = get_config(
"recaptcha_secret_key")
recaptcha.init_app(app)
# Initialization
init_template_globals(app)
init_request_processors(app)
# Cache Initialization
cache.init_app(app)
app.cache = cache
from app.admin import admin
from app.handler import page_not_found, forbidden, general_error, gateway_error, too_many_requests
app.register_blueprint(admin)
# Error Handler
app.register_error_handler(403, forbidden)
app.register_error_handler(404, page_not_found)
app.register_error_handler(429, too_many_requests)
app.register_error_handler(500, general_error)
app.register_error_handler(502, gateway_error)
return app
def create_app():
app = Flask(__name__)
app.config.from_object('app.config')
app.config['CACHE_TYPE'] = 'simple'
cors = CORS(app)
config_db(app)
config_ma(app)
cache.init_app(app)
Migrate(app, app.db)
from app.views import bp_views
app.register_blueprint(bp_views)
return app
def create_app():
app = Flask(__name__, instance_relative_config=True)
app.wsgi_app = ProxyFix(app.wsgi_app)
cache.init_app(app)
app.config.from_object('app.config.Config')
db.init_app(app)
app.register_blueprint(blueprint)
with app.app_context():
# Imports
from . import views
# Creates a table for our model
db.create_all()
return app
def create_app():
"""Create Flask app."""
app = Flask(__name__)
config_app(app)
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.init_app(app)
login_manager.login_view = 'auth.login'
# Create user loader function
@login_manager.user_loader
def load_user(user_id):
return db.session.query(User).get(user_id)
# Register components
# app.register_blueprint(infomation)
# app.register_blueprint(vulner)
# 将各个路由注册到实例上
app.register_blueprint(aj)
app.register_blueprint(company)
app.register_blueprint(trend)
app.register_blueprint(message)
app.register_blueprint(jobtype)
app.register_blueprint(data)
app.register_blueprint(datalog)
app.register_blueprint(auth)
app.register_blueprint(recommend)
app.register_blueprint(user_operate)
cache.init_app(app)
class NonASCIIJsonEncoder(json.JSONEncoder):
def __init__(self, **kwargs):
kwargs['ensure_ascii'] = False
super(NonASCIIJsonEncoder, self).__init__(**kwargs)
app.json_encoder = NonASCIIJsonEncoder
return app
"""
import os
from flask import Flask
from flask_cors import CORS
def get_app_base_path():
""" Get app base path. """
return os.path.dirname(os.path.realpath(__file__))
def get_instance_folder_path():
""" Get instance folder path. """
return os.path.join(get_app_base_path(), 'instance')
app = Flask(__name__,
instance_path=get_instance_folder_path())
app.config['JSON_SORT_KEYS'] = False
CORS(app)
app.config.from_pyfile('config.py')
from app.routes import bp
app.register_blueprint(bp)
from app.cache import cache
cache.init_app(app)
def create_app(env_id, env_api_key, config_name):
"""Flask application factory.
:param config_name: Flask Configuration
:type config_name: app.config class
:returns: a flask application
"""
app = Flask(__name__)
if env_api_key:
app.config['LD_CLIENT_KEY'] = env_api_key
logging.info(env_api_key)
if env_id:
app.config['LD_FRONTEND_KEY'] = env_id
logging.info(env_id)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
app = build_environment(app)
app.ldclient = setup_ld_client(app)
app.logger.info("APP VERSION: " + app.config['VERSION'])
bootstrap.init_app(app)
flask_cache_key = env_id + "-flask-"
cache_config = {
**app.config['CACHE_CONFIG'], 'CACHE_KEY_PREFIX': flask_cache_key
}
cache.init_app(app, config=cache_config)
login.init_app(app)
login.login_view = 'core.login'
from app.models import AnonymousUser
login.anonymous_user = AnonymousUser
migrate.init_app(app, db)
from app.routes import core
app.register_blueprint(core)
@app.before_request
def setLoggingLevel():
"""Set Logging Level Based on Feature Flag
This uses LaunchDarkly to update the logging level dynamically.
Before each request runs, we check the current logging level and
it does not match, we update it to the new value.
Logging levels are integer values based on the standard Logging library
in python: https://docs.python.org/3/library/logging.html#logging-levels
This is an operational feature flag.
"""
from flask import request
logLevel = app.ldclient.variation("set-logging-level",
getLdMachineUser(request),
logging.INFO)
app.logger.info("Log level is {0}".format(logLevel))
# set app
app.logger.setLevel(logLevel)
# set werkzeug
logging.getLogger('werkzeug').setLevel(logLevel)
# set root
logging.getLogger().setLevel(logLevel)
return app
from flask import Flask
from flask.ext.babel import Babel
from flask_bower import Bower
from app import configurator
from app.cache import cache
from flask.ext.cors import CORS
from flask.ext.pymongo import PyMongo
app = Flask(__name__, template_folder="templates")
cors = CORS(app)
babel = Babel(app)
bower = Bower(app)
mongo = PyMongo(app)
load = configurator.get("modules")("load")
cache.init_app(app,config={'CACHE_TYPE': 'simple'})
from app import views
from flask import Flask
from flask.ext.babel import Babel
from flask_bower import Bower
from app import configurator
from app.cache import cache
from flask.ext.cors import CORS
app = Flask(__name__, template_folder="templates")
cors = CORS(app)
babel = Babel(app)
bower = Bower(app)
load = configurator.get("modules")("load")
cache.init_app(app, config={'CACHE_TYPE': 'simple'})
if "capitains-ahab" in load:
from Ahab import ahab
app.register_blueprint(ahab)
from joth import joth
app.register_blueprint(joth)
from app import views
