def create_app(): """创建Flask app""" app = Flask(__name__) cache = Cache(app, config={'CACHE_TYPE': 'simple'}) cache.init_app(app) # Load config config = load_config() app.config.from_object(config) # CSRF protect csrf.init_app(app) # 注册组件 register_db(app) register_routes(app) register_jinja(app) register_error_handle(app) register_logger(app) register_uploadsets(app) # before every request @app.before_request def before_request(): """Do something before request""" # 记录用户的访问时间到redis g.user = get_current_user() if g.user: set_user_active_time(g.user.id) g.msg_num = MailBox.query.filter(MailBox.recver_id == g.user.id, MailBox.result == None).count() from .utils.devices import Devices devices = Devices(app) return app
def create_app(): global cache app = Flask(__name__, static_folder="../dist/static", template_folder="../dist") cache = Cache(config={'CACHE_TYPE': 'simple'}) cache.init_app(app) CORS(app, resources={r"/api/*": {"origins": "*"}}) return app
def assertCacheInitedWithoutError(self, cache_type_value): config = { 'CACHE_TYPE': cache_type_value, 'CACHE_NO_NULL_WARNING': True, } cache = Cache() try: cache.init_app(self.app, config=config) except: self.fail("Can't set CACHE_TYPE to %s" % cache_type_value)
def test_21_redis_url_custom_db(self): config = { 'CACHE_TYPE': 'redis', 'CACHE_REDIS_URL': 'redis://localhost:6379/2', } cache = Cache() cache.init_app(self.app, config=config) rconn = self.app.extensions['cache'][cache] \ ._client.connection_pool.get_connection('foo') assert rconn.db == 2
def test_21_redis_url_custom_db(self): config = { 'CACHE_TYPE': 'redis', 'CACHE_REDIS_URL': 'redis://localhost:6379/2', } cache = Cache() cache.init_app(self.app, config=config) rconn = self.app.extensions['cache'][cache] \ ._client.connection_pool.get_connection('foo') assert rconn.db == 2
def create_app(): app = Flask(__name__) cache = Cache(app,config={'CACHE_TYPE': 'simple'}) cache.init_app(app) app.debug = True app.register_blueprint(api) db = CassandraDBConnector() return app
def clear_cache(): if (not pqr.debug): return "You're not supposed to be here o_0" global cache cache.clear() cache = Cache(config={'CACHE_TYPE': 'null'}) cache.init_app(pqr) print cache.config print pqr.debug flash('Cache cleared') return redirect(url_for('molecule', key=MOLECULE_OF_THE_WEEK))
def test_20_redis_url_default_db(self): config = { 'CACHE_TYPE': 'redis', 'CACHE_REDIS_URL': 'redis://localhost:6379', } cache = Cache() cache.init_app(self.app, config=config) from werkzeug.contrib.cache import RedisCache assert isinstance(self.app.extensions['cache'][cache], RedisCache) rconn = self.app.extensions['cache'][cache] \ ._client.connection_pool.get_connection('foo') assert rconn.db == 0
def test_20_redis_url_default_db(self): config = { 'CACHE_TYPE': 'redis', 'CACHE_REDIS_URL': 'redis://localhost:6379', } cache = Cache() cache.init_app(self.app, config=config) from werkzeug.contrib.cache import RedisCache assert isinstance(self.app.extensions['cache'][cache], RedisCache) rconn = self.app.extensions['cache'][cache] \ ._client.connection_pool.get_connection('foo') assert rconn.db == 0
def create_app(name=None): app = Flask(name) if os.environ.get('PRODUCTION'): app.config.from_object(ProductionConfig) print "running with ProductionConfig" else: app.config.from_object(DefaultConfig) print "running with DefaultConfig" # sentry if app.config.get('SENTRY_DSN'): sentry = Sentry() sentry.init_app(app) app.sentry = sentry # assets assets = Environment(app) assets.url = app.static_url_path scss_bundle = Bundle('css/*.scss', 'css/*.css', filters=['scss', 'cssmin'], depends='css/*.scss', output='css/all.css') assets.register('scss_all', scss_bundle) js_bundle = Bundle('js/*.js', filters='rjsmin', output='js/all.js') assets.register('js_all', js_bundle) Compress(app) # cache if app.config['DEBUG']: cache_type = 'null' else: cache_type = 'simple' cache = Cache(config={'CACHE_TYPE': cache_type}) cache.init_app(app) app.cache = cache # CDN cdn = CDN() cdn.init_app(app) # workaround flask-assets / flask-cdn integration if app.config.get('CDN_HTTPS'): cdn_scheme = 'https' else: cdn_scheme = 'http' if app.config.get('FLASK_ASSETS_USE_CDN') and app.config.get('CDN_DOMAIN'): app.jinja_env.globals['FLASK_CDN'] = '%s://%s' % (cdn_scheme, app.config['CDN_DOMAIN']) return app
def create_app(): """创建Flask app""" app = Flask(__name__) cache = Cache(app,config={'CACHE_TYPE': 'simple'}) cache.init_app(app) # Load config config = load_config() app.config.from_object(config) # CSRF protect csrf.init_app(app) # if app.debug: # DebugToolbarExtension(app) # from .mails import mail # mail.init_app(app) # 注册组件 register_db(app) register_routes(app) register_jinja(app) register_error_handle(app) register_logger(app) register_uploadsets(app) # load chinese name dict from dict.txt once # from utils.account import CheckName # # # 加载dict.txt # CheckName(app) # before every request @app.before_request def before_request(): """Do something before request""" # 记录用户的访问时间到redis g.user = get_current_user() if g.user: set_user_active_time(g.user.id) from .utils.devices import Devices devices = Devices(app) return app
def compile_cam_images(): try: with current_app.test_request_context(): print "[+] Starting cam images cache reset..." cache = Cache(config={'CACHE_TYPE': 'redis', 'CACHE_REDIS_DB': 0}) cache.init_app(current_app) cam_images = _compile_cam_images() if "error" not in cam_images: cache.set('cam_images', cam_images, timeout=CACHE_TIMEOUT) print "[+] cam images cache reset." else: print "[-] Error in cache update" except Exception as err: message = 'compile_cam_images exception: %s' % err.message current_app.logger.warning(message)
def compile_large_format_files(): try: with current_app.test_request_context(): print "[+] Starting large format file cache reset..." cache = Cache(config={'CACHE_TYPE': 'redis', 'CACHE_REDIS_DB': 0}) cache.init_app(current_app) data = _compile_large_format_files() if "error" not in data: cache.set('large_format', data, timeout=CACHE_TIMEOUT) print "[+] large format files updated." else: print "[-] Error in large file format update" except Exception as err: message = 'compile_large_format_files exception: %s' % err.message current_app.logger.warning(message)
def compile_assets(): try: print '\n debug - *** tasks - compile_assets()' with current_app.test_request_context(): print "[+] Starting asset cache reset..." cache = Cache(config={'CACHE_TYPE': 'redis', 'CACHE_REDIS_DB': 0}) cache.init_app(current_app) url = current_app.config['UFRAME_ASSETS_URL'] + '/%s' % ('assets') payload = requests.get(url) if payload.status_code is 200: # Cache assets_list data = payload.json() assets, asset_rds = _compile_assets(data) if "error" not in assets: cache.set('asset_list', assets, timeout=CACHE_TIMEOUT) print "[+] Asset list cache reset" # Cache assets_dict (based on success of _compile_assets returning assets) assets_dict = get_assets_dict_from_list(assets) if not assets_dict: message = 'Warning: get_assets_dict_from_list returned empty assets_dict.' print '\n debug -- message: ', message current_app.logger.info(message) if isinstance(assets_dict, dict): cache.set('assets_dict', assets_dict, timeout=CACHE_TIMEOUT) print "[+] Assets dictionary cache reset" else: print "[-] Error in Assets dictionary cache update" else: print "[-] Error in asset_list and asset_dict cache update" # Cache assets_rd if asset_rds: cache.set('asset_rds', asset_rds, timeout=CACHE_TIMEOUT) print "[+] Asset reference designators cache reset..." else: print "[-] Error in asset_rds cache update" else: print "[-] Error in cache update" except Exception as err: message = 'compile_assets exception: %s' % err.message current_app.logger.warning(message) raise Exception(message)
class CachedStore(SessionStore): def __init__(self, app, session_cache_config=None, app_cache_config=None): SessionStore.__init__(self) # check if app cache config exists, otherwise use the same as cache_config if app_cache_config and not session_cache_config: self._app_cache_client = Cache(config=app_cache_config) self._session_cache_client = Cache(config=app_cache_config) elif app_cache_config and session_cache_config: self._app_cache_client = Cache(config=app_cache_config) self._session_cache_client = Cache(config=session_cache_config) elif not app_cache_config and session_cache_config: self._app_cache_client = Cache(config=session_cache_config) self._session_cache_client = Cache(config=session_cache_config) else: self._app_cache_client = self._session_cache_client = Cache() self._app_cache_client.init_app(app) #self._session_cache_client.init_app(app) # now set the app config to contain the cache app.config['_session_cache'] = self._session_cache_client app.config['_app_cache'] = self._app_cache_client def save(self, session): key = self._get_memcache_key(session.sid) data = json.dumps(dict(session)) print "{0}:{1}".format(key, data) self._cache_client.set(key, data) def delete(self, session): key = self._get_memcache_key(session.sid) self._memcache_client.delete(key) def get(self, sid): key = self._get_memcache_key(sid) data = self._memcache_client.get(key) if data is not None: session = json.loads(data) else: session = {} return self.session_class(session, sid, False) def _get_memcache_key(self, sid): if isinstance(sid, unicode): sid = sid.encode('utf-8') return sid
def compile_glider_tracks(): try: with current_app.test_request_context(): print "[+] Starting glider tracks cache reset..." cache = Cache(config={'CACHE_TYPE': 'redis', 'CACHE_REDIS_DB': 0}) cache.init_app(current_app) glider_tracks = _compile_glider_tracks(True) if "error" not in glider_tracks: cache.set('glider_tracks', glider_tracks, timeout=CACHE_TIMEOUT) print "[+] Glider tracks cache reset." else: print "[-] Error in cache update" except Exception as err: message = 'compile_glider_tracks exception: %s' % err.message current_app.logger.warning(message)
def run(): """Runs the flask app using the config.ini found in the working dir.""" import webcronmon import webcronmon.config config = webcronmon.active_config = webcronmon.config.load() webcronmon.app.debug = config.app.debug cache = Cache(config=config.cache.as_dictionary) cache.init_app(webcronmon.app) import webcronmon.api webcronmon.api.list_monitors = cache.cached( key_prefix='list_monitors', timeout=config.api_cache.list_monitors )(webcronmon.api.list_monitors) webcronmon.api.list_monitor_states = cache.cached( key_prefix='list_monitor_states', timeout=config.api_cache.list_monitor_states )(webcronmon.api.list_monitor_states) webcronmon.api.list_monitor_uptimes = cache.cached( key_prefix='list_monitor_uptimes', timeout=config.api_cache.list_monitor_uptimes )(webcronmon.api.list_monitor_uptimes) import webcronmon.views for route, shown_groups in config.routes: view = partial( webcronmon.views.show_monitors, config=config, shown_groups=shown_groups ) webcronmon.app.add_url_rule(route, route.replace('/', '-'), view) # force logging through webcronmon webcronmon.app._logger = logging.getLogger('webcronmon') webcronmon.app.logger_name = 'webcronmon' try: webcronmon.app.run( host=config.app.host, port=config.app.port, debug=config.app.debug, ) except KeyboardInterrupt: pass
def compile_bad_assets(): try: with current_app.test_request_context(): print "[+] Starting bad asset cache reset..." cache = Cache(config={'CACHE_TYPE': 'redis', 'CACHE_REDIS_DB': 0}) cache.init_app(current_app) url = current_app.config['UFRAME_ASSETS_URL'] + '/assets' payload = requests.get(url) if payload.status_code is 200: data = payload.json() bad_assets = _compile_bad_assets(data) if "error" not in bad_assets: cache.set('bad_asset_list', bad_assets, timeout=CACHE_TIMEOUT) print "[+] Bad asset cache reset" else: print "[-] Error in cache update" except Exception as err: message = 'compile_bad_assets exception: %s' % err.message current_app.logger.warning(message)
def run(): """Runs the flask app using the config.ini found in the working dir.""" import webcronmon import webcronmon.config config = webcronmon.active_config = webcronmon.config.load() webcronmon.app.debug = config.app.debug cache = Cache(config=config.cache.as_dictionary) cache.init_app(webcronmon.app) import webcronmon.api webcronmon.api.list_monitors = cache.cached( key_prefix='list_monitors', timeout=config.api_cache.list_monitors)(webcronmon.api.list_monitors) webcronmon.api.list_monitor_states = cache.cached( key_prefix='list_monitor_states', timeout=config.api_cache.list_monitor_states)( webcronmon.api.list_monitor_states) webcronmon.api.list_monitor_uptimes = cache.cached( key_prefix='list_monitor_uptimes', timeout=config.api_cache.list_monitor_uptimes)( webcronmon.api.list_monitor_uptimes) import webcronmon.views for route, shown_groups in config.routes: view = partial(webcronmon.views.show_monitors, config=config, shown_groups=shown_groups) webcronmon.app.add_url_rule(route, route.replace('/', '-'), view) # force logging through webcronmon webcronmon.app._logger = logging.getLogger('webcronmon') webcronmon.app.logger_name = 'webcronmon' try: webcronmon.app.run( host=config.app.host, port=config.app.port, debug=config.app.debug, ) except KeyboardInterrupt: pass
def compile_vocabulary(): try: with current_app.test_request_context(): print "[+] Starting vocabulary cache reset..." cache = Cache(config={'CACHE_TYPE': 'redis', 'CACHE_REDIS_DB': 0}) cache.init_app(current_app) url = current_app.config['UFRAME_VOCAB_URL'] + '/vocab' payload = requests.get(url) if payload.status_code is 200: data = payload.json() vocab_dict, vocab_codes = compile_vocab(data) if "error" not in vocab_dict: cache.set('vocab_dict', vocab_dict, timeout=CACHE_TIMEOUT) cache.set('vocab_codes', codes, timeout=CACHE_TIMEOUT) print "[+] Vocabulary cache reset" else: print "[-] Error in cache update" except Exception as err: message = 'compile_vocabulary exception: %s' % err.message current_app.logger.warning(message)
def compile_c2_toc(): try: c2_toc = {} with current_app.test_request_context(): print "[+] Starting c2 toc cache reset..." cache = Cache(config={'CACHE_TYPE': 'redis', 'CACHE_REDIS_DB': 0}) cache.init_app(current_app) try: c2_toc = _compile_c2_toc() except Exception as err: message = 'Error processing compile_c2_toc: ', err.message current_app.logger.warning(message) if c2_toc is not None: cache.set('c2_toc', c2_toc, timeout=CACHE_TIMEOUT) print "[+] C2 toc cache reset..." else: print "[-] Error in cache update" except Exception as err: message = 'compile_c2_toc exception: ', err.message current_app.logger.warning(message)
def create_app(): """创建Flask app""" app = Flask(__name__) cache = Cache(app, config={'CACHE_TYPE': 'simple'}) cache.init_app(app) # Load config config = load_config() app.config.from_object(config) # CSRF protect csrf.init_app(app) # 注册组件 register_db(app) register_routes(app) register_jinja(app) register_error_handle(app) register_logger(app) register_uploadsets(app) # before every request @app.before_request def before_request(): """Do something before request""" # 记录用户的访问时间到redis g.user = get_current_user() if g.user: set_user_active_time(g.user.id) g.msg_num = MailBox.query.filter(MailBox.recver_id == g.user.id, MailBox.result == None).count() from .utils.devices import Devices devices = Devices(app) return app
def compile_assets_rd(): try: asset_rds = {} with current_app.test_request_context(): print "[+] Starting asset reference designators cache reset..." cache = Cache(config={'CACHE_TYPE': 'redis', 'CACHE_REDIS_DB': 0}) cache.init_app(current_app) try: asset_rds, _ = _compile_asset_rds() except Exception as err: message = 'Error processing _compile_asset_rds: ', err.message current_app.logger.warning(message) if asset_rds: cache.set('asset_rds', asset_rds, timeout=CACHE_TIMEOUT) print "[+] Asset reference designators cache reset..." else: print "[-] Error in cache update" except Exception as err: message = 'compile_asset_rds exception: %s' % err.message current_app.logger.warning(message) raise Exception(message)
def test_23_init_app_sets_app_attribute(self): cache = Cache() cache.init_app(self.app) assert cache.app == self.app
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. :param 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 keyword args, the keys/values will get patched into the moin configuration class (before its 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: if not app.config.from_envvar('MOINCFG', silent=True): # no MOINCFG env variable set, try stuff in cwd: from os import path flask_config_file = path.abspath('wikiconfig_local.py') if not path.exists(flask_config_file): flask_config_file = path.abspath('wikiconfig.py') if not path.exists(flask_config_file): flask_config_file = None if flask_config_file: app.config.from_pyfile(flask_config_file) 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 BaseConverter class ItemNameConverter(BaseConverter): """Like the default :class:`UnicodeConverter`, but it also matches slashes (except at the beginning AND end). This is useful for wikis and similar applications:: Rule('/<itemname:wikipage>') Rule('/<itemname:wikipage>/edit') """ regex = '[^/]+?(/[^/]+?)*' weight = 200 app.url_map.converters['itemname'] = ItemNameConverter # register modules, before/after request functions from MoinMoin.apps.frontend import frontend frontend.before_request(before_wiki) frontend.teardown_request(teardown_wiki) app.register_blueprint(frontend) from MoinMoin.apps.admin import admin admin.before_request(before_wiki) admin.teardown_request(teardown_wiki) app.register_blueprint(admin, url_prefix='/+admin') from MoinMoin.apps.feed import feed feed.before_request(before_wiki) feed.teardown_request(teardown_wiki) app.register_blueprint(feed, url_prefix='/+feed') from MoinMoin.apps.misc import misc misc.before_request(before_wiki) misc.teardown_request(teardown_wiki) app.register_blueprint(misc, url_prefix='/+misc') from MoinMoin.apps.serve import serve app.register_blueprint(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') init_backends(app) clock.stop('create_app init backends') 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.register_error_handler(403, themed_error) clock.stop('create_app flask-themes') clock.stop('create_app total') del clock return app
from pqr import pqr, secret_config from settings import APP_JSON, APP_MOL2, APP_ARTICLES # Python library imports import os import ujson as json import markdown import datetime from Levenshtein import ratio # Regular expressions for chemical formula parsing import re cache = Cache(pqr, config={'CACHE_TYPE': 'simple'}) cache.init_app(pqr) redirect_table = {} amount_mol = None MOLECULE_OF_THE_WEEK = 'GZCGUPFRVQAUEE-SLPGGIOYSA-N' WEEKLY_MOL_NAME = None pqr.debug = True last_updated_wm = datetime.datetime.strptime('Aug 7 1996', '%b %d %Y').date() Masses = dict(H=1.01, He=4.00, Li=6.94, Be=9.01, B=10.81, C=12.01,
from flask import Flask, url_for, request, send_from_directory, redirect from flask import render_template from flask.ext.cache import Cache from jinja2 import FileSystemLoader cache = Cache(config={'CACHE_TYPE': 'simple'}) app = Flask(__name__) cache.init_app(app) @app.route('/') @cache.cached() def main(): return redirect("http://jemyoung.com/about/") @app.route('/about/') def about(): dev = request.args.get('dev', False) return render_template('about.html', dev=dev) @app.route('/blog/') def blog(): return redirect("http://blog.jemyoung.com", code=302) # @app.route('/robots.txt') # @cache.cached()
def init(app): global cache cache = Cache(app, config={'CACHE_TYPE': 'memcached'}) cache.init_app(app)
def test_19_dict_config_both(self): cache = Cache(config={'CACHE_TYPE': 'null'}) cache.init_app(self.app, config={'CACHE_TYPE': 'simple'}) from werkzeug.contrib.cache import SimpleCache assert isinstance(self.app.extensions['cache'][cache], SimpleCache)
app.config['CONFIG_FILE'] = os.path.abspath('app/config.yaml') app.config['PROPAGATE_EXCEPTIONS'] = True configStr = open(app.config['CONFIG_FILE'], 'r') app.config['CONFIG'] = yaml.load(configStr) sqlite_db = os.path.abspath('db/elastatus.db') app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////%s' % sqlite_db # Allow arbitrary python code in Jinja templates app.jinja_options['extensions'].append('jinja2.ext.do') db = SQLAlchemy(app) auth = HTTPBasicAuth() mail = Mail(app) cache = Cache() cache.init_app(app, config={'CACHE_TYPE': 'simple', 'CACHE_DEFAULT_TIMEOUT':app.config['CONFIG']['sgaudit']['cache_timeout'] }) if app.config['CONFIG']['jobs']['enabled']: from jobs import * from app.models import * @app.before_first_request def create_db(): if not os.path.exists(sqlite_db): db.create_all() from views import elastatus as elastatus
#coding=utf-8 #!/usr/bin/env python from flask import Flask from admin.admin import admin from blog.blog import blog from flask.ext.cache import Cache cache = Cache(config={'CACHE_TYPE': 'simple'}) config = { 'CACHE_TYPE': 'redis', 'CACHE_REDIS_HOST': '10.10.10.57', 'CACHE_REDIS_PORT': 6379, 'CACHE_REDIS_DB': '', 'CACHE_REDIS_PASSWORD': '' } pyshell = Flask(__name__, template_folder='templates', static_folder='static') pyshell.config.from_object(config) cache.init_app(pyshell, ) pyshell.register_blueprint(admin, url_prefix='/admin') pyshell.register_blueprint(blog, url_prefix='/blog') if __name__ == '__main__': pyshell.run() #pyshell.run(host='0.0.0.0', port=5000, debug=True)
def test_18_dict_config_initapp(self): cache = Cache() cache.init_app(self.app, config={'CACHE_TYPE': 'simple'}) assert cache.config['CACHE_TYPE'] == 'simple'
class CacheTestCase(unittest.TestCase): 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 tearDown(self): self.app = None self.cache = None self.tc = None def test_00_set(self): self.cache.set('hi', 'hello') assert self.cache.get('hi') == 'hello' def test_01_add(self): self.cache.add('hi', 'hello') assert self.cache.get('hi') == 'hello' self.cache.add('hi', 'foobar') assert self.cache.get('hi') == 'hello' def test_02_delete(self): self.cache.set('hi', 'hello') self.cache.delete('hi') assert self.cache.get('hi') is None def test_03_cached_view(self): @self.app.route('/') @self.cache.cached(5) def cached_view(): return str(time.time()) tc = self.app.test_client() rv = tc.get('/') the_time = rv.data time.sleep(2) rv = tc.get('/') assert the_time == rv.data time.sleep(5) rv = tc.get('/') assert the_time != rv.data def test_04_cached_view_unless(self): @self.app.route('/a') @self.cache.cached(5, unless=lambda: True) def non_cached_view(): return str(time.time()) @self.app.route('/b') @self.cache.cached(5, unless=lambda: False) def cached_view(): return str(time.time()) tc = self.app.test_client() rv = tc.get('/a') the_time = rv.data time.sleep(1) rv = tc.get('/a') assert the_time != rv.data rv = tc.get('/b') the_time = rv.data time.sleep(1) rv = tc.get('/b') assert the_time == rv.data def test_05_cached_function(self): with self.app.test_request_context(): @self.cache.cached(2, key_prefix='MyBits') def get_random_bits(): return [random.randrange(0, 2) for i in range(50)] my_list = get_random_bits() his_list = get_random_bits() assert my_list == his_list time.sleep(4) his_list = get_random_bits() assert my_list != his_list def test_06_memoize(self): with self.app.test_request_context(): @self.cache.memoize(5) def big_foo(a, b): return a + b + random.randrange(0, 100000) result = big_foo(5, 2) time.sleep(1) assert big_foo(5, 2) == result result2 = big_foo(5, 3) assert result2 != result time.sleep(4) assert big_foo(5, 2) != result assert big_foo(5, 3) == result2 time.sleep(1) assert big_foo(5, 3) != result2 def test_07_delete_memoize(self): with self.app.test_request_context(): @self.cache.memoize(5) def big_foo(a, b): return a + b + random.randrange(0, 100000) result = big_foo(5, 2) result2 = big_foo(5, 3) time.sleep(1) assert big_foo(5, 2) == result assert big_foo(5, 2) == result assert big_foo(5, 3) != result assert big_foo(5, 3) == result2 self.cache.delete_memoized(big_foo) assert big_foo(5, 2) != result assert big_foo(5, 3) != result2 def test_08_delete_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b): return a + b + random.randrange(0, 100000) result_a = big_foo(5, 1) result_b = big_foo(5, 2) assert big_foo(5, 1) == result_a assert big_foo(5, 2) == result_b self.cache.delete_memoized(big_foo, 5, 2) assert big_foo(5, 1) == result_a assert big_foo(5, 2) != result_b def test_09_args_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b): return sum(a) + sum(b) + random.randrange(0, 100000) result_a = big_foo([5, 3, 2], [1]) result_b = big_foo([3, 3], [3, 1]) assert big_foo([5, 3, 2], [1]) == result_a assert big_foo([3, 3], [3, 1]) == result_b self.cache.delete_memoized(big_foo, [5, 3, 2], [1]) assert big_foo([5, 3, 2], [1]) != result_a assert big_foo([3, 3], [3, 1]) == result_b def test_10_kwargs_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b=None): return a + sum(b.values()) + random.randrange(0, 100000) result_a = big_foo(1, dict(one=1, two=2)) result_b = big_foo(5, dict(three=3, four=4)) assert big_foo(1, dict(one=1, two=2)) == result_a assert big_foo(5, dict(three=3, four=4)) == result_b self.cache.delete_memoized(big_foo, 1, dict(one=1, two=2)) assert big_foo(1, dict(one=1, two=2)) != result_a assert big_foo(5, dict(three=3, four=4)) == result_b def test_11_cache_key_property(self): @self.app.route('/') @self.cache.cached(5) def cached_view(): return str(time.time()) assert hasattr(cached_view, "make_cache_key") assert callable(cached_view.make_cache_key) tc = self.app.test_client() rv = tc.get('/') the_time = rv.data with self.app.test_request_context(): cache_data = self.cache.get(cached_view.make_cache_key()) assert the_time == cache_data def test_12_make_cache_key_function_property(self): @self.app.route('/<foo>/<bar>') @self.cache.memoize(5) def cached_view(foo, bar): return str(time.time()) assert hasattr(cached_view, "make_cache_key") assert callable(cached_view.make_cache_key) tc = self.app.test_client() rv = tc.get('/a/b') the_time = rv.data cache_key = cached_view.make_cache_key(cached_view.uncached, foo=u"a", bar=u"b") cache_data = self.cache.get(cache_key) assert the_time == cache_data different_key = cached_view.make_cache_key(cached_view.uncached, foo=u"b", bar=u"a") different_data = self.cache.get(different_key) assert the_time != different_data def test_13_cache_timeout_property(self): @self.app.route('/') @self.cache.memoize(5) def cached_view1(): return str(time.time()) @self.app.route('/<foo>/<bar>') @self.cache.memoize(10) def cached_view2(foo, bar): return str(time.time()) assert hasattr(cached_view1, "cache_timeout") assert hasattr(cached_view2, "cache_timeout") assert cached_view1.cache_timeout == 5 assert cached_view2.cache_timeout == 10 # test that this is a read-write property cached_view1.cache_timeout = 2 cached_view2.cache_timeout = 3 assert cached_view1.cache_timeout == 2 assert cached_view2.cache_timeout == 3 tc = self.app.test_client() rv1 = tc.get('/') time1 = rv1.data time.sleep(1) rv2 = tc.get('/a/b') time2 = rv2.data # VIEW1 # it's been 1 second, cache is still active assert time1 == tc.get('/').data time.sleep(2) # it's been 3 seconds, cache is not still active assert time1 != tc.get('/').data # VIEW2 # it's been 2 seconds, cache is still active assert time2 == tc.get('/a/b').data time.sleep(2) # it's been 4 seconds, cache is not still active assert time2 != tc.get('/a/b').data def test_14_memoized_multiple_arg_kwarg_calls(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b, c=[1, 1], d=[1, 1]): return sum(a) + sum(b) + sum(c) + sum(d) + random.randrange( 0, 100000) result_a = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) assert big_foo([5, 3, 2], [1], d=[3, 3], c=[3, 3]) == result_a assert big_foo(b=[1], a=[5, 3, 2], c=[3, 3], d=[3, 3]) == result_a assert big_foo([5, 3, 2], [1], [3, 3], [3, 3]) == result_a def test_15_memoize_multiple_arg_kwarg_delete(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b, c=[1, 1], d=[1, 1]): return sum(a) + sum(b) + sum(c) + sum(d) + random.randrange( 0, 100000) result_a = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) self.cache.delete_memoized(big_foo, [5, 3, 2], [1], [3, 3], [3, 3]) result_b = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) assert result_a != result_b self.cache.delete_memoized(big_foo, [5, 3, 2], b=[1], c=[3, 3], d=[3, 3]) result_b = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) assert result_a != result_b self.cache.delete_memoized(big_foo, [5, 3, 2], [1], c=[3, 3], d=[3, 3]) result_a = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) assert result_a != result_b self.cache.delete_memoized(big_foo, [5, 3, 2], b=[1], c=[3, 3], d=[3, 3]) result_a = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) assert result_a != result_b self.cache.delete_memoized(big_foo, [5, 3, 2], [1], c=[3, 3], d=[3, 3]) result_b = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) assert result_a != result_b self.cache.delete_memoized(big_foo, [5, 3, 2], [1], [3, 3], [3, 3]) result_a = big_foo([5, 3, 2], [1], c=[3, 3], d=[3, 3]) assert result_a != result_b def test_16_memoize_kwargs_to_args(self): with self.app.test_request_context(): def big_foo(a, b, c=None, d=None): return sum(a) + sum(b) + random.randrange(0, 100000) expected = (1, 2, 'foo', 'bar') args, kwargs = self.cache.memoize_kwargs_to_args( big_foo, 1, 2, 'foo', 'bar') assert (args == expected) args, kwargs = self.cache.memoize_kwargs_to_args(big_foo, 2, 'foo', 'bar', a=1) assert (args == expected) args, kwargs = self.cache.memoize_kwargs_to_args(big_foo, a=1, b=2, c='foo', d='bar') assert (args == expected) args, kwargs = self.cache.memoize_kwargs_to_args(big_foo, d='bar', b=2, a=1, c='foo') assert (args == expected) args, kwargs = self.cache.memoize_kwargs_to_args(big_foo, 1, 2, d='bar', c='foo') assert (args == expected) def test_17_dict_config(self): cache = Cache(config={'CACHE_TYPE': 'simple'}) cache.init_app(self.app) 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_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_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'
import os, json from urlparse import urlparse, urljoin from notifications import send_prr_email from spam import is_spam, is_working_akismet_key from requests import get from time import time from flask.ext.cache import Cache from recaptcha.client import captcha # Initialize login login_manager = LoginManager() login_manager.init_app(app) # Initialize cache cache = Cache() cache.init_app(app, config={'CACHE_TYPE': 'simple'}) # Submitting a new request def new_request(passed_recaptcha = False, data = None): if request.method == 'POST' or data: if not passed_recaptcha: data = request.form.copy() email = data['request_email'] request_text = data['request_text'] if request_text == "": return render_template('error.html', message = "You cannot submit an empty request.") if email == "" and 'ignore_email' not in data and not passed_recaptcha: return render_template('missing_email.html', form = data, user_id = get_user_id()) if is_spam(request_text) and not passed_recaptcha:
class CacheTestCase(unittest.TestCase): 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 tearDown(self): self.app = None self.cache = None self.tc = None def test_00_set(self): self.cache.set('hi', 'hello') assert self.cache.get('hi') == 'hello' def test_01_add(self): self.cache.add('hi', 'hello') assert self.cache.get('hi') == 'hello' self.cache.add('hi', 'foobar') assert self.cache.get('hi') == 'hello' def test_02_delete(self): self.cache.set('hi', 'hello') self.cache.delete('hi') assert self.cache.get('hi') is None def test_03_cached_view(self): @self.app.route('/') @self.cache.cached(5) def cached_view(): return str(time.time()) tc = self.app.test_client() rv = tc.get('/') the_time = rv.data time.sleep(2) rv = tc.get('/') assert the_time == rv.data time.sleep(5) rv = tc.get('/') assert the_time != rv.data def test_04_cached_view_unless(self): @self.app.route('/a') @self.cache.cached(5, unless=lambda: True) def non_cached_view(): return str(time.time()) @self.app.route('/b') @self.cache.cached(5, unless=lambda: False) def cached_view(): return str(time.time()) tc = self.app.test_client() rv = tc.get('/a') the_time = rv.data time.sleep(1) rv = tc.get('/a') assert the_time != rv.data rv = tc.get('/b') the_time = rv.data time.sleep(1) rv = tc.get('/b') assert the_time == rv.data def test_05_cached_function(self): with self.app.test_request_context(): @self.cache.cached(2, key_prefix='MyBits') def get_random_bits(): return [random.randrange(0, 2) for i in range(50)] my_list = get_random_bits() his_list = get_random_bits() assert my_list == his_list time.sleep(4) his_list = get_random_bits() assert my_list != his_list def test_06_memoize(self): with self.app.test_request_context(): @self.cache.memoize(5) def big_foo(a, b): return a+b+random.randrange(0, 100000) result = big_foo(5, 2) time.sleep(1) assert big_foo(5, 2) == result result2 = big_foo(5, 3) assert result2 != result time.sleep(4) assert big_foo(5, 2) != result assert big_foo(5, 3) == result2 time.sleep(1) assert big_foo(5, 3) != result2 def test_07_delete_memoize(self): with self.app.test_request_context(): @self.cache.memoize(5) def big_foo(a, b): return a+b+random.randrange(0, 100000) result = big_foo(5, 2) result2 = big_foo(5, 3) time.sleep(1) assert big_foo(5, 2) == result assert big_foo(5, 2) == result assert big_foo(5, 3) != result assert big_foo(5, 3) == result2 self.cache.delete_memoized(big_foo) assert big_foo(5, 2) != result assert big_foo(5, 3) != result2 def test_08_delete_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b): return a+b+random.randrange(0, 100000) result_a = big_foo(5, 1) result_b = big_foo(5, 2) assert big_foo(5, 1) == result_a assert big_foo(5, 2) == result_b self.cache.delete_memoized(big_foo, 5, 2) assert big_foo(5, 1) == result_a assert big_foo(5, 2) != result_b def test_09_args_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b): return sum(a)+sum(b)+random.randrange(0, 100000) result_a = big_foo([5,3,2], [1]) result_b = big_foo([3,3], [3,1]) assert big_foo([5,3,2], [1]) == result_a assert big_foo([3,3], [3,1]) == result_b self.cache.delete_memoized(big_foo, [5,3,2], [1]) assert big_foo([5,3,2], [1]) != result_a assert big_foo([3,3], [3,1]) == result_b def test_10_kwargs_memoize(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b=None): return a+sum(b.values())+random.randrange(0, 100000) result_a = big_foo(1, dict(one=1,two=2)) result_b = big_foo(5, dict(three=3,four=4)) assert big_foo(1, dict(one=1,two=2)) == result_a assert big_foo(5, dict(three=3,four=4)) == result_b self.cache.delete_memoized(big_foo, 1, dict(one=1,two=2)) assert big_foo(1, dict(one=1,two=2)) != result_a assert big_foo(5, dict(three=3,four=4)) == result_b def test_11_cache_key_property(self): @self.app.route('/') @self.cache.cached(5) def cached_view(): return str(time.time()) assert hasattr(cached_view, "make_cache_key") assert callable(cached_view.make_cache_key) tc = self.app.test_client() rv = tc.get('/') the_time = rv.data with self.app.test_request_context(): cache_data = self.cache.get(cached_view.make_cache_key()) assert the_time == cache_data def test_12_make_cache_key_function_property(self): @self.app.route('/<foo>/<bar>') @self.cache.memoize(5) def cached_view(foo, bar): return str(time.time()) assert hasattr(cached_view, "make_cache_key") assert callable(cached_view.make_cache_key) tc = self.app.test_client() rv = tc.get('/a/b') the_time = rv.data cache_key = cached_view.make_cache_key(cached_view.uncached, foo=u"a", bar=u"b") cache_data = self.cache.get(cache_key) assert the_time == cache_data different_key = cached_view.make_cache_key(cached_view.uncached, foo=u"b", bar=u"a") different_data = self.cache.get(different_key) assert the_time != different_data def test_13_cache_timeout_property(self): @self.app.route('/') @self.cache.memoize(5) def cached_view1(): return str(time.time()) @self.app.route('/<foo>/<bar>') @self.cache.memoize(10) def cached_view2(foo, bar): return str(time.time()) assert hasattr(cached_view1, "cache_timeout") assert hasattr(cached_view2, "cache_timeout") assert cached_view1.cache_timeout == 5 assert cached_view2.cache_timeout == 10 # test that this is a read-write property cached_view1.cache_timeout = 2 cached_view2.cache_timeout = 3 assert cached_view1.cache_timeout == 2 assert cached_view2.cache_timeout == 3 tc = self.app.test_client() rv1 = tc.get('/') time1 = rv1.data time.sleep(1) rv2 = tc.get('/a/b') time2 = rv2.data # VIEW1 # it's been 1 second, cache is still active assert time1 == tc.get('/').data time.sleep(2) # it's been 3 seconds, cache is not still active assert time1 != tc.get('/').data # VIEW2 # it's been 2 seconds, cache is still active assert time2 == tc.get('/a/b').data time.sleep(2) # it's been 4 seconds, cache is not still active assert time2 != tc.get('/a/b').data def test_14_memoized_multiple_arg_kwarg_calls(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b,c=[1,1],d=[1,1]): return sum(a)+sum(b)+sum(c)+sum(d)+random.randrange(0, 100000) result_a = big_foo([5,3,2], [1], c=[3,3], d=[3,3]) assert big_foo([5,3,2], [1], d=[3,3], c=[3,3]) == result_a assert big_foo(b=[1],a=[5,3,2],c=[3,3],d=[3,3]) == result_a assert big_foo([5,3,2], [1], [3,3], [3,3]) == result_a def test_15_memoize_multiple_arg_kwarg_delete(self): with self.app.test_request_context(): @self.cache.memoize() def big_foo(a, b,c=[1,1],d=[1,1]): return sum(a)+sum(b)+sum(c)+sum(d)+random.randrange(0, 100000) result_a = big_foo([5,3,2], [1], c=[3,3], d=[3,3]) self.cache.delete_memoized(big_foo, [5,3,2],[1],[3,3],[3,3]) result_b = big_foo([5,3,2], [1], c=[3,3], d=[3,3]) assert result_a != result_b self.cache.delete_memoized(big_foo, [5,3,2],b=[1],c=[3,3],d=[3,3]) result_b = big_foo([5,3,2], [1], c=[3,3], d=[3,3]) assert result_a != result_b self.cache.delete_memoized(big_foo, [5,3,2],[1],c=[3,3],d=[3,3]) result_a = big_foo([5,3,2], [1], c=[3,3], d=[3,3]) assert result_a != result_b self.cache.delete_memoized(big_foo, [5,3,2],b=[1],c=[3,3],d=[3,3]) result_a = big_foo([5,3,2], [1], c=[3,3], d=[3,3]) assert result_a != result_b self.cache.delete_memoized(big_foo, [5,3,2],[1],c=[3,3],d=[3,3]) result_b = big_foo([5,3,2], [1], c=[3,3], d=[3,3]) assert result_a != result_b self.cache.delete_memoized(big_foo, [5,3,2],[1],[3,3],[3,3]) result_a = big_foo([5,3,2], [1], c=[3,3], d=[3,3]) assert result_a != result_b def test_16_memoize_kwargs_to_args(self): with self.app.test_request_context(): def big_foo(a, b, c=None, d=None): return sum(a)+sum(b)+random.randrange(0, 100000) expected = (1,2,'foo','bar') args, kwargs = self.cache.memoize_kwargs_to_args(big_foo, 1,2,'foo','bar') assert (args == expected) args, kwargs = self.cache.memoize_kwargs_to_args(big_foo, 2,'foo','bar',a=1) assert (args == expected) args, kwargs = self.cache.memoize_kwargs_to_args(big_foo, a=1,b=2,c='foo',d='bar') assert (args == expected) args, kwargs = self.cache.memoize_kwargs_to_args(big_foo, d='bar',b=2,a=1,c='foo') assert (args == expected) args, kwargs = self.cache.memoize_kwargs_to_args(big_foo, 1,2,d='bar',c='foo') assert (args == expected) def test_17_dict_config(self): cache = Cache(config={'CACHE_TYPE': 'simple'}) cache.init_app(self.app) 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_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'
from urlparse import urlparse, urljoin from notifications import send_prr_email from spam import is_spam, is_working_akismet_key from requests import get from time import time from flask.ext.cache import Cache from recaptcha.client import captcha from timeout import timeout # Initialize login login_manager = LoginManager() login_manager.init_app(app) # Initialize cache cache = Cache() cache.init_app(app, config={"CACHE_TYPE": "simple"}) # Submitting a new request def new_request(passed_recaptcha=False, data=None): if data or request.method == "POST": if not data and not passed_recaptcha: data = request.form.copy() email = data["request_email"] request_text = data["request_text"] if request_text == "": return render_template("error.html", message="You cannot submit an empty request.") if email == "" and "ignore_email" not in data and not passed_recaptcha: return render_template("missing_email.html", form=data, user_id=get_user_id()) if (app.config["ENVIRONMENT"] == "PRODUCTION") and is_spam(request_text) and not passed_recaptcha: return render_template(
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'
'Access-Control-Allow-Origin': '*' } # Make and configure the Flask app app = Flask(__name__) if debug_app: app.debug = True # Set up cache cache_config = { 'CACHE_TYPE': 'filesystem', 'CACHE_THRESHOLD': 1000, 'CACHE_DIR': 'cache' } cache = Cache(config=cache_config) cache.init_app(app, config=cache_config) # Just a default route @app.route('/') @cache.cached(timeout=500) def index(): return 'This is a whitelisted JSON to JSONP proxy.' # Proxy route @app.route('/proxy') def handle_proxy(): request_url = request.args.get('url', '') callback = request.args.get('callback', '') request_parsed = urlparse.urlparse(request_url)
from requests import get from time import time from flask.ext.cache import Cache from recaptcha.client import captcha from timeout import timeout from flask import jsonify, request, Response import anyjson import helpers # Initialize login login_manager = LoginManager() login_manager.init_app(app) # Initialize cache cache = Cache() cache.init_app(app, config={'CACHE_TYPE': 'simple'}) # Set flags: check_for_spam = False if app.config['ENVIRONMENT'] == 'PRODUCTION': check_for_spam = True # Submitting a new request def new_request(passed_recaptcha = False, data = None): user_id = get_user_id() if data or request.method == 'POST': if not data and not passed_recaptcha: data = request.form.copy() email = data['request_email'] request_text = data['request_text']
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. :param 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 keyword args, the keys/values will get patched into the moin configuration class (before its 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: if not app.config.from_envvar('MOINCFG', silent=True): # no MOINCFG env variable set, try stuff in cwd: from os import path flask_config_file = path.abspath('wikiconfig_local.py') if not path.exists(flask_config_file): flask_config_file = path.abspath('wikiconfig.py') if not path.exists(flask_config_file): flask_config_file = None if flask_config_file: app.config.from_pyfile(flask_config_file) 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 BaseConverter class ItemNameConverter(BaseConverter): """Like the default :class:`UnicodeConverter`, but it also matches slashes (except at the beginning AND end). This is useful for wikis and similar applications:: Rule('/<itemname:wikipage>') Rule('/<itemname:wikipage>/edit') """ regex = '[^/]+?(/[^/]+?)*' weight = 200 app.url_map.converters['itemname'] = ItemNameConverter # register modules, before/after request functions from MoinMoin.apps.frontend import frontend frontend.before_request(before_wiki) frontend.teardown_request(teardown_wiki) app.register_blueprint(frontend) from MoinMoin.apps.admin import admin admin.before_request(before_wiki) admin.teardown_request(teardown_wiki) app.register_blueprint(admin, url_prefix='/+admin') from MoinMoin.apps.feed import feed feed.before_request(before_wiki) feed.teardown_request(teardown_wiki) app.register_blueprint(feed, url_prefix='/+feed') from MoinMoin.apps.misc import misc misc.before_request(before_wiki) misc.teardown_request(teardown_wiki) app.register_blueprint(misc, url_prefix='/+misc') from MoinMoin.apps.serve import serve app.register_blueprint(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') init_backends(app) clock.stop('create_app init backends') 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.register_error_handler(403, themed_error) clock.stop('create_app flask-themes') clock.stop('create_app total') del clock return app
def test_17_dict_config(self): cache = Cache(config={'CACHE_TYPE': 'simple'}) cache.init_app(self.app) assert cache.config['CACHE_TYPE'] == 'simple'
app = Flask(__name__) app.secret_key = 'SUPERSECRET' # you should change this to something equally random app.config['CONFIG_FILE'] = os.path.abspath('app/config.yaml') configStr = open(app.config['CONFIG_FILE'], 'r') app.config['CONFIG'] = yaml.load(configStr) sqlite_db = os.path.abspath('db/elastatus.db') app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////%s' % sqlite_db db = SQLAlchemy(app) auth = HTTPBasicAuth() mail = Mail(app) cache = Cache() cache.init_app(app, config={ 'CACHE_TYPE': 'simple', 'CACHE_DEFAULT_TIMEOUT': app.config['CONFIG']['sgaudit']['cache_timeout'] }) if app.config['CONFIG']['jobs']['enabled']: from jobs import * from app.models import * @app.before_first_request def create_db(): if not os.path.exists(sqlite_db): db.create_all()
def test_23_init_app_sets_app_attribute(self): cache = Cache() cache.init_app(self.app) assert cache.app == self.app
import models from wtforms.ext.appengine.ndb import model_form from xml.dom.minidom import parse import urllib2 import base64 import datetime import locale locale.setlocale(locale.LC_ALL, "") import unicodedata # caching from flask.ext.cache import Cache cache = Cache(with_jinja2_ext=False) from application import app cache.init_app(app, config={'CACHE_TYPE': 'gaememcached'}) syskey = app.config['SYSKEY'] def strip_accents(s): return ''.join((c for c in unicodedata.normalize('NFD', s) if unicodedata.category(c) != 'Mn')) def authorize_user(user): if not user: return False if users.is_current_user_admin(): return True else: return False
class Application(Flask): def __init__(self, app_config, import_name, static_path=None, static_url_path=None, static_folder='static', template_folder='templates', instance_path=None, instance_relative_config=False): from flask.ext.cache import Cache from ambry.library import Library from ambry.run import get_runconfig self._initialized = False self.csrf = CsrfProtect() self.login_manager = LoginManager() super(Application, self).__init__(import_name, static_path, static_url_path, static_folder, template_folder, instance_path, instance_relative_config) self.config.update(app_config) l = Library(get_runconfig(), read_only=True, echo=False) self.cache = Cache(config={ 'CACHE_TYPE': 'filesystem', 'CACHE_DIR': l.filesystem.cache('ui') }) self.cache.init_app(self) def __call__(self, environ, start_response): if not self._initialized: from ambry.library import Library from ambry.run import get_runconfig rc = get_runconfig() l = Library(rc, read_only=True, echo=False) secret_key = None if os.getenv('AMBRY_UI_SECRET'): app.logger.info("Using secret_key from env") secret_key = os.getenv('AMBRY_UI_SECRET') if not secret_key and l.ui_config.secret: app.logger.info("Using secret_key from library") secret_key = l.ui_config.secret if not secret_key: from uuid import uuid4 app.logger.warn( "SECRET_KEY was not set. Setting to a random value") secret_key = str( uuid4()) # Must be the same for all worker processes. if not self.config['WTF_CSRF_SECRET_KEY']: self.config['WTF_CSRF_SECRET_KEY'] = secret_key self.config['SECRET_KEY'] = secret_key title = os.getenv('AMBRY_UI_TITLE', "Ambry Data Library"), if l.ui_config.website_title: title = l.ui_config.website_title self.config['website_title'] = title self.secret_key = secret_key self.csrf.init_app(self) self.session_interface = ItsdangerousSessionInterface() self.login_manager.init_app(app) Bootstrap(app) self._initialized = True return super(Application, self).__call__(environ, start_response)
def test_17_dict_config(self): cache = Cache(config={'CACHE_TYPE': 'simple'}) cache.init_app(self.app) assert cache.config['CACHE_TYPE'] == 'simple'
from sqlalchemy import distinct import graphsub import threading from datetime import datetime import rdsapi import searchRDSinstance import requests from flask.ext.migrate import Migrate, MigrateCommand from flask.ext.cache import Cache cache = Cache() app = Flask(__name__) manager = Manager(app) bootstrap = Bootstrap(app) moment = Moment(app) cache.init_app(app) BASE_DIR = os.path.dirname(os.path.abspath(__file__)) @app.after_request def add_header(response): response.headers['Cache-Control'] = 'max-age=30' return response @app.route("/check", methods=["GET", "POST"]) def check(): ##################ESC DB Insert######################## r = request.args.get('check') if r == 'ecs':
def test_19_dict_config_both(self): cache = Cache(config={'CACHE_TYPE': 'null'}) cache.init_app(self.app, config={'CACHE_TYPE': 'simple'}) from werkzeug.contrib.cache import SimpleCache assert isinstance(self.app.extensions['cache'][cache], SimpleCache)
def test_18_dict_config_initapp(self): cache = Cache() cache.init_app(self.app, config={'CACHE_TYPE': 'simple'}) assert cache.config['CACHE_TYPE'] == 'simple'
} # Make and configure the Flask app app = Flask(__name__) if debug_app: app.debug = True # Set up cache cache_config = { 'CACHE_TYPE': 'filesystem', 'CACHE_THRESHOLD': 1000, 'CACHE_DIR': 'cache' } cache = Cache(config = cache_config) cache.init_app(app, config = cache_config) # Just a default route @app.route('/') @cache.cached(timeout = 500) def index(): return 'This is a whitelisted JSON to JSONP proxy.' # Proxy route @app.route('/proxy') def handle_proxy(): request_url = request.args.get('url', '') callback = request.args.get('callback', '')