def make_env(app): # environment-based configuration loading env = Environments(app, var_name="BEAVY_ENV") env.from_yaml(os.path.join(BASE_DIR, 'config.yml')) # env.from_yaml(os.path.join(os.getcwd(), 'config.yml')) with open(os.path.join(os.getcwd(), 'config.yml'), "r") as r: deepmerge(app.config, yaml.load(r)) # allow for environment variables to update items if os.environ.get("BEAVY_CONFIG_FROM_ENV", False): app.config.update(os.environ) if "DATABASE_URL" in os.environ: app.config["SQLALCHEMY_DATABASE_URI"] = os.environ["DATABASE_URL"] if "RABBITMQ_URL" in os.environ: app.config["CELERY_BROKER_URL"] = os.environ["RABBITMQ_URL"] if "REDIS_URL" in os.environ: app.config["RATELIMIT_STORAGE_URL"] = os.environ["REDIS_URL"] app.config["CACHE_REDIS_URL"] = os.environ["REDIS_URL"] # update social buttons _FLBLPRE = "flask_social_blueprint.providers.{}" if "SOCIAL_BLUEPRINT" not in app.config: app.config["SOCIAL_BLUEPRINT"] = dict([ ("." in name and name or _FLBLPRE.format(name), values) for name, values in app.config.get("SOCIAL_LOGINS").items() ]) return env
def create_app(package_name, package_path, settings_override=None, settings='settings.yaml'): """ Create a L{flask.Flask} application with common configuration applied. @param package_name: application package name. @param package_path: package path to search for blueprints. @param settings: the settings per environment in YAML. @param settings_override: a dictionary of settings to override. @return: the Flask application; never C{None}. """ app = Flask(package_name, instance_relative_config=True) env = Environments(app) env.from_yaml(os.path.join(os.getcwd(), '', settings)) app.config.from_object(settings_override) logging.basicConfig(level=logging.DEBUG) register_blueprints(app, package_name, package_path) return app
def make_env(app): # environment-based configuration loading env = Environments(app, var_name="BEAVY_ENV") env.from_yaml(os.path.join(BASE_DIR, 'config.yml')) # env.from_yaml(os.path.join(os.getcwd(), 'config.yml')) with open(os.path.join(os.getcwd(), 'config.yml'), "r") as r: deepmerge(app.config, yaml.load(r)) # allow for environment variables to update items if os.environ.get("BEAVY_CONFIG_FROM_ENV", False): app.config.update(os.environ) if "DATABASE_URL" in os.environ: app.config["SQLALCHEMY_DATABASE_URI"] = os.environ["DATABASE_URL"] if "RABBITMQ_URL" in os.environ: app.config["CELERY_BROKER_URL"] = os.environ["RABBITMQ_URL"] if "REDIS_URL" in os.environ: app.config["RATELIMIT_STORAGE_URL"] = os.environ["REDIS_URL"] app.config["CACHE_REDIS_URL"] = os.environ["REDIS_URL"] # update social buttons _FLBLPRE = "flask_social_blueprint.providers.{}" if "SOCIAL_BLUEPRINT" not in app.config: app.config["SOCIAL_BLUEPRINT"] = dict([ ("." in name and name or _FLBLPRE.format(name), values) for name, values in app.config.get("SOCIAL_LOGINS").items()]) return env
def create_app(config_name): app = Flask(__name__) env = Environments(app, default_env=config_name) env.from_yaml(os.path.join(basedir, 'config.yml')) celery.conf.update(BROKER_URL=app.config['REDIS_URL'], CELERY_RESULT_BACKEND=app.config['REDIS_URL']) #Adding logging capabilities. if app.config['LOGGING'] == True: import logging logger = logging.getLogger('replicate') logger.setLevel(logging.DEBUG) log_directory = basedir + app.config['LOG_FILE_PTAH'] log_filename = log_directory + app.config['LOG_FILE'] if not os.path.exists(os.path.dirname(log_filename)): os.makedirs(os.path.dirname(log_filename)) file_handler = logging.FileHandler(log_filename, mode='a+') stream_handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s - %(process)d - %(name)s - %(module)s:%(lineno)d - %(levelname)s - %(message)s' ) file_handler.setFormatter(formatter) stream_handler.setFormatter(formatter) app.logger.addHandler(file_handler) #app.logger.addHandler(stream_handler) app.logger.setLevel(logging.DEBUG) app.logger.info('Application Process Started') #SSL if not app.debug and not app.testing and app.config['SSL_DISABLE']: from flask.ext.sslify import SSLify sslify = SSLify(app) # handle proxy server headers from werkzeug.contrib.fixers import ProxyFix app.wsgi_app = ProxyFix(app.wsgi_app) db.init_app(app) login_manager.init_app(app) cache.init_app(app) csrf.init_app(app) redis_store.init_app(app) from ooiservices.app.main import api as main_blueprint app.register_blueprint(main_blueprint) from ooiservices.app.uframe import uframe as uframe_blueprint app.register_blueprint(uframe_blueprint, url_prefix='/uframe') from ooiservices.app.redmine import redmine as redmine_blueprint app.register_blueprint(redmine_blueprint, url_prefix='/redmine') return app
def create_app(): """Return a Flask app configured for the correct env (test, dev, prod).""" app = Flask(__name__) env = Environments(app) env.from_yaml(os.path.join(os.getcwd(), 'config.yaml')) api = Api(app) api.add_resource(PlayerListResource, '/players') api.add_resource(PlayerResource, '/players/<string:name>') api.add_resource(GameListResource, '/games') api.add_resource(ChallengeListResource, '/challenges') db.init_app(app) return app
def create_app(config_name): app = Flask(__name__) env = Environments(app, default_env=config_name) app.config.from_object(env.from_yaml('config.yml')) certfile = app.config['OAUTH_CERTIFICATE_PATH'] with open(certfile, 'r') as contents: key_contents = contents.read() key = RSA.importKey(key_contents) app.oauth_certificate = key.publickey().exportKey() bootstrap.init_app(app) db.init_app(app) mail.init_app(app) if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify sslify = SSLify(app) @app.errorhandler(InvalidUsage) def handle_invalid_usage(error): response = jsonify(error.to_dict()) response.status_code = error.status_code return response from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') from .api_1_0 import api as api_1_0_blueprint app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0') return app
def make_env(app): # environment-based configuration loading env = Environments(app, var_name="BEAVY_ENV") env.from_yaml(os.path.join(BASE_DIR, 'config.yml')) env.from_yaml(os.path.join(os.getcwd(), 'config.yml')) # update social buttons _FLBLPRE = "flask_social_blueprint.providers.{}" if not "SOCIAL_BLUEPRINT" in app.config: app.config["SOCIAL_BLUEPRINT"] = dict([ ("." in name and name or _FLBLPRE.format(name), values) for name, values in app.config.get("SOCIAL_LOGINS").items() ]) return env
def create_app(config_name): app = Flask(__name__) env = Environments(app, default_env=config_name) app.config.from_object(env.from_yaml('config.yml')) certfile = app.config['OAUTH_CERTIFICATE_PATH'] with open(certfile, 'r') as fd: kt = fd.read() key = RSA.importKey(kt) app.oauth_certificate = key.publickey().exportKey() bootstrap.init_app(app) db.init_app(app) mail.init_app(app) if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify sslify = SSLify(app) @app.errorhandler(InvalidUsage) def handle_invalid_usage(error): response = jsonify(error.to_dict()) response.status_code = error.status_code return response from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') from .api_1_0 import api as api_1_0_blueprint app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0') return app
def make_env(app): # environment-based configuration loading env = Environments(app, var_name="BEAVY_ENV") env.from_yaml(os.path.join(BASE_DIR, 'config.yml')) # env.from_yaml(os.path.join(os.getcwd(), 'config.yml')) with open(os.path.join(os.getcwd(), 'config.yml'), "r") as r: deepmerge(app.config, yaml.load(r)) # update social buttons _FLBLPRE = "flask_social_blueprint.providers.{}" if "SOCIAL_BLUEPRINT" not in app.config: app.config["SOCIAL_BLUEPRINT"] = dict([ ("." in name and name or _FLBLPRE.format(name), values) for name, values in app.config.get("SOCIAL_LOGINS").items()]) return env
def __init__(self): super(Main, self).__init__( __name__, static_url_path='/res', static_folder='../webapp/resources', template_folder='templates') # Runtime environment (e.g., export FLASK_ENV=PRODUCTION) # https://pythonhosted.org/Flask-Environments env = Environments(self) env.from_yaml(os.path.join(os.getcwd(), 'config/config.yml')) # Config logging. # https://docs.python.org/2/howto/logging.html logging.config.dictConfig(yaml.load(open(self.config['LOG_CONFIG']))) # Jinja2 templates. # http://jinja.pocoo.org/docs/dev/api # http://flask.pocoo.org/docs/0.10/api/#flask.Flask.jinja_options self.jinja_options = flask.Flask.jinja_options.copy() self.jinja_options.update(dict( trim_blocks=True, lstrip_blocks=True )) # http://pythonhosted.org/Flask-Session # http://flask.pocoo.org/docs/0.10/quickstart/#sessions self.session = Session(self) # Enable injection within this class. # https://github.com/alecthomas/injector injector = Injector() injector.install_into(self) # Flask injection. # NOTE: Order of modules is important. LOG.info('### %s ###' % self.config['ENVIORNMENT']) FlaskInjector(app=self, injector=injector, modules=[ ConfigModule, OAuthConfigModule, TwitterModule, ViewModule, OAuthRouterModule ])
class FlaskEnvironmentsTestCase(unittest.TestCase): DEFAULT_ENV = None VAR_NAME = None DATABASE_VALUE = 'development_db' def setUp(self): self.app = Flask(__name__) self.environments = Environments(self.app, var_name=self.VAR_NAME, default_env=self.DEFAULT_ENV) def test_from_object(self): self.environments.from_object('tests.config') self.assertEqual(self.app.config['DATABASE'], self.DATABASE_VALUE) def test_from_yaml(self): path = os.path.join(os.getcwd(), 'tests', 'config.yml') self.environments.from_yaml(path) self.assertEqual(self.app.config['DATABASE'], self.DATABASE_VALUE)
def create_app(package_name, package_path, settings_override=None, settings='settings.yaml'): """ Create a L{flask.Flask} application with common configuration applied. @param package_name: application package name. @param settings_override: a dictionary of settings to override. @return: the Flask application; never C{None}. """ app = Flask(package_name, instance_relative_config=True) env = Environments(app) env.from_yaml(os.path.join(os.getcwd(), '', settings)) app.config.from_object(settings_override) logging.basicConfig(level=logging.DEBUG) register_blueprints(app, package_name, package_path) register_injection_modules(app, package_name, package_path, settings_override=settings_override) return app
from flask import Flask from flask.ext.mongokit import MongoKit from flask.ext.login import LoginManager from flask.ext.mail import Mail from flask_environments import Environments # Create application object app = Flask(__name__) env = Environments(app) env.from_yaml('config.yml') # Create logging if app.config.get('LOG_FILE') == True: import logging from logging import FileHandler file_handler = FileHandler('log.txt') file_handler.setLevel(logging.INFO) app.logger.addHandler(file_handler) # Create the database connection db = MongoKit(app) # Create the Redis connection import redis from rq import Queue redis_connection = redis.from_url(app.config.get("REDIS_URL")) queue = Queue('default', connection=redis_connection, default_timeout=600) from rq_scheduler import Scheduler scheduler = Scheduler(queue_name="default", connection=redis_connection)
from flask_injector import FlaskInjector import os from config import ConfigModule from view import ViewModule import service.twitter # # Flask App. # app = flask.Flask(__name__, template_folder='templates') # Runtime environment (FLASK_ENV) # https://pythonhosted.org/Flask-Environments env = Environments(app) env.from_yaml(os.path.join(os.getcwd(), 'config/config.yml')) # Flask injection modules. # https://github.com/alecthomas/injector FlaskInjector(app=app, modules=[ ConfigModule, ViewModule, service.twitter.ServiceModule ]) # # Start-up. # if __name__ == '__main__': app.run(host='0.0.0.0', port=app.config['PORT'])
def create_app(config_name): app = Flask(__name__) env = Environments(app, default_env=config_name) if os.path.exists(os.path.join(basedir, "config_local.yml")): env.from_yaml(os.path.join(basedir, "config_local.yml")) else: env.from_yaml(os.path.join(basedir, "config.yml")) # Uses REDIS_URL from config.yml to set the connection to the redis-server cache.config = {"CACHE_TYPE": "redis", "CACHE_REDIS_URL": app.config["REDIS_URL"]} # Adding logging capabilities. if app.config["LOGGING"] is True: import logging logger = logging.getLogger("replicate") logger.setLevel(logging.DEBUG) log_directory = basedir + app.config["LOG_FILE_PTAH"] log_filename = log_directory + app.config["LOG_FILE"] if not os.path.exists(os.path.dirname(log_filename)): os.makedirs(os.path.dirname(log_filename)) file_handler = logging.FileHandler(log_filename, mode="a+") stream_handler = logging.StreamHandler() formatter = logging.Formatter( "%(asctime)s - %(process)d - %(name)s - " + "%(module)s:%(lineno)d - %(levelname)s - %(message)s" ) file_handler.setFormatter(formatter) stream_handler.setFormatter(formatter) app.logger.addHandler(file_handler) # app.logger.addHandler(stream_handler) app.logger.setLevel(logging.DEBUG) app.logger.info("Application Process Started") # SSL if not app.debug and not app.testing and app.config["SSL_DISABLE"]: from flask.ext.sslify import SSLify sslify = SSLify(app) # handle proxy server headers from werkzeug.contrib.fixers import ProxyFix app.wsgi_app = ProxyFix(app.wsgi_app) db.init_app(app) login_manager.init_app(app) cache.init_app(app) csrf.init_app(app) redis_store.init_app(app) cors.init_app(app) # Flask-Security Init from ooiservices.app.models import User, Role user_datastore = SQLAlchemyUserDatastore(db, User, Role) security = Security(app, user_datastore) from ooiservices.app.main import api as main_blueprint app.register_blueprint(main_blueprint) from ooiservices.app.uframe import uframe as uframe_blueprint app.register_blueprint(uframe_blueprint, url_prefix="/uframe") from ooiservices.app.redmine import redmine as redmine_blueprint app.register_blueprint(redmine_blueprint, url_prefix="/redmine") from ooiservices.app.alfresco import alfresco as alfresco_blueprint app.register_blueprint(alfresco_blueprint, url_prefix="/alfresco") from ooiservices.app.m2m import m2m as m2m_blueprint app.register_blueprint(m2m_blueprint, url_prefix="/m2m") # If debug is enabled add route for site-map if app.config["DEBUG"]: app.add_url_rule("/site-map", "site_map", site_map) return app
#!/usr/bin/env python ''' ooiui.core.app.science Defines the application for the Science UI ''' import os from flask import Flask from flask.ext.cache import Cache from flask_environments import Environments app = Flask(__name__, static_url_path='', template_folder='../../templates', static_folder='../../static') env = Environments(app, default_env='DEVELOPMENT') basedir = 'ooiui/config' if os.path.exists(os.path.join(basedir, 'config_local.yml')): env.from_yaml(os.path.join(basedir, 'config_local.yml')) else: env.from_yaml(os.path.join(basedir, 'config.yml')) cache = Cache(app, config={'CACHE_TYPE': app.config['CACHE_TYPE']})
app The application context ''' from celery import Celery from celery.schedules import crontab from flask import Flask, url_for, jsonify from flask_environments import Environments import os celery = Celery('__main__') app = Flask(__name__, static_folder='web/static') env = Environments(app, default_env='DEVELOPMENT') env.from_yaml('config.yml') # Override config file with local version if os.path.exists('config.local.yml'): env.from_yaml('config.local.yml') celery.conf.update(broker_url=app.config['REDIS_URL'], result_backend=app.config['REDIS_URL']) TaskBase = celery.Task class ContextTask(TaskBase): abstract = True def __call__(self, *args, **kwargs): with app.app_context():
# Version 1.0.0-alpha6 import os import sys from flask import Flask, jsonify from flask_environments import Environments from flask_sqlalchemy import SQLAlchemy from flask_marshmallow import Marshmallow from flask_caching import Cache from flask_cors import cross_origin from oauth2client.service_account import ServiceAccountCredentials # instantiate the application app = Flask(__name__) env = Environments(app) env.from_yaml(os.path.join(os.getcwd(), 'conf/main.yml')) db = SQLAlchemy(app) ma = Marshmallow(app) # setup caching cache = Cache(app, config={ 'CACHE_TYPE': app.config['CACHE']['TYPE'], 'CACHE_DIR': os.path.join(os.getcwd(), app.config['CACHE']['DIRECTORY']) }) @app.errorhandler(404) @cross_origin()
from flask import Flask from flask.ext import admin from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.security import Security, SQLAlchemyUserDatastore from flask_environments import Environments import flask_admin app = Flask(__name__) env = Environments(app) ROOT = os.path.dirname(__file__) CONFIG_YAML = 'config.yaml' if os.path.exists(op.join(ROOT, 'config.yaml')): env.from_yaml(op.join(ROOT, 'config.yaml')) if hasattr(app.config, 'DEBUG_TOOLBAR') and app.config['DEBUG_TOOLBAR']: from flask_debugtoolbar import DebugToolbarExtension toolbar = DebugToolbarExtension(app) db = SQLAlchemy(app) # Custom login. @app.route('/login', methods=['GET', 'POST']) def login(): """Must be defined upper setup flask-security.""" from budgetfamily.auth.views import flask_login return flask_login()
""" Mail reader and pase images linkg generate database and download images """ import os from flask import Flask from flask.ext.cors import CORS from flask_environments import Environments from flask.ext.pymongo import PyMongo app = Flask(__name__) app.name = 'Mailer' env = Environments(app) config_file = os.path.join(os.path.abspath('./app'), 'config', 'config.yml') secrets_file = os.path.join(os.path.abspath('./app'), 'config', 'secrets.yml') env.from_yaml(config_file) env.from_yaml(secrets_file) mongo = PyMongo(app) CORS(app) app.jinja_env.line_statement_prefix = '%' from app import routers
# Copyright 2014 MongoDB, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os from flask import Flask from flask_environments import Environments from pymongo import MongoClient app = Flask(__name__) env = Environments(app) env.from_yaml(os.path.join(os.path.abspath(os.path.join('..', os.path.dirname(__file__))), '..', 'config.yaml')) mongodb = MongoClient(app.config['MONGO_HOST'], app.config['MONGO_PORT']) db = mongodb[app.config['MONGO_DBNAME']]
import os from flask import Flask, jsonify from flask_sqlalchemy import SQLAlchemy from flask_environments import Environments from flask.ext.bootstrap import Bootstrap from jinja2 import Environment, PackageLoader # init flask app app = Flask(__name__) # init db con db = SQLAlchemy(app) # configure flask env = Environments(app) env.from_yaml(os.path.join(os.getcwd(), 'flaskapi', 'config', 'config.yml')) # configure jinja env = Environment(loader=PackageLoader('flaskapi', 'templates')) env.filters['jsonify'] = jsonify # bootstrap bootstrap = Bootstrap(app) # TODO: configure per environment logging # app module imports import models.asset import controllers.api import controllers.errors
#!/usr/bin/env python ''' ooiui.core.app.science Defines the application for the Science UI ''' from flask import Flask from flask.ext.cache import Cache from flask_environments import Environments app = Flask(__name__, static_url_path='', template_folder='../../templates', static_folder='../../static') env = Environments(app, default_env='DEVELOPMENT') env.from_yaml('ooiui/config/config.yml') cache = Cache(app, config={'CACHE_TYPE': app.config['CACHE_TYPE']})
Copyright 2015 RPS ASA See LICENSE.txt ''' from flask import Flask from flask_environments import Environments from flask.ext.sqlalchemy import SQLAlchemy from flask_restful import Api from cbibs_api.reverse_proxy import ReverseProxied import os app = Flask(__name__) app.wsgi_app = ReverseProxied(app.wsgi_app) env = Environments(app) env.from_yaml('config.yml') if os.path.exists('config.local.yml'): env.from_yaml('config.local.yml') if app.config['LOGGING'] == True: import logging logger = logging.getLogger('pyprojects.app') logger.setLevel(logging.DEBUG) log_directory = app.config['LOG_FILE_PATH'] log_filename = os.path.join(log_directory,app.config['LOG_FILE']) if not os.path.exists(os.path.dirname(log_filename)): os.makedirs(os.path.dirname(log_filename)) file_handler = logging.FileHandler(log_filename, mode='a+') stream_handler = logging.StreamHandler()
# Copyright 2014 MongoDB, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os from flask import Flask from flask_environments import Environments from pymongo import MongoClient app = Flask(__name__) env = Environments(app) env.from_yaml( os.path.join( os.path.abspath(os.path.join('..', os.path.dirname(__file__))), '..', 'config.yaml')) mongodb = MongoClient(app.config['MONGO_HOST'], app.config['MONGO_PORT']) db = mongodb[app.config['MONGO_DBNAME']]
def create_app(config_name): app = Flask(__name__) env = Environments(app, default_env=config_name) if os.path.exists(os.path.join(basedir, 'config_local.yml')): env.from_yaml(os.path.join(basedir, 'config_local.yml')) else: env.from_yaml(os.path.join(basedir, 'config.yml')) celery.conf.update(BROKER_URL=app.config['REDIS_URL'], CELERY_RESULT_BACKEND=app.config['REDIS_URL']) #Adding logging capabilities. if app.config['LOGGING'] == True: import logging logger = logging.getLogger('replicate') logger.setLevel(logging.DEBUG) log_directory = basedir + app.config['LOG_FILE_PTAH'] log_filename = log_directory + app.config['LOG_FILE'] if not os.path.exists(os.path.dirname(log_filename)): os.makedirs(os.path.dirname(log_filename)) file_handler = logging.FileHandler(log_filename, mode='a+') stream_handler = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s - %(process)d - %(name)s - %(module)s:%(lineno)d - %(levelname)s - %(message)s') file_handler.setFormatter(formatter) stream_handler.setFormatter(formatter) app.logger.addHandler(file_handler) #app.logger.addHandler(stream_handler) app.logger.setLevel(logging.DEBUG) app.logger.info('Application Process Started') #SSL if not app.debug and not app.testing and app.config['SSL_DISABLE']: from flask.ext.sslify import SSLify sslify = SSLify(app) # handle proxy server headers from werkzeug.contrib.fixers import ProxyFix app.wsgi_app = ProxyFix(app.wsgi_app) db.init_app(app) login_manager.init_app(app) cache.init_app(app) csrf.init_app(app) redis_store.init_app(app) cors.init_app(app) from ooiservices.app.main import api as main_blueprint app.register_blueprint(main_blueprint) from ooiservices.app.uframe import uframe as uframe_blueprint app.register_blueprint(uframe_blueprint, url_prefix='/uframe') from ooiservices.app.redmine import redmine as redmine_blueprint app.register_blueprint(redmine_blueprint, url_prefix='/redmine') # If debug is enabled add route for site-map if app.config['DEBUG']: app.add_url_rule('/site-map', 'site_map', site_map) return app