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():
