from flask.ext.cache import Cache
import os
# Setup the Cache
cache = Cache(
config={
'CACHE_TYPE':
'filesystem',
'CACHE_DIR':
str(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) +
'/cache'
})
#make a http last modified wrapper
from flask import make_response
from functools import wraps, update_wrapper
from datetime import datetime, timedelta
def httpdate(dt):
"""Return a string representation of a date according to RFC 1123
(HTTP/1.1).
The supplied date must be in UTC.
"""
weekday = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"][dt.weekday()]
month = [
"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct",
"Nov", "Dec"
][dt.month - 1]
return "%s, %02d %s %04d %02d:%02d:%02d GMT" % (
logging.basicConfig(
format=
"%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s",
datefmt="%m/%d/%Y %I:%M:%S %p",
level=logging.INFO,
)
logging.getLogger("socketio").setLevel(logging.ERROR)
logging.getLogger("engineio").setLevel(logging.ERROR)
app = Flask(__name__)
socketio = SocketIO(app,
async_mode="eventlet",
engineio_logger=False,
message_queue="redis://")
cache = Cache(app, config={"CACHE_TYPE": "simple"})
CACHE_TIMEOUT = 600
requests.packages.urllib3.disable_warnings()
BRANCHES_SETTINGS = {}
APP_SETTINGS = {}
def update_all_rules():
"""Set next active rules for all branches."""
try:
for i in range(1, len(RULES_FOR_BRANCHES)):
set_next_rule_to_redis(i, database.get_next_active_rule(i))
logging.info("Rules updated")
def configure(app):
config_file = os.environ.get('GRAPHITE_API_CONFIG',
'/etc/graphite-api.yaml')
if os.path.exists(config_file):
with open(config_file) as f:
config = yaml.safe_load(f)
config['path'] = config_file
else:
warnings.warn("Unable to find configuration file at {0}, using "
"default config.".format(config_file))
config = {}
configure_logging(config)
for key, value in list(default_conf.items()):
config.setdefault(key, value)
app.statsd = None
if 'statsd' in config:
try:
from statsd import StatsClient
except ImportError:
warnings.warn("'statsd' is provided in the configuration but "
"the statsd client is not installed. Please `pip "
"install statsd`.")
else:
c = config['statsd']
app.statsd = StatsClient(c['host'], c.get('port', 8125))
app.cache = None
if 'cache' in config:
try:
from flask.ext.cache import Cache
except ImportError:
warnings.warn("'cache' is provided in the configuration but "
"Flask-Cache is not installed. Please `pip install "
"Flask-Cache`.")
else:
cache_conf = {
'CACHE_DEFAULT_TIMEOUT': 60,
'CACHE_KEY_PREFIX': 'graphite-api:'
}
for key, value in config['cache'].items():
cache_conf['CACHE_{0}'.format(key.upper())] = value
app.cache = Cache(app, config=cache_conf)
loaded_config = {'functions': {}}
for functions in config['functions']:
loaded_config['functions'].update(load_by_path(functions))
if 'carbon' in config:
if 'hashing_keyfunc' in config['carbon']:
config['carbon']['hashing_keyfunc'] = load_by_path(
config['carbon']['hashing_keyfunc'])
else:
config['carbon']['hashing_keyfunc'] = lambda x: x
loaded_config['carbon'] = config.get('carbon', None)
finders = []
for finder in config['finders']:
finders.append(load_by_path(finder)(config))
loaded_config['store'] = Store(finders)
app.config['GRAPHITE'] = loaded_config
app.config['TIME_ZONE'] = config['time_zone']
logger.info("configured timezone", timezone=app.config['TIME_ZONE'])
app.config['admin_token'] = config['admin_token']
app.config['multi_tenant'] = config['multi_tenant']
if 'sentry_dsn' in config:
try:
from raven.contrib.flask import Sentry
except ImportError:
warnings.warn("'sentry_dsn' is provided in the configuration but "
"the sentry client is not installed. Please `pip "
"install raven[flask]`.")
else:
Sentry(app, dsn=config['sentry_dsn'])
app.wsgi_app = TrailingSlash(
CORS(app.wsgi_app, config.get('allowed_origins')))
if config.get('render_errors', True):
app.errorhandler(500)(error_handler)
def test_17_dict_config(self):
cache = Cache(config={'CACHE_TYPE': 'simple'})
cache.init_app(self.app)
assert cache.config['CACHE_TYPE'] == 'simple'
def setUp(self):
self.app = Flask(__name__)
self.app.cache = Cache(self.app, config={'CACHE_TYPE': 'simple'})
self.app.cache.clear()
self.app_context = self.app.app_context()
self.app_context.push()
def add_resource(cls):
api.add_resource(cls, '/api/%s' % cls.RESOURCE_NAME, '/api/%s/<id>' % cls.RESOURCE_NAME)
app = Flask(__name__)
app.json_encoder = CustomJSONEncoder
SESSION_TYPE = 'redis'
CACHE_TYPE = 'redis'
SQLALCHEMY_DATABASE_URI = CONF.psql_db_url
app.config.from_object(__name__)
db = SQLAlchemy(app)
Session(app)
cache = Cache(app, config={'CACHE_TYPE': CACHE_TYPE, 'CACHE_REDIS_HOST': CONF.redis_host,
'CACHE_REDIS_PORT': CONF.redis_port})
from yeti.api.filter import auth_filter, log_filter, audit_filter, permission_filter
# api = Api(app, decorators=[audit_filter, permission_filter, auth_filter, log_filter])
api = Api(app, decorators=[audit_filter, auth_filter, log_filter])
api.route = types.MethodType(api_route, api)
redis_conn = Redis(CONF.redis_host, CONF.redis_port)
@app.before_request
def before_request():
db.session()
#!/usr/bin/env python
import json
import urllib2
from flask import Flask
from flask.ext.cache import Cache
from bs4 import BeautifulSoup
APP = Flask(__name__)
CACHE = Cache(APP, config={'CACHE_TYPE': 'simple'})
CACHE_TIMEOUT = 1800 # 30 minutes
URL = 'http://www.urbandictionary.com'
def get_wod(day=0):
if day > 6:
raise LookupError(
'Words of the day older than one week from today are not available.'
)
content = urllib2.urlopen(URL).read()
soup = BeautifulSoup(content)
words = []
for div in soup.findAll('a', attrs={'class': 'word'}):
words.append(div.text.strip())
meanings = __get_elements_of_class('meaning', soup)
elements = __get_elements_of_class('example', soup)
if platform.system() == 'Windows':
debug = False
path = os.getcwd() + '\\cache\\'
host = '127.0.0.1'
port = 808
else:
debug = True
host = '0.0.0.0'
path = 'cache/'
debug = False
port = 80
index_path = path + 'index.json'
cache = Cache(app,
config={
'CACHE_TYPE': 'filesystem',
'CACHE_THRESHOLD': sys.maxint,
'CACHE_DEFAULT_TIMEOUT': 60 * 60 * 24,
'CACHE_DIR': path
})
time_out = 60
@app.route('/')
def index():
index_doc = {
'update_time': 0,
'doc': {},
}
# 没有缓存文件
if os.path.exists(index_path) == False:
index_doc['doc'] = get_index_doc()
from flask.ext.mongoengine import MongoEngine, MongoEngineSessionInterface
from flask.ext.login import LoginManager
from flask_wtf.csrf import CsrfProtect
from flask.ext.cache import Cache
import memcache
from core.utils.libsmq import *
from mongoengine.queryset import Q
import datetime
from hashlib import md5
import pytz
gm_client = JSONGearmanClient(['localhost:4730'])
app = Flask(__name__)
cache = Cache(app, config={'CACHE_TYPE': 'memcached'})
csrf = CsrfProtect()
app.debug = True
app.config["MONGODB_SETTINGS"] = {'DB': "rubicon"}
app.config["SECRET_KEY"] = "t/eSb1zxF6fK2B/JNc0X2w=="
app.config['UPLOAD_FOLDER'] = '/opt/rubicon/csv_data'
app.config['UPLOAD_DATASETS'] = '/opt/rubicon/datasets'
app.config['ALLOWED_NUMBERS_EXTENSIONS'] = set(['csv'])
app.config['WTF_CSRF_CHECK_DEFAULT'] = False
app.config['MODELS_PATH'] = '/opt/rubicon/models'
db = MongoEngine(app)
app.session_interface = MongoEngineSessionInterface(db)
bcrypt = Bcrypt(app)
# -*- coding: utf-8 -*-
__author__ = 'florije'
from flask import Flask, jsonify, request
from flask.ext.cache import Cache
from flask.ext.sqlalchemy import SQLAlchemy
from celery import Celery
import logging
from logging.handlers import TimedRotatingFileHandler
cache = Cache(
config={
'CACHE_TYPE': 'redis',
'CACHE_KEY_PREFIX': 'fcache',
'CACHE_REDIS_HOST': 'localhost',
'CACHE_REDIS_PORT': '6379',
'CACHE_REDIS_URL': 'redis://localhost:6379'
})
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db'
app.config.update(CELERY_BROKER_URL='redis://localhost:6379',
CELERY_RESULT_BACKEND='redis://localhost:6379')
cache.init_app(app)
db = SQLAlchemy(app)
handler = TimedRotatingFileHandler(filename='{0}'.format('logs.log'),
when='D',
interval=1,
handler = logging.StreamHandler(stream=sys.stdout)
app.logger.addHandler(handler)
app.logger.setLevel('INFO')
app.wsgi_app = ReverseProxied(app.wsgi_app)
got_request_exception.connect(log_exception, app)
#we want the old behavior for reqparse
compat.patch_reqparse()
rest_api = Api(app, catch_all_404s=True, serve_challenge_on_401=True)
from navitiacommon.models import db
db.init_app(app)
cache = Cache(app, config=app.config['CACHE_CONFIGURATION'])
if app.config['AUTOCOMPLETE'] is not None:
global_autocomplete = utils.create_object(
app.config['AUTOCOMPLETE']['class_path'],
**app.config['AUTOCOMPLETE']['kwargs'])
else:
global_autocomplete = None
from jormungandr.instance_manager import InstanceManager
i_manager = InstanceManager(
instances_dir=app.config.get('INSTANCES_DIR', None),
start_ping=app.config.get('START_MONITORING_THREAD', True))
i_manager.initialisation()
from flask.ext.assets import Environment, Bundle
assets = Environment(app)
assets.load_path.append(os.path.join(oec_dir, "assets/js/"))
js = Bundle("warning.js",
"visualization.js",
"configs/*.js",
"helpers/*.js",
output="js/visualization.js")
assets.register("js", js)
# DB connection object
db = SQLAlchemy(app)
# set up cache for views
view_cache = Cache(app)
# Global Latest Year Variables
available_years = {"sitc": range(1962, 2014), "hs92": range(1995, 2014), \
"hs96": range(1998, 2014), "hs02": range(2003, 2014), \
"hs07": range(2008, 2013), "country": range(1962, 2014)}
# Global for excluded countries
excluded_countries = ["ocglp", "xxwld", "asymd", "eumco", "saguf", "euksv", \
"nabes", "nacuw", "navir", "eusjm", "namaf", "naant", "afreu", "afssd", \
"afmyt", "eufro", "eubel", "eulux", "afswz", "afbwa", "aflso", "afnam", \
"napri", "namtq", "euimn", "eulie", "euddr", "eufdr", "nablm", "eusun", \
"euscg", "euyug"]
random_countries = ["afago","afdza","afegy","afmar","afnga","afzaf","asare", \
"asaze","asbgd","aschn","ashkg","asidn","asind","asirn","asirq","asisr", \
"asjpn","askaz","askor","askwt","asmys","asomn","aspak","asphl","asqat", \
from flask.ext.cache import Cache
from flask.ext.mail import Mail
from flask_assets import Environment
from webassets.loaders import PythonLoader as PythonAssetsLoader
app = Flask(__name__)
# ENV configuration
env = os.environ.get('WHATSTODAY_ENV', 'dev')
app.config.from_object('app.settings.%sConfig' % env.capitalize())
app.config['ENV'] = env
# Memcached
if env == 'dev':
# Use Simple Cache
cache = Cache(app, config={'CACHE_TYPE': 'simple'})
else:
import pylibmc
def pylibmc_cache(app, config, args, kwargs):
return pylibmc.Client(servers=app.config['CACHE_MEMCACHED_SERVERS'],
binary=True)
cache = Cache(app, config={'CACHE_TYPE': pylibmc_cache})
cache.init_app(app)
# DB
db = SQLAlchemy(app)
# Login manager
__author__ = 'ufarooqi'
from flask.ext.cache import Cache
from candidate_pool_service.common.utils.models_utils import init_talent_app
from candidate_pool_service.common.routes import CandidatePoolApi
from candidate_pool_service.common.talent_config_manager import TalentConfigKeys
from candidate_pool_service.common.talent_celery import init_celery_app
from candidate_pool_service.common.models.db import db
app, logger = init_talent_app(__name__)
try:
# Instantiate Flask-Cache object
cache = Cache(app, config={'CACHE_TYPE': 'redis', 'CACHE_REDIS_URL': app.config['REDIS_URL']})
# Instantiate Celery
celery_app = init_celery_app(app, 'celery_stats_scheduler')
from api.talent_pools import talent_pool_blueprint
from api.talent_pipelines import talent_pipeline_blueprint
from api.smartlists import smartlist_blueprint
app.register_blueprint(talent_pipeline_blueprint, url_prefix=CandidatePoolApi.URL_PREFIX)
app.register_blueprint(talent_pool_blueprint, url_prefix=CandidatePoolApi.URL_PREFIX)
app.register_blueprint(smartlist_blueprint, url_prefix=CandidatePoolApi.URL_PREFIX)
db.create_all()
db.session.commit()
logger.info("Starting candidate_pool_service in %s environment", app.config[TalentConfigKeys.ENV_KEY])
# Application setup
class MyFlask(Flask):
jinja_options = dict(Flask.jinja_options)
jinja_options.setdefault(
'extensions', []).append('i2p2www.extensions.HighlightExtension')
app = application = MyFlask('i2p2www',
template_folder=TEMPLATE_DIR,
static_url_path='/_static',
static_folder=STATIC_DIR)
app.debug = bool(os.environ.get('APP_DEBUG', 'False'))
babel = Babel(app, default_domain=DEFAULT_GETTEXT_DOMAIN)
cache = Cache(app, config=CACHE_CONFIG)
#################
# Babel selectors
@babel.localeselector
def get_locale():
# If viewing specs, require English
if request.path.startswith('/spec'):
return 'en'
# If the language is already set from the url, use that
if hasattr(g, 'lang'):
return g.lang
# otherwise try to guess the language from the user accept
# header the browser transmits. The best match wins.
from itertools import groupby
from cStringIO import StringIO
import csv
from shapely.wkb import loads
from shapely.geometry import box, asShape
from collections import OrderedDict
from urlparse import urlparse
from hashlib import md5
from plenario.models import MasterTable, MetaTable
from plenario.database import session, app_engine as engine, Base
from plenario.utils.helpers import get_socrata_data_info, slugify, increment_datetime_aggregate
from plenario.tasks import add_dataset
from plenario.settings import CACHE_CONFIG
cache = Cache(config=CACHE_CONFIG)
API_VERSION = '/v1'
RESPONSE_LIMIT = 1000
CACHE_TIMEOUT = 60 * 60 * 6
VALID_DATA_TYPE = ['csv', 'json']
VALID_AGG = ['day', 'week', 'month', 'quarter', 'year']
WEATHER_COL_LOOKUP = {
'daily': {
'temp_lo': 'temp_min',
'temp_hi': 'temp_max',
'temp_avg': 'temp_avg',
'precip_amount': 'precip_total',
},
'hourly': {
'temp_lo': 'drybulb_fahrenheit',
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.cache import Cache
import xml.etree.ElementTree as ET
import json
app = Flask(__name__)
db = SQLAlchemy(app)
cache = Cache(app, config={'CACHE_TYPE': 'simple'})
def dump_table_xml(elements, table, parent_node, collection_name,
element_name):
collection = ET.SubElement(parent_node, collection_name)
for element in elements:
element_node = ET.SubElement(collection, element_name)
element_dict = dict(
(col, getattr(element, col)) for col in table.columns.keys())
for key, value in element_dict.iteritems():
ET.SubElement(element_node, str(key)).text = unicode(value)
return collection
"""
@elements is a result set from sqlalchemy
@table is the table name used for the result set
returns a list of dicts
"""
def dump_table(elements, table):
all = [
#! /usr/bin/env python
# -*- encoding: utf-8 -*-
# Standard Lib
from datetime import timedelta
# Extra Lib
from flask import Flask
from flask.ext.babel import Babel
from flask.ext.cache import Cache
# Custom Tools
from tools.config import conf
# Create Aplication
app = Flask(__name__)
app.secret_key = conf.get('flask', 'secret_key')
app.debug = conf.get('flask', 'debug') == 'True'
app.config['BABEL_DEFAULT_LOCALE'] = conf.get('localization', 'locale')
app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(
minutes=int(conf.get('auth', 'session_minute')))
# Manage translation for the new application
babel = Babel(app)
# Manage Cache for the new application
cache = Cache(app, config={'CACHE_TYPE': conf.get('cache', 'method')})
# Clear Cache
cache.clear()
import os
import sys
from flask import Flask, redirect, send_from_directory, render_template
from flask.ext.cache import Cache
import logics
SERVER_PATH = os.path.abspath(os.path.dirname(sys.argv[0]))
STATIC_DIR = os.path.join(SERVER_PATH, "static")
TEMPLATE_DIR = os.path.join(SERVER_PATH, "template")
app = Flask(
"modelce", static_url_path=STATIC_DIR, template_folder=TEMPLATE_DIR)
cache = Cache(
app, config={'CACHE_TYPE': 'filesystem',
'CACHE_DIR': './_cache'})
baseline_commit_url = "https://github.com/Superjomn/paddle-modelci-baseline/commit"
paddle_commit_url = "https://github.com/PaddlePaddle/Paddle/commit"
@app.route('/')
@cache.cached(timeout=10)
def index():
return render_template(
'dashboard.html',
current_module='dashboard',
paddle_commit_url=paddle_commit_url,
source_code_updated=logics.source_code_updated(),
baseline_commit_url=baseline_commit_url,
last_success_commit=logics.last_success_commit(),
last_fail_commit=logics.last_fail_commit(),
__name__,
instance_relative_config = True
)
# Which config to use
mode = os.environ.get("PORTALAPI_MODE")
if mode is None:
raise Exception, "No API mode designated. Set the PORTALAPI_MODE environment variable to 'dev' or 'prod'"
elif mode == "dev":
print "Starting with development config..."
app.config.from_object("portalapi.flask_cfg.DevConfig")
elif mode == "prod":
print "Starting with production config..."
app.config.from_object("portalapi.flask_cfg.ProdConfig")
elif mode == "quick":
print "Starting with quick config..."
app.config.from_object("portalapi.flask_cfg.QuickConfig")
else:
raise Exception, "Unrecognized value for PORTALAPI_MODE: " + mode
# Enable cross-domain headers on all routes
CORS(app)
# Enable caching
cache = Cache(
app,
config = app.config["CACHE_CONFIG"]
)
from portalapi.controllers import routes
MAIL_SERVER='smtp.gmail.com',
MAIL_PORT=587,
MAIL_USE_TLS=True,
MAIL_USE_SSL=False,
MAIL_USERNAME='******',
MAIL_PASSWORD='******')
flask_mail = Mail(app)
db = MongoEngine(app)
login_manager = LoginManager()
login_manager.init_app(app)
flask_bcrypt = Bcrypt(app)
def register_blueprints(app):
# Prevents circular import (May be not helpful)#
from IdeaExplorer.views import posts
app.register_blueprint(posts)
register_blueprints(app)
cache = Cache(app)
from IdeaExplorer import restserver
if __name__ == '__main__':
app.run()
from flask.ext.migrate import Migrate
from flask.ext.cache import Cache
APP_DIR = os.path.dirname(__file__)
CONFIG_MODULE = os.environ.get('CARAVEL_CONFIG', 'caravel.config')
# Logging configuration
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object(CONFIG_MODULE)
db = SQLA(app)
cache = Cache(app, config=app.config.get('CACHE_CONFIG'))
migrate = Migrate(app, db, directory=APP_DIR + "/migrations")
class MyIndexView(IndexView):
@expose('/')
def index(self):
return redirect('/caravel/welcome')
appbuilder = AppBuilder(
app, db.session,
base_template='caravel/base.html',
indexview=MyIndexView,
security_manager_class=app.config.get("CUSTOM_SECURITY_MANAGER"))
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 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
# -*- coding: utf-8 -*- """Extensions module. Each extension is initialized in the app factory located in app.py """ from flask.ext.sqlalchemy import SQLAlchemy db = SQLAlchemy() from flask.ext.migrate import Migrate migrate = Migrate() from flask.ext.bcrypt import Bcrypt bcrypt = Bcrypt() # from flask.ext.admin import Admin # admin = Admin() from flask.ext.cache import Cache cache = Cache() from flask.ext.debugtoolbar import DebugToolbarExtension debug_toolbar = DebugToolbarExtension()
# coding: utf-8
from __future__ import (print_function, unicode_literals, absolute_import)
from flask import Flask
from flask.ext.mongoengine import MongoEngine
from flask.ext.cors import CORS
from flask.ext.cache import Cache
app = Flask(__name__)
app.config.from_object('app.settings')
enable_cors = app.config.get("ENABLE_CORS", False)
if enable_cors:
CORS(app, resources={
r"/properties/*": {
"origins": "*"
},
})
db = MongoEngine(app)
cache = Cache(config={"CACHE": app.config.get("CACHE_TYPE")})
cache.init_app(app)
from app.resources import properties
app.register_blueprint(properties.blueprint)
else: # we're debugging
DEBUG = True
env = None
if env:
redis = redis_from_url(env["DOTCLOUD_DATA_REDIS_URL"])
else: # we're debugging
redis = Redis()
showtime_parse_queue = Queue('showtime_parse', redis)
rp = redis.connection_pool.connection_kwargs
cache = Cache(app,
config={
'CACHE_TYPE': 'redis',
'CACHE_REDIS_HOST': rp.get('host'),
'CACHE_REDIS_POST': rp.get('port'),
'CACHE_REDIS_PASSWORD': rp.get('password')
})
### Various utilities I'll break out later
class SchemaEncoder(json.JSONEncoder):
"""
Encodes JSON from SQLAlchemy schemas that have .__json__() as well as datetimes
"""
def default(self, obj):
if isinstance(obj, db.Model):
return obj.__json__()
if isinstance(obj, datetime):
return obj.isoformat()
('CACHE_THRESHOLD', int),
('CACHE_KEY_PREFIX', text_type),
('CACHE_OBJECT_MAX_SIZE', int),
]
defaults = {
'CACHE_KEY_PREFIX': 'apiproxy:',
'CACHE_OBJECT_MAX_SIZE': (1000**2) * 5
}
if CACHE_TYPE.endswith("memcached"):
defaults.update({
'CACHE_MEMCACHED_SERVERS': ['127.0.0.1:11211'],
'CACHE_OBJECT_MAX_SIZE': (1000**2) * 1
})
config = defaults.copy()
for key, trans in env_keys:
envvar = ENV.get('EVE_API_%s' % key, None)
if not envvar:
continue
try:
envvar = trans(envvar)
except:
sys.stderr.write(
"The environment variable 'EVE_API_%s' is malformed: %r'" %
(key, envvar))
continue
config[key] = envvar
CACHE_OBJECT_MAX_SIZE = config.pop('CACHE_OBJECT_MAX_SIZE')
cache = Cache(app, config=config)
def create_app():
app = Flask(__name__)
app.config.from_object('config')
wfilehandler = logging.FileHandler('werkzeug.log')
wfilehandler.setLevel(logging.DEBUG)
wlog = logging.getLogger('werkzeug')
wlog.setLevel(logging.DEBUG)
wlog.addHandler(wfilehandler)
filehandler = logging.FileHandler('flask.log')
filehandler.setLevel(logging.DEBUG)
app.logger.setLevel(logging.DEBUG)
app.logger.addHandler(filehandler)
return app
app = create_app()
cache = Cache(app,
config={
'CACHE_TYPE': 'redis',
'CACHE_DEFAULT_TIMEOUT': 1000000000
})
from app import views, models
from database import db
@app.teardown_appcontext
def shutdown_session(exception=None):
db.remove()
from flaskext.gravatar import Gravatar
gravatar = Gravatar(size=35,
rating='g',
default='mm',
force_default=False,
force_lower=False)
from flask.ext.misaka import Misaka
md = Misaka(fenced_code=True,
superscript=True,
strikethrough=True,
hard_wrap=True,
autolink=True)
from flask.ext.cache import Cache
cache = Cache() # cache cache :)
def github_oauth(app):
from rauth.service import OAuth2Service
github = OAuth2Service(
name='github',
base_url='https://api.github.com/',
authorize_url='https://github.com/login/oauth/authorize',
access_token_url='https://github.com/login/oauth/access_token',
client_id=app.config['GITHUB_CONSUMER_KEY'],
client_secret=app.config['GITHUB_CONSUMER_SECRET'],
)
return github
