def init_app(app):
db.init_app(app)
cache.init_app(app)
debug_toolbar.init_app(app)
app.template_folder = os.path.join(os.path.dirname(__file__), 'templates/')
migrate = Migrate(app, db)
# Import and register the different asset bundles
assets_env = Environment(app)
assets_env.load_path = [os.path.join(os.path.dirname(__file__), 'static')]
assets_env.directory = os.path.join(os.path.dirname(__file__), 'static')
assets_env.url = '/admin/static/'
# assets_env.register('js_all', js)
print("directory ", assets_env.directory, os.path.join(os.path.dirname(__file__), 'static/'))
assets_loader = PythonAssetsLoader(assets)
for name, bundle in list(assets_loader.load_bundles().items()):
assets_env.register(name, bundle)
# Setup user handling
from silverflask.models import User
user_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(user_adapter)
user_manager.init_app(app)
###
# SILVERFLASK
###
upload_path = os.path.join(app.instance_path, app.config["SILVERFLASK_UPLOAD_PATH"])
app.config["SILVERFLASK_ABSOLUTE_UPLOAD_PATH"] = upload_path
app.storage_backend = LocalFileStorageBackend(upload_path)
from silverflask.controllers.page_controller import SiteTreeController
app.register_blueprint(SiteTreeController.create_blueprint(app))
from silverflask.core.dev_controller import DevController
app.register_blueprint(DevController.create_blueprint(app))
from silverflask.controllers.cms_controller import CMSController, PagesCMSController, FilesCMSController, \
DataObjectCMSController
app.register_blueprint(CMSController.create_blueprint(app))
app.register_blueprint(DataObjectCMSController.create_blueprint(app))
app.register_blueprint(PagesCMSController.create_blueprint(app))
app.register_blueprint(FilesCMSController.create_blueprint(app))
from silverflask.controllers.security_controller import SecurityController
app.register_blueprint(SecurityController.create_blueprint(app))
from silverflask.core.theme import init_themes
init_themes(app)
from silverflask.controllers.main import setup_processors, init_blueprint
from silverflask.controllers.cms import bp as cms_bp
setup_processors(app)
main = init_blueprint(app)
app.register_blueprint(main)
app.register_blueprint(cms_bp, url_prefix='/admin')
# for rule in app.url_map.iter_rules():
# print(rule)
return app
def register_web_ui(mgr):
global manager, assets
manager = mgr
assets_cache = os.path.join(manager.config_base, '.webassets-cache')
if not os.path.isdir(assets_cache):
os.mkdir(assets_cache)
assets = Environment(webui_app)
assets.directory = assets_cache
for p in _get_plugin_paths():
assets.append_path(p, url="%s/plugin" % webui_app.url_path)
assets.cache = assets_cache
assets.url = '%s/cache' % webui_app.url_path
if 'debug' in manager.args:
assets.debug = True
load_assets()
load_ui_plugins()
register_app(webui_app.url_path, webui_app)
register_home('%s/' % webui_app.url_path)
def install(cls, app):
"""Install the extension into the application."""
Environment.resolver_class = InvenioResolver
env = Environment(app)
env.url = "{0}/{1}/".format(app.static_url_path,
app.config["ASSETS_BUNDLES_DIR"])
env.directory = os.path.join(app.static_folder,
app.config["ASSETS_BUNDLES_DIR"])
env.append_path(app.static_folder)
env.auto_build = app.config.get("ASSETS_AUTO_BUILD", True)
# The filters less and requirejs don't have the same behaviour by
# default. Make sure we are respecting that.
app.config.setdefault("LESS_RUN_IN_DEBUG", True)
app.config.setdefault("REQUIREJS_RUN_IN_DEBUG", False)
# Fixing some paths as we forced the output directory with the
# .directory
app.config.setdefault("REQUIREJS_BASEURL", app.static_folder)
requirejs_config = os.path.join(env.directory,
app.config["REQUIREJS_CONFIG"])
if not os.path.exists(requirejs_config):
app.config["REQUIREJS_CONFIG"] = os.path.relpath(
os.path.join(app.static_folder,
app.config["REQUIREJS_CONFIG"]),
env.directory)
app.jinja_env.add_extension(BundleExtension)
app.context_processor(BundleExtension.inject)
def assets_env(app):
env = Environment(app)
env.url = "/static"
# App Engine doesn't support automatic rebuilding.
env.auto_build = False
# This file needs to be shipped with your code.
env.manifest = ('file:' + os.path.join(root_dir, 'webassets.manifest'))
env.versions = 'hash:32'
# create static bundles
env.register('new_js',
'js/hiro.js',
filters='yui_js',
output="javascript/hiro.%(version)s.js")
env.register('hoc_js',
'js/hoc.js',
filters='yui_js',
output="javascript/hoc.%(version)s.js")
env.register('new_css',
'css/hiro.css',
filters='cssmin',
output="stylesheets/hiro.%(version)s.css")
env.register('hoc_css',
'css/hoc.css',
filters='cssmin',
output="stylesheets/hoc.%(version)s.css")
env.debug = app.config['DEBUG']
return env
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
upload_folder = os.path.join(app.root_path, 'uploads/attachments/')
if not os.path.isdir(upload_folder):
os.makedirs(upload_folder)
app.config['UPLOAD_FOLDER'] = upload_folder
bootstrap.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
assets = Environment(app)
assets.url = app.static_url_path
index_scss = Bundle('scss/index.scss', filters='pyscss', output='index.css')
common_scss = Bundle('scss/common.scss', filters='pyscss', output='common.css')
assets.register('scss_index', index_scss)
assets.register('scss_common', common_scss)
from .main import main as main_blueprint
from .auth import auth as auth_blueprint
from .admin import admin as admin_blueprint
from .post import post as post_blueprint
app.register_blueprint(main_blueprint)
app.register_blueprint(auth_blueprint, url_prefix='/auth')
app.register_blueprint(admin_blueprint, url_prefix='/admin')
app.register_blueprint(post_blueprint, url_prefix='/post')
return app
def register_web_ui(mgr):
global manager, assets
manager = mgr
assets_cache = os.path.join(manager.config_base, '.webassets-cache')
if not os.path.isdir(assets_cache):
os.mkdir(assets_cache)
assets = Environment(webui_app)
assets.directory = assets_cache
for p in _get_plugin_paths():
assets.append_path(p, url="%s/plugin" % webui_app.url_path)
assets.cache = assets_cache
assets.url = '%s/cache' % webui_app.url_path
if 'debug' in manager.args:
assets.debug = True
load_assets()
load_ui_plugins()
register_app(webui_app.url_path, webui_app)
register_home('%s/' % webui_app.url_path)
def init_assets(application):
assets = Environment(application)
assets.url = application.static_url_path
bootstrap_css = LogBundle(*list(find('bootstrap*.css')), filters='cssmin', output='css/bootstrap.css')
scss = LogBundle(*list(find('*.scss')), filters='pyscss, cssmin', output='css/app.css')
assets.register('app.css', bootstrap_css, scss)
jq_bstrap_list = list(chain(find('jquery*.js'), find('bootstrap*.js')))
js_list = filter(lambda x: x not in jq_bstrap_list, find('*.js'))
jq_bstrap = LogBundle(*jq_bstrap_list, filters='rjsmin', output='js/jq-bstrap.js')
js = LogBundle(*js_list, filters='rjsmin', output='js/all.js')
coffee = LogBundle(*list(find('*.coffee')), filters='coffeescript, rjsmin', output='js/coffee.js')
assets.register('app.js', *filter(lambda x: x, [jq_bstrap, js, coffee]))
favicon = LogBundle(*list(find('favicon.ico')), output='img/favicon.ico')
assets.register('favicon.ico', favicon)
logo = LogBundle(*list(find('logo.png')), output='img/logo.png')
assets.register('logo.png', logo)
forkme = LogBundle(*list(find('forkme.png')), output='img/forkme.png')
assets.register('forkme.png', forkme)
#assets.add(bundle)
#bundle.build()
def init_app(app):
assets = Environment(app)
assets.debug = app.config.get('DEBUG', False)
assets.directory = app.static_folder
assets.url = app.static_url_path
assets.directory = app.static_folder
assets.append_path(assets_directory)
assets.append_path(app.static_folder)
def create_app(package_name, js_assets=None, css_assets=None,
settings_override=None):
"""Flask app factory."""
app = Flask(package_name, instance_relative_config=True)
app.config.from_pyfile('settings.cfg', silent=False)
app.config.from_object(settings_override)
assets = Environment(app)
assets.url = '../static'
common_css_assets = [
'css/bootstrap.min.css',
'css/animations.css',
'css/superfish.css',
'css/prettyPhoto.css',
'css/style.css',
'css/colors/blue.css',
'css/theme-responsive.css',
]
common_js_assets = [
'js/jquery.min.js',
'js/bootstrap.min.js',
'js/handlebars.js',
'js/ember.js',
'js/jquery.cookie.js',
'js/jquery.ba-bbq.min.js',
]
if js_assets is not None:
js_assets = common_js_assets + js_assets
else:
js_assets = common_js_assets
js_bundle = Bundle(
*js_assets,
filters='jsmin',
output='gen/' + package_name + '.js'
)
assets.register('js_all', js_bundle)
if css_assets is not None:
css_assets = common_css_assets + css_assets
else:
css_assets = common_css_assets
css_bundle = Bundle(
*css_assets,
filters='cssmin',
output='gen/' + package_name + '.css'
)
assets.register('css_all', css_bundle)
assets.init_app(app)
return app
def handle(self, app, **kwargs):
assets = Environment(app)
assets.url = app.static_url_path# = os.path.join(_appdir, 'static')
assets.register('all_css', app.bundles['all_css_min'])
assets.register('all_js', app.bundles['all_js_min'])
log = logging.getLogger('webassets')
log.addHandler(logging.StreamHandler())
log.setLevel(logging.DEBUG)
cmdenv = CommandLineEnvironment(assets, log)
cmdenv.invoke('build', kwargs)
def configure_extensions(app):
# Flask-PyMongo
mongo.init_app(app)
# Flask-OAuthlib
oauth.init_app(app)
# Flask-Login
@login_manager.user_loader
def load_user(user_id):
"""Returns the currently active user as an object.
Since this app doesn't handle passwords etc. there isn't as much
incentive to keep pinging the database for every request protected
by 'login_required'.
Instead I set the expiration for the session cookie to expire at
regular intervals.
"""
# 1. Retrive user data from the session
# 2. Create new User object based of that (potential) data
data = {
'user_id': session.get('user_id'),
'name': session.get('name'),
'email': session.get('email')
}
if data.get('email'):
user = User(**data)
else:
user = None
return user
login_manager.init_app(app)
# Flask-Assets
# Doing setup here to avoid RuntimeError: assets instance not bound...
assets = Environment(app)
assets.auto_build = app.config.get('DEBUG')
assets.load_path = [
os.path.join(os.path.dirname(__file__), 'scss'),
os.path.join(os.path.dirname(__file__), 'coffee'),
os.path.join(os.path.dirname(__file__), 'handlebars'),
os.path.join(os.path.dirname(__file__), 'vendor'),
]
assets.url = app.static_url_path
assets.register('js_all', js)
assets.register('js_app', js_app)
assets.register('ember_templates', ember_templates)
assets.register('scss_all', scss)
# New Relic Python Agent
newrelic.agent.initialize('newrelic.ini')
def bundle_assets(app):
assets = Environment(app)
assets.url = app.static_url_path
scss = Bundle('css/lib/normalize.css',
'css/lib/skeleton.css',
'css/lib/font-awesome.min.css',
'css/vv_skeleton.scss',
'css/main.scss',
'css/about.scss',
'css/contact.scss',
'css/partials/modal.scss',
filters = 'pyscss', output = 'all.css')
assets.register('scss_all', scss)
def configure_static_assets(app):
loader = YAMLLoader('assets.yaml')
assets = Environment(app)
assets.manifest = None
assets.cache = False
assets.directory = './makers'
assets.url = ''
for name, bundle in loader.load_bundles().items():
assets.register(name, bundle)
app.environment = assets
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 init_app(app):
assets = Environment(app)
assets.debug = app.config.get('DEBUG', False)
assets.directory = app.static_folder
assets.url = app.static_url_path
assets.directory = app.static_folder
assets.append_path(assets_directory)
assets.append_path(app.static_folder)
assets.register("h5bp_css", h5bp_css)
assets.register("h5bp_shiv", h5bp_shiv)
assets.register("h5bp_head_js", h5bp_head_js)
if assets.debug:
assets.register("h5bp_body_js", h5bp_body_js_devel)
else:
assets.register("h5bp_body_js", h5bp_body_js_production)
def setup_bundles(app):
assets_env = Environment(app)
assets_env.url = '/statics'
assets_env.manifest = 'file:Compiled/static-manifest-version'
assets_env.cache = False
assets_env.auto_build = False
assets_env.debug = app.config.get('DEVELOPMENT') == True
# load and register bundles
config_path = app.instance_path + '/config/asset_bundles.yaml'
bundles = YAMLLoader(config_path).load_bundles()
for name, bundle in bundles.iteritems():
assets_env.register(name, bundle)
app.assets_env = assets_env
def setup_app(app):
"""Initialize Assets extension."""
app.config.setdefault("LESS_RUN_IN_DEBUG", False)
assets = Environment(app)
assets.url = app.static_url_path + "/"
assets.directory = app.static_folder
commands = (("LESS_BIN", "lessc"),
("CLEANCSS_BIN", "cleancss"))
import subprocess
for key, cmd in commands:
try:
command = app.config.get(key, cmd)
subprocess.call([command, "--version"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
except OSError:
app.logger.error("Executable `{0}` was not found. You can specify "
"it via {1}."
.format(cmd, key))
app.config["ASSETS_DEBUG"] = True
assets.debug = True
def _jinja2_new_bundle(tag, collection, name=None, filters=None):
if len(collection):
name = "invenio" if name is None else name
sig = hash(",".join(collection) + "|" + str(filters))
kwargs = {
"output": "{0}/{1}-{2}.{0}".format(tag, name, sig),
"filters": filters,
"extra": {"rel": "stylesheet"}
}
# If LESS_RUN_IN_DEBUG is set to False, then the filters are
# removed and each less file will be parsed by the less JavaScript
# library.
if assets.debug and not app.config.get("LESS_RUN_IN_DEBUG", True):
kwargs["extra"]["rel"] = "stylesheet/less"
kwargs["filters"] = None
return Bundle(*collection, **kwargs)
app.jinja_env.extend(new_bundle=_jinja2_new_bundle,
default_bundle_name='90-invenio')
app.jinja_env.add_extension(CollectionExtension)
return app
def init_app(app):
here, f = os.path.split(os.path.abspath(__file__))
# configure assets
assets = Environment(app)
assets.versions = 'hash'
assets.directory = '%s/src' % here
if app.debug == False:
assets.auto_build = False
# i have no idea why, but an arbitrary
# second path segment is required here
assets.url = '/static/turnip'
# load asset bundles
bundles = YAMLLoader("%s/src/assets.yaml" % here).load_bundles()
[assets.register(name, bundle) for name, bundle in bundles.iteritems()]
def create_app():
app = Flask(__name__,
static_url_path='',
static_folder='../public',
template_folder='../views')
app.config.update(config['flask'])
CsrfProtect(app)
mail.init_app(app)
ViewFilters.register(app)
assets = Environment(app)
assets.load_path = [
app.static_folder,
approot('bower_components')
]
assets.url = app.static_url_path
if app.debug:
css_filters = 'sass,cssmin'
js_filters = 'jsmin'
else:
css_filters = 'sass'
js_filters = None
css_bundle = Bundle('style.sass', filters=css_filters, output='bundle.min.css')
assets.register('css_all', css_bundle)
js_bundle = Bundle('jquery/dist/jquery.js', 'sjcl/sjcl.js', 'jquery-qrcode/jquery.qrcode.min.js', 'js/*.js', filters=js_filters, output='bundle.min.js')
assets.register('js_all', js_bundle)
app.register_blueprint(Blueprint(
'bower', __name__, static_url_path='/bower', static_folder=approot('bower_components')))
blueprint.register(app)
for paste in db_session.query(Paste.key).filter_by(legacy=True).all():
route = u'/' + paste.key
app.add_url_rule(route, 'legacy_show_'+paste.key, partial(redirect, '/paste/' + paste.key))
if config['paste.spam_ml']:
spam_ml.load()
return app
def init_assets(application):
assets = Environment(application)
assets.config['SASS_BIN'] = "/usr/local/bin/sass"
assets.load_path = ["assets/"]
assets.url = "/static"
css_main = Bundle('sass/app.scss',
filters=('pyscss,cssmin'),
depends=('sass/*.scss', 'sass/**/*.scss', 'sass/**/**/*.scss'),
output='css/gen/app.%(version)s.css')
assets.register('css_main', css_main)
js_base = Bundle('js/vendor/excanvas.js',
'js/vendor/jquery-1.11.1.js',
'js/vendor/jquery.minecraftskin.js')
js_main = Bundle(js_base,
filters='rjsmin',
output='js/gen/app.%(version)s.js')
assets.register('js_main', js_main)
def create_app():
app = Flask('zgeist',
static_folder=util.approot('public'),
template_folder=util.approot('view'))
app.debug = True
assets = Environment(app)
assets.url = app.static_url_path
css_bundle = Bundle('css/style.sass', filters='sass', output='gen/style.css')
assets.register('css_all', css_bundle)
js_bundle = Bundle('js/*.js', output='gen/packed.min.js')
assets.register('js_all', js_bundle)
# automagically discovers and loads all the
# blueprints in the frontend package
util.register_blueprints(app, __name__, __path__)
return app
def init_app(app):
# Initialize webassets, the asset pipeline
assets = Environment(app)
assets.debug = app.config['DEBUG']
cur_path = os.path.dirname(os.path.abspath(__file__))
assets_load_path = os.path.join(cur_path, 'static')
if ('WEBASSETS_PATH' in app.config):
assets_load_path = app.config['WEBASSETS_PATH']
logger.debug('Using asset directory specified in config.')
logger.debug('Using asset directory of: {0}.'.format(assets_load_path))
# Output path for compiled assets
assets.directory = os.path.join(cur_path, 'static')
assets.url = '/static/'
assets.from_yaml(os.path.join(cur_path, 'assets.yml'))
assets.config['closure_compressor_optimization'] = 'SIMPLE_OPTIMIZATIONS'
assets.config['closure_extra_args'] = ['--language_in', 'ECMASCRIPT5']
assets.append_path(assets_load_path)
return assets
import importlib
from flask import Flask, Blueprint
from flask.ext.assets import Bundle, Environment
from flask.ext.security import Security, SQLAlchemyUserDatastore
from flask.ext.sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config.from_object('config.development')
# Assets
assets = Environment(app)
assets.url = '/static'
assets.directory = app.config['ASSETS_DEST']
less = Bundle('less/base.less', filters='less', output='gen/style.css')
assets.register('all-css', less)
# Database
db = SQLAlchemy(app)
# Admin
import admin
# Security
from starter.auth.models import User, Role
from config.cdn import proxied
from utils.flaskutils import RegisterJst
from utils.ext.bunch import Bunch
from utils.ext.path import Path
from .app import app
Coffee = partial(Bundle, filters='coffeescript', debug=False)
SCSS = partial(Bundle, filters='pyscss', debug=False)
JS = partial(Bundle, filters='yui_js')
CSS = partial(Bundle, filters='yui_css')
assets = Environment(app)
assets.url = proxied('/static/')
class Special(str):
pass
class Depends(Special):
pass
asset_spec = {
"todo.js": (
'todo/jst/*.jst',
'todo/TodoModel.coffee',
'todo/TodoCollection.coffee',
from modules.log import initialize
initialize()
application = Flask(
__name__, static_folder=join(abspath(dirname(__file__)), 'resources'),
)
application.config.from_pyfile('settings.py')
assets = Environment(application)
assets.cache = not application.config['DEBUG']
assets.debug = application.config['DEBUG']
assets.directory = application.static_folder
assets.manifest = 'json:assets/versions.json'
assets.url = application.static_url_path
assets.url_expire = True
assets.versions = 'hash'
assets.register('javascripts', Bundle(
'vendor/jquery/dist/jquery.js',
'vendor/angular/angular.min.js',
'vendor/bootstrap/dist/js/bootstrap.js',
'vendor/highcharts/highcharts-all.js',
'javascripts/all.js',
filters='rjsmin' if not application.config['DEBUG'] else None,
output='assets/compressed.js',
))
assets.register('stylesheets', Bundle(
Bundle(
'stylesheets/all.less', filters='less', output='stylesheets/all.css',
),
"""
qgic
~~~~
Website for the Queen's Global Innovation Conference (2013)
blah blah blah
"""
from flask import Flask, render_template, url_for
from flask.ext.assets import Environment, Bundle
app = Flask(__name__)
assets = Environment(app)
assets.url = '/static' # HACK HACK HACK
assets.auto_build = False
assets.debug = False
assets.manifest = "file:assets-manifest"
assets.register('css_screen', 'sass/screen.sass',
filters='compass', output='css/screen.%(version)s.css')
assets.register('css_print', 'sass/print.sass',
filters='compass', output='css/print.%(version)s.css')
assets.register('js', 'coffee/main.coffee',
filters='coffeescript', output='js/main.%(version)s.js')
@app.route('/')
def home():
"delete_old_file": False,
"rename_enabled": False,
"rename_search": "",
"rename_replace": ""
}
})
app.config["CSRF_SESSION_KEY"] = config["general"]["csrf_session_key"]
app.config["SECRET_KEY"] = config["general"]["secret_key"]
assets = Environment(app)
# use app/static/compiled as output path for webassets' assets
assets.directory = os.path.abspath(app.root_path + os.sep + "static" + os.sep +
"compiled")
assets.url = "/static/compiled"
# use app/static as load path for assets
assets.append_path(app.root_path + os.sep + "static", "static")
# load asset definitions from "static/webassets.py"
assets_loader = PythonAssetsLoader(webassets)
bundles = assets_loader.load_bundles()
for bundle in bundles:
assets.register(bundle, bundles[bundle])
db = SQLAlchemy(app)
babel = Babel(app)
Compress(app)
static_folder=join(abspath(dirname(__file__)),
'resources'))
application.config.from_pyfile('settings/__init__.py')
application.config.from_pyfile(
'settings/%(environment)s.py' % {
'environment': environ.get('environment', 'serve'),
},
silent=True)
assets = Environment(application)
assets.cache = False
assets.debug = application.config['DEBUG']
assets.directory = application.static_folder
assets.manifest = 'json:assets/versions.json'
assets.url = application.static_url_path
assets.url_expire = True
assets.versions = 'hash'
assets.register(
'javascripts',
Bundle(
'vendor/jquery/dist/jquery.js',
'vendor/bootstrap/dist/js/bootstrap.js',
filters='rjsmin' if not application.config['DEBUG'] else None,
output='assets/compressed.js',
))
assets.register(
'stylesheets',
Bundle(
Bundle(
'stylesheets/all.less',
def init_app(app):
db.init_app(app)
cache.init_app(app)
debug_toolbar.init_app(app)
app.template_folder = os.path.join(os.path.dirname(__file__), 'templates/')
migrate = Migrate(app, db)
# Import and register the different asset bundles
assets_env = Environment(app)
assets_env.load_path = [os.path.join(os.path.dirname(__file__), 'static')]
assets_env.directory = os.path.join(os.path.dirname(__file__), 'static')
assets_env.url = '/admin/static/'
# assets_env.register('js_all', js)
print("directory ", assets_env.directory,
os.path.join(os.path.dirname(__file__), 'static/'))
assets_loader = PythonAssetsLoader(assets)
for name, bundle in list(assets_loader.load_bundles().items()):
assets_env.register(name, bundle)
# Setup user handling
from silverflask.models import User
user_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(user_adapter)
user_manager.init_app(app)
###
# SILVERFLASK
###
upload_path = os.path.join(app.instance_path,
app.config["SILVERFLASK_UPLOAD_PATH"])
app.config["SILVERFLASK_ABSOLUTE_UPLOAD_PATH"] = upload_path
app.storage_backend = LocalFileStorageBackend(upload_path)
from silverflask.controllers.page_controller import SiteTreeController
app.register_blueprint(SiteTreeController.create_blueprint(app))
from silverflask.core.dev_controller import DevController
app.register_blueprint(DevController.create_blueprint(app))
from silverflask.controllers.cms_controller import CMSController, PagesCMSController, FilesCMSController, \
DataObjectCMSController
app.register_blueprint(CMSController.create_blueprint(app))
app.register_blueprint(DataObjectCMSController.create_blueprint(app))
app.register_blueprint(PagesCMSController.create_blueprint(app))
app.register_blueprint(FilesCMSController.create_blueprint(app))
from silverflask.controllers.security_controller import SecurityController
app.register_blueprint(SecurityController.create_blueprint(app))
from silverflask.core.theme import init_themes
init_themes(app)
from silverflask.controllers.main import setup_processors, init_blueprint
from silverflask.controllers.cms import bp as cms_bp
setup_processors(app)
main = init_blueprint(app)
app.register_blueprint(main)
app.register_blueprint(cms_bp, url_prefix='/admin')
# for rule in app.url_map.iter_rules():
# print(rule)
return app
"""
qgic
~~~~
Website for the Queen's Global Innovation Conference (2013)
blah blah blah
"""
from flask import Flask, render_template, url_for
from flask.ext.assets import Environment, Bundle
app = Flask(__name__)
assets = Environment(app)
assets.url = '/static' # HACK HACK HACK
assets.auto_build = False
assets.debug = False
assets.manifest = "file:assets-manifest"
assets.register('css_screen',
'sass/screen.sass',
filters='compass',
output='css/screen.%(version)s.css')
assets.register('css_print',
'sass/print.sass',
filters='compass',
output='css/print.%(version)s.css')
assets.register('js',
'coffee/main.coffee',
from dexter.app import app
# setup assets
from flask.ext.assets import Environment, Bundle
assets = Environment(app)
assets.url_expire = False
assets.debug = app.config['ENV'] == 'development'
assets.directory = '%s/public' % app.config.root_path
assets.load_path = ['assets']
assets.url = '/public'
assets.register('css',
Bundle(
'css/bootstrap-3.2.0.min.css',
'css/bootstrap-theme-3.2.0.min.css',
'css/font-awesome-4.3.0.min.css',
'css/datepicker3.css',
'css/bootstrap-datetimepicker.min.css',
'css/daterangepicker-bs3.css',
'css/select2-3.4.8.css',
'css/select2-bootstrap-3.4.8.css',
'css/dropzone-3.10.2.css',
Bundle(
'css/*.scss',
filters='pyscss',
output='css/app.%(version)s.css'),
output='css/all.%(version)s.css'))
assets.register('mine-css',
Bundle(
'css/bootstrap-3.2.0.min.css',
def init(app):
assets = Environment(app)
if app.config.get('CARAVELA_ENV') == 'production':
assets.debug=False
assets.auto_build=False
#else:
# assets.debug = True
assets.url = app.static_url_path
assets.register('common.js', Bundle(
'lib/jquery-1.9.1.min.js',
'lib/bootstrap.js',
'lib/modernizr-2.6.1.min.js',
'lib/underscore-min.js',
'lib/less-1.3.0.min.js',
'lib/jquery-ui-1.10.1.custom.min.js',
'lib/jquery.mousewheel.js',
'lib/handlebars-1.0.0.js',
'lib/ember-1.0.0.js',
'lib/ember-data.js',
'lib/ember-table.js',
'lib/d3.v3.min.js',
'lib/vega.js',
'lib/d3.geo.projection.min.js',
'lib/codemirror.js',
'lib/mode/javascript/javascript.js',
'js/app.js',
'js/routes/*.js',
'js/controllers/*.js',
'js/models/*.js',
'js/views/*.js',
#filters='rjsmin',
output='assets/common.js'
))
sass = Bundle(
'**/*.sass',
filters='compass',
output='assets/sass.css'
)
assets.register('sass.css', sass)
assets.register('common.css', Bundle(
sass,
'css/bootstrap.min.css',
'lib/codemirror.css',
'css/persona-buttons.css',
'css/style.css',
output='assets/common.css'
))
assets.config.update(dict(
jst_compiler = "Em.Handlebars.compile",
jst_namespace= "Em.TEMPLATES"
))
assets.register('app.handlebars', Bundle(
'templates/*.handlebars',
'templates/**/*.handlebars',
filters='jst',
output='assets/app.handlebars'
))
"parameters": "-acodec aac -strict experimental -s 1280x720 -aspect = 1280:720 -preset slow -crf 22 -f matroska -vcodec libx265",
"delete_old_file": False,
"rename_enabled": False,
"rename_search": "",
"rename_replace": ""
}
})
app.config["CSRF_SESSION_KEY"] = config["general"]["csrf_session_key"]
app.config["SECRET_KEY"] = config["general"]["secret_key"]
assets = Environment(app)
# use app/static/compiled as output path for webassets' assets
assets.directory = os.path.abspath(app.root_path + os.sep + "static" + os.sep + "compiled")
assets.url = "/static/compiled"
# use app/static as load path for assets
assets.append_path(app.root_path + os.sep + "static", "static")
# load asset definitions from "static/webassets.py"
assets_loader = PythonAssetsLoader(webassets)
bundles = assets_loader.load_bundles()
for bundle in bundles:
assets.register(bundle, bundles[bundle])
db = SQLAlchemy(app)
babel = Babel(app)
Compress(app)
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.DEBUG)
loggers = [app.logger, logging.getLogger('elasticsearch')]
for logger in loggers:
logger.setLevel(logging.WARNING)
logger.addHandler(stream_handler)
# When I'm ready to fix this with bower and stuff
# look at http://adambard.com/blog/fresh-flask-setup/
assets = Environment(app)
assets.directory = 'eheritage/static/'
assets.url = '/static/'
assets.debug = True
js = Bundle('app.js',
filters='jsmin', output='gen/packed.js')
assets.register('js_all', js)
# scss = Bundle('*.scss', filters='scss', output='gen/scss.css')
# css = Bundle('style.css', # scss,
# filters='pyscss,cssmin', output='gen/style.css')
# assets.register('css_all', css)
app.json_encoder = IterableAwareEncoder
'db1': app.config['SQLALCHEMY_DATABASE_URI'],
}
root_path = os.path.abspath("%s/.." % os.path.dirname(__file__))
tmp_path = "%s/tmp" % root_path
os.environ['BOTO_ENDPOINTS'] = os.path.abspath(
"%s/config/boto_endpoints.json" % root_path)
###################
# ASSETS SETTINGS #
###################
assets = Environment(app)
loader = YAMLLoader("%s/assets/assets.yml" % root_path)
bundles = loader.load_bundles()
assets.register(bundles)
assets.set_directory("%s/public" % root_path)
assets.load_path.append('./assets/')
assets.url = '/'
assets.manifest = "json:%s/public/gen/webassets-manifest.json" % root_path
development_mode = not environment.equals('production')
assets.cache = development_mode
assets.auto_build = development_mode
assets.debug = development_mode
# MD Feb-2015 Allow created files to be group writeable. This will fix some problems with files created in the /tmp
# directory that are accessed both by Celery and duesty scripts. The /tmp directory should have set "chmod g+s tmp"
os.umask(0o002)
__author__ = 'hsk81'
###############################################################################
###############################################################################
from flask.ext.assets import Environment
from webassets.loaders import YAMLLoader
from ..app import app
###############################################################################
###############################################################################
loader = YAMLLoader (app.config['YML_FILE'])
bundles = loader.load_bundles ()
assets = Environment (app)
assets.manifest = 'cache'
assets.register (bundles)
assets.url = app.config.get ('CDN')
###############################################################################
###############################################################################
from flask.ext.sqlalchemy import SQLAlchemy
from flask_heroku import Heroku
from flask.ext.assets import Environment, Bundle
import wtforms as wtf
app = Flask(__name__)
heroku = Heroku(app)
app.config.from_envvar('APP_CONFIG')
# Set up the database
db = SQLAlchemy(app)
# CSS/JS/etc assets
assets = Environment(app)
assets.url = 'static'
assets.register('js_all',
'js/lib/*.js', 'js/*.js',
filters='uglifyjs', output='gen/js_all.min.js')
assets.register('css_all',
'css/*.css',
Bundle('css/*.less', filters='less'),
filters='cssmin',
output='gen/css_all.min.css')
# Sample Model
class SampleModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(15), unique=False)
def create_app(config=None, debug=False):
'''
Inicializa la aplicación Flask. Carga los siguientes módulos:
- index: página de inicio
- page: páginas estáticas
- user: gestión del usuario
- files: búsqueda y obtención de ficheros
- status: servicio de monitorización de la aplicación
Y además, inicializa los siguientes servicios:
- Configuración: carga valores por defecto y modifica con el @param config
- Web Assets: compilación y compresión de recursos estáticos
- i18n: detección de idioma en la URL y catálogos de mensajes
- Cache y auth: Declarados en el módulo services
- Files y users: Clases para acceso a datos
'''
app = Flask(__name__)
app.config.from_object(defaults)
app.debug = debug
# Configuración
if config:
app.config.from_object(config)
# Gestión centralizada de errores
logging.getLogger().setLevel(logging.DEBUG if debug else logging.INFO)
if app.config["SENTRY_DSN"]:
sentry.init_app(app)
# Configuración dependiente de la versión del código
revision_filename_path = os.path.join(os.path.dirname(app.root_path), "revision")
if os.path.exists(revision_filename_path):
f = open(revision_filename_path, "r")
data = f.read()
f.close()
revisions = tuple(
tuple(i.strip() for i in line.split("#")[0].split())
for line in data.strip().split("\n")
if line.strip() and not line.strip().startswith("#"))
revision_hash = md5(data).hexdigest()
app.config.update(
CACHE_KEY_PREFIX = "%s%s/" % (
app.config["CACHE_KEY_PREFIX"] if "CACHE_KEY_PREFIX" in app.config else "",
revision_hash
),
REVISION_HASH = revision_hash,
REVISION = revisions
)
else:
app.config.update(
REVISION_HASH = None,
REVISION = ()
)
# Registra filtros de plantillas
register_filters(app)
# Registra valores/funciones para plantillas
app.jinja_env.globals["u"] = u
# Oauth
init_oauth(app)
# Blueprints
app.register_blueprint(index)
app.register_blueprint(page)
app.register_blueprint(user)
app.register_blueprint(files)
app.register_blueprint(api)
add_labs(app) # Labs (blueprints y alternativas en pruebas)
# Web Assets
if not os.path.isdir(app.static_folder+"/gen"): os.mkdir(app.static_folder+"/gen")
assets = Environment(app)
assets.debug = app.debug
assets.url=app.static_url_path
register_filter(JsSlimmer)
register_filter(CssSlimmer)
assets.register('css_all', 'css/jquery-ui.css', Bundle('css/main.css', filters='pyscss', output='gen/main.css', debug=False), filters='css_slimmer', output='gen/foofind.css')
assets.register('css_ie', 'css/ie.css', filters='css_slimmer', output='gen/ie.css')
assets.register('css_ie7', 'css/ie7.css', filters='css_slimmer', output='gen/ie7.css')
assets.register('css_search', 'css/jquery-ui.css', Bundle('css/search.css', filters='pyscss', output='gen/s.css', debug=False), filters='css_slimmer', output='gen/search.css')
assets.register('css_labs', 'css/jquery-ui.css', Bundle('css/labs.css', filters='pyscss', output='gen/l.css', debug=False), filters='css_slimmer', output='gen/labs.css')
assets.register('css_admin', Bundle('css/admin.css', filters='css_slimmer', output='gen/admin.css'))
assets.register('js_all', Bundle('js/jquery.js', 'js/jquery-ui.js', 'js/jquery.ui.selectmenu.js', 'js/files.js', filters='rjsmin', output='gen/foofind.js'), )
assets.register('js_ie', Bundle('js/html5shiv.js', 'js/jquery-extra-selectors.js', 'js/selectivizr.js', filters='rjsmin', output='gen/ie.js'))
assets.register('js_labs', Bundle('js/jquery.js', 'js/jquery-ui.js', 'js/labs.js', filters='rjsmin', output='gen/labs.js'))
assets.register('js_admin', Bundle('js/jquery.js', 'js/admin.js', filters='rjsmin', output='gen/admin.js'))
# Detección de idioma
@app.url_defaults
def add_language_code(endpoint, values):
'''
Añade el código de idioma a una URL que lo incluye.
'''
if 'lang' in values or not g.lang:
return
if app.url_map.is_endpoint_expecting(endpoint, 'lang'):
values['lang'] = g.lang
pull_lang_code_languages = tuple(
(code,localedata.load(code)["languages"][code].capitalize(), code in app.config["BETA_LANGS"])
for code in app.config["ALL_LANGS"])
@app.url_value_preprocessor
def pull_lang_code(endpoint, values):
'''
Carga el código de idioma en la variable global.
'''
# obtiene el idioma de la URL
g.url_lang = None
if values is not None:
g.url_lang = values.pop('lang', None)
# si esta lista de idiomas permitidos
if g.url_lang and g.url_lang in app.config["ALL_LANGS"]:
g.lang = g.url_lang
# si el usuario esta logueado y tiene establecido el idioma se asigna ese
elif "user" in session and "lang" in session["user"]:
g.lang = session["user"]["lang"]
# si no esta logueado y ha elegido un idioma
elif "lang" in session:
g.lang = session["lang"]
else:
accept = request.accept_languages.values()
# si viene, se coge el que mas convenga dependiendo del que tenga establecido en su navegador o el idioma por defecto
locale = Locale.negotiate((option.replace("-","_") for option in accept), app.config["ALL_LANGS"]) if accept else None
if locale:
g.lang = locale.language
else:
g.lang = app.config["LANGS"][0] # valor por defecto si todo falla
# se carga la lista de idiomas como se dice en cada idioma
g.languages = pull_lang_code_languages
g.beta_lang = g.lang in app.config["BETA_LANGS"]
# Traducciones
babel.init_app(app)
@babel.localeselector
def get_locale():
'''
Devuelve el código del idioma activo.
'''
try: return g.lang
except: return "en"
# Cache
cache.init_app(app)
# Autenticación
auth.setup_app(app)
auth.login_view="user.login"
auth.login_message="login_required"
@auth.user_loader
def load_user(userid):
user = User(userid)
if not user.has_data:
data = usersdb.find_userid(userid)
if data is None:
return None
user.set_data(data)
return user
# Mail
mail.init_app(app)
# Acceso a bases de datos
filesdb.init_app(app)
usersdb.init_app(app)
pagesdb.init_app(app)
feedbackdb.init_app(app)
configdb.init_app(app)
# Servicio de búsqueda
@app.before_first_request
def init_search():
searchd_servers = [(server["_id"], str(server["sp"]), int(server["spp"])) for server in filesdb.get_servers() if "sp" in server]
stats = {server[0]:filesdb.get_server_stats(server[0]) for server in searchd_servers}
searchd.init_app(app, searchd_servers, stats)
init_search_stats()
# Taming
taming.init_app(app)
# Refresco del contador de ficheros
lastcount = [filesdb.count_files()]
def countupdater():
lastcount[0] = long(filesdb.count_files())
eventmanager.interval(app.config["COUNT_UPDATE_INTERVAL"], countupdater)
# Refresco de conexiones
eventmanager.interval(app.config["FOOCONN_UPDATE_INTERVAL"], filesdb.load_servers_conn)
# Refresco de configuración
configdb.pull()
eventmanager.interval(app.config["CONFIG_UPDATE_INTERVAL"], configdb.pull)
# Profiler
profiler.init_app(app, feedbackdb)
# Carga la traducción alternativa
fallback_lang = support.Translations.load(os.path.join(app.root_path, 'translations'), ["en"])
# Unittesting
unit.init_app(app)
# Inicializa
init_labs(app)
if app.config["UNITTEST_INTERVAL"]:
eventmanager.timeout(20, unit.run_tests)
eventmanager.interval(app.config["UNITTEST_INTERVAL"], unit.run_tests)
# Inicio del eventManager
eventmanager.start()
@app.before_request
def before_request():
# No preprocesamos la peticiones a static
if request.path.startswith("/static"):
return
# si el idioma de la URL es inválido, devuelve página no encontrada
if g.url_lang and not g.url_lang in app.config["ALL_LANGS"]:
abort(404)
# ignora peticiones sin blueprint
if request.blueprint is None:
if request.path.endswith("/"):
if "?" in request.url:
return redirect(request.url_root[:-1] + request.path + request.url[request.url.find("?"):], 301)
return redirect(request.url[:-1], 301)
return
# si no es el idioma alternativo, lo añade por si no se encuentra el mensaje
if g.lang!="en":
get_translations().add_fallback(fallback_lang)
# dominio de la web
g.domain = request.url_root[8:-1] if request.url_root.startswith("https") else request.url_root[7:-1]
# título de la página por defecto
g.title = g.domain
# contador de archivos totales
g.count_files = lastcount[0]
# Páginas de error
@app.errorhandler(400)
@app.errorhandler(401)
@app.errorhandler(403)
@app.errorhandler(404)
@app.errorhandler(405)
@app.errorhandler(408)
@app.errorhandler(409)
@app.errorhandler(410)
@app.errorhandler(411)
@app.errorhandler(412)
@app.errorhandler(413)
@app.errorhandler(414)
@app.errorhandler(415)
@app.errorhandler(416)
@app.errorhandler(417)
@app.errorhandler(418)
@app.errorhandler(500)
@app.errorhandler(501)
@app.errorhandler(502)
@app.errorhandler(503)
def all_errors(e):
error = str(e.code) if hasattr(e,"code") else "500"
message_msgid = "error_%s_message" % error
message_msgstr = _(message_msgid)
if message_msgstr == message_msgid:
message_msgstr = _("error_500_message")
description_msgid = "error_%s_description" % error
description_msgstr = _(description_msgid)
if description_msgstr == description_msgid and hasattr(e,"description"):
message_msgstr = _("error_500_description")
try:
g.title = "%s %s" % (error, message_msgstr)
g.count_files = lastcount[0]
return render_template('error.html', zone="errorhandler", error=error, description=description_msgstr), int(error)
except Exception as ex: #si el error ha llegado sin contexto se encarga el servidor de él
logging.warn(ex)
return make_response("",error)
return app
from __future__ import division, print_function, absolute_import, unicode_literals
from flask import Flask
from flask_wtf.csrf import CsrfProtect
from flask.ext.assets import Environment, Bundle
from flask.ext.mail import Mail
from celery import Celery
from webassets.filter import get_filter
from .util import root, config, DictAssetLoader
#: Flask application instance
app = Flask('zg', **config('app'))
app.config.update(config('flask'))
#: Celery instance
celery = Celery('zg-celery')
celery.conf.update(config('celery'))
#: Flask mail instance
mail = Mail()
CsrfProtect(app)
assets = Environment(app)
assets.url = ''
assets.directory = root('./public')
assets.load_path = [app.static_folder, root('./bower_components')]
assets.register(DictAssetLoader(config('assets')).load_bundles(assets))
import zg.routes
from flask.ext.assets import Environment, Bundle
# from flask.ext.sqlalchemy import SQLAlchemy
import logging
from logging import Formatter, FileHandler
from forms import *
#----------------------------------------------------------------------------#
# App Config.
#----------------------------------------------------------------------------#
app = Flask(__name__)
app.config.from_object('config')
#db = SQLAlchemy(app)
assets = Environment(app)
assets.url = app.static_url_path
scss = Bundle('sass/_main.scss', filters='pyscss', output='css/main.css')
assets.register('scss_all', scss)
menu.Menu(app=app)
# Automatically tear down SQLAlchemy.
'''
@app.teardown_request
def shutdown_session(exception=None):
db_session.remove()
'''
# Login required decorator.
'''
def login_required(test):
__author__ = 'hsk81'
###############################################################################
###############################################################################
from flask.ext.assets import Environment
from webassets.loaders import YAMLLoader
from ..app import app
###############################################################################
###############################################################################
loader = YAMLLoader(app.config['YML_FILE'])
bundles = loader.load_bundles()
assets = Environment(app)
assets.manifest = 'cache'
assets.register(bundles)
assets.url = app.config.get('CDN')
###############################################################################
###############################################################################
from flask.ext.assets import Environment, Bundle
# from flask.ext.sqlalchemy import SQLAlchemy
import logging
from logging import Formatter, FileHandler
from forms import *
#----------------------------------------------------------------------------#
# App Config.
#----------------------------------------------------------------------------#
app = Flask(__name__)
app.config.from_object('config')
#db = SQLAlchemy(app)
assets = Environment(app)
assets.url = app.static_url_path
scss = Bundle('sass/_main.scss', filters='pyscss', output='css/main.css')
assets.register('scss_all', scss)
menu.Menu(app=app)
# Automatically tear down SQLAlchemy.
'''
@app.teardown_request
def shutdown_session(exception=None):
db_session.remove()
'''
# Login required decorator.
'''
def login_required(test):
from config.cdn import proxied
from utils.flaskutils import RegisterJst
from utils.ext.bunch import Bunch
from utils.ext.path import Path
from .app import app
Coffee = partial(Bundle, filters='coffeescript', debug=False)
SCSS = partial(Bundle, filters='pyscss', debug=False)
JS = partial(Bundle, filters='yui_js')
CSS = partial(Bundle, filters='yui_css')
assets = Environment(app)
assets.url = proxied('/static/')
class Special(str): pass
class Depends(Special): pass
asset_spec = {
"todo.js": ('todo/jst/*.jst', 'todo/TodoModel.coffee', 'todo/TodoCollection.coffee', 'todo/TodoView.coffee',
'todo/Router.coffee', 'todo/AppView.coffee', 'todo/app.coffee',),
"todo.css": ('todo/css/*.css',),
}
def get_rules(kind):
if kind == '.css':
return Bunch(
final_filter = ["yui_css", get_filter('cssrewrite', replace=proxied)],
compilers = {".scss": "pyscss"},
from dexter.app import app
# setup assets
from flask.ext.assets import Environment, Bundle
assets = Environment(app)
assets.url_expire = False
assets.debug = app.config['ENV'] == 'development'
assets.directory = '%s/public' % app.config.root_path
assets.load_path = ['assets']
assets.url = '/public'
assets.register(
'css',
Bundle('css/bootstrap-3.2.0.min.css',
'css/bootstrap-theme-3.2.0.min.css',
'css/font-awesome-4.3.0.min.css',
'css/datepicker3.css',
'css/bootstrap-datetimepicker.min.css',
'css/daterangepicker-bs3.css',
'css/select2-3.4.8.css',
'css/select2-bootstrap-3.4.8.css',
'css/dropzone-3.10.2.css',
Bundle('css/*.scss',
filters='pyscss',
output='css/app.%(version)s.css'),
output='css/all.%(version)s.css'))
assets.register(
'mine-css',
Bundle('css/bootstrap-3.2.0.min.css',
'css/bootstrap-theme-3.2.0.min.css',
from modules.security import AESEncryption
from modules.localisation import languages
os.path.dirname(os.path.abspath(__file__))
parser = SafeConfigParser()
parser.read('config.ini')
app = Flask(__name__)
app.jinja_env.line_statement_prefix = '%'
assets = Environment(app)
babel = Babel(app)
app.register_blueprint(error_controller)
app.register_blueprint(admin_controller)
if parser.has_option('webserver', 'static_url'):
app.static_url_path = "//" + parser.get('webserver', 'static_url')
assets.url = parser.get('webserver', 'static_url')
if parser.getboolean('webserver', 'force_https'):
try:
from flask_sslify import SSLify
sslify = SSLify(app, permanent=True)
except ImportError:
pass
if parser.getboolean('application', 'debug'):
app.debug = True
Scss(app,
static_dir='static/css',
asset_dir='static/sass',
load_paths=['static/sass'])
