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 run_server(options): api_listener = Api() gevent.spawn(api_listener.run) # # Setup flask app static_url_path = "/changed-so-it-doesnt-conflict-with-blueprint-static-path" app = Flask(__name__, static_url_path=static_url_path) app.config.from_pyfile(options["config"].name) app.register_blueprint(FrontendBlueprint()) # # JS/CSS & HTML minification in production if not app.config.get('DEBUG'): from .misc.jinja2htmlcompress import HTMLCompress app.jinja_env.add_extension(HTMLCompress) assets = Environment() assets.init_app(app) # # Run server http = WSGIServer((options['http_host'], options['http_port']), app) LOGGER.info('Listening on %s:%s', options['http_host'], options['http_port']) try: http.serve_forever() return 0 except KeyboardInterrupt: http.stop() api_listener.stop() LOGGER.info('Application Terminated') return 0
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 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 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 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 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 __init__(self, *args, **kwargs): super(Application, self).__init__(__name__) self.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True self.config['DEBUG'] = True # self.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test.db' self.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///database.db' db.init_app(self) self.register_blueprint(api) self.register_blueprint(user) self.register_blueprint(others) assets = Environment(self) assets.load_path = [ os.path.join(os.path.dirname(__file__), 'bower_components'), os.path.join(os.path.dirname(__file__), 'static/js'), # os.path.join(os.path.dirname(__file__), 'bower_components'), ] assets.register( 'js_all', Bundle( '**/**.min.js', 'js/**.min.js', output='js_all.js' ) )
def create_app(): """创建Flask app""" app = Flask(__name__) app.config.from_object(config) # CSRF protect CsrfProtect(app) if app.debug: DebugToolbarExtension(app) else: from .utils.sentry import sentry sentry.init_app(app) # from .mails import mail # mail.init_app(app) assets = Environment() assets.init_app(app) # 注册组件 register_db(app) register_routes(app) register_jinja(app) register_error_handle(app) register_uploadsets(app) # before every request @app.before_request def before_request(): pass 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 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 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(): 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 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 bundle(app): assets = Environment(app) assets.debug = True theme_bundle(assets) base_bundle(assets) app_bundle(assets) return assets
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 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 init_assets(app): assets = Environment(app) assets.register('css_lib', Bundle( 'bower_components/bootstrap/dist/css/bootstrap.min.css', filters='cssmin', output='../../static/css/lib.css' )) assets.register('css_dist', Bundle( 'less/common.less', 'less/login.less', 'less/item.less', filters='less, cssmin', output='../../static/css/dist.css' )) assets.register('js_lib', Bundle( 'bower_components/jquery/dist/jquery.min.js', 'bower_components/bootstrap/dist/js/bootstrap.min.js', filters='jsmin', output='../../static/js/lib.js' )) assets.register('js_dist', Bundle( 'coffee/common.coffee', 'coffee/login.coffee', 'coffee/item.coffee', filters='coffeescript, jsmin', output='../../static/js/dist.js' )) return assets
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 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 _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 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 _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 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_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 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 register_bundles(app): assets = Environment(app) assets.debug = app.config.get('ASSETS_DEBUG', False) ## # CSS css_global = Bundle( 'css/shared/normalize.scss', 'css/global.scss', filters='scss, cssmin', output='gen/global.css') assets.register('css_global', css_global) css_home = Bundle( 'css/home.scss', filters='scss, cssmin', #otheCssBundled output='gen/home.css') assets.register('css_home', css_home) ## # Javascript js_global = Bundle('js/jquery-1.9.1.js', 'js/global.js','js/someUtil.js') js_global = Bundle( Bundle(js_global), #otherJsBundled, output='gen/script.js' ) assets.register('js_global', js_global)
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 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')) config = os.path.join(os.path.dirname( __file__ ), "../config/", "config.cfg") app.config.from_pyfile(config) # Secret key needed to use sessions. app.secret_key = app.config['SECRET_KEY'] app.mail = Mail(app) # Initialize SQL Alchemy and Flask-Login # Instantiate the Bcrypt extension db.init_app(app) if (app.config['CREATE_SCHEMA']): with app.app_context(): db.create_all() 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
class TestConfigNoAppBound: """The application is not bound to a specific app. """ def setup(self): self.env = Environment() def test_no_app_available(self): """Without an application bound, we can't do much.""" assert_raises(RuntimeError, setattr, self.env, "debug", True) assert_raises(RuntimeError, self.env.config.get, "debug") def test_global_defaults(self): """We may set defaults even without an application, however.""" self.env.config.setdefault("FOO", "BAR") with Flask(__name__).test_request_context(): assert self.env.config["FOO"] == "BAR" def test_multiple_separate_apps(self): """Each app has it's own separate configuration. """ app1 = Flask(__name__) self.env.init_app(app1) # With no app yet available... assert_raises(RuntimeError, getattr, self.env, "url") # ...set a default self.env.config.setdefault("FOO", "BAR") # When an app is available, the default is used with app1.test_request_context(): assert self.env.config["FOO"] == "BAR" # If the default is overridden for this application, it # is still valid for other apps. self.env.config["FOO"] = "42" assert self.env.config["FOO"] == "42" app2 = Flask(__name__) with app2.test_request_context(): assert self.env.config["FOO"] == "BAR" def test_key_error(self): """KeyError is raised if a config value doesn't exist. """ with Flask(__name__).test_request_context(): assert_raises(KeyError, self.env.config.__getitem__, "YADDAYADDA") # The get() helper, on the other hand, simply returns None assert self.env.config.get("YADDAYADDA") == None
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' ))
app.config['ANALYTICS']['GOOGLE_CLASSIC_ANALYTICS']['ENABLED'] = True app.config['ANALYTICS']['GOOGLE_CLASSIC_ANALYTICS']['ACCOUNT'] = 'UA-4138452-1' cache = SimpleCache() # api docs regex converter class RegexConverter(BaseConverter): def __init__(self, url_map, *items): super(RegexConverter, self).__init__(url_map) self.regex = items[0] app.url_map.converters['regex'] = RegexConverter # assets assets = Environment(app) scss = Bundle('stylesheets/main.scss', filters='pyscss', output='gen/scss.css') all_css = Bundle('vendor/*.css', scss, filters='cssmin', output="gen/all.css") assets.register('css_all', all_css) js = Bundle('vendor/jquery-3.1.1.min.js', 'vendor/jquery.timeago.js', 'vendor/bootstrap.min.js', 'vendor/showdown.min.js', 'javascripts/*.js', filters='jsmin', output='gen/packed.js') assets.register('js_all', js) # constants
app.config['SQLALCHEMY_POOL_SIZE'] = 1000 app.config['SQLALCHEMY_POOL_RECYCLE'] = 1500 app.config['SQLALCHEMY_BINDS'] = { '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
def setup_assets(app): """Setup assets.""" from flask.ext.assets import Environment assets = Environment(app)
# -*- coding: utf-8 -*- import os from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.assets import Environment from webassets.loaders import PythonLoader from {{cookiecutter.repo_name}} import assets from {{cookiecutter.repo_name}}.models import db assets_env = Environment() def create_app(config_object, env): '''An application factory, as explained here: http://flask.pocoo.org/docs/patterns/appfactories/ :param config_object: The configuration object to use. :param env: A string, the current environment. Either "dev" or "prod" ''' app = Flask(__name__) app.config.from_object(config_object) app.config['ENV'] = env # Initialize SQLAlchemy db.init_app(app) # Register asset bundles assets_env.init_app(app) assets_loader = PythonLoader(assets) for name, bundle in assets_loader.load_bundles().iteritems(): assets_env.register(name, bundle) # Register blueprints from {{cookiecutter.repo_name}}.modules import public, member
# setup logging @app.before_first_request def setup_logging(): if not app.debug: app.logger.addHandler(logging.StreamHandler()) app.logger.setLevel(logging.INFO) # Getting the supported languages from SUMO LANGUAGES = requests.get( (app.config['SUMO_URL'] + 'offline/get-languages')).json() LANGUAGES = json.dumps(LANGUAGES['languages']) # Sets up the assets assets = Environment(app) assets.auto_build = app.debug assets.debug = app.debug # we don't need this as manifest.appcache will change assets.url_expire = False css = Bundle('css/develop/gaia.css', 'css/develop/doc.css', 'css/develop/installer.css', 'css/develop/nav.css', 'css/develop/app.css', filters='cssmin', output='css/app.min.css') assets.register('css_all', css) scripts = ['js/develop/app.js']
# -*- coding: utf-8 -*- from flask.ext.assets import Bundle, Environment css = Bundle("libs/font-awesome4/css/font-awesome.min.css", "libs/bootstrap/dist/css/bootstrap.css", "css/style.css", filters="cssmin", output="public/css/common.css") js = Bundle("libs/jQuery/dist/jquery.js", "libs/bootstrap/dist/js/bootstrap.js", "js/plugins.js", filters='jsmin', output="public/js/common.js") assets = Environment() assets.register("js_all", js) assets.register("css_all", css)
DEBUG = True FLATPAGES_AUTO_RELOAD = DEBUG FLATPAGES_ROOT = 'content' POST_DIR = 'posts' PAGE_DIR = 'pages' FLATPAGES_EXTENSION = '.md' SITE_NAME = 'Diary of a Future Dev' SERVER_PORT = 8000 app = Flask(__name__) app.config.from_object(__name__) flatpages = FlatPages(app) freezer = Freezer(app) assets = Environment(app) assets.url_expire = False @app.route('/') def index(): """ Show a list of most recent posts on index page """ posts = [p for p in flatpages if p.path.startswith(POST_DIR)] return render_template('index.html', posts=posts) @app.route('/tutorials/') def tutorials(): """ Show a list of most recent posts on index page """ posts = [p for p in flatpages if p.path.startswith(POST_DIR)] return render_template('tutorials.html', posts=posts) @app.route('/community/')
from flask.ext.assets import Environment, Bundle from flask.ext.cache import Cache from flask.ext.mail import Mail from flask.ext.redis import Redis app = Flask(__name__) if os.path.exists(".production"): app.config.from_object('configs.Production') else: app.config.from_object('configs.Testing') babel = Babel(app) db = SQLAlchemy(app) cache = Cache(app) assets = Environment(app) mail = Mail(app) redis = Redis(app) from controllers.catalog import catalog from controllers.manager import manager from models import * app.register_blueprint(catalog, url_prefix='/<lang_code>') app.register_blueprint(manager, url_prefix='/manager') css = Bundle( 'source/css/third-party/normalize-1.1.2.css', 'source/css/third-party/flags.css',
# Load default configuration from config.py app.config.from_object("config") # Setup caching cache = Cache(app) # Run SCSS compilers if DEBUG if DEBUG: from flask.ext.scss import Scss Scss(app) # Run JS compiler from flask.ext.assets import Environment, Bundle assets = Environment(app) assets.load_path.append(os.path.join(base_dir, "assets/js/")) js = Bundle("libs/first/*.js", "libs/second/*.js", "base.js", "plugins/*.js", "helpers/*.js", "styles/*.js", "viz/*.js", "viz/configs/*.js", "viz/data/*.js", "viz/geo/*.js", output="js/site.js") assets.register("js", js) # Load and register the modules for each different section of the site
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)
from os import listdir from flask import Flask, render_template from flask.ext.assets import Environment, Bundle app = Flask(__name__) app.config.from_pyfile('%s/config/default.cfg' % app.root_path) app.config.from_envvar('FLASK_CONFIG') # Compile, combile and minify all static assets automatically assets = Environment(app) assets.register('js', Bundle( *['/'.join(['js', f]) for f in listdir('app/static/js')], filters='uglifyjs', output='assets/main.%(version)s.min.js' )) assets.register('css', Bundle( # nested sass bundle Bundle(*['/'.join(['scss', f]) for f in listdir('app/static/scss')], filters='scss', output='assets/scss.combined.%(version)s.css'), # cssmin bundle *['/'.join(['css', f]) for f in listdir('app/static/css')], filters='cssmin', output='assets/combined.%(version)s.min.css' )) @app.route('/') def hello(): return render_template('base.html')
def init(app): """Initialize CSS and JavaScript asset bundles """ js_libs = Bundle("js/libs/jquery-1.6.2.min.js", "js/libs/jquery.dropkick-1.0.0.js", "js/libs/json2.js", "js/libs/underscore.js", "js/libs/backbone.js", "js/libs/swfobject.js", "js/libs/spin-1.2.2.js", filters="jsmin", output="libs.js") js_common = Bundle("js/app/tools.js", "js/app/common.js", filters="jsmin", output="common.js") js_home = Bundle("js/app/stats.js", "js/app/home.js", filters="jsmin", output="home.js") js_profile = Bundle("js/app/profile.js", filters="jsmin", output="profile.js") css_less = Bundle("css/style.less", filters="less", output="style.css", debug=False) css_main = Bundle(Bundle("css/lib/screen.css", "css/lib/dropkick.css"), css_less, filters="cssmin", output="main.css") css_ie8 = Bundle("css/ie8.css", filters="cssmin", output="ie8.css") # Admin Assets js_admin_libs = Bundle("js/libs/jquery-1.6.2.min.js", "js/libs/jquery-ui-1.8.16.min.js", "js/libs/json2.js", "js/libs/underscore.js", "js/libs/backbone.js", filters="jsmin", output="admin_libs.js") js_admin_common = Bundle("js/app/admin_tools.js", "js/app/admin.js", filters="jsmin", output="admin_common.js") css_admin_less = Bundle("css/admin.less", filters="less", output="admin.css", debug=False) css_admin_main = Bundle("css/lib/screen.css", "css/lib/smoothness/jquery-ui-1.8.16.css", css_admin_less, filters="cssmin", output="admin_main.css") assets = Environment(app) assets.debug = app.config['ENVIRONMENT'] in ['development', 'staging'] assets.register('js_libs', js_libs) assets.register('js_common', js_common) assets.register('js_home', js_home) assets.register('js_profile', js_profile) assets.register("css_main", css_main) assets.register("css_ie8", css_ie8) assets.register("js_admin_libs", js_admin_libs) assets.register("js_admin_common", js_admin_common) assets.register("css_admin_main", css_admin_main)
'js/bootstrap.js', 'js/toastr.min.js', 'js/freelancer.js', 'js/run_prettify.js', 'js/site_personal.js', 'js/prettify.js', 'js/run_prettify.js', 'js/classie.js', 'js/socialShare.min.js', 'js/cbpAnimatedHeader.js', filters='jsmin'), 'third_party_css': Bundle('css/jquery-ui.min.css', 'css/font-awesome.min.css', 'css/bootstrap.min.css', 'css/prettify.css', 'css/site_personal.css', 'css/arthref.min.css', 'css/toastr.min.css', 'css/freelancer.css', filters='cssmin') } site_assets = Environment(app) site_assets.register(bundles) def get_assets(): print('Here from lblrsm.assets....') return site_assets
#!/usr/bin/env python import sys from os import path sys.path.insert(0, path.join(path.dirname(__file__), '../src')) from flask import Flask, render_template, url_for from flask.ext.assets import Environment, Bundle app = Flask(__name__) assets = Environment(app) assets.register('main', 'style1.css', 'style2.css', output='cached.css', filters='cssmin') @app.route('/') def index(): return render_template('index.html') app.run(debug=True)
from flask.ext.assets import Environment from flask.ext.babel import Babel from flask.ext.script import Manager from flask.ext.sqlalchemy import SQLAlchemy # Flask extensions assets = Environment() db = SQLAlchemy() babel = Babel() class ContextfulManager(Manager): """Flask-Script manager that creates a test request context""" def create_app(self, **kwargs): app = super(ContextfulManager, self).create_app(**kwargs) app.test_request_context().__enter__() return app
ASSETS_DEBUG = DEBUG app = Flask(__name__, static_folder="assets") app.config.from_object(__name__) # # Jinja, CSS, LESS, and JS Assets # WATCH_PATTERNS = ( "README.md", "/templates/**", "/pages/**", "/assets/**" ) assets = Environment(app) css_files = ['home.less'] css_all = Bundle(*['less/' + file for file in css_files], filters=['less', 'cleancss'], output='gen/css_all.css') assets.register("css_all", css_all) js_files = ['home.js'] js_all = Bundle(*['js/' + file for file in js_files], filters='rjsmin', output='gen/js_all.js') assets.register("js_all", js_all) css_lib_files = ['bootstrap.css', 'bootstrap-theme.css'] css_lib = Bundle(*['lib/css/' + file for file in css_lib_files], filters='cleancss', output='gen/css_lib.css') assets.register("css_lib", css_lib)
CsrfProtect(app) mongo = PyMongo(app) login_manager = LoginManager() login_manager.init_app(app) eve_db = sqlalchemy.create_engine(app.config['EVE_STATIC_DUMP']) oauth = OAuth(app) hr_oauth = oauth.remote_app( 'j4hr2', app_key='J4OAUTH' ) rQueue = Queue(connection=redis.StrictRedis(app.config['REDIS'])) api_oauth = requests.Session() api_oauth.headers.update({ 'x-oauth-key': app.config['J4OAUTH']['consumer_key'], 'x-oauth-secret': app.config['J4OAUTH']['consumer_secret']}) # Register asset bundles assets_env = Environment() assets_env.init_app(app) assets_loader = PythonLoader(assets) for name, bundle in assets_loader.load_bundles().iteritems(): assets_env.register(name, bundle)
output = list(rows_iterator) # iterators break the cache middleware return Response(output, mimetype='text/csv') # TODO: this fake URL is used to run unittests. It should be disabled on a deploy @app.route('/fakelogin') def fake_login(): import os from flask import session if 'PC_FAKE_OID' in os.environ: session['openid'] = os.environ['PC_FAKE_OID'] # static asset versioning and packaging assets = Environment(app) js = Bundle('jquery-1.11.0.js', 'bootstrap-3.1.1/dist/js/bootstrap.js', 'bootstrap-selectpicker/bootstrap-select.js', 'typeahead.bundle.js', 'lodash.min.js', 'can.jquery.js', filters='rjsmin', output='build/tuxtrax-%(version)s.js') css = Bundle('ptrax.css', output='build/tuxtrax-%(version)s.css') try: os.environ["DEBUG"] except KeyError:
Portions copyright 2012 Twitter, Inc. (Parts licensed under Apache License v2.0) Portions copyright (c) 2009-2012 Hunter Perrin (Parts licensed under GPLv3) Portions copyright (c) jQuery UI Team (Parts licensed under MIT license) Portions copyright (c) 2011, Benjamin Arthur Lupton (Parts licensed under BSD license) Portions copyright 2012 Stefan Petre, Andrew Rowls (Parts licensed under Apache License v2.0) */ """) shutil.copyfileobj(_in, out) def copyrighter_app(_in, out, **kw): out.write("""/* Webasset generated for DTG. Copyright (c) 2012 The DTG Team. Licensed under AGPLv3. See https://bitbucket.org/xoraxax/dtg/raw/tip/LICENSE for details. */ """) shutil.copyfileobj(_in, out) assets = Environment(app) assets.register('js_lib', Bundle(*["js/" + name for name in ( "jquery-1.8.3.js", "jquery-ui-1.9.2.custom.js", "jquery.history.js", "bootstrap.js", "jquery.pnotify.js", # "jquery.hotkeys.js", "URI.js", "bootstrap-datepicker.js", "locales/bootstrap-datepicker.de.js")], filters=(minifier_strong, copyrighter_lib), output="gen/packed_lib.js")) assets.register('js_app', Bundle("js/app.js", "js/tutorial.js", filters=(minifier, copyrighter_app), output="gen/packed_app.js")) css_all = Bundle(*["css/" + name for name in ( "bootstrap.css", "bootstrap-responsive.css", "style.css", "cupertino/jquery-ui-1.8.21.custom.css", "jquery.pnotify.default.css", "datepicker.css")], filters=("cssrewrite", "cssmin"), output="gen/packed.css") assets.register("css_all", css_all) # command line code
A microblog reflection application written as Flask tutorial with Flask and sqlite3. :copyright: (c) 2014 by Armin Ronacher. :license: BSD, see LICENSE for more details. """ from flask import Flask, request, render_template, jsonify from lib import StudentLib, DBConnect, RecordLib, RecordTypeLib, ClassLib from flask.ext.assets import Environment, Bundle app = Flask(__name__) session = DBConnect.connect() env = Environment(app) # Bundle and register javascript and CSS js_common = Bundle('js/jquery/jquery.js', output='gen/common.js') js_student = Bundle('js/student/student.js', output='gen/student.js') js_charts = Bundle('js/charts/charts.min.js','js/charts/credCharts.js', output='gen/charts.js') css_common = Bundle('css/style.css', output='gen/common.css') env.register('js_common', js_common) env.register('js_student', js_student) env.register('js_charts', js_charts) env.register('css_common', css_common) ### Student Routes @app.route('/_student/get_student_names')
# load config app.config.update( DEBUG=debug, SHOW_GA=show_ga, SECRET_KEY=os.environ.get('SECRET_KEY', ''), # GOOGLE_LOGIN_CLIENT_ID=os.environ.get('GOOGLE_LOGIN_CLIENT_ID', ''), # GOOGLE_LOGIN_CLIENT_SECRET=os.environ.get('GOOGLE_LOGIN_CLIENT_SECRET', ''), # GOOGLE_LOGIN_REDIRECT_URI=os.environ.get('GOOGLE_LOGIN_REDIRECT_URI', ''), SQLALCHEMY_TRACK_MODIFICATIONS=True, SQLALCHEMY_DATABASE_URI=os.environ.get( 'SQLALCHEMY_DATABASE_URI', 'postgres://*****:*****@localhost/beer'), ) db = SQLAlchemy(app) # setup assetbundle assets = Environment(app) assets.debug = False # app.debug # (debug=True f***s up jsx) bundles = PythonLoader('web.assetbundles').load_bundles() for name, bundle in bundles.iteritems(): assets.register(name, bundle) # add various views from web import views from web import api app.db_session = db.session
#!/usr/bin/env python # -*- coding: utf-8 -*- import os from flask.ext.assets import Bundle, Environment js = Bundle(\ 'libs/jquery/dist/jquery.min.js',\ ) css = Bundle('css/style.css') assets = Environment() assets.register('js_all', js) assets.register('css_all', css)
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
"utm_source": "transactional", "utm_campaign": "user-account" } } } } message.extra_headers = { 'X-SMTPAPI': json.dumps(extra_headers) } original_send(message) app.extensions.get('mail').send = send_email_with_sendgrid # setup assets from flask.ext.assets import Environment, Bundle assets = Environment(app) assets.url_expire = False assets.debug = app.debug # source files assets.load_path = ['%s/static' % app.config.root_path] from webassets.filter.pyscss import PyScss assets.register('css', Bundle( 'font-awesome-4.2.0/css/font-awesome.min.css', 'chosen/chosen.min.css', Bundle( 'resources/css/style.scss', 'resources/css/bill-progress.scss', filters=PyScss(load_paths=assets.load_path),
#from flask folder get class/package Flask from flask import Flask, render_template from flask.ext.assets import Environment, Bundle app = Flask(__name__, static_folder='static') #name is referencing the Flask object assets = Environment(app) assets.init_app(app) @app.route('/') def homepage(): return render_template('index.html') if __name__ == "__main__": app.debug = True #the debug log is displayed on the console app.run() # app.run('0.0.0.0', debug = True) you can set your own address #one way to do it # app = Flask(__name__) #name is referencing the Flask object # @app.route('/') #this is the root page # def home(): # return "hello" # # @app.route('/profile/<username>') #localhost:5000/profile/whatever word you set # def profile(username): # return "hey, your name is %s" % username + " i hate that name" #
from flask.ext.assets import Bundle, Environment assets_env = Environment() common_css = Bundle('../static/less/*.less', filters='less', output='../public/css/common.css') assets_env.register('common_css', common_css) common_js = Bundle('../static/bower_components/jquery/dist/jquery.js', '../static/bower_components/bootstrap/dist/js/bootstrap.js', output='../public/js/common.js') assets_env.register('common_js', common_js) application_js = Bundle('../static/coffee/*.coffee', filters='coffeescript', output='../public/js/application.js') assets_env.register('application_js', application_js)
from flask.ext.assets import Bundle, Environment from url_shortener import app bundles = { 'script': Bundle('javascript/main.js', output='generated/script.js'), 'style': Bundle('stylesheet/main.scss', filters='pyscss', output='generated/style.css') } assets = Environment(app) assets.register(bundles)
return url_for(rule, **kwargs) application = Flask(__name__, static_folder=join(abspath(dirname(__file__)), 'resources')) application.config.update(dictionary) application.jinja_env.add_extension('jinja2.ext.do') application.jinja_env.add_extension('jinja2.ext.loopcontrols') application.jinja_env.add_extension('jinja2.ext.with_') application.jinja_env.globals['url_for'] = url_for_ 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 = 'timestamp' assets.register( 'stylesheets', Bundle( Bundle('stylesheets/all.less', filters='less', output='stylesheets/all.css'),
import urlparse import json import random import base64 import re import api from stackblink import stackblink from skymorph import skymorph from sdss import sdss app = Flask(__name__) app.secret_key = 'not a secret key' # bundling assets = Environment(app) # This filter can be helping for debugging javascript. def noop_filter(_in, out, **kw): out.write(_in.read()) # main routes @app.route("/") def index(): return render_template('index.html') @app.route("/3d") def view_3d():