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)