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 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) # 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.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_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 bulk_resource import bulk_resource as bulk_resource_blueprint app.register_blueprint(bulk_resource_blueprint, url_prefix='/bulk-resource') from descriptor import descriptor as descriptor_blueprint app.register_blueprint(descriptor_blueprint, url_prefix='/descriptor') from single_resource import single_resource as single_resource_blueprint app.register_blueprint(single_resource_blueprint, url_prefix='/single-resource') from suggestion import suggestion as suggestion_blueprint app.register_blueprint(suggestion_blueprint, url_prefix='/suggestion') 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)
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(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) # Register Jinja template functions from utils import register_template_utils register_template_utils(app) # 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.register("app_css", app_css) assets_env.register("app_js", app_js) assets_env.register("vendor_css", vendor_css) assets_env.register("vendor_js", vendor_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") 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 register_assets(app, debug=False): """We add the app's root path to assets search path. However, the output directory is relative to `app.static_folder`. """ assets = Environment(app) assets.debug = debug assets.auto_build = True assets.manifest = 'file' assets.append_path(app.root_path) site_js = Bundle( 'static/app.js', filters=('uglifyjs',), output='js/bundle.js' ) assets.register('site_js', site_js) site_css = Bundle( 'static/style.css', filters=('cssmin',), output='css/bundle.css' ) assets.register('site_css', site_css)
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
class TestUrlAndDirectory(TempEnvironmentHelper): """By default, the 'url' and 'directory' settings of webassets are not used in Flask-Assets; that is, the values are automatically handled based on the configuration of the Flask app and the modules used. The user can disable the automatic handling by setting these values if he needs to for some reason. Let's test the different scenarios to ensure everything works. """ def setup(self): TempEnvironmentHelper.setup(self) self.app = Flask(__name__, static_path='/app_static') from tests import test_module if not Blueprint: self.module = Module(test_module.__name__, name='module', static_path='/mod_static') self.app.register_module(self.module) else: self.blueprint = Blueprint('module', test_module.__name__, static_url_path='/mod_static', static_folder='static') self.app.register_blueprint(self.blueprint) self.env = Environment(self.app) def test_config_values_not_set_by_default(self): assert not 'directory' in self.env.config assert not 'url' in self.env.config assert_raises(KeyError, self.env.config.__getitem__, 'directory') assert_raises(KeyError, self.env.config.__getitem__, 'url') def test_directory_auto(self): """Test how we resolve file references through the Flask static system by default (if no custom 'env.directory' etc. values have been configured manually). """ assert not 'directory' in self.env.config root = self.app.root_path assert get_all_bundle_files(Bundle('foo'), self.env) == [root + '/static/foo'] # Modules prefixes in paths are handled specifically. assert get_all_bundle_files(Bundle('module/bar'), self.env) == [root + '/test_module/static/bar'] # Prefixes that aren't valid module names are just considered # subfolders of the main app. assert get_all_bundle_files(Bundle('nomodule/bar'), self.env) == [root + '/static/nomodule/bar'] # In case the name of a app-level subfolder conflicts with a # module name, you can always use this hack: assert get_all_bundle_files(Bundle('./module/bar'), self.env) == [root + '/static/module/bar'] # Custom static folder self.app.static_folder = '/' assert get_all_bundle_files(Bundle('foo'), self.env) == ['/foo'] def test_url_auto(self): """Test how urls are generated via the Flask static system by default (if no custom 'env.url' etc. values have been configured manually). """ assert not 'url' in self.env.config assert Bundle('foo', env=self.env).urls() == ['/app_static/foo'] # Urls for files that point to a module use that module's url prefix. assert Bundle('module/bar', env=self.env).urls() == ['/mod_static/bar'] # Try with a prefix that's not actually a valid module assert Bundle('nomodule/bar', env=self.env).urls() == ['/app_static/nomodule/bar'] # [Regression] Ensure that any request context we may have added # to the stack has been removed. from flask import _request_ctx_stack assert _request_ctx_stack.top is None def test_custom_load_path(self): """A custom load_path is configured - this will affect how we deal with source files. """ self.env.append_path(self.tempdir, '/custom/') self.create_files(['foo', 'module/bar']) assert get_all_bundle_files(Bundle('foo'), self.env) == [self.path('foo')] # We do not recognize references to modules. assert get_all_bundle_files(Bundle('module/bar'), self.env) == [self.path('module/bar')] assert Bundle('foo', env=self.env).urls() == ['/custom/foo'] assert Bundle('module/bar', env=self.env).urls() == ['/custom/module/bar'] # [Regression] With a load path configured, generating output # urls still works, and it still uses the flask system. self.env.debug = False self.env.url_expire = False assert Bundle('foo', output='out', env=self.env).urls() == ['/app_static/out'] def test_custom_directory_and_url(self): """Custom directory/url are configured - this will affect how we deal with output files.""" # Create source source file, make it findable (by default, # static_folder) is set to a fixed subfolder of the test dir (why?) self.create_files({'a': ''}) self.app.static_folder = self.tempdir # Setup custom directory/url pair for output self.env.directory = self.tempdir self.env.url = '/custom' self.env.debug = False # Return build urls self.env.url_expire = False # No query strings assert Bundle('a', output='foo', env=self.env).urls() == ['/custom/foo'] # We do not recognize references to modules. assert Bundle('a', output='module/bar', env=self.env).urls() == ['/custom/module/bar'] def test_existing_request_object_used(self): """[Regression] Check for a bug where the url generation code of Flask-Assets always added a dummy test request to the context stack, instead of using the existing one if there is one. We test this by making the context define a custom SCRIPT_NAME prefix, and then we check if it affects the generated urls, as it should. """ with self.app.test_request_context( '/', environ_overrides={'SCRIPT_NAME': '/yourapp'}): assert Bundle('foo', env=self.env).urls() == ['/yourapp/app_static/foo'] def test_glob(self): """Make sure url generation works with globs.""" self.app.static_folder = self.tempdir self.create_files({'a.js': 'foo', 'b.js': 'bar'}) assert list(sorted(self.mkbundle('*.js', env=self.env).urls())) == [ '/app_static/a.js', '/app_static/b.js']
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) # 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.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) assets_env.register('asylum_css', asylum_css) assets_env.register('asylum_scss', asylum_scss) assets_env.register('asylum_js', asylum_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 bulk_resource import bulk_resource as bulk_resource_blueprint app.register_blueprint(bulk_resource_blueprint, url_prefix='/bulk-resource') from descriptor import descriptor as descriptor_blueprint app.register_blueprint(descriptor_blueprint, url_prefix='/descriptor') from single_resource import single_resource as single_resource_blueprint app.register_blueprint(single_resource_blueprint, url_prefix='/single-resource') from suggestion import suggestion as suggestion_blueprint app.register_blueprint(suggestion_blueprint, url_prefix='/suggestion') return app
"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) @babel.localeselector def get_locale(): # try to guess the language from the user accept header the browser transmits. We support de/en.
from webassets.ext.jinja2 import AssetsExtension from flask.ext.assets import Environment as FlaskAssetsEnvironment from conf import * from devserver import devserver, date_filter from admin.models import get_news, get_gigs env.roledefs = {'demo': [DEMO_SERVER], 'local': ['localhost']} roots = {DEMO_SERVER: DEMO_ROOT} wa_env = webassets.Environment(BUILD_PATH, '/') wa_env.append_path('static/css') fla_env = FlaskAssetsEnvironment(devserver) fla_env.append_path('static/css') all_css = ['font-awesome.min.css', 'jquery.mCustomScrollbar.css', 'normalize.css', 'styles.css'] bundle = webassets.Bundle(*all_css, output='static/css/main.css') b2 = webassets.Bundle(*all_css, output='css/_build.css') wa_env.register('css', bundle) fla_env.register('css', b2) @task def build_templates(): jj_env = jinja2.Environment(loader=jinja2.FileSystemLoader(TEMPLATE_PATH), extensions=[AssetsExtension]) jj_env.assets_environment = wa_env jj_env.filters['date'] = date_filter static_root = os.path.join(BUILD_PATH, 'static')
from flask import Flask, url_for from flask.ext.assets import Environment, Bundle from flask.ext.sqlalchemy import SQLAlchemy import os app = Flask(__name__) conf = os.environ.get('APP_CONFIG', 'pghtrash.config.DevelopmentConfig') app.config.from_object(conf) db = SQLAlchemy(app) # Set up less compilation assets = Environment(app) assets.append_path('assets') assets.register('css_all', '*.css', Bundle('pghtrash.less', filters='less'), filters='cssmin', output='.gen/pghtrash.min.css', depends='*.less') # Load our routes from pghtrash.routes import setup_routes setup_routes(app) # Insure models are loaded from pghtrash import models
class TestUrlAndDirectory(TempEnvironmentHelper): """By default, the 'url' and 'directory' settings of webassets are not used in Flask-Assets; that is, the values are automatically handled based on the configuration of the Flask app and the modules used. The user can disable the automatic handling by setting these values if he needs to for some reason. Let's test the different scenarios to ensure everything works. """ def setup(self): TempEnvironmentHelper.setup(self) self.app = Flask(__name__, static_path='/app_static') import test_module if not Blueprint: self.module = Module(test_module.__name__, name='module', static_path='/mod_static') self.app.register_module(self.module) else: self.blueprint = Blueprint('module', test_module.__name__, static_url_path='/mod_static', static_folder='static') self.app.register_blueprint(self.blueprint) self.env = Environment(self.app) def test_config_values_not_set_by_default(self): assert not 'directory' in self.env.config assert not 'url' in self.env.config assert_raises(KeyError, self.env.config.__getitem__, 'directory') assert_raises(KeyError, self.env.config.__getitem__, 'url') def test_directory_auto(self): """Test how we resolve file references through the Flask static system by default (if no custom 'env.directory' etc. values have been configured manually). """ assert not 'directory' in self.env.config root = self.app.root_path assert get_all_bundle_files(Bundle('foo'), self.env) == [root + '/static/foo'] # Modules prefixes in paths are handled specifically. assert get_all_bundle_files(Bundle('module/bar'), self.env) == [ root + '/test_module/static/bar' ] # Prefixes that aren't valid module names are just considered # subfolders of the main app. assert get_all_bundle_files(Bundle('nomodule/bar'), self.env) == [ root + '/static/nomodule/bar' ] # In case the name of a app-level subfolder conflicts with a # module name, you can always use this hack: assert get_all_bundle_files(Bundle('./module/bar'), self.env) == [root + '/static/module/bar'] # Custom static folder self.app.static_folder = '/' assert get_all_bundle_files(Bundle('foo'), self.env) == ['/foo'] def test_url_auto(self): """Test how urls are generated via the Flask static system by default (if no custom 'env.url' etc. values have been configured manually). """ assert not 'url' in self.env.config assert Bundle('foo').urls(self.env) == ['/app_static/foo'] # Urls for files that point to a module use that module's url prefix. assert Bundle('module/bar').urls(self.env) == ['/mod_static/bar'] # Try with a prefix that's not actually a valid module assert Bundle('nomodule/bar').urls( self.env) == ['/app_static/nomodule/bar'] # [Regression] Ensure that any request context we may have added # to the stack has been removed. from flask import _request_ctx_stack assert _request_ctx_stack.top is None def test_custom_load_path(self): """A custom load_path is configured - this will affect how we deal with source files. """ self.env.append_path(self.tempdir, '/custom/') self.create_files(['foo', 'module/bar']) assert get_all_bundle_files(Bundle('foo'), self.env) == [self.path('foo')] # We do not recognize references to modules. assert get_all_bundle_files(Bundle('module/bar'), self.env) == [self.path('module/bar')] assert Bundle('foo').urls(self.env) == ['/custom/foo'] assert Bundle('module/bar').urls(self.env) == ['/custom/module/bar'] # [Regression] With a load path configured, generating output # urls still works, and it still uses the flask system. self.env.debug = False self.env.url_expire = False assert Bundle('foo', output='out').urls(self.env) == ['/app_static/out'] def test_custom_directory_and_url(self): """Custom directory/url are configured - this will affect how we deal with output files.""" # Create source source file, make it findable (by default, # static_folder) is set to a fixed subfolder of the test dir (why?) self.create_files({'a': ''}) self.app.static_folder = self.tempdir # Setup custom directory/url pair for output self.env.directory = self.tempdir self.env.url = '/custom' self.env.debug = False # Return build urls self.env.url_expire = False # No query strings assert Bundle('a', output='foo').urls(self.env) == ['/custom/foo'] # We do not recognize references to modules. assert Bundle('a', output='module/bar').urls( self.env) == ['/custom/module/bar'] def test_existing_request_object_used(self): """[Regression] Check for a bug where the url generation code of Flask-Assets always added a dummy test request to the context stack, instead of using the existing one if there is one. We test this by making the context define a custom SCRIPT_NAME prefix, and then we check if it affects the generated urls, as it should. """ with self.app.test_request_context( '/', environ_overrides={'SCRIPT_NAME': '/yourapp'}): assert Bundle('foo').urls(self.env) == ['/yourapp/app_static/foo'] def test_glob(self): """Make sure url generation works with globs.""" self.app.static_folder = self.tempdir self.create_files({'a.js': 'foo', 'b.js': 'bar'}) assert list(sorted(self.mkbundle('*.js').urls( self.env))) == ['/app_static/a.js', '/app_static/b.js']
"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) @babel.localeselector def get_locale(): # try to guess the language from the user accept header the browser transmits. We support de/en.