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 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 init_debug_toolbar(self):
if (not self.testing
and self.config.get('DEBUG_TB_ENABLED')
and 'debugtoolbar' not in self.blueprints):
try:
from flask_debugtoolbar import DebugToolbarExtension, DebugToolbar
except ImportError:
logger.warning('DEBUG_TB_ENABLED is on but flask_debugtoolbar '
'is not installed.')
else:
try:
default_config = DebugToolbar.config
init_dbt = DebugToolbarExtension
except AttributeError:
# debugtoolbar > 0.8.0
dbt = DebugToolbarExtension()
default_config = dbt._default_config(self)
init_dbt = dbt.init_app
if not 'DEBUG_TB_PANELS' in self.config:
# add our panels to default ones
self.config['DEBUG_TB_PANELS'] = list(default_config['DEBUG_TB_PANELS'])
self.config['DEBUG_TB_PANELS'].append(
'abilian.services.indexing.debug_toolbar.IndexedTermsDebugPanel'
)
init_dbt(self)
for view_name in self.view_functions:
if view_name.startswith('debugtoolbar.'):
extensions.csrf.exempt(self.view_functions[view_name])
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_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 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_debug_toolbar(app):
if not app.debug or app.testing:
return
try:
from flask_debugtoolbar import DebugToolbarExtension
except ImportError:
logger.warning("Running in debug mode but flask_debugtoolbar is not installed.")
return
dbt = DebugToolbarExtension()
default_config = dbt._default_config(app)
init_dbt = dbt.init_app
if "DEBUG_TB_PANELS" not in app.config:
# add our panels to default ones
app.config["DEBUG_TB_PANELS"] = list(default_config["DEBUG_TB_PANELS"])
init_dbt(app)
for view_name in app.view_functions:
if view_name.startswith("debugtoolbar."):
extensions.csrf.exempt(app.view_functions[view_name])
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
def server():
DebugToolbarExtension(app)
app.run(host=app.config.get("HOST"),
port=app.config.get("PORT"),
debug=True)
def create_app(test_config=None):
### TUYAUTERIE ###
# create and configure the app
# c'est la doc qui dit qu'il vaut mieux utiliser la forme split
app = Flask(__name__.split('.')[0], instance_relative_config=True)
app.config.from_mapping(
SECRET_KEY='dev',
TOOLBAR=os.environ.get('TOOLBAR'),
TITRE='Des Nombres Premiers à chaque mise à jour !',
DEBUG_TB_TEMPLATE_EDITOR_ENABLED=True,
#EXPLAIN_TEMPLATE_LOADING=True
)
if test_config is None:
# load the instance config, if it exists, when not testing
# contient essentiellement la "SECRET_KEY"
app.config.from_pyfile('config.py', silent=True)
else:
# load the test config if passed in
app.config.from_mapping(test_config)
# si la variable d'environnement "SECRET_KEY" existe alors c'est la bonne (bonne pratique docker)
if os.environ.get('SECRET_KEY'):
app.config.from_mapping(SECRET_KEY=os.environ['SECRET_KEY'], )
# autoescape sur .j2
from jinja2 import select_autoescape
app.jinja_env.autoescape = select_autoescape(default_for_string=True,
disabled_extensions=('txt', ),
default=True)
# ensure the instance folder exists
try:
os.makedirs(app.instance_path)
except OSError:
pass
# la toolbar
if app.config['TOOLBAR']:
from flask_debugtoolbar import DebugToolbarExtension
#toolbar = DebugToolbarExtension(app)
DebugToolbarExtension(app)
if app.debug: # lorsqu'il y a la toolbar, le logger n'envoie plus les debug
app.logger.propagate = True
@app.route('/robots.txt')
@app.route('/humans.txt')
@app.route('/favicon.ico')
@app.route('/sitemap.xml')
def static_from_root():
return send_from_directory(app.static_folder, request.path[1:])
# session côté serveur
redis = os.environ.get('REDIS') if os.environ.get('REDIS') else False
app.config.update(
SESSION_TYPE='redis' if redis else 'filesystem',
SESSION_COOKIE_HTTPONLY=True,
SESSION_COOKIE_SAMESITE='Lax',
#SESSION_COOKIE_SECURE=True, # impose HTTPS
SESSION_USE_SIGNER=True,
SESSION_FILE_DIR=os.path.join(app.instance_path, 'flask_session'),
PERMANENT_SESSION_LIFETIME=2 * 24 * 3600 + 3600 # 49 heures
)
if redis:
from redis import Redis
hp = redis.split(':')
h = hp[0]
p = 6379 if len(hp) == 1 else int(hp[1])
app.config['SESSION_REDIS'] = Redis(host=h, port=p)
Session(app)
# Markdown
from flaskext.markdown import Markdown
Markdown(app)
# sécuriser les FORM HTML
# from flask_wtf.csrf import CSRFProtect
# CSRFProtect(app)
### Mon appli ###
from primes import primes
app.register_blueprint(primes.bp)
app.add_url_rule('/', endpoint='homepage')
return app
def create_app(debug=None):
app = Flask(__name__)
# Configuration files
import critiquebrainz.default_config
app.config.from_object(critiquebrainz.default_config)
app.config.from_pyfile(os.path.join(
os.path.dirname(os.path.realpath(__file__)), "..", "config.py"),
silent=True)
if debug is not None:
app.debug = debug
# Error handling
from critiquebrainz.frontend.error_handlers import init_error_handlers
init_error_handlers(app)
# Logging
from critiquebrainz import loggers
loggers.init_loggers(app)
if app.debug:
# Debug toolbar
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
app.config['DEBUG_TB_TEMPLATE_EDITOR_ENABLED'] = True
from flask_uuid import FlaskUUID
FlaskUUID(app)
from critiquebrainz.data import db
db.init_app(app)
# Memcached
if 'MEMCACHED_SERVERS' in app.config:
from critiquebrainz import cache
cache.init(app.config['MEMCACHED_SERVERS'],
app.config['MEMCACHED_NAMESPACE'],
debug=1 if app.debug else 0)
import critiquebrainz.frontend.babel
babel.init_app(app)
import critiquebrainz.frontend.login
login.login_manager.init_app(app)
from critiquebrainz.frontend.login.provider import MusicBrainzAuthentication
login.mb_auth = MusicBrainzAuthentication(
name='musicbrainz',
client_id=app.config['MUSICBRAINZ_CLIENT_ID'],
client_secret=app.config['MUSICBRAINZ_CLIENT_SECRET'],
authorize_url="https://musicbrainz.org/oauth2/authorize",
access_token_url="https://musicbrainz.org/oauth2/token",
base_url="https://musicbrainz.org/")
# APIs
from critiquebrainz.frontend.external import mbspotify
mbspotify.init(app.config['MBSPOTIFY_BASE_URI'],
app.config['MBSPOTIFY_ACCESS_KEY'])
from critiquebrainz.frontend.external import musicbrainz
musicbrainz.init(app.config['MUSICBRAINZ_USERAGENT'],
critiquebrainz.__version__,
hostname=app.config['MUSICBRAINZ_HOSTNAME'])
# Template utilities
app.jinja_env.add_extension('jinja2.ext.do')
from critiquebrainz.utils import reformat_date, reformat_datetime, track_length
app.jinja_env.filters['date'] = reformat_date
app.jinja_env.filters['datetime'] = reformat_datetime
app.jinja_env.filters['track_length'] = track_length
app.jinja_env.filters['entity_details'] = musicbrainz.get_entity_by_id
app.jinja_env.filters['language_name'] = lambda language_code: Locale(
language_code).get_language_name(get_locale())
# Blueprints
from critiquebrainz.frontend.views.index import frontend_bp
from critiquebrainz.frontend.views.review import review_bp
from critiquebrainz.frontend.views.search import search_bp
from critiquebrainz.frontend.views.artist import artist_bp
from critiquebrainz.frontend.views.release_group import release_group_bp
from critiquebrainz.frontend.views.release import release_bp
from critiquebrainz.frontend.views.event import event_bp
from critiquebrainz.frontend.views.mapping import mapping_bp
from critiquebrainz.frontend.views.user import user_bp
from critiquebrainz.frontend.views.profile import profile_bp
from critiquebrainz.frontend.views.place import place_bp
from critiquebrainz.frontend.views.profile_apps import profile_apps_bp
from critiquebrainz.frontend.views.login import login_bp
from critiquebrainz.frontend.views.oauth import oauth_bp
from critiquebrainz.frontend.views.reports import reports_bp
from critiquebrainz.frontend.views.log import log_bp
app.register_blueprint(frontend_bp)
app.register_blueprint(review_bp, url_prefix='/review')
app.register_blueprint(search_bp, url_prefix='/search')
app.register_blueprint(artist_bp, url_prefix='/artist')
app.register_blueprint(release_group_bp, url_prefix='/release-group')
app.register_blueprint(release_bp, url_prefix='/release')
app.register_blueprint(event_bp, url_prefix='/event')
app.register_blueprint(place_bp, url_prefix='/place')
app.register_blueprint(mapping_bp, url_prefix='/mapping')
app.register_blueprint(user_bp, url_prefix='/user')
app.register_blueprint(profile_bp, url_prefix='/profile')
app.register_blueprint(profile_apps_bp, url_prefix='/profile/applications')
app.register_blueprint(login_bp, url_prefix='/login')
app.register_blueprint(oauth_bp, url_prefix='/oauth')
app.register_blueprint(reports_bp, url_prefix='/reports')
app.register_blueprint(log_bp, url_prefix='/log')
return app
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 init_ext(app):
db.init_app(app)
migrate.init_app(app, db)
DebugToolbarExtension(app)
cache.init_app(app)
import os
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_debugtoolbar import DebugToolbarExtension
from flask_cors import CORS
from flask_migrate import Migrate
from flask_bcrypt import Bcrypt
db = SQLAlchemy()
toolbar = DebugToolbarExtension()
migrate = Migrate()
bcrypt = Bcrypt()
def create_app(script_info=None):
app = Flask(__name__)
CORS(app)
# set configuration
app_settings = os.getenv('APP_SETTINGS')
app.config.from_object(app_settings)
db.init_app(app)
toolbar.init_app(app)
migrate.init_app(app, db)
bcrypt.init_app(app)
from project.api.users import users_blueprint
app.register_blueprint(users_blueprint)
from project.api.auth import auth_blueprint
app.register_blueprint(auth_blueprint)
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)
# Inintialize webpack support
webpack.init_app(app)
# Initialize Mail by Flask-Mail
mail.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 DebugToolbar
if app.config['DEBUG']:
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
# Initialize app blueprint
from .blueprints.app import app as app_blueprint
app.register_blueprint(app_blueprint, url_prefix='')
# Initialize CLI shell command
@app.shell_context_processor
def make_shell_context():
return dict(app=app, db=db)
# Initialize CLI command for Celery
@app.cli.command()
@click.argument('queue', nargs=1, default=PROJECT_NAME)
def celeryworker(queue):
sys.argv = [
'celery', 'worker', '-n {}@%h'.format(uuid.uuid4()), '-A',
'{}.celery_app:celery_application'.format(PROJECT_NAME), '-E',
'-Q', queue, '--loglevel=info'
]
sys.exit(celery_main())
@app.cli.command()
def celerybeat():
sys.argv = [
'celery', 'beat', '-A',
'{}.celery_app:celery_application'.format(PROJECT_NAME),
'--loglevel=info'
]
sys.exit(celery_main())
# 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 create_app(config=None): #pylint: disable=too-many-statements
'''
Create an instance of the app.
'''
app = Flask(__name__)
with open('/noi/app/config/config.yml', 'r') as config_file:
app.config.update(yaml.load(config_file))
app.config['CELERYBEAT_SCHEDULE'] = CELERYBEAT_SCHEDULE
if config is None:
try:
with open('/noi/app/config/local_config.yml', 'r') as config_file:
app.config.update(yaml.load(config_file))
except IOError:
app.logger.warn("No local_config.yml file")
else:
app.config.update(config)
# Confirming email is currently unsupported.
app.config['SECURITY_CONFIRMABLE'] = False
with open('/noi/app/data/deployments.yaml') as deployments_yaml:
deployments = yaml.load(deployments_yaml)
l10n.configure_app(app)
app.register_blueprint(views)
if app.config['DEBUG']:
app.register_blueprint(style_guide.views)
try:
from flask_debugtoolbar import DebugToolbarExtension
debug_toolbar = DebugToolbarExtension(app)
except:
app.logger.exception('Initialization of Flask-DebugToolbar '
'failed.')
if not app.config['DEBUG'] and app.config.get('ADMINS'):
email_errors.init_app(app)
cache.init_app(app)
csrf.init_app(app)
mail.init_app(app)
bcrypt.init_app(app)
s3.init_app(app)
#configure_uploads(app, (photos))
# Setup Flask-Security
user_datastore = DeploySQLAlchemyUserDatastore(db, User, Role)
security.init_app(app,
datastore=user_datastore,
login_form=NOILoginForm,
register_form=NOIRegisterForm,
forgot_password_form=NOIForgotPasswordForm,
reset_password_form=NOIResetPasswordForm,
change_password_form=NOIChangePasswordForm)
db.init_app(app)
alchemydumps.init_app(app, db)
#login_manager.init_app(app)
assets.init_app(app)
app.jinja_env.filters['slug'] = lambda x: slugify(x).lower()
noi_deploy = app.config['NOI_DEPLOY']
if noi_deploy == '_default':
app.logger.warn('No NOI_DEPLOY found in config, deploy-specific '
'attributes like the About page, custom domains and '
'logos will be missing.')
this_deployment = deployments.get(noi_deploy, deployments['_default'])
default_deployment = deployments['_default']
if 'locale' in this_deployment:
app.config['BABEL_DEFAULT_LOCALE'] = this_deployment['locale']
app.config['SEARCH_DEPLOYMENTS'] = this_deployment.get('searches',
[]) or []
app.config['SEARCH_DEPLOYMENTS'].append(noi_deploy)
babel.init_app(app)
l10n.init_app(app)
app.config['DOMAINS'] = this_deployment.get('domains',
default_deployment['domains'])
app.config['CONTACT_FORM_ID'] = this_deployment.get(
'contact_form_id', default_deployment['contact_form_id'])
# Constants that should be available for all templates.
global_config_json = {}
for exposed_var in EXPOSED_APP_CONFIG_VARS:
if exposed_var in app.config:
global_config_json[exposed_var] = app.config[exposed_var]
global_config_json = json.dumps(global_config_json)
app.jinja_env.globals['global_config_json'] = global_config_json
app.jinja_env.globals['get_locale'] = get_locale
app.jinja_env.globals['NOI_DEPLOY'] = noi_deploy
app.jinja_env.globals['ORG_TYPES'] = ORG_TYPES
app.jinja_env.globals['NOI_COLORS'] = NOI_COLORS
app.jinja_env.globals['LEVELS'] = LEVELS
app.jinja_env.globals['LEVELS_BY_SCORE'] = LEVELS_BY_SCORE
app.jinja_env.globals['QUESTIONS_BY_ID'] = QUESTIONS_BY_ID
app.jinja_env.globals['QUESTIONNAIRES_BY_ID'] = QUESTIONNAIRES_BY_ID
app.jinja_env.globals['ABOUT'] = this_deployment.get(
'about', default_deployment['about'])
if not app.config.get('MAIL_USERNAME') or not app.config.get(
'MAIL_PASSWORD'):
app.logger.warn('No MAIL_SERVER found in config, password reset will '
'not work.')
if not app.config.get('GA_TRACKING_CODE'):
app.logger.warn('No GA_TRACKING_CODE found in config, analytics will'
' not work.')
# Order questionnaires for deployments that want custom order.
questionnaire_order = this_deployment.get('questions',
default_deployment['questions'])
if questionnaire_order:
new_order = []
for topic in questionnaire_order:
if isinstance(topic, basestring):
q_id = topic
custom_description = None
else:
q_id = topic.keys()[0]
custom_description = topic[q_id].get('description')
try:
questionnaire = [q for q in QUESTIONNAIRES
if q['id'] == q_id][0]
if custom_description:
questionnaire['description'] = custom_description
new_order.append(questionnaire)
#new_order.append(filter(lambda q: q['id'] == q_id, QUESTIONNAIRES)[0])
except IndexError:
raise Exception(
'Cannot find questionairre ID "{}", aborting'.format(q_id))
app.jinja_env.globals['QUESTIONNAIRES'] = new_order
else:
app.jinja_env.globals['QUESTIONNAIRES'] = QUESTIONNAIRES
# Signals
@user_registered.connect_via(app)
def add_deployment_role(sender, **kwargs):
"""
Add role for this deployment whenever a new user registers.
"""
user = kwargs['user']
try:
role = Role.query.filter_by(name=sender.config['NOI_DEPLOY']).one()
except NoResultFound:
role = Role(name=sender.config['NOI_DEPLOY'])
db.session.add(role)
user.roles.append(role)
db.session.add(user)
db.session.commit()
sass.init_app(app)
csp.init_app(app)
return app
# Bcrypt
bcrypt = Bcrypt()
bcrypt.init_app(app)
# QRCode
qrcode = QRcode()
qrcode.init_app(app)
# Babel
domain = Domain(dirname='translations')
babel = Babel(default_domain=domain)
babel.init_app(app)
# Toolbar
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
# Flask-Assets
from .assets import bundles
assets = Environment(app)
assets.append_path(os.path.join(os.path.dirname(__file__), './static'))
assets.append_path(
os.path.join(os.path.dirname(__file__), './static/bower_components'))
assets.register(bundles)
# Flask-Admin
admin = Admin(app,
name='Interface Admin',
index_view=StatisticsView(url='/admin', name='Vue générale'))
admin.add_view(CompanyView(get_db().companies, name='Entreprises'))
def init_app(cls, app):
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension(app) # noqa: F841
def __init__(self, init_object_name):
"""Constructor for the CortexFlask application. Reads the config, sets
up logging, configures Jinja and Flask."""
# Call the superclass (Flask) constructor
super(CortexFlask, self).__init__(init_object_name)
# CSRF exemption support
self._exempt_views = set()
self.before_request(self._csrf_protect)
# CSRF token function in templates
self.jinja_env.globals['csrf_token'] = self._generate_csrf_token
# Load the __init__.py config defaults
self.config.from_object("cortex.defaultcfg")
# Load system config file
self.config.from_pyfile('/data/cortex/cortex.conf')
# Set up logging to file
if self.config['FILE_LOG'] == True:
file_handler = RotatingFileHandler(self.config['LOG_DIR'] + '/' + self.config['LOG_FILE'], 'a', self.config['LOG_FILE_MAX_SIZE'], self.config['LOG_FILE_MAX_FILES'])
file_handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)s: %(message)s'))
self.logger.addHandler(file_handler)
# Set up the max log level
if self.debug:
self.logger.setLevel(logging.DEBUG)
file_handler.setLevel(logging.DEBUG)
else:
self.logger.setLevel(logging.INFO)
file_handler.setLevel(logging.INFO)
# Output some startup info
self.logger.info('cortex version ' + self.config['VERSION'] + ' initialised')
self.logger.info('cortex debug status: ' + str(self.config['DEBUG']))
# set up e-mail alert logging
if self.config['EMAIL_ALERTS'] == True:
# Log to file where e-mail alerts are going to
self.logger.info('cortex e-mail alerts are enabled and being sent to: ' + str(self.config['ADMINS']))
# Create the mail handler
mail_handler = SMTPHandler(self.config['SMTP_SERVER'], self.config['EMAIL_FROM'], self.config['ADMINS'], self.config['EMAIL_SUBJECT'])
# Set the minimum log level (errors) and set a formatter
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(Formatter("""
A fatal error occured in Cortex.
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Logger Name: %(name)s
Process ID: %(process)d
Further Details:
%(message)s
"""))
self.logger.addHandler(mail_handler)
# Debug Toolbar
if self.config['DEBUG_TOOLBAR']:
self.debug = True
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension(self)
self.logger.info('cortex debug toolbar enabled - DO NOT USE THIS ON LIVE SYSTEMS!')
# check the database is up and is working
self.init_database()
# set up permissions
self.init_permissions()
def make_flask_stack(conf, **app_conf):
""" This has to pass the flask app through all the same middleware that
Pylons used """
root = os.path.dirname(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
debug = asbool(app_conf.get('debug', app_conf.get('DEBUG', False)))
testing = asbool(app_conf.get('testing', app_conf.get('TESTING', False)))
app = flask_app = CKANFlask(__name__)
app.debug = debug
app.testing = testing
app.template_folder = os.path.join(root, 'templates')
app.app_ctx_globals_class = CKAN_AppCtxGlobals
app.url_rule_class = CKAN_Rule
# Update Flask config with the CKAN values. We use the common config
# object as values might have been modified on `load_environment`
if config:
app.config.update(config)
else:
app.config.update(conf)
app.config.update(app_conf)
# Do all the Flask-specific stuff before adding other middlewares
# Secret key needed for flask-debug-toolbar and sessions
if not app.config.get('SECRET_KEY'):
app.config['SECRET_KEY'] = config.get('beaker.session.secret')
if not app.config.get('SECRET_KEY'):
raise RuntimeError(u'You must provide a value for the secret key'
' with the SECRET_KEY config option')
if debug:
from flask_debugtoolbar import DebugToolbarExtension
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
DebugToolbarExtension(app)
# Use Beaker as the Flask session interface
class BeakerSessionInterface(SessionInterface):
def open_session(self, app, request):
if 'beaker.session' in request.environ:
return request.environ['beaker.session']
def save_session(self, app, session, response):
session.save()
namespace = 'beaker.session.'
session_opts = dict([(k.replace('beaker.', ''), v)
for k, v in config.iteritems()
if k.startswith(namespace)])
if (not session_opts.get('session.data_dir')
and session_opts.get('session.type', 'file') == 'file'):
cache_dir = app_conf.get('cache_dir') or app_conf.get('cache.dir')
session_opts['session.data_dir'] = '{data_dir}/sessions'.format(
data_dir=cache_dir)
app.wsgi_app = SessionMiddleware(app.wsgi_app, session_opts)
app.session_interface = BeakerSessionInterface()
# Add Jinja2 extensions and filters
extensions = [
'jinja2.ext.do', 'jinja2.ext.with_', jinja_extensions.SnippetExtension,
jinja_extensions.CkanExtend,
jinja_extensions.CkanInternationalizationExtension,
jinja_extensions.LinkForExtension, jinja_extensions.ResourceExtension,
jinja_extensions.UrlForStaticExtension,
jinja_extensions.UrlForExtension
]
for extension in extensions:
app.jinja_env.add_extension(extension)
app.jinja_env.filters['empty_and_escape'] = \
jinja_extensions.empty_and_escape
# Common handlers for all requests
app.before_request(ckan_before_request)
app.after_request(ckan_after_request)
# Template context processors
app.context_processor(helper_functions)
app.context_processor(c_object)
@app.route('/hello', methods=['GET'])
def hello_world():
return 'Hello World, this is served by Flask'
@app.route('/hello', methods=['POST'])
def hello_world_post():
return 'Hello World, this was posted to Flask'
# Auto-register all blueprints defined in the `views` folder
_register_core_blueprints(app)
# Set up each IBlueprint extension as a Flask Blueprint
for plugin in PluginImplementations(IBlueprint):
if hasattr(plugin, 'get_blueprint'):
app.register_extension_blueprint(plugin.get_blueprint())
# Start other middleware
for plugin in PluginImplementations(IMiddleware):
app = plugin.make_middleware(app, config)
# Fanstatic
if debug:
fanstatic_config = {
'versioning': True,
'recompute_hashes': True,
'minified': False,
'bottom': True,
'bundle': False,
}
else:
fanstatic_config = {
'versioning': True,
'recompute_hashes': False,
'minified': True,
'bottom': True,
'bundle': True,
}
app = Fanstatic(app, **fanstatic_config)
for plugin in PluginImplementations(IMiddleware):
try:
app = plugin.make_error_log_middleware(app, config)
except AttributeError:
log.critical('Middleware class {0} is missing the method'
'make_error_log_middleware.'.format(
plugin.__class__.__name__))
# Update the main CKAN config object with the Flask specific keys
# that were set here or autogenerated
flask_config_keys = set(flask_app.config.keys()) - set(config.keys())
for key in flask_config_keys:
config[key] = flask_app.config[key]
# Add a reference to the actual Flask app so it's easier to access
app._wsgi_app = flask_app
return app
# CSRFProtect
csrf.init_app(application)
# DB manager
db = SQLAlchemy(application)
# Email
mail = Mail(application)
# user login
login_manager = LoginManager()
login_manager.init_app(application)
login_manager.login_view = 'home.login'
# debuging
dtb = DebugToolbarExtension(application)
# logger
logger = logging.getLogger('application')
########## Scheduler ##########
jobstores = {
# 'mongo': MongoDBJobStore(),
'default': SQLAlchemyJobStore(url=application.config['SQLALCHEMY_DATABASE_URI'])
}
executors = {
'default': ThreadPoolExecutor(20),
'processpool': ProcessPoolExecutor(5)
}
job_defaults = {
def create_app(cfg_file='prod-config.yaml', testing=False, debug=False):
usage = "usage: %prog"
description = "Anella app"
version = "%anella 0.1"
output.OUTPUT.info("Initialising...")
opt_parser = optparse.OptionParser(usage=usage,
version=version,
description=description)
opt_parser.add_option(
"-c",
"--cfg",
metavar="FILE",
action="store",
type="string",
help="specify the full path to an alternate config FILE",
dest="cfg_file",
default=cfg_file)
opt_parser.add_option("--debug",
action="store_true",
help="Debug mode",
dest="debug",
default=debug)
(options, args) = opt_parser.parse_args()
load_config(configfile=options.cfg_file, )
app = Flask('anella', static_url_path='', static_folder='public')
app.config['HOST'] = get_cfg('app__host')
app.config['PORT'] = get_cfg('app__port')
app.config['MONGODB_SETTINGS'] = {
'db': get_cfg('database__database_name'),
'host': get_cfg('database__host'),
'port': get_cfg('database__port'),
}
# PyMongo
app.config['MONGO_DBNAME'] = get_cfg('database__database_name')
app.config['MONGO_HOST'] = get_cfg('database__host')
app.config['MONGO_PORT'] = get_cfg('database__port')
# MongoEngine
app.config['MONGODB_DATABASE'] = get_cfg('database__database_name')
app.config['MONGODB_HOST'] = get_cfg('database__host')
app.config['MONGODB_PORT'] = get_cfg('database__port')
app.config['TESTING'] = True
app.config['SECRET_KEY'] = 'flask+mongoengine=<3'
app.config['SESSION_COOKIE_NAME'] = 'anella'
if options.debug:
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
app.debug = True
app.config['DEBUG_TB_PANELS'] = (
'flask.ext.debugtoolbar.panels.versions.VersionDebugPanel',
'flask.ext.debugtoolbar.panels.timer.TimerDebugPanel',
'flask.ext.debugtoolbar.panels.headers.HeaderDebugPanel',
'flask.ext.debugtoolbar.panels.request_vars.RequestVarsDebugPanel',
'flask.ext.debugtoolbar.panels.template.TemplateDebugPanel',
'flask.ext.debugtoolbar.panels.logger.LoggingPanel',
'flask.ext.mongoengine.panels.MongoDebugPanel')
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
# app.config['RESTFUL_JSON']=dict(cls=MongoengineEncoder)
LOGGER.info(pformat(app.config))
mongo = PyMongo(app)
# db = MongoEngine(app)
# Is this necessary?
conn = connect(get_cfg('database__database_name'),
host=get_cfg('database__host'),
port=get_cfg('database__port'))
LOGGER.info(pformat(conn))
add_rules(app)
api = Api(app)
add_resources(api)
app.session_interface = MongoSessionInterface(
db=app.config['MONGO_DBNAME'],
host=app.config['MONGO_HOST'],
port=app.config['MONGO_PORT'])
# db = MongoEngine(app)
# set_db(db)
if testing:
app.config['TESTING'] = True
return app
@app.route('/')
def index():
'''Index. User can read instructions here for the game'''
return render_template('index.html')
@app.route('/play.json')
def play():
'''Get word ready to diplaying'''
level = request.args.get('level')
print('FORNT END LEVEL:', level)
print(type(level)) #str
word = gen_random_word.random_word(int(level))
data_dict = {'word': word}
return jsonify(data_dict)
####################### RUNNING MY SERVER ###############################
if __name__ == "__main__":
app.debug = True # We have to set debug=True here, since it has to be True at the point that we invoke the DebugToolbarExtension
DebugToolbarExtension(app) # Use the DebugToolbar
app.run(host="0.0.0.0")
from flask import Flask, render_template, request, redirect, flash, jsonify
from flask_debugtoolbar import DebugToolbarExtension
from random import randint, choice, sample
app = Flask(__name__)
app.config['SECRET_KEY'] = 'oh-so-secret' #sessions?
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
debug = DebugToolbarExtension(app) #only works when you use render
MOVIES = {'Jurassic Park', 'Aladdin', 'Weener Dog Movie'}
@app.route('/old-home-page')
def redirect_to_home():
"""redirect to new home"""
return redirect('/') # use redirect
@app.route('/')
def home_page():
return render_template('home.html')
@app.route('/movies')
def show_all_movies():
"""Show list of all movies in a fake DB"""
return render_template('movies.html', movies=MOVIES)
@app.route('/movies/new', methods=['POST'])
def add_movie():
def make_flask_stack(conf, **app_conf):
""" This has to pass the flask app through all the same middleware that
Pylons used """
root = os.path.dirname(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
debug = asbool(conf.get('debug', conf.get('DEBUG', False)))
testing = asbool(app_conf.get('testing', app_conf.get('TESTING', False)))
app = flask_app = CKANFlask(__name__)
app.debug = debug
app.testing = testing
app.template_folder = os.path.join(root, 'templates')
app.app_ctx_globals_class = CKAN_AppCtxGlobals
app.url_rule_class = CKAN_Rule
app.jinja_options = jinja_extensions.get_jinja_env_options()
# Update Flask config with the CKAN values. We use the common config
# object as values might have been modified on `load_environment`
if config:
app.config.update(config)
else:
app.config.update(conf)
app.config.update(app_conf)
# Do all the Flask-specific stuff before adding other middlewares
# Secret key needed for flask-debug-toolbar and sessions
if not app.config.get('SECRET_KEY'):
app.config['SECRET_KEY'] = config.get('beaker.session.secret')
if not app.config.get('SECRET_KEY'):
raise RuntimeError(u'You must provide a value for the secret key'
' with the SECRET_KEY config option')
if debug:
from flask_debugtoolbar import DebugToolbarExtension
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
DebugToolbarExtension(app)
from werkzeug.debug import DebuggedApplication
app = DebuggedApplication(app, True)
app = app.app
log = logging.getLogger('werkzeug')
log.setLevel(logging.DEBUG)
# Use Beaker as the Flask session interface
class BeakerSessionInterface(SessionInterface):
def open_session(self, app, request):
if 'beaker.session' in request.environ:
return request.environ['beaker.session']
def save_session(self, app, session, response):
session.save()
namespace = 'beaker.session.'
session_opts = dict([(k.replace('beaker.', ''), v)
for k, v in config.iteritems()
if k.startswith(namespace)])
if (not session_opts.get('session.data_dir') and
session_opts.get('session.type', 'file') == 'file'):
cache_dir = app_conf.get('cache_dir') or app_conf.get('cache.dir')
session_opts['session.data_dir'] = '{data_dir}/sessions'.format(
data_dir=cache_dir)
app.wsgi_app = SessionMiddleware(app.wsgi_app, session_opts)
app.session_interface = BeakerSessionInterface()
# Add Jinja2 extensions and filters
app.jinja_env.filters['empty_and_escape'] = \
jinja_extensions.empty_and_escape
# Common handlers for all requests
app.before_request(ckan_before_request)
app.after_request(ckan_after_request)
# Template context processors
app.context_processor(helper_functions)
app.context_processor(c_object)
@app.context_processor
def ungettext_alias():
u'''
Provide `ungettext` as an alias of `ngettext` for backwards
compatibility
'''
return dict(ungettext=ungettext)
# Babel
pairs = [(os.path.join(root, u'i18n'), 'ckan')] + [
(p.i18n_directory(), p.i18n_domain())
for p in PluginImplementations(ITranslation)
]
i18n_dirs, i18n_domains = zip(*pairs)
app.config[u'BABEL_TRANSLATION_DIRECTORIES'] = ';'.join(i18n_dirs)
app.config[u'BABEL_DOMAIN'] = 'ckan'
app.config[u'BABEL_MULTIPLE_DOMAINS'] = ';'.join(i18n_domains)
babel = CKANBabel(app)
babel.localeselector(get_locale)
@app.route('/hello', methods=['GET'])
def hello_world():
return 'Hello World, this is served by Flask'
@app.route('/hello', methods=['POST'])
def hello_world_post():
return 'Hello World, this was posted to Flask'
# Auto-register all blueprints defined in the `views` folder
_register_core_blueprints(app)
_register_error_handler(app)
# Set up each IBlueprint extension as a Flask Blueprint
for plugin in PluginImplementations(IBlueprint):
if hasattr(plugin, 'get_blueprint'):
plugin_blueprints = plugin.get_blueprint()
if not isinstance(plugin_blueprints, list):
plugin_blueprints = [plugin_blueprints]
for blueprint in plugin_blueprints:
app.register_extension_blueprint(blueprint)
lib_plugins.register_package_blueprints(app)
lib_plugins.register_group_blueprints(app)
# Set flask routes in named_routes
for rule in app.url_map.iter_rules():
if '.' not in rule.endpoint:
continue
controller, action = rule.endpoint.split('.')
needed = list(rule.arguments - set(rule.defaults or {}))
route = {
rule.endpoint: {
'action': action,
'controller': controller,
'highlight_actions': action,
'needed': needed
}
}
config['routes.named_routes'].update(route)
# Start other middleware
for plugin in PluginImplementations(IMiddleware):
app = plugin.make_middleware(app, config)
# Fanstatic
fanstatic_enable_rollup = asbool(app_conf.get('fanstatic_enable_rollup',
False))
if debug:
fanstatic_config = {
'versioning': True,
'recompute_hashes': True,
'minified': False,
'bottom': True,
'bundle': False,
'rollup': fanstatic_enable_rollup,
}
else:
fanstatic_config = {
'versioning': True,
'recompute_hashes': False,
'minified': True,
'bottom': True,
'bundle': True,
'rollup': fanstatic_enable_rollup,
}
root_path = config.get('ckan.root_path', None)
if root_path:
root_path = re.sub('/{{LANG}}', '', root_path)
fanstatic_config['base_url'] = root_path
app = Fanstatic(app, **fanstatic_config)
for plugin in PluginImplementations(IMiddleware):
try:
app = plugin.make_error_log_middleware(app, config)
except AttributeError:
log.critical('Middleware class {0} is missing the method'
'make_error_log_middleware.'
.format(plugin.__class__.__name__))
# Initialize repoze.who
who_parser = WhoConfig(conf['here'])
who_parser.parse(open(app_conf['who.config_file']))
app = PluggableAuthenticationMiddleware(
app,
who_parser.identifiers,
who_parser.authenticators,
who_parser.challengers,
who_parser.mdproviders,
who_parser.request_classifier,
who_parser.challenge_decider,
logging.getLogger('repoze.who'),
logging.WARN, # ignored
who_parser.remote_user_key
)
# Update the main CKAN config object with the Flask specific keys
# that were set here or autogenerated
flask_config_keys = set(flask_app.config.keys()) - set(config.keys())
for key in flask_config_keys:
config[key] = flask_app.config[key]
# Add a reference to the actual Flask app so it's easier to access
app._wsgi_app = flask_app
return app
server.config[
"SQLALCHEMY_TRACK_MODIFICATIONS"] = SQLALCHEMY_TRACK_MODIFICATIONS
CORS(server,
resources={r"/*": {
"origins": "*"
}},
headers=["Content-Type", "X-Requested-With", "Authorization"])
db.init_app(server)
db.app = server
for blueprint in vars(routes).values():
if isinstance(blueprint, Blueprint):
server.register_blueprint(blueprint, url_prefix=APPLICATION_ROOT)
server.secret_key = "development key"
DebugToolbarExtension(server)
DebugAPIExtension(server)
# Append Browse API Panel to Flask-DebugToolbar defaults
# (or add explicitly)
config = server.config
config["DEBUG_API_PREFIX"] = "/my-cellar"
panels = list(config["DEBUG_TB_PANELS"])
panels.append("flask_debug_api.BrowseAPIPanel")
config["DEBUG_TB_PANELS"] = panels
@server.route("/")
def index():
return "<html><body></body></html>"
from .auth import load_user
from .cli import register_cli
from .services import db, migrate, login_manager
from .views import register_blueprints
try:
# Dev dependencies
from flask_debugtoolbar import DebugToolbarExtension
except ImportError:
DebugToolbarExtension = None
env_name = os.environ.get("FLASK_ENV", "development")
app = Flask(__name__)
app.config.from_object(f"postfix_mail_admin.config.{env_name.title()}Config")
db.init_app(app)
migrate.init_app(app)
login_manager.init_app(app)
if app.debug:
if DebugToolbarExtension is not None:
debug_toolbar = DebugToolbarExtension()
debug_toolbar.init_app(app)
login_manager.user_loader(load_user)
register_blueprints(app)
register_cli(app)
from flask import Flask, request, render_template
from flask_debugtoolbar import DebugToolbarExtension
from stories import Story, story, story_2
app = Flask(__name__)
app.config['SECRET_KEY'] = "secret-secret"
debug = DebugToolbarExtension(app)
@app.route('/')
def go_home():
"""Return to homepage"""
return render_template("home.html")
@app.route('/story-form-1')
def go_form_1():
"""Navigate to story 1 entry form"""
return render_template("story-1-form.html")
@app.route('/story-1')
def get_story_1():
"""Display madlib story"""
choices = {
"place": request.args["place"],
"adjective": request.args["adjective"],
"noun": request.args["noun"],
"verb": request.args["verb"],
"plural_noun": request.args["plural_noun"]
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')
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 __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
# -*-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(config):
'''创建应用实例'''
env_cfg = get_config()
template_folder = env_cfg.get('template_folder', None)
static_folder = env_cfg.get('static_folder', None)
static_url_prefix = env_cfg.get('static_url_prefix', None)
app = Flask(__name__,
template_folder=template_folder,
static_folder=static_folder,
static_url_path=static_url_prefix)
# Flask内部选项配置
app.config['SECRET_KEY'] = config.get('secret', '!secret!')
app.debug = config.get('debug', False) # app.config['DEBUG']
app.config['JSON_AS_ASCII'] = False
if config.get('debugtoolbar', False):
# 分析器
app.config['DEBUG_TB_PROFILER_ENABLED'] = True
# 启用模板编辑
app.config['DEBUG_TB_TEMPLATE_EDITOR_ENABLED'] = True
# 禁用 拦截重定向
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
toolbar = DebugToolbarExtension(app)
# 路径前缀
if app.debug and bool(config.get('url_prefix', None)):
app.wsgi_app = PrefixMiddleware(app.wsgi_app,
prefix=config['url_prefix'])
# 配置数据库
db_cfg = env_cfg['db_config']
# 数据库类型
db_type = db_cfg['type']
db_cfg.pop('type')
db_kwargs = config.get('db_kwargs', {})
engine = get_engine(db_type, user_config=db_cfg, **db_kwargs)
# Flask-SQLAlchemy配置
app.config['SQLALCHEMY_DATABASE_URI'] = engine.url
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# 关联Flask-SQLAlchemy到当前app
db.init_app(app)
app.db = db
with app.app_context():
db.create_all()
# cdn 配置
app.config['CDN_LIST'] = env_cfg.get('cdn_list', {})
app.config['USE_CDN'] = config.get('use_cdn', False)
# 对路由规则增加正则支持
app.url_map.converters['regex'] = RegexConverter
# HTTP异常处理
app.handle_http_exception = get_http_exception_handler(app)
# 加载CDN配置
app = with_cdn_setting(app)
# 加载自定义模板过滤器
app = with_template_filters(app)
# 设置应用钩子
app = with_request_hook(app)
# 设置应用路由(顶级)
app = with_top_level_routes(app)
# 注册蓝图(子应用)
for item in blueprints:
app.register_blueprint(item[1], url_prefix=item[0])
# WSGI代理支持
app.wsgi_app = ProxyFix(app.wsgi_app, num_proxies=1)
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
def _enable_debug_toolbar():
"""Enable flask debug toolbar for benchmarking requests."""
if getattr(settings, "FLASK_DEBUGTOOLBAR", False):
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
def create_app(config=None):
app = Flask(__name__)
# read .envs and configuration class
app = read_env(app, config)
app.secret_key = app.config.get('SECRET_KEY')
# define logging patterns
import logging # %(pathname)
if app.config.get("TESTING"):
log_format = ("[%(asctime)s] %(funcName)s:%(lineno)d "
"%(levelname)s - %(message)s")
log_level = logging.DEBUG
else:
log_format = ("[%(asctime)s] {%(filename)s#%(funcName)s:%(lineno)d} "
"%(levelname)s - %(message)s")
log_level = logging.INFO
formatter = logging.Formatter(log_format)
handler = logging.StreamHandler()
handler.setLevel(log_level)
handler.setFormatter(formatter)
app.logger.addHandler(handler)
app.logger.setLevel(log_level)
# remove default Flask debug handler
del app.logger.handlers[0]
# setup apps
from flask_debugtoolbar import DebugToolbarExtension
from flask_mongoengine import MongoEngine
from flask_bcrypt import Bcrypt
from flask_rq2 import RQ
from flask_restful import Api
from flask_login import LoginManager
DebugToolbarExtension(app)
MongoEngine(app)
Bcrypt(app)
RQ(app)
api = Api(app)
login_manager = LoginManager(app)
# register view blueprints
from project.home.views import app_blueprint
from project.admin.views import admin_blueprint
from project.user.views import user_blueprint
app.register_blueprint(app_blueprint)
app.register_blueprint(admin_blueprint)
app.register_blueprint(user_blueprint)
# register api endpoints
from .api import Resources, API_VERSION
for resource, url in Resources:
_endpoint = ".".join(API_VERSION.format(url).split("/")[1:-1])
api.add_resource(resource, API_VERSION.format(url), endpoint=_endpoint)
# import custom login manager functions
from project.home.login_manager import load_user_from_request, load_user
login_manager.login_view = "user.login"
login_manager.user_loader(load_user)
login_manager.request_loader(load_user_from_request)
# jinja extensions
app.jinja_env.add_extension('jinja2.ext.do')
# default flashed messages category
login_manager.login_message_category = 'info'
login_manager.needs_refresh_message_category = 'info'
return app
def init_app(app):
from flask_debugtoolbar import DebugToolbarExtension
app.debug = True
app.logger.addHandler(fileHandler)
DebugToolbarExtension(app)
from flask_api_app.database import db
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.
city_name = request.args.get('city_name')
session.pop(
city_name) # Remove the key with the city name from the session
return redirect('/')
@app.route('/favorites.json')
def get_favorites():
"""Get the list of favorite cities to determine if the favorite box should be checked"""
fav_cities = {}
for city in session:
fav_cities[city] = session[city]
return (jsonify({'favorites': fav_cities}))
if __name__ == '__main__':
# connect to your database before app.run gets called. If you don’t do this,
# Flask won’t be able to access your database!
connect_to_db(app)
app.run(host='0.0.0.0')
app.debug = True # Set debug mode to True before enabling the toolbar
DebugToolbarExtension(app) # Enable the DebugToolbar
from flask.ext.migrate import Migrate, MigrateCommand
from flask.ext.script import Manager
from flask import render_template
from flask import request
from icalendar import Calendar, Event
from flask_debugtoolbar import DebugToolbarExtension
import open_event.models.event_listeners
from open_event.models import db
from open_event.views.admin.admin import AdminView
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
app = Flask(__name__)
toolbar = DebugToolbarExtension(app)
def create_app():
auto = Autodoc(app)
cal = Calendar()
event = Event()
from open_event.views.views import app as routes
app.register_blueprint(routes)
migrate = Migrate(app, db)
db.init_app(app)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
environ['HTTP_HOST'] = x_forwarded_host
return self.app(environ, start_response)
app = Flask(__name__)
app.wsgi_app = ReverseProxied(app.wsgi_app)
app.config.from_pyfile('../settings.cfg')
# set database config
dbdir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'data'))
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(
dbdir, 'app.db')
db = SQLAlchemy(app)
# debug toolbar
debug_toolbar = DebugToolbarExtension(app)
# set user auth config
lm = LoginManager()
lm.init_app(app)
lm.login_view = 'views/main.login'
# initializing connection to GRQ's Elasticsearch
grq_es = ElasticsearchUtility(app.config['ES_URL'], app.logger)
# initializing connection to Mozart's Elasticsearch
mozart_es = ElasticsearchUtility(app.config['MOZART_ES_URL'], app.logger)
# views blueprints
from tosca.views.main import mod as viewsModule
app.register_blueprint(viewsModule)
def create_app():
app = Flask(__name__,\
static_folder="static/",\
template_folder="templates/",\
static_url_path="/static")
set_config(app)
# set up extensions
cache.init_app(app)
db.init_app(app)
datepicker(app)
mail.init_app(app)
# blueprints
app.register_blueprint(auth)
app.register_blueprint(admin_blueprint)
app.register_blueprint(charts_blueprint)
app.register_blueprint(debug_blueprint)
app.register_blueprint(webapi)
app.register_blueprint(monitor_blueprint)
# form csrf
csrf.init_app(app)
# login_manager
login_manager = LoginManager()
login_manager.login_view = 'charts.now'
login_manager.init_app(app)
from .models import User
@login_manager.user_loader
def load_user(user_id):
# since the user_id is just the primary key of our user table, use it in the query for the user
return User.query.get(int(user_id))
# Scss
assets = Environment(app)
assets.versions = 'timestamp'
assets.url_expire = True
assets.manifest = 'file:/tmp/manifest.to-be-deployed' # explict filename
assets.cache = False
assets.auto_build = True
assets.url = app.static_url_path
scss = Bundle('scss/__main__.scss',
filters='pyscss',
output='css/main.css',
depends=['scss/*.scss'])
assets.register('scss_all', scss)
assets.debug = False
app.config['ASSETS_DEBUG'] = False
with app.app_context():
init_db_admin_config()
toolbar = DebugToolbarExtension(app)
return (app)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
'DATABASE_URL', 'postgresql:///gastronaut').replace(
'postgres://', 'postgresql://', 1)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# Dev / Production setup differentiation:
#
# if development server enable debugging and load local keys.
if not os.environ.get('SECRET_KEY'):
from flask_debugtoolbar import DebugToolbarExtension
from development_local.local_settings import SECRET_KEY
app.config["SECRET_KEY"] = SECRET_KEY
app.config['SQLALCHEMY_ECHO'] = True
app.config["DEBUG_TB_INTERCEPT_REDIRECTS"] = False
DEBUG = DebugToolbarExtension(app)
logging.basicConfig(filename='gastronaut.log', level=logging.WARNING,
format='%(levelname)s:%(asctime)s:%(message)s')
# if production server enable sentry and load environ variables.
else:
sentry_init(
dsn="https://[email protected]/5319947", # NOQA E 501
integrations=[FlaskIntegration(), SqlalchemyIntegration()]
)
app.config["SECRET_KEY"] = os.environ.get('SECRET_KEY')
DEBUG = False
connect_db(app)
