def setUp(self): app = Flask(__name__) app.debug = False app.config['CACHE_TYPE'] = 'simple' self.cache = Cache() self.cache.init_app(app) self.app = app
def configure_extensions(app): print ' [LOAD] PostgreSQL extension' app.db = PostgreSQL(app) print ' [LOAD] Cache extension' app.cache = Cache(app) print ' [LOAD] Authentication extension' app.auth = Auth(app) print ' [LOAD] Amazon S3 extension' app.s3 = S3Connection(app.config['AWS_ACCESS_KEY_ID'], app.config['AWS_SECRET_ACCESS_KEY'])
from flaskext.cache import Cache from flaskext.uploads import UploadSet, IMAGES, configure_uploads from blinker import Namespace import setting import sys app = Flask(__name__) app.config.from_object(setting) app.debug = True toolbar = DebugToolbarExtension(app) mail = Mail(app) babel = Babel(app) cache = Cache(app) #db = SQLAlchemy(app) principals = Principal(app) login_manager = LoginManager() login_manager.setup_app(app) userimage = UploadSet('userimage', IMAGES) configure_uploads(app, (userimage)) # setting # fix issue of unicode reload(sys) sys.setdefaultencoding("utf-8") # fix issue of forerign_keys problem for SQLite #db.session.execute('PRAGMA foreign_keys=ON;') class SQLiteForeignKeysListener(PoolListener):
class ProxyFixupHelper(object): def __init__(self, app): self.app = app def __call__(self, environ, start_response): # Only perform this fixup if the current remote host is localhost. if environ['REMOTE_ADDR'] == '127.0.0.1': host = environ.get('HTTP_X_REAL_IP', False) if host: environ['REMOTE_ADDR'] = host return self.app(environ, start_response) # Flask Extensions babel = Babel() cache = Cache() # SQL ORM Missive: # # Don't use models to automatically generate schemas. After iterating several # times with SQLAlchemy (and nearly every other ORM from frameworks both long # since dead and still trendy), to get a schema "just right" requires # entirely too much fiddling in the ORM. My hard earned lesson: SQL is the # right dialect to describe your database's structure (read: do not use an # ORM to generate DDL). Other than portability, what's the advantage of # describing your schema in SQLAlchemy? # # For as fantastic as SQLAlchemy is, using SQLAlchemy to generate schema is # the equivalent of giving yourself a lobotomy while in the middle of # attempting to write a Pulitzer Prize article. Why handicap yourself? Use # SQLAlchemy for what it excels at: generating efficient SQL based on
def create_app_ext(flask_config_file=None, flask_config_dict=None, moin_config_class=None, warn_default=True, **kwargs): """ Factory for moin wsgi apps @param flask_config_file: a flask config file name (may have a MOINCFG class), if not given, a config pointed to by MOINCFG env var will be loaded (if possible). @param flask_config_dict: a dict used to update flask config (applied after flask_config_file was loaded [if given]) @param moin_config_class: if you give this, it'll be instantiated as app.cfg, otherwise it'll use MOINCFG from flask config. If that also is not there, it'll use the DefaultConfig built into MoinMoin. @oaram warn_default: emit a warning if moin falls back to its builtin default config (maybe user forgot to specify MOINCFG?) @param **kwargs: if you give additional key/values here, they'll get patched into the moin configuration class (before it instance is created) """ clock = Clock() clock.start('create_app total') app = Flask('MoinMoin') clock.start('create_app load config') if flask_config_file: app.config.from_pyfile(flask_config_file) else: app.config.from_envvar('MOINCFG', silent=True) if flask_config_dict: app.config.update(flask_config_dict) Config = moin_config_class if not Config: Config = app.config.get('MOINCFG') if not Config: if warn_default: logging.warning("using builtin default configuration") from MoinMoin.config.default import DefaultConfig as Config for key, value in kwargs.iteritems(): setattr(Config, key, value) if Config.secrets is None: # reuse the secret configured for flask (which is required for sessions) Config.secrets = app.config.get('SECRET_KEY') app.cfg = Config() clock.stop('create_app load config') clock.start('create_app register') # register converters from werkzeug.routing import PathConverter app.url_map.converters['itemname'] = PathConverter # register modules, before/after request functions from MoinMoin.apps.frontend import frontend frontend.before_request(before_wiki) frontend.after_request(after_wiki) app.register_module(frontend) from MoinMoin.apps.admin import admin admin.before_request(before_wiki) admin.after_request(after_wiki) app.register_module(admin, url_prefix='/+admin') from MoinMoin.apps.feed import feed feed.before_request(before_wiki) feed.after_request(after_wiki) app.register_module(feed, url_prefix='/+feed') from MoinMoin.apps.misc import misc misc.before_request(before_wiki) misc.after_request(after_wiki) app.register_module(misc, url_prefix='/+misc') from MoinMoin.apps.serve import serve app.register_module(serve, url_prefix='/+serve') clock.stop('create_app register') clock.start('create_app flask-cache') cache = Cache() cache.init_app(app) app.cache = cache clock.stop('create_app flask-cache') # init storage clock.start('create_app init backends') app.unprotected_storage, app.storage = init_backends(app) clock.stop('create_app init backends') clock.start('create_app index rebuild') if app.cfg.index_rebuild: app.unprotected_storage.index_rebuild() # XXX run this from a script clock.stop('create_app index rebuild') clock.start('create_app load/save xml') import_export_xml(app) clock.stop('create_app load/save xml') clock.start('create_app flask-babel') i18n_init(app) clock.stop('create_app flask-babel') # configure templates clock.start('create_app flask-themes') setup_themes(app) if app.cfg.template_dirs: app.jinja_env.loader = ChoiceLoader([ FileSystemLoader(app.cfg.template_dirs), app.jinja_env.loader, ]) app.error_handlers[403] = themed_error clock.stop('create_app flask-themes') clock.stop('create_app total') del clock return app
def test_19_dict_config_both(self): cache = Cache(config={'CACHE_TYPE': 'null'}) cache.init_app(self.app, config={'CACHE_TYPE': 'simple'}) assert cache.config['CACHE_TYPE'] == 'simple'
def test_18_dict_config_initapp(self): cache = Cache() cache.init_app(self.app, config={'CACHE_TYPE': 'simple'}) assert cache.config['CACHE_TYPE'] == 'simple'
def test_17_dict_config(self): cache = Cache(config={'CACHE_TYPE': 'simple'}) cache.init_app(self.app) assert cache.config['CACHE_TYPE'] == 'simple'