def configure_bundle(app):
bundles = {
'js_all': Bundle(
'jquery/dist/jquery.min.js',
'js/libs/underscore-min.js',
'js/libs/backbone-min.js',
'foundation-sites/dist/foundation.min.js',
'js/libs/foundation-datepicker.min.js',
'js/libs/moment-with-locales.min.js',
'js/*.js',
output='gen/all.js',
filters='jsmin'),
'css_all': Bundle(
'css/libs/*.css',
'css/*.css',
Bundle('main.scss',
filters='scss',
depends='**/*.scss'),
filters='cssmin',
output='gen/all.css')
}
assets = Environment(app)
assets.load_path = [
os.path.join(os.path.dirname(__file__), 'static'),
os.path.join(os.path.dirname(__file__), 'bower_components'),
]
assets.register(bundles)
def register_assets(app):
from flask.ext.assets import Environment, Bundle
assets = Environment(app)
js_common = Bundle(
'js/jquery-1.10.2.min.js',
'js/bootstrap.min.js',
'js/ripples.min.js',
'js/material.min.js',
filters='jsmin',
output='app.js')
assets.register('js_common', js_common)
css = Bundle(
'css/bootstrap.min.css',
'css/ripples.min.css',
'css/material-wfont.min.css',
# 'css/common.css',
filters='cssmin',
output='app.css'
)
assets.register('css_common', css)
assets.init_app(app)
def create_app():
app = Flask(__name__,
instance_relative_config=True,
static_folder='../static/',
static_url_path='/static',
template_folder='pages')
app.config.from_pyfile('settings.py')
assets = Environment(app)
db.init_app(app)
#Compress All Assets
js = Bundle('javascripts/vendor/jquery-1.9.1.min.js',
'javascripts/main.js',
'javascripts/plugins.js',
'javascripts/vendor/modernizr-2.6.2.min.js',
'javascripts/vendor/Underscore-1.5.1.js',
'javascripts/vendor/backbone-min.js',
filters='jsmin',
output='gen/packedjs.js')
assets.register('js_all', js)
css = Bundle('stylesheets/css/boilerplate_main.css',
'stylesheets/css/normalize.css',
'stylesheets/css/page.css',
filters='cssmin',
output='gen/packedcss.css')
assets.register('css_all', css)
return app
def configurate_app(config_file=''):
"""
Configures Flask app
:param config_file: Absolute path to Py config file, optional
:returns: App object, host and port
"""
# Load config
app.config.from_pyfile('defaults.py')
app.config.from_pyfile(config_file, silent=True)
if app.config.get('MINIFY_HTML', False):
app.jinja_env.add_extension('flask_utils.jinja2htmlcompress.HTMLCompress')
# Setup web assets
assets = Environment(app)
js = Bundle('common.js', filters='jsmin', output='gen/main.%(version)s.js')
css = Bundle('common.css', filters='cssmin', output='gen/main.%(version)s.css')
assets.register('js_all', js)
assets.register('css_all', css)
# Set host and port
port = app.config.get('PORT', 5000)
host = app.config.get('HOST', '127.0.0.1')
return app, host, port
def create_app(mode="development"):
"""Create webapp instance."""
app = Flask(__name__)
#Initilise DB
from bluespot.extensions import db
db.init_app(app)
# Load the default configuration
app.config.from_object('config.default')
#Load user specified config
app.config.from_yaml(os.path.join(app.root_path, '..', 'config.yaml'))
#initlize assets
assets = Environment(app)
assets.register(bundles)
# simple load all blueprint settings, enabled in config
load_blueprint_settings(app, blueprint_path='bluespot')
# simple load all blueprints, enabled in config
load_blueprints(app, blueprint_path='bluespot')
# Enable DebugToolbar on debug
# Enable error handler on productive mode
if app.config['DEBUG']:
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
app.logger.error("DEV")
else:
# add errorhandler
#error_handler(app)
app.logger.error("PROD")
@app.route("/")
def home():
return "OK"
return app
def register_static_resources(app):
"""
Uses app as context to register static assets
add new directory by creating glob and then Bundle
(current bundles)
- css
- js
"""
assets = AssetsEnvironment(app)
cutoff = len('webapp/static/')
js_files = glob.glob("webapp/static/js/*.js")
js_bundle = [fname[cutoff:] for fname in js_files]
js_bundle = AssetsBundle(
# framework stuff
AssetsBundle(
*js_bundle
),
output='gen/packed.js'
)
css_files = glob.glob("webapp/static/css/*.css")
css_bundle = [fname[cutoff:] for fname in css_files]
css_bundle = AssetsBundle(
AssetsBundle(
*css_bundle
),
output='gen/packed.css'
)
assets.register('js_all', js_bundle)
assets.register('css_all', css_bundle)
def configure_assets(app):
assets = Environment(app)
css = Bundle(
'bootstrap/bootstrap.min.css',
'dist/css/flat-ui.min.css',
'bootstrap-datetimepicker/css/bootstrap-datetimepicker.css',
# 'bootstrap/bootstrap-theme.min.css',
# 'others/select2/select2.min.css',
# 'others/smartwizard/smart_wizard.css',
# 'fonts/font-awesome.min.css',
'main.css',
filters="cssmin",
output='temp/common_packed.css')
js = Bundle(
'dist/js/vendor/jquery.min.js',
'jquery/jquery.form.js',
'dist/js/vendor/video.js',
'dist/js/flat-ui.min.js',
'bootstrap-datetimepicker/js/bootstrap-datetimepicker.js',
'bootstrap-datetimepicker/js/locales/bootstrap-datetimepicker.zh-CN.js',
'message.js',
# 'others/particles/particles.js',
# 'others/select2/select2.full.min.js',
# 'others/jquery.sortable.min.js',
# 'others/smartwizard/jquery.smartWizard.js',
'main.js',
filters='jsmin',
output='temp/common_packed.js')
assets.register('css_common', css)
assets.register('js_common', js)
def bundle_assets(app, minify=True):
js_filters = ['yui_js'] if minify else None
css_filters = ['yui_css'] if minify else None
js = Bundle(
'js/google_maps.js',
'js/ajax.js',
filters=js_filters,
output='gen/packed.js',
)
css = Bundle(
'css/style.css',
'css/responsive.css',
'css/fonts.css',
filters=css_filters,
output='gen/packed.css',
)
assets = Environment()
assets.register('js', js)
assets.register('css', css)
app.config['ASSETS_DEBUG'] = not minify
assets.init_app(app)
def configure_assets(app):
assets = Environment(app)
js = Bundle(*BUNDLE_JS, filters='jsmin', output='output/packed.js')
css_rewrite = get_filter('cssrewrite', replace={'/static/': '../'})
css = Bundle(*BUNDLE_CSS,
filters=(css_rewrite, 'cssmin'),
output='output/packed.css')
ie7_css = Bundle(*BUNDLE_IE7_CSS,
filters='cssmin',
output='output/packed_ie7.css')
ie8_css = Bundle(*BUNDLE_IE8_CSS,
filters='cssmin',
output='output/packed_ie8.css')
ie9_css = Bundle(*BUNDLE_IE9_CSS,
filters='cssmin',
output='output/packed_ie9.css')
print_css = Bundle(*BUNDLE_PRINT_CSS,
filters='cssmin',
output='output/packed_print.css')
assets.register('packed_js', js)
assets.register('packed_css', css)
assets.register('packed_ie7_css', ie7_css)
assets.register('packed_ie8_css', ie8_css)
assets.register('packed_ie9_css', ie9_css)
assets.register('packed_print_css', print_css)
def configure_assets(app):
assets = Environment(app)
js = Bundle(*BUNDLE_JS, filters='jsmin', output='output/packed.js')
css = Bundle(*BUNDLE_CSS, filters='cssmin', output='output/packed.css')
assets.register('packed_js', js)
assets.register('packed_css', css)
def init_app(app):
webassets = Environment(app)
webassets.register('apollo_css', apollo_css)
webassets.register('apollo_js', apollo_js)
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
def configure_assets(app):
""" Set up Flask-Assets """
assets = Environment(app)
assets_output_dir = os.path.join(app.config['STATIC_ROOT'], 'gen')
if not os.path.exists(assets_output_dir):
os.mkdir(assets_output_dir)
less_css = Bundle('less/style.less',
filters='less',
output='gen/style.css',
debug=False
)
coffee_script = Bundle('coffee/script.coffee',
filters='coffeescript',
output='gen/script.js',
debug=False
)
assets.register('css_all', less_css,
filters='cssmin',
output='gen/packed.css',
debug=app.debug
)
assets.register('js_all', 'js/plugins.js', coffee_script,
filters='uglifyjs',
output='gen/packed.js',
debug=app.debug)
def init_app(app):
webassets = Environment(app)
webassets.register("apollo_css", apollo_css)
webassets.register("apollo_js", apollo_js)
webassets.manifest = "cache" if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
def load_assets(app):
Bower(app)
env = Environment(app)
app.config['COMPASS_CONFIG'] = {'sourcemap': True}
env.load_path = [
os.path.join(os.path.dirname(__file__), 'bower_components'),
os.path.join(os.path.dirname(__file__), 'styles'),
]
# env.cache = False
# env.manifest = False
env.register(
'js_all',
Bundle(
'jquery/dist/jquery.min.js',
'bootstrap-sass/assets/javascripts/bootstrap.min.js',
output='js_all.js'
)
)
env.register(
'css_all',
Bundle(
'all.scss',
depends='*.scss',
filters='compass',
output='css_all.css'
)
)
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 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 create_app():
global app
global db
global login_manager
# Flask
app = Flask(__name__)
app.config.from_object('config.flask_config')
# SQLAlchemy
db = SQLAlchemy(app)
# Login
login_manager = LoginManager(app)
login_manager.login_view = 'users.login'
# Assets
assets = Environment(app)
less = Bundle('less/*.less',
filters='less',
output='css/gen/style.css',
depends='less/*.less')
assets.register('less_all', less)
# Debug
app.config['DEBUG'] = (len(argv) == 2 and argv[1] == 'debug')
@login_manager.user_loader
def load_user(userid):
from models import User
return User.query.get(userid)
register_blueprints(app)
return app, db
def create_app(mode="development"):
"""Create webapp instance."""
app = Flask(__name__)
#Initilise DB
from bluespot.extensions import db
db.init_app(app)
# Load the default configuration
app.config.from_object('config.default')
#Load user specified config
app.config.from_yaml(os.path.join(app.root_path,'..','config.yaml'))
#initlize assets
assets = Environment(app)
assets.register(bundles)
# simple load all blueprint settings, enabled in config
load_blueprint_settings(app,blueprint_path='bluespot')
# simple load all blueprints, enabled in config
load_blueprints(app,blueprint_path='bluespot')
# Enable DebugToolbar on debug
# Enable error handler on productive mode
if app.config['DEBUG']:
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
app.logger.error( "DEV")
else:
# add errorhandler
#error_handler(app)
app.logger.error( "PROD")
@app.route("/")
def home():
return "OK"
return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) mail.init_app(app) login_manager.setup_app(app) assets = Environment(app) assets.register(bundles()) from .shared import shared as shared_blueprint app.register_blueprint(shared_blueprint) from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint) from .blog import blog as blog_blueprint app.register_blueprint(blog_blueprint) from .main import main as main_blueprint app.register_blueprint(main_blueprint) db.init_app(app) # with app.app_context(): # # Extensions like Flask-SQLAlchemy now know what the "current" app # # is while within this block. Therefore, you can now run........ # db.create_all() return app
def compile_assets(app, bundle_config=bundles_config):
if not bundle_config:
raise ConfigNotFoundError('Bundles config is empty')
assets = Environment(app)
for name, settings in bundle_config.iteritems():
bundle = check_and_compile_bundle(name, settings)
assets.register(name, bundle)
def compile_assets(app, bundle_config=bundles_config):
if not bundle_config:
raise ConfigNotFoundError('Bundles config is empty')
assets = Environment(app)
for name, settings in bundle_config.iteritems():
bundle = check_and_compile_bundle(name, settings)
assets.register(name, bundle)
def create_app(instance_path=None, debug=False, test=False):
use_instances = False
if instance_path is not None:
use_instances = True
app = Flask(__name__,
instance_relative_config=use_instances,
instance_path=instance_path,
template_folder="views",
static_path='/static',
static_url_path='/static')
app.debug = debug
app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension')
app.config.from_object('app.config')
app.config.from_pyfile('config.py')
if not test:
CsrfProtect(app)
assets = Environment(app)
css_bundle = Bundle('less/main.less',
output='css/main.css',
filters='less')
assets.register('css', css_bundle)
js_bundle = Bundle('js/main.js', output="main.min.js", filters="rjsmin")
assets.register('js', js_bundle)
email = FlaskMailgunMessage(app)
@app.route('/', methods=['GET', 'POST'])
def index():
form = ApplicationForm()
if form.validate_on_submit():
if form.squirrel.data:
# ANTI SPAM YO
app.logger.info('SECRET SQUIRREL')
return redirect(url_for('index'))
form_data = "name: {}\nemail: {}\nphone: {}\n\n".format(
form.name.data, form.email.data, form.phone.data)
app.logger.info(form_data)
# send the email
email.send(form_data)
flash(app.config['THANKS_FLASH'])
return redirect(url_for('index'))
return render_template('index.jade', form=form)
return app
def create_app():
from server.views.frontend import frontend as blueprint_frontend
from server.views.entry import entry as blueprint_entry
from server.views.filter import filter as blueprint_filter
from server.views.pinboard import pinboard as blueprint_pinboard
from server.db import db
from server.login import login_manager
app = Flask(__name__, instance_relative_config=True)
app.jinja_options = dict(app.jinja_options)
app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension')
app.config.from_pyfile("default_settings.py")
app.config.from_envvar('PINBOARD_SETTINGS', silent=True)
if not app.debug:
file_handler = WatchedFileHandler(app.config.get("LOG_FILENAME",
"pinboard.log"))
file_handler.setLevel(logging.WARNING)
app.logger.addHandler(file_handler)
assets = Environment(app)
js_assets = Bundle(
"scripts/jquery-1.7.2.js",
"scripts/jquery-ui-1.8.16.custom.min.js",
#"scripts/chosen.jquery.min.js",
"scripts/bootstrap.min.js",
"scripts/angular-1.0.1.js",
#"scripts/angular-cookies-1.0.0.js",
#"scripts/taffy.js",
"scripts/sugar-1.2.4.min.js",
#"scripts/jquery.couch.js",
Bundle("lib/*.coffee", filters=["coffeescript", ]),
filters=["rjsmin", ],
output="generated_app.js",
)
css_assets = Bundle(
"stylesheets/jquery-ui-1.8.16.custom.css",
Bundle(
"stylesheets/app.less",
filters=["less", ],
),
filters=["cssmin", ],
output="generated_app.css",
)
assets.register('js_all', js_assets)
assets.register('css_all', css_assets)
db.init_app(app)
login_manager.setup_app(app)
app.register_blueprint(blueprint_frontend)
app.register_blueprint(blueprint_entry, url_prefix="/entry")
app.register_blueprint(blueprint_filter, url_prefix="/filter")
app.register_blueprint(blueprint_pinboard, url_prefix="/pinboards")
return app
def create_app(config='dev'):
""" Flask application factory
:param str config: type of app to build, either "prod" or "dev"
"""
# Create flask application
app = Flask(__name__)
app.config.from_object('settings')
app.config['ENV'] = config
app.jinja_env.trim_blocks = True
# Debug toolbar (when debug=true)
debug_toolbar = DebugToolbarExtension(app)
app.config['DEBUG_TB_PROFILER_ENABLED'] = True
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
# Register Blueprints
app.register_blueprint(views_base.base)
app.register_blueprint(views_blog.blog)
# Flask-Assets; bundles all css/js files in minifed file
assets = Environment(app)
css_all = Bundle('css/bootstrap-flatly.min.css', 'css/highlightjs.min.css', 'css/font-awesome.css', 'css/main.css',
filters='cssmin', output='gen/style.css')
js_all = Bundle('js/vendor/jquery.min.js', 'js/vendor/bootstrap.min.js', 'js/vendor/showdown-gfm.min.js',
'js/vendor/highlight.min.js', 'js/main.js', filters='jsmin', output='gen/libs.js')
assets.register('css_all', css_all)
assets.register('js_all', js_all)
if app.config['DEBUG']:
assets.debug = True
app.config['ASSETS_DEBUG'] = True
# Set up Flask-User
babel = Babel(app)
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app
# Init the cache
cache.init_app(app)
Moment(app) # moment.js
Misaka(app, autolink=True, # Misaka Markdown
fenced_code=True, lax_html=True, strikethrough=True,
superscript=True, tables=True, wrap=True)
# Init Admin page
admin = Admin(app, index_view=AdminMain(endpoint='admin'))
admin.add_view(PostAdminView())
admin.add_view(NewPostView())
admin.add_view(ModelView(Comment, db.session))
static_path = os.path.join(BASE_DIR, 'app', 'static')
admin.add_view(FileAdminView(static_path, '/static/', name='Static Files'))
# Initialize DB
db.init_app(app)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
# Register Jinja template functions
from utils import register_template_utils
register_template_utils(app)
app.jinja_env.globals.update(format_price=format_price)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.config['sass_line_comments'] = False
assets_env.config['sass_debug_info'] = False
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
assets_env.register('guiders_js', guiders_js)
assets_env.register('images_png', images_png)
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
SSLify(app)
# Create app blueprints
from main import main as main_blueprint
app.register_blueprint(main_blueprint)
from account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from merchant import merchant as merchant_blueprint
app.register_blueprint(merchant_blueprint, url_prefix='/merchant')
from vendor import vendor as vendor_blueprint
app.register_blueprint(vendor_blueprint, url_prefix='/vendor')
return app
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 init(app):
assets = Environment(app)
js = Bundle(*app.config['JS_ASSETS'], output=app.config['JS_ASSETS_OUTPUT'],
filters=app.config['JS_ASSETS_FILTERS'])
css = Bundle(*app.config['CSS_ASSETS'], output=app.config['CSS_ASSETS_OUTPUT'],
filters=app.config['CSS_ASSETS_FILTERS'])
assets.register('js_all', js)
assets.register('css_all', css)
def _configure_assets(app):
from flask.ext.assets import Environment
assets = Environment(app)
pyload = PythonLoader('config.assets')
bundles = pyload.load_bundles()
assets.register('main_js', bundles['main_js'])
assets.register('main_css', bundles['main_css'])
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 register_assets(app):
app.jinja_env.filters['formatDollars'] = formatDollars
assets = Environment(app)
css = Bundle('css/normalize.css',
'css/skeleton.css',
'css/custom.css', filters='cssmin', output='gen/packed.css')
assets.register('css_all', css)
return app
def configure_assets(app):
from flask.ext.assets import Environment, Bundle
assets = Environment(app)
js = Bundle('js/vendor/jquery-1.9.0.min.js', 'js/vendor/underscore.min.js',
'js/vendor/bootstrap.min.js', 'js/vendor/backbone.min.js',
'js/controllers/base.js',
filters='jsmin', output='gen/packed.js')
assets.register('js_all', js)
css = Bundle('css/bootstrap.min.css', 'css/bootstrap-responsive.min.css', 'css/style.css',
filters='cssmin', output='gen/packed.css')
assets.register('css_all', css)
def create_app():
app = Flask(__name__)
app.config.from_object('config')
app.config.from_envvar('MULCHN_CONFIG', silent=True)
app.config['ASSETS_UGLIFYJS_EXTRA_ARGS'] = '-m'
app.config.setdefault('PAGINATION_NUM', 5)
# db.configure_engine(os.environ.get("DATABASE_URL", app.config.get('DATABASE_URL')))
assets = Environment(app)
css_slicklist = Bundle('css/slicklist.less',
filters="less",
output="css/slicklist.css")
assets.register('css_slicklist', css_slicklist)
css_main = Bundle('css/main.less',
filters="less",
output="css/main.css")
assets.register('css_main', css_main)
js_app = Bundle('js/add.coffee',
'js/dialog.coffee',
'js/geolocation.coffee',
'js/logindialog.coffee',
'js/router.coffee',
'js/account.coffee',
'js/question/model.coffee',
'js/question/collection.coffee',
'js/question/view.coffee',
'js/question/list.coffee',
'js/question/paginator.coffee',
'js/main.coffee',
filters='coffeescript,rjsmin',
output='js/m.js')
assets.register('js_app', js_app)
js_frameworks = Bundle(
'js/lib/jquery.js',
'js/lib/lodash.js',
'js/lib/backbone.js',
'js/lib/bootstrap.js',
'js/lib/geolocation.js',
filters='rjsmin',
output='js/frameworks.js')
assets.register('js_frameworks', js_frameworks)
js_d3 = Bundle(
'js/lib/topojson.js',
'js/lib/d3.js',
# filters='rjsmin',
output='js/d3.topojson.js')
assets.register('js_d3', js_d3)
return app
def initialise_app(app, configclass):
# Load the default configuration
app.config.from_object(configclass)
# Load the configuration from the instance folder
try:
app.config.from_pyfile('config.py')
except:
print 'No instance config file'
if app.config['USE_PROXY']:
app.wsgi_app = ProxyFix(app.wsgi_app)
toolbar = DebugToolbarExtension(app)
db.init_app(app)
mail.init_app(app)
assets = Environment(app)
assets.register(bundles)
from .models import User, Feed, Entry, Author, Role
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
app.security = Security(app, user_datastore)
wtf.add_helpers(app)
admin = Admin(app, 'Admin', index_view=SecuredAdminIndexView())
admin.add_view(SecuredModelView(User, db.session))
admin.add_view(SecuredModelView(Feed, db.session))
admin.add_view(SecuredModelView(Entry, db.session))
admin.add_view(SecuredModelView(Author, db.session))
app.register_blueprint(frontend_blueprint)
identity_loaded.connect_via(app)(on_identity_loaded)
add_errorhandlers(app)
Principal(app)
if not app.debug:
import logging
from .utils.loggers import add_logger_filehandler, add_logger_external
add_logger_filehandler(app)
if app.config['LOG_ADDRESS']:
add_logger_external(app)
app.logger.setLevel(logging.INFO)
app.logger.info(u'{0} startup'.format(app.config['PROJECT_NAME']))
return app
def register_assets(app):
app.jinja_env.filters['formatDollars'] = formatDollars
assets = Environment(app)
css = Bundle('css/normalize.css',
'css/skeleton.css',
'css/custom.css',
filters='cssmin',
output='gen/packed.css')
assets.register('css_all', css)
return app
def init(app):
assets = Environment(app)
js = Bundle(*app.config['JS_ASSETS'],
output=app.config['JS_ASSETS_OUTPUT'],
filters=app.config['JS_ASSETS_FILTERS'])
css = Bundle(*app.config['CSS_ASSETS'],
output=app.config['CSS_ASSETS_OUTPUT'],
filters=app.config['CSS_ASSETS_FILTERS'])
assets.register('js_all', js)
assets.register('css_all', css)
def _get_assets(output, filters):
global _assets
if _assets is None:
_assets = Environment(app)
flexboss_css = Bundle(
"css/flexboss.scss",
output=output,
filters=filters,
depends=("css/**/*.scss")
)
_assets.register("flexboss_css", flexboss_css)
return _assets
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 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 asset_register(app):
assets = Environment(app)
assets.config['less_bin'] = '/usr/local/node/node-v0.10.32/bin/lessc'
assets.config['less_run_in_debug'] = True
css_bundle = Bundle('css/*.css', 'css/less/default.less',
filters='less', output='styles.css')
assets.register('css_main', css_bundle)
return assets
def _init_assets(app):
"""Setup for Flask-Assets."""
scripts = Bundle('js/script.js',
filters='closure_js',
output='js/scripts.%(version)s.js')
styles = Bundle('css/style.css',
filters='yui_css',
output='css/styles.%(version)s.css')
env = Environment(app)
# env.url_expire = True
env.register('scripts', scripts)
env.register('styles', styles)
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(object_name, env='prod'):
app = Flask(__name__)
app.config.from_object(object_name)
app.config['ENV'] = env
app.register_blueprint(main_blueprint)
assets = Environment(app)
css = Bundle('css/style.scss', filters='scss', output='css/style.css')
assets.register('base_style', css)
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
class TestEnv:
def setup(self):
self.app = Flask(__name__)
self.env = Environment(self.app)
self.env.debug = True
self.app.config.update({
'ASSETS_DIRECTORY': '',
'ASSETS_URL': '/foo',
})
self.env.register('test', 'file1', 'file2')
def test_tag_available(self):
"""Jinja tag has been made available.
"""
t = self.app.jinja_env.from_string('{% assets "test" %}{{ASSET_URL}};{% endassets %}')
assert t.render() == '/foo/file1;/foo/file2;'
def test_from_yaml(self):
"""YAML configuration gets loaded
"""
f = open('test.yaml', 'w')
f.write("""
yamltest:
contents:
- yamlfile1
- yamlfile2
""")
f.close()
self.env.from_yaml('test.yaml')
t = self.app.jinja_env.from_string('{% assets "yamltest" %}{{ASSET_URL}};{% endassets %}')
assert t.render() == '/foo/yamlfile1;/foo/yamlfile2;'
os.remove('test.yaml')
def test_from_python_module(self):
"""Python configuration module gets loaded
"""
import types
module = types.ModuleType('test')
module.pytest = Bundle('pyfile1', 'pyfile2')
self.env.from_module(module)
t = self.app.jinja_env.from_string('{% assets "pytest" %}{{ASSET_URL}};{% endassets %}')
assert t.render() == '/foo/pyfile1;/foo/pyfile2;'
def setup_assets(app):
assets = Environment(app)
assets.init_app(app)
css = Bundle(
"css/bootstrap.css",
"css/layout.css",
output="css/_style.css")
js = Bundle(
"js/jquery.min.js",
"js/jquery.router.js",
"js/custom.js",
output="js/_basic.js")
assets.register('css_all', css)
assets.register('js_all', js)
def configure_assets(app):
assets = Environment(app)
assets.versions = 'hash'
assets.url_expire = True
# ----------------------------------------- #
# Bundle the assets, using "normal" cache busting
non_hljs_css = Bundle('private/css/bootswatch/journal/bootstrap.css',
'private/css/custom.css',
output='public/css/non-hljs.%(version)s.css')
hljs_css = Bundle('private/css/highlightjs-style.css',
output='public/css/hljs.%(version)s.css')
#font_ttf = Bundle('private/fonts/glyphicons-halflings-regular.ttf',
# output='public/fonts/glyphicons-halflings-regular.ttf')
assets.register('non_hljs_css', non_hljs_css)
assets.register('hljs_css', hljs_css)
#assets.register('font_ttf', font_ttf)
return assets
def init(app):
""" Bundle projects assets """
assets = Environment(app)
if 'JS_ASSETS' in app.config and len(app.config['JS_ASSETS']) > 0:
js = Bundle(*app.config['JS_ASSETS'],
output=app.config['JS_ASSETS_OUTPUT'],
filters=app.config['JS_ASSETS_FILTERS'])
assets.register('js_all', js)
if 'CSS_ASSETS' in app.config and len(app.config['CSS_ASSETS']) > 0:
css = Bundle(*app.config['CSS_ASSETS'],
output=app.config['CSS_ASSETS_OUTPUT'],
filters=app.config['CSS_ASSETS_FILTERS'])
assets.register('css_all', css)
app.assets = assets
def create_app(config=None):
app = Flask(__name__)
# If no config file is passed in on the command line:
if config is None:
config = os.path.join(app.root_path, os.environ.get('FLASK_APPLICATION_SETTINGS'))
app.config.from_pyfile(config)
# Secret key needed to use sessions.
app.secret_key = app.config['SECRET_KEY']
# Initialize SQL Alchemy and Flask-Login
# Instantiate the Bcrypt extension
db.init_app(app)
login_manager.init_app(app)
bcrypt.init_app(app)
# CSRF protection
csrf.init_app(app)
# Web assets (js, less)
assets = Environment(app)
js = Bundle('js/main.js',
filters='jsmin', output='gen/bundle.js')
assets.register('js_all', js)
# Automatically tear down SQLAlchemy
@app.teardown_request
def shutdown_session(exception=None):
db.session.remove()
@app.before_request
def before_request():
g.user = current_user
app.register_blueprint(unauthenticated)
app.register_blueprint(authenticated)
app.register_blueprint(users)
return app
def compile_assets(app, controller_name):
if not isinstance(controller_name, str):
raise TypeError(
'The parameter controller_name must be an instance of String')
if len(controller_name) == 0:
raise ValueError(
'The parameter controller_name must have a length of more than 0')
assets = Environment(app)
coffee = compile_asset(controller_name=controller_name,
asset_type=ASSET_TYPE_COFFEE)
js = compile_asset(controller_name=controller_name,
asset_type=ASSET_TYPE_JS)
js_compiled_all = Bundle(coffee, js, filters='rjsmin', output='out/x.js')
css = compile_asset(controller_name=controller_name,
asset_type=ASSET_TYPE_CSS)
assets.register('css_all', css)
assets.register('js_compiled_all', js_compiled_all)
def init_webassets(flask_app, config):
""" Initialize Flask-Assets extension. """
assets = Environment(flask_app)
assets.debug = flask_app.debug
dart_root = 'dart/web' if flask_app.debug else 'dart/build/web'
assets.register("less", Bundle(
"less/bootstrap/bootstrap.less",
"less/font-awesome/font-awesome.less",
filters="less",
output="combined/bootstrap.css",
depends="less/*.less"
))
assets.register('dart', Bundle(
dart_root + '/main.dart'
))
assets.register("javascript", Bundle(
'js/d3.js',
'js/markdown.js',
dart_root + '/packages/web_components/dart_support.js',
dart_root + '/packages/browser/dart.js',
output='combined/combined.js'
))
def setup_assets(app):
assets = Environment(app)
assets.init_app(app)
css = Bundle(
"stylesheets/foundation.css",
"stylesheets/foundation_icons_general/"
"stylesheets/general_foundicons.css",
"stylesheets/app.css",
output="stylesheets/_basic_style.css")
js = Bundle(
"javascripts/jquery.js",
"javascripts/modernizr.foundation.js",
"javascripts/galleria.js",
"javascripts/app.js",
output="javascripts/_basic.js")
assets.register('css_all', css)
assets.register('js_all', js)
def configure_extensions(app):
db.init_app(app)
migrate.init_app(app, db)
login_manager.init_app(app)
principal.init_app(app)
init_celery_app(app, celery)
csrf.init_app(app)
mail.init_app(app)
moment.init_app(app)
assets = Environment(app)
css = Bundle('css/libs/bootstrap.css',
'css/libs/codemirror.css',
'css/styles.css',
output='gen/style.css')
js = Bundle('js/libs/jquery.js',
'js/libs/codemirror.js',
'js/libs/bootstrap.js',
'js/tailer.js',
'js/hook-form.js',
output='gen/common.js')
assets.register('css', css)
assets.register('js', js)
def start_app():
app = Flask(__name__)
app.config['S3_BUCKET_NAME'] = 'readsy'
app.config['S3_CDN_DOMAIN'] = 'dwdhruapbuq08.cloudfront.net'
app.config['S3_USE_HTTPS'] = False
app.config['USE_S3_DEBUG'] = True # should be true
app.config['AWS_ACCESS_KEY_ID'] = os.environ['AWS_ACCESS_KEY_ID']
app.config['AWS_SECRET_ACCESS_KEY'] = os.environ['AWS_SECRET_ACCESS_KEY']
s3 = FlaskS3()
s3.init_app(app)
assets = Environment()
# use closure_js once i have java 7
js = Bundle('js/jquery.cookie.js', 'js/app.js', 'js/froala_editor.min.js', 'js/sharrre.min.js', filters='rjsmin', output='gen/packed.js')
css = Bundle('css/bootstrap.min.css', 'css/froala_editor.min.css', 'css/bootstrapcustom.css', 'css/sharre.css', filters='cssmin', output='gen/packed.css')
assets.register('js_all', js)
assets.register('css_all', css)
app.config['ASSETS_DEBUG'] = False
assets.init_app(app)
app.config['FLASK_ASSETS_USE_S3'] = True #should be true
return app
def register_assets(app):
from flask.ext.assets import Environment, Bundle
assets = Environment(app)
js_common = Bundle('js/jquery-1.10.2.min.js',
'js/bootstrap.min.js',
'js/ripples.min.js',
'js/material.min.js',
filters='jsmin',
output='app.js')
assets.register('js_common', js_common)
css = Bundle(
'css/bootstrap.min.css',
'css/ripples.min.css',
'css/material-wfont.min.css',
# 'css/common.css',
filters='cssmin',
output='app.css')
assets.register('css_common', css)
assets.init_app(app)
def configure_assets(app):
assets = Environment(app)
js_lib = Bundle('src/js/lib/underscore.js',
'src/js/lib/jquery-1.8.3.js',
'src/js/lib/backbone.js',
'src/js/lib/backbone-relational.js',
'src/js/lib/sprintf-0.7-beta1.js',
'src/js/vendor/select2/select2.js',
'src/js/vendor/Pikaday/pikaday.js',
'src/js/vendor/facebox/facebox.js',
'src/js/vendor/highcharts/highcharts.src.js',
'src/js/vendor/bootstrap/bootstrap-alert.js',
'src/js/vendor/bootstrap/bootstrap-modal.js',
'src/js/vendor/bootstrap/bootstrap-modalmanager.js',
'src/js/lib/upclick.js',
filters='yui_js',
output='dist/js/libs.js')
js_app = Bundle('src/js/app/app.js',
'src/js/app/models/all.js',
'src/js/app/views/DraftInvoiceView.js',
'src/js/app/views/EditInvoiceItemView.js',
'src/js/app/views/InvoiceFormView.js',
'src/js/app/views/NewInvoiceItemView.js',
filters='yui_js',
output='dist/js/app.js')
js_templates = Bundle('src/js/app/templates/*.html',
output='dist/js/templates.js',
filters='jst')
css_global = Bundle('src/sass/screen.scss',
filters='scss',
output='dist/css/screen.css')
css_pdf = Bundle('src/sass/pdf.scss',
filters='scss',
output='dist/css/pdf.css')
assets.register('js_lib', js_lib)
assets.register('js_app', js_app)
assets.register('js_templates', js_templates)
assets.register('css_global', css_global)
assets.register('css_pdf', css_pdf)
