def create_app(settings_ns):
babel = Babel()
app = Flask(
__name__,
static_url_path="/static",
static_folder="static",
instance_relative_config=False,
)
app.config.from_object(settings_ns)
app.register_blueprint(main_bp)
app.jinja_env.filters["clean_uri"] = clean_uri
app.context_processor(utility_processor)
babel.init_app(app)
if app.config["DEBUG"]:
try:
from flask_debugtoolbar import DebugToolbarExtension
except ImportError:
LOGGER.info('cannot import lib "flask_debugtoolbar". '
'Make sure it is installed and available in the '
'import path.')
else:
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
return app
def configure_packages(app):
debug_toolbar = DebugToolbarExtension()
themes = Themes()
debug_toolbar.init_app(app)
themes.init_themes(app, app_identifier="forumcodename")
db.init_app(app)
def create_app():
model_manager = ModelManager()
toolbar = DebugToolbarExtension()
app = Flask(__name__)
app.debug = False
app.config["SECRET_KEY"] = "hello world"
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:"
app.config["DEBUG_TB_INTERCEPT_REDIRECTS"] = False
app.config["DEBUG_TB_PROFILER_ENABLED"] = True
db.init_app(app)
model_manager.register_model(User)
model_manager.register_model(Address)
model_manager.register_model(RandomTypeTable)
model_manager.init_app(app, db)
toolbar.init_app(app)
with app.app_context():
db.create_all()
populate(db.session)
return app
def register_extensions(app):
if app.debug:
from flask_debugtoolbar import DebugToolbarExtension
debug_toolbar = DebugToolbarExtension()
debug_toolbar.init_app(app)
db.init_app(app)
mail.init_app(app)
wtf.add_helpers(app)
md.init_app(app)
s3.init_app(app)
celery.init_app(app)
assets.init_app(app)
assets.register(bundles)
migrate.init_app(app, db)
admin.init_app(app)
register_health_check(app, db)
sentry_sdk.init(
dsn=app.config.get("SENTRY_DSN"), integrations=[FlaskIntegration()]
)
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
configure_security(app, user_datastore)
def create_app(script_info=None):
app = Flask('sweext_web', static_url_path='')
# check the env is prod or dev
if os.getenv('RUN_IN_PROD') == 'True':
app.config.from_object('sweext_web.config.web_config.Config')
else:
app.config.from_object('sweext_web.config.web_config_dev.DevConfig')
db.init_app(app)
HomeUrlRegister.register()
StepsUrlRegister.register()
ClaimUrlRegister.register()
app.register_blueprint(home.views.home_blueprint)
app.register_blueprint(steps.views.steps_blueprint)
app.register_blueprint(claim.views.claim_blueprint)
app.debug = False
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
app.register_error_handler(401, HttpError.handle_401)
app.register_error_handler(403, HttpError.handle_403)
app.register_error_handler(404, HttpError.handle_404)
app.register_error_handler(405, HttpError.handle_405)
app.register_error_handler(500, HttpError.handle_500)
return app
def create_app():
app = Flask(__name__)
app.config.from_object(config)
config.init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
babel.init_app(app)
celery.conf.update(app.config)
if app.config['SSL_REDIRECT']:
from flask_sslify import SSLify
SSLify(app)
app.wsgi_app = ProxyFix(app.wsgi_app)
if app.debug:
from flask_debugtoolbar import DebugToolbarExtension
debug_toolbar = DebugToolbarExtension()
debug_toolbar.init_app(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
return app
def create_app(config_name=None):
if config_name is None:
config_name = os.getenv('FLASK_CONFIG', 'default')
app = Flask(__name__)
app.config['SECRET_KEY'] = 'xxxxxxxxx'
app.debug = False
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
# 配置引入
app.config.from_object(config[config_name])
app.config.from_object(TaskConfig())
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
# 上下文推送
#app.app_context().push()
# 注册扩展
register_extensions(app)
register_blueprints(app)
register_commands(app)
# 启动apscheduler服务
scheduler.start()
# apscheduler api认证
@scheduler.authenticate
def authenticate(auth):
return auth['username'] == 'guest' and auth['password'] == 'guest'
return app
def create_app(settings_ns):
babel = Babel()
app = Flask(
__name__,
static_url_path="/static",
static_folder="static",
instance_relative_config=False,
)
app.config.from_object(settings_ns)
app.register_blueprint(main_bp)
app.jinja_env.filters["clean_uri"] = clean_uri
app.context_processor(utility_processor)
babel.init_app(app)
if app.config["DEBUG"]:
try:
from flask_debugtoolbar import DebugToolbarExtension
except ImportError:
LOGGER.info('cannot import lib "flask_debugtoolbar". '
'Make sure it is installed and available in the '
'import path.')
else:
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
return app
def create_app(config_filename=None, config_object=None):
"""
Create a new application object. The database and CLI are automatically
wired up. If ``config_filename`` or ``config_object`` are not ``None`` they
are passed to :py:func:`app.config.from_pyfile` and
:py:func:`app.config.from_object` respectively.
Returns the newly created application object.
"""
app = Flask(__name__)
app.config.from_object('psephology.config.default')
if config_filename is not None:
app.config.from_pyfile(config_filename)
if config_object is not None:
app.config.from_object(config_object)
db.init_app(app)
migrate.init_app(app, db, render_as_batch=True)
app.register_blueprint(ui)
app.register_blueprint(api, url_prefix='/api')
app.cli.add_command(cli)
# Things which should only be present in DEBUG-enabled apps
app.debug = app.config.get('DEBUG', False)
if app.debug:
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
return app
def create_app(config_filename=None):
app = Flask(__name__)
app.config.from_object('bitsbox.config.default')
if config_filename is not None:
app.config.from_pyfile(config_filename)
db.init_app(app)
migrate.init_app(app, db, render_as_batch=True)
app.register_blueprint(ui)
app.cli.add_command(cli)
# Things which should only be present in DEBUG-enabled apps
app.debug = app.config.get('DEBUG', False)
if app.debug:
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
# GraphQL support
app.register_blueprint(graphql, url_prefix='/graphql')
app.register_blueprint(graphiql, url_prefix='/graphiql')
return app
def create_app(config_name):
app = Flask(__name__)
CORS(app, supports_credentials=True)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
db.app = app
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
login_manager.init_app(app)
init_swagger(app)
# 蓝图注册
from pyfw.system import system_blue
app.register_blueprint(system_blue, url_prefix='/api/v1/common')
return app
def create_app():
app = Flask(__name__,
static_folder=static_folder,
template_folder=template_folder)
app.register_blueprint(user_blueprint, url_prefix='/user')
# 设置数据库配置
app.config['SQLALCHEMY_DATABASE_URI'] = get_sqlalchemy_uri(MYSQL_DATABASE)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# 配置redis-->session
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = redis.Redis(host=REDIS_DATABASE['HOST'],
port=REDIS_DATABASE['PORT'])
app.config['SECRET_KEY'] = 'secret_key'
app.debug = True
db.init_app(app)
se = Session()
se.init_app(app)
bar = DebugToolbarExtension()
bar.init_app(app)
return app
def create_app(script_info=None):
# instantiate the app
app = Flask(__name__)
CORS(app)
# set config
app_settings = os.getenv('APP_SETTINGS')
app.config.from_object(app_settings)
# set up extensions
db.init_app(app)
migrate.init_app(app, db)
if app.config['DEBUG_TB_ENABLED']:
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
# register blueprints
from project.api.users import users_blueprint
app.register_blueprint(users_blueprint)
# shell context for flask cli
@app.shell_context_processor
def ctx():
return {'app': app, 'db': db}
return app
def create_app(config_class=Config):
"""
Functional that creating Flask app from config
"""
logging.basicConfig(filename='logs/' + __name__ + '.log',
level=logging.ERROR)
app = Flask(__name__)
app.config.from_object(config_class)
db.init_app(app)
migrate.init_app(app, db)
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
config = app.config
panels = list(config['DEBUG_TB_PANELS'])
config['DEBUG_TB_PANELS'] = panels
from .fin.routes.csv import csv
from .fin.routes.asset import asset
from .site import site
app.register_blueprint(asset, url_prefix='/fin')
app.register_blueprint(csv, url_prefix='/fin')
app.register_blueprint(site)
app.jinja_env.filters['zip'] = zip
return app
def create_app():
# Initialize Flask instance and enable static file serving
app = Flask(__name__)
app.config.from_object(config[ENV_CONFIG]()) # instance is for __init__
app.wsgi_app = WhiteNoise(app.wsgi_app, root='static/')
# Initialize Sentry for error tracking
sentry.init_app(app)
# Custom Json
app.json_encoder = CustomJSONEncoder
compress.init_app(app)
# Initialize DebugToolbar
if app.config['DEBUG']:
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
# Initialize Database and Migration by Flask-Sqlalchey and Flask-Migrate
db.init_app(app)
migrate.init_app(
app,
db,
directory=join(
abspath(dirname(project.__file__)),
'migrations')) # set directory for compatible with Heroku
# Initialize app blueprint
from .blueprints.app import app as app_blueprint
app.register_blueprint(app_blueprint, url_prefix='/')
# Initialize api10 blueprint
from .blueprints.apiv1 import apiv1 as apiv1_blueprint
app.register_blueprint(apiv1_blueprint, url_prefix='/v1')
# Initialize CLI shell command
@app.shell_context_processor
def make_shell_context():
return dict(app=app, db=db)
# Initialize CLI command for pytest-cov
@app.cli.command(name='py.test')
@click.option('--cov')
@click.option('--cov-report')
def pytest_cov(cov, cov_report):
"""Run pytest with pytest-cov plugin."""
import pytest
sys.argv = ['py.test', '-s']
sys.argv += ['--cov={}'.format(cov)] if cov else []
sys.argv += ['--cov-report={}'.format(cov_report)
] if cov_report else []
sys.exit(pytest.main())
return app
def register_debug_extensions(app): from flask_debugtoolbar import DebugToolbarExtension toolbar = DebugToolbarExtension() toolbar.init_app(app) from flask_admin.contrib.mongoengine import ModelView import flask_admin as admin admin = admin.Admin(app, 'TimeTracker:Admin') # Add views from models import User, Role admin.add_view(ModelView(User)) admin.add_view(ModelView(Role))
def init_ext(app):
migrate = Migrate(app=app,db=db)
se = Session()
se.init_app(app)
db.init_app(app)
# 调试插件的实例化
debug = DebugToolbarExtension()
debug.init_app(app)
#缓存
cache.init_app(app,config=CACHE.get("default"))
bootstrap.init_app(app)
def build_flask_app(use_local_db):
""" Build and initialize the flask app. """
app = Flask(__name__)
app.config['DEBUG'] = DEBUG
# Set the log level for the super logger
logger.set_log_level(LOG_LEVEL)
# Secret key used by Flask to sign cookies.
app.config['SECRET_KEY'] = FLASK_SECRET
# Cache all static files for 1 year by default.
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = ONE_YEAR
if use_local_db:
logger.info('app', 'Loading local user database...')
app.config['SQLALCHEMY_DATABASE_URI'] = LOCAL_DB_URI
else:
logger.info('app', 'Loading remote user database...')
app.config['SQLALCHEMY_DATABASE_URI'] = DB_URI
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.config['SQLALCHEMY_RECORD_QUERIES'] = True
# Initialize SQLAlchemy and integrate it with the Flask instance
DB.init_app(app)
app.register_blueprint(blueprint)
# Enable login management
login_manager.init_app(app)
# Enable WebSocket integration
socketio.init_app(app)
# Enable gzip compression of static assets
Compress().init_app(app)
# Enable indefinite caching of static assets based on hash values
CacheBuster(config=STATIC_CACHE_CONFIG).init_app(app)
# Enable the Flask debug toolbar ONLY if debug mode is enabled
debug_toolbar = DebugToolbarExtension()
debug_toolbar.init_app(app)
# Inject certain constants defined in 'inject_constants' for Jinja processing
app.context_processor(inject_constants)
return app
def init_app(config_file, create_tables=None):
app.config.from_object('cleansweep.default_settings')
if config_file:
# take the absolute path, otherwise Flask looks for file relative to the app
# insted of PWD.
config_path = config_file and os.path.abspath(config_file)
app.config.from_pyfile(config_path, silent=True)
logger.info("init_app %s", config_path)
if os.getenv('CLEANSWEEP_SETTINGS'):
app.config.from_envvar('CLEANSWEEP_SETTINGS')
utils.setup_error_emails(app)
utils.setup_logging(app)
# Setup the view helpers
view_helpers.init_app(app)
# load plugins
plugins = app.config['DEFAULT_PLUGINS'] + app.config['PLUGINS']
for name in plugins:
plugin.load_plugin(name)
# enable create_tables if a value is not speficied and the app is running in debug mode
if create_tables is None and app.config['DEBUG']:
create_tables = True
if create_tables:
db.create_all()
if app.debug:
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
if app.debug or app.config.get("ENABLE_MOCKDOWN") == "true":
import mockdown
app.register_blueprint(mockdown.mockdown_app, url_prefix="/mockups")
mockdown._mockdown.set_root("mockups")
# load all helpers
from . import helpers
# load all the views
from . import views
app.logger.info("Starting cleansweep app")
return app
def main(global_config, **settings):
""" WSGI-Server erzeugen und konfigurieren. """
# extrat all flask.* configuration items
flaskConfig = pasteToFlaskConfig(global_config, settings)
DEBUG = flaskConfig.get('DEBUG', '0') in ['1', 'on', 'true']
VERBOSE = int(global_config.get('STARTUP_VERBOSE', 0))
# create app instance
connexionApp = connexion.App("{{cookiecutter.project_name}}", debug=DEBUG, swagger_ui=True)
flaskApp = connexionApp.app
# configure
flaskApp.config.update(flaskConfig)
cloudFoundryfyConfig(flaskApp.config)
# Rest-Endpoint CF Spring Actuator like Metadaten (Definition im sub-package api.actuator)
apiFile = pkg_resources.resource_filename(__name__, 'schema/actuator.yml')
connexionApp.add_api(apiFile, strict_validation=False, validate_responses=True,
resolver=connexion.RestyResolver('%s.api.actuator' % (__package__)),
base_path='/cloudfoundryapplication')
# Restendpoint App Version 1 (Definition im sub-package api)
apiFile = pkg_resources.resource_filename(__name__, 'schema/app_v1.yml')
connexionApp.add_api(apiFile, strict_validation=True, validate_responses=True,
resolver=connexion.RestyResolver('%s.api' % (__package__)))
if VERBOSE > 0:
print(yaml.dump(flaskApp.config))
if DEBUG:
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension()
toolbar.init_app(flaskApp)
{% if cookiecutter.use_reldb.startswith('y') %}
# proaktive Initialisierung der Datenbank (entfernen -> lazy)
from .model import getDb
with flaskApp.app_context():
db = getDb()
{%- endif -%}
{% if cookiecutter.use_ui.startswith('y') %}
# simple web-ui page without swagger
from .ui.hello import helloPage
flaskApp.register_blueprint(helloPage)
{%- endif -%}
return flaskApp
def add_debug_toolbar(app):
app.config['DEBUG_TB_PANELS'] = (
'flask_debugtoolbar.panels.versions.VersionDebugPanel',
'flask_debugtoolbar.panels.timer.TimerDebugPanel',
'flask_debugtoolbar.panels.headers.HeaderDebugPanel',
'flask_debugtoolbar.panels.request_vars.RequestVarsDebugPanel',
'flask_debugtoolbar.panels.config_vars.ConfigVarsDebugPanel',
'flask_debugtoolbar.panels.template.TemplateDebugPanel',
'flask_debugtoolbar.panels.logger.LoggingPanel',
'flask_debugtoolbar.panels.route_list.RouteListDebugPanel',
'flask_debugtoolbar.panels.profiler.ProfilerDebugPanel')
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
def init_ext(app):
migrate = Migrate()
migrate.init_app(app=app, db=db)
db.init_app(app=app)
Session(app=app)
debugtoolbar = DebugToolbarExtension()
debugtoolbar.init_app(app=app)
Bootstrap(app=app)
cache.init_app(app=app)
# 邮箱初始化
mail.init_app(app=app)
def init_app(config_file, create_tables=None):
app.config.from_object('cleansweep.default_settings')
if config_file:
# take the absolute path, otherwise Flask looks for file relative to the app
# insted of PWD.
config_path = config_file and os.path.abspath(config_file)
app.config.from_pyfile(config_path, silent=True)
logger.info("init_app %s", config_path)
if os.getenv('CLEANSWEEP_SETTINGS'):
app.config.from_envvar('CLEANSWEEP_SETTINGS')
utils.setup_error_emails(app)
utils.setup_logging(app)
# Setup the view helpers
view_helpers.init_app(app)
# load plugins
plugins = app.config['DEFAULT_PLUGINS'] + app.config['PLUGINS']
for name in plugins:
plugin.load_plugin(name)
# enable create_tables if a value is not speficied and the app is running in debug mode
if create_tables is None and app.config['DEBUG']:
create_tables = True
if create_tables:
db.create_all()
if app.debug:
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
if app.debug or app.config.get("ENABLE_MOCKDOWN") == "true":
enable_mockdown()
# load all helpers
from . import helpers
# load all the views
from . import views
app.logger.info("Starting cleansweep app")
return app
def init_app(cls, app):
from flask_debugtoolbar import DebugToolbarExtension
debug = DebugToolbarExtension()
debug.init_app(app)
@app.after_app_request
def after_request(response):
for query in get_debug_queries():
if query.duration >= current_app.config[
'FLASK_SLOW_DB_QUERY_TIME']:
current_app.logger.warning(
'Slow query: %s\nParameters: %s\nDuration: %fs\nContext: %s\n'
% (query.statement, query.parameters, query.duration,
query.context))
return response
def init_app(config_file, create_tables=False):
# take the absolute path, otherwise Flask looks for file relative to the app
# insted of PWD.
config_path = os.path.abspath(config_file)
app.config.from_object('cleansweep.default_settings')
# Hack to make it easier to specify production config
app.config.from_pyfile(config_path, silent=True)
if os.getenv('CLEANSWEEP_SETTINGS'):
app.config.from_envvar('CLEANSWEEP_SETTINGS')
utils.setup_error_emails(app)
utils.setup_logging(app)
logger.info("init_app %s", config_path)
# Setup the view helpers
view_helpers.init_app(app)
# load plugins
plugins = app.config['DEFAULT_PLUGINS'] + app.config['PLUGINS']
for name in plugins:
plugin.load_plugin(name)
if create_tables:
db.create_all()
if app.debug:
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
if app.debug or app.config.get("ENABLE_MOCKDOWN") == "true":
import mockdown
app.register_blueprint(mockdown.mockdown_app, url_prefix="/mockups")
mockdown._mockdown.set_root("mockups")
# load all helpers
from . import helpers
# load all the views
from . import views
app.logger.info("Starting cleansweep app")
return app
def extensions_fabrics(app):
# see https://github.com/xen/flask-project-template
from flask_bcrypt import Bcrypt
bcrypt = Bcrypt()
bcrypt.init_app(app)
from flask_bootstrap import Bootstrap
bootstrap = Bootstrap()
bootstrap.init_app(app)
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
def init_ext(app):
# 实例化
se = Session()
# 绑定app
se.init_app(app)
# db绑定
db.init_app(app)
# 实例化migrate
migrate = Migrate(app=app, db=db)
bs.init_app(app)
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
cache.init_app(app)
def register_extensions(app):
"""Register Flask extensions."""
# initialize extensions
migrate = Migrate()
moment = Moment()
csrf = CSRFProtect()
toolbar = DebugToolbarExtension()
# register extensions
moment.init_app(app)
migrate.init_app(app, db)
db.init_app(app)
toolbar.init_app(app)
csrf.init_app(app)
csrf.exempt("fyyur.controllers.venues.search_venues")
csrf.exempt("fyyur.controllers.venues.delete_venue")
csrf.exempt("fyyur.controllers.artists.search_artists")
app.jinja_env.filters["datetime"] = format_datetime
def init_ext(app):
# 命令行参数使用
migrate = Migrate()
migrate.init_app(app=app,db=db)
db.init_app(app=app)
Session(app=app)
# 开启调试
debugtoolbar = DebugToolbarExtension()
debugtoolbar.init_app(app=app)
# 使用模板
Bootstrap(app=app)
# 初始化缓存
cache.init_app(app=app)
# 邮箱初始化
mail.init_app(app=app)
def register_extensions(self, app):
if app.debug:
debug_toolbar = DebugToolbarExtension()
debug_toolbar.init_app(app)
db.init_app(app)
mail.init_app(app)
wtf.add_helpers(app)
s3.init_app(app)
assets = Environment(app)
assets.register(bundles)
admin.init_app(app)
register_health_check(app, db)
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
app.security = Security(app, user_datastore)
def init_ext(app):
# flask-session
app.config['SECRET_KEY'] = '119'
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_KEY_PREFIX'] = 'flask1905'
Session(app=app)
# sqlalchemy
db.init_app(app=app)
# flask-migrate
migrate = Migrate()
migrate.init_app(app=app, db=db)
# flask-bootstrap
Bootstrap(app=app)
# flask-debugtoolbar
app.debug = True
debugtoolbar = DebugToolbarExtension()
debugtoolbar.init_app(app=app)
def create_app(**config_overrides: dict) -> Flask:
"""Create the Flask app
Returns:
Flask -- a Flask app instance
"""
app = Flask(__name__)
# setup logging
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s %(levelname)s %(name)s : %(message)s")
# setup app config
app.config.from_object("settings")
app.config.update(config_overrides)
# setup database
db.init_app(app)
# setup admin dashboard
app.config["FLASK_ADMIN_SWATCH"] = "flatly"
admin = Admin(app, name="Admin", template_mode="bootstrap3")
admin.add_view(MovieDocumentView(MovieDocument))
# setup blueprints
app.register_blueprint(blueprint)
# setup CLI commands
app.cli.add_command(dev_cli)
# setup debug toolbar
app.config["DEBUG_TB_PANELS"] = [
"flask_mongoengine.panels.MongoDebugPanel"
]
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
return app
def create_app(test_config=None):
# create and configure the app
app = Flask(__name__, instance_relative_config=True)
app.config.from_mapping(
SECRET_KEY='dev',
DATABASE=os.path.join(app.instance_path, 'flaskr.sqlite3'),
)
if test_config is None:
# load the instance config, if it exists, when not testing
app.config.from_pyfile('config.py', silent=True)
else:
# load the test config if passed in
app.config.from_mapping(test_config)
try:
os.makedirs(app.instance_path)
except OSError:
pass
@app.route('/hello')
def hello():
return 'Hello, World!'
from . import db
db.init_app(app)
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
from . import auth
app.register_blueprint(auth.bp)
from . import blog
app.register_blueprint(blog.bp)
app.add_url_rule('/', endpoint='index')
return app
def profile():
""" Run profiler and debugger."""
from flask_debugtoolbar import DebugToolbarExtension
import flask_profiler
app.config["flask_profiler"] = {
"enabled": app.config["DEBUG"],
"storage": {
"engine": "sqlite"
},
"basicAuth": {
"enabled": False
},
"ignore": ["^/tests/.*", "^/src"],
}
flask_profiler.init_app(app)
app.config["DEBUG_TB_PROFILER_ENABLED"] = True
app.config["DEBUG_TB_INTERCEPT_REDIRECTS"] = False
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
print(
" * Flask profiling running at http://127.0.0.1:4000/flask-profiler/")
def _create_app(self):
app = Flask(__name__)
self._load_config(app)
self._register_path(app)
# use template pug(jade)
app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension')
# use webpack
webpack = Webpack()
webpack.init_app(app)
# routing
register_routes(app)
# init db
init_db(app)
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
return app
def create_app(settings_file):
app = Flask(__name__)
app.config.from_pyfile(settings_file)
cache.init_app(app)
mail = Mail()
csrf = CsrfProtect()
csrf.init_app(app)
db.init_app(app)
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
app.mail = mail
mail.init_app(app)
app.hashids = Hashids(salt="salty seafaring sailor", min_length=8)
register_errorhandlers(app)
app.register_blueprint(main)
return app
# -*-coding:utf-8-*-
# author qomo
from flask_debugtoolbar import DebugToolbarExtension
from app import app
from models import Note
import views
debugger = DebugToolbarExtension()
debugger.init_app(app)
if __name__ == '__main__':
Note.create_table(True)
app.run()
def create_app():
app = Flask(__name__,
static_url_path='/static',
static_folder='static',
instance_relative_config=False)
# Configurações
app.config.from_object('webapp.config.default') # Configuração basica
app.config.from_envvar('OPAC_CONFIG', silent=True) # configuração do ambiente
# Assets
js = Bundle('js/vendor/jquery-1.11.0.min.js',
'js/vendor/bootstrap.min.js',
'js/vendor/jquery-ui.min.js',
'js/plugins.js',
'js/main.js',
filters='jsmin', output='js/bundle.js')
css = Bundle('css/bootstrap.min.css',
'css/scielo-portal.css',
filters='cssmin', output='css/bundle.css')
assets.register('js_all', js)
assets.register('css_all', css)
assets.init_app(app)
# i18n
babel.init_app(app)
# login
login_manager.init_app(app)
if app.config['DEBUG']:
# Toolbar
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
# Mongo
dbmongo.init_app(app)
# SQLAlchemy
dbsql.init_app(app)
# Emails
mail.init_app(app)
# Interface do admin
from .models import User
# from .admin import views
from webapp.admin import views
admin = flask_admin.Admin(
app, 'OPAC admin',
index_view=views.AdminIndexView(),
template_mode='bootstrap3',
base_template="admin/opac_base.html")
admin.add_view(views.CollectionAdminView(Collection, name=lazy_gettext(u'Coleção')))
admin.add_view(views.SponsorAdminView(Sponsor, name=lazy_gettext(u'Financiador')))
admin.add_view(views.JournalAdminView(Journal, name=lazy_gettext(u'Periódico')))
admin.add_view(views.IssueAdminView(Issue, name=lazy_gettext(u'Fascículo')))
admin.add_view(views.ArticleAdminView(Article, name=lazy_gettext(u'Artigo')))
admin.add_view(views.UserAdminView(User, dbsql.session, name=lazy_gettext(u'Usuário')))
from .main import main as main_bp
app.register_blueprint(main_bp)
app.wsgi_app = ProxyFix(app.wsgi_app)
return app
def create_app():
app = Flask(__name__)
app.config.from_object('application.default_settings')
db.init_app(app)
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
## ------------------------------- ##
# initializing blueprints #
## ------------------------------- ##
# frontend blueprints
from .blueprints.frontend import frontend
app.register_blueprint(frontend)
# products/displays blueprints
from .blueprints.tfts import tft
app.register_blueprint(tft)
from .blueprints.lcd import lcd
app.register_blueprint(lcd)
from .blueprints.oled import oled
app.register_blueprint(oled)
from .blueprints.epaper import epaper
app.register_blueprint(epaper)
from .blueprints.custom_displays import custom_displays
app.register_blueprint(custom_displays)
# products/touch panels blueprints
from .blueprints.touch_panels import touch_panels
app.register_blueprint(touch_panels)
# products/thermal_printers blueprints
from .blueprints.thermal_printers import thermal_printers
app.register_blueprint(thermal_printers)
# products/computers blueprints
from .blueprints.computers import computers
app.register_blueprint(computers)
# products/others blueprints
from .blueprints.others import others
app.register_blueprint(others)
# 404 page not found "route"
@app.errorhandler(404)
def not_found():
title = "404 Page not found"
return render_template('404.html', title=title), 404
# 500 server error "route"
@app.errorhandler(500)
def server_error():
title = "500 Server Error"
db.session.rollback()
return render_template('500.html', title=title), 500
return app
def create_app():
app = Flask(__name__,
static_url_path='/static',
static_folder='static',
instance_relative_config=False)
app.url_map.converters['regex'] = RegexConverter
# Configurações
app.config.from_object('webapp.config.default') # Configuração basica
app.config.from_envvar('OPAC_CONFIG', silent=True) # configuração do ambiente
# login
login_manager.session_protection = 'strong'
login_manager.login_view = 'admin.login_view'
login_manager.init_app(app)
# Minificando o HTML
if not app.config['DEBUG']:
HTMLMIN(app)
# Registrando os filtros
app.jinja_env.filters['abbrmonth'] = jinja_filters.abbrmonth
app.jinja_env.filters['trans_alpha2'] = custom_filters.trans_alpha2
# Assets
js = Bundle('js/vendor/jquery-1.11.0.min.js',
'js/vendor/underscore-min.js',
'js/vendor/bootstrap.min.js',
'js/vendor/iframeResizer.min.js',
'js/vendor/clipboard.js',
'js/common.js',
'js/main.js',
filters='jsmin', output='js/bundle.js')
css = Bundle('css/bootstrap.min.css',
'css/scielo-portal.css',
'css/style.css',
filters='cssmin', output='css/bundle.css')
assets.register('js_all', js)
assets.register('css_all', css)
assets.init_app(app)
# i18n
babel.init_app(app)
# Debug Toolbar
if app.config['DEBUG']:
# Toolbar
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
# Mongo
dbmongo.init_app(app)
# SQLAlchemy
dbsql.init_app(app)
# Emails
mail.init_app(app)
# Interface do admin
from .models import User, File, Image
# from .admin import views
from webapp.admin import views
admin = flask_admin.Admin(
app, 'OPAC admin',
index_view=views.AdminIndexView(),
template_mode='bootstrap3',
base_template="admin/opac_base.html")
admin.add_view(views.CollectionAdminView(Collection, category=lazy_gettext(u'Catálogo'), name=lazy_gettext(u'Coleção')))
admin.add_view(views.SponsorAdminView(Sponsor, category=lazy_gettext(u'Catálogo'), name=lazy_gettext(u'Financiador')))
admin.add_view(views.JournalAdminView(Journal, category=lazy_gettext(u'Catálogo'), name=lazy_gettext(u'Periódico')))
admin.add_view(views.IssueAdminView(Issue, category=lazy_gettext(u'Catálogo'), name=lazy_gettext(u'Fascículo')))
admin.add_view(views.ArticleAdminView(Article, category=lazy_gettext(u'Catálogo'), name=lazy_gettext(u'Artigo')))
admin.add_view(views.PressReleaseAdminView(PressRelease, category=lazy_gettext(u'Catálogo'), name=lazy_gettext(u'Press Release')))
admin.add_view(views.ResourceAdminView(Resource, category=lazy_gettext(u'Catálogo'), name=lazy_gettext(u'Recursos')))
admin.add_view(views.NewsAdminView(News, category=lazy_gettext(u'Notícias'), name=lazy_gettext(u'Notícias')))
admin.add_view(views.FileAdminView(File, dbsql.session, category=lazy_gettext(u'Ativos')))
admin.add_view(views.ImageAdminView(Image, dbsql.session, category=lazy_gettext(u'Ativos')))
admin.add_view(views.PagesAdminView(Pages, category=lazy_gettext(u'Ativos'), name=lazy_gettext(u'Páginas')))
admin.add_view(views.UserAdminView(User, dbsql.session, category=lazy_gettext(u'Gestão'), name=lazy_gettext(u'Usuário')))
from .main import main as main_bp
app.register_blueprint(main_bp)
app.wsgi_app = ProxyFix(app.wsgi_app)
return app
from flask_api_app.extensions import oauth
app = FlaskApiApp(__name__)
app.config['SECRET_KEY'] = '123456790'
# Create in-memory database
app.config['DATABASE_FILE'] = 'sample_db.sqlite'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + app.config['DATABASE_FILE']
app.config['SQLALCHEMY_ECHO'] = True
app.init_extensions()
db.init_app(app)
debug_toolbar = DebugToolbarExtension()
debug_toolbar.init_app(app)
@api.route('/sample1')
@oauth.require_oauth('email')
def handle_sample1():
return jsonify({'hello': 'world'})
app.register_core_blueprint(api=api, api_url_prefix='/api/v1.0')
def build_sample_db():
"""
Populate a small db with some example entries.
"""
app = Flask('weblab.core.server')
app.config['SECRET_KEY'] = os.urandom(32)
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
app.config['DEBUG'] = True
@app.route("/site-map")
def site_map():
lines = []
for rule in app.url_map.iter_rules():
line = str(escape(repr(rule)))
lines.append(line)
ret = "<br>".join(lines)
return ret
admin_app = AdministrationApplication(app, cfg_manager, ups, bypass_authz = True)
@admin_app.app.route('/')
def index():
return redirect('/weblab/admin')
initialize_i18n(app)
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
print("Open: http://localhost:5000/weblab/admin/")
app.run(debug=True, host='0.0.0.0')
app.config['SQLALCHEMY_RECORD_QUERIES'] = True
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
app.logger.addHandler(logging.StreamHandler(sys.stdout))
app.logger.setLevel(logging.INFO)
# logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)
admin_view = AdminView("Open Event")
admin_view.init(app)
admin_view.init_login(app)
return app, manager, db
@app.errorhandler(404)
def page_not_found(e):
if request_wants_json():
return json.dumps({"error": "endpoint_not_found"})
return render_template('404.html'), 404
# taken from http://flask.pocoo.org/snippets/45/
def request_wants_json():
best = request.accept_mimetypes.best_match(
['application/json', 'text/html'])
return best == 'application/json' and \
request.accept_mimetypes[best] > \
request.accept_mimetypes['text/html']
current_app, manager, database = create_app()
toolbar.init_app(current_app)
def __init__(self, server, cfg_manager):
core_server_url = cfg_manager.get_value( 'core_server_url', '' )
self.script_name = urlparse.urlparse(core_server_url).path.split('/weblab')[0] or ''
self.app = Flask('weblab.core.wl')
self.app.config['SECRET_KEY'] = os.urandom(32)
self.app.config['APPLICATION_ROOT'] = self.script_name
self.app.config['SESSION_COOKIE_PATH'] = self.script_name + '/weblab/'
self.app.config['SESSION_COOKIE_NAME'] = 'weblabsession'
# Initialize internationalization code.
initialize_i18n(self.app)
# Mostly for debugging purposes, this snippet will print the site-map so that we can check
# which methods we are routing.
@self.app.route("/site-map")
def site_map():
lines = []
for rule in self.app.url_map.iter_rules():
line = str(escape(repr(rule)))
lines.append(line)
ret = "<br>".join(lines)
return ret
flask_debug = cfg_manager.get_value('flask_debug', False)
core_facade_port = cfg_manager.get_value(configuration_doc.CORE_FACADE_PORT, 'unknown')
if flask_debug and not is_testing():
print("*" * 50, file=sys.stderr)
print("WARNING " * 5, file=sys.stderr)
print("flask_debug is set to True. This is an important security leak. Do not use it in production, only for bugfixing!!!", file=sys.stderr)
print("If you want to see the debug toolbar in Flask pages, also use http://localhost:{0}/weblab/".format(core_facade_port), file=sys.stderr)
print("WARNING " * 5, file=sys.stderr)
print("*" * 50, file=sys.stderr)
self.app.config['DEBUG'] = flask_debug
if os.path.exists('logs'):
f = os.path.join('logs','admin_app.log')
else:
f = 'admin_app.log'
file_handler = RotatingFileHandler(f, maxBytes = 50 * 1024 * 1024)
file_handler.setLevel(logging.WARNING)
self.app.logger.addHandler(file_handler)
super(WebLabFlaskServer, self).__init__(cfg_manager, self.app)
json_api = Blueprint('json', __name__)
weblab_api.apply_routes_api(json_api, server)
self.app.register_blueprint(json_api, url_prefix = '/weblab/json')
self.app.register_blueprint(json_api, url_prefix = '/weblab/login/json')
authn_web = Blueprint('login_web', __name__)
weblab_api.apply_routes_login_web(authn_web, server)
self.app.register_blueprint(authn_web, url_prefix = '/weblab/login/web')
static_folder = os.path.abspath(os.path.join(os.path.dirname(__file__), 'static'))
core_web = Blueprint('core_web', __name__, static_folder=static_folder)
weblab_api.apply_routes_web(core_web, server)
self.app.register_blueprint(core_web, url_prefix = '/weblab/web')
# Register the blueprint for the new (year 2015) flask-based web client.
# The .apply_routes_webclient method is dynamically generated, the name matches
# that in the wl.py module.
# Attempt at setting the right static folder.
core_webclient = Blueprint('core_webclient', __name__, static_folder=static_folder)
weblab_api.apply_routes_webclient(core_webclient, server)
self.app.register_blueprint(core_webclient, url_prefix = '/weblab/web/webclient')
@self.app.context_processor
def inject_weblab_api():
return dict(weblab_api=weblab_api)
self.admin_app = AdministrationApplication(self.app, cfg_manager, server)
if flask_debug:
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension()
toolbar.init_app(self.app)
self.app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
self.app.config['DEBUG_TB_PROFILER_ENABLED'] = True
