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 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',
""" 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 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'])