def init_app(app):
webassets = Environment(app)
webassets.register('css_all', css_all)
webassets.register('js_vendor', js_vendor)
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
def register_assets(app):
assets = Environment(app)
assets.url = app.static_url_path
assets.directory = app.static_folder
assets.append_path('assets')
scss = Bundle('scss/main.scss', filters='pyscss', output='main.css', depends=('scss/*.scss'))
assets.register('scss_all', scss)
def create_app(object_name='bosphorus.settings', env='dev'):
app = create_barebones_app(object_name, env)
# Import and register the different asset bundles
assets_env = Environment()
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# register our blueprints
from controllers.main import main
from controllers.user import user
from controllers.studies import studies
from controllers.person import person
from controllers.protocol import protocol
from utils import proxy
app.register_blueprint(main)
app.register_blueprint(user)
app.register_blueprint(person)
app.register_blueprint(studies)
app.register_blueprint(protocol)
app.register_blueprint(proxy)
return app
def init_app(self, app):
env = Environment(app)
env.url_expire = True
env.register('css_app', css_app)
env.register('js_app', js_app)
env.manifest = 'cache' if not app.debug else False
env.cache = not app.debug
env.debug = app.debug
def init_app(app):
webassets = Environment(app)
webassets.url = app.static_url_path
webassets.register('js_lodjers', js_lodjers)
webassets.register('js_mixpanel', js_mixpanel)
webassets.register('css_lodjers', css_lodjers)
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
class InvenioAssets(object):
"""Invenio asset extension."""
def __init__(self, app=None, **kwargs):
r"""Extension initialization.
:param app: An instance of :class:`~flask.Flask`.
:param \**kwargs: Keyword arguments are passed to ``init_app`` method.
"""
self.env = Environment()
self.collect = Collect()
if app:
self.init_app(app, **kwargs)
def init_app(self, app, entry_point_group='invenio_assets.bundles',
**kwargs):
"""Initialize application object.
:param app: An instance of :class:`~flask.Flask`.
:param entry_point_group: A name of entry point group used to load
``webassets`` bundles.
.. versionchanged:: 1.0.0b2
The *entrypoint* has been renamed to *entry_point_group*.
"""
self.init_config(app)
self.env.init_app(app)
self.collect.init_app(app)
if entry_point_group:
self.load_entrypoint(entry_point_group)
app.extensions['invenio-assets'] = self
def init_config(self, app):
"""Initialize configuration.
:param app: An instance of :class:`~flask.Flask`.
"""
app.config.setdefault('REQUIREJS_BASEURL', app.static_folder)
app.config.setdefault('COLLECT_STATIC_ROOT', app.static_folder)
app.config.setdefault('COLLECT_STORAGE', 'flask_collect.storage.link')
app.config.setdefault(
'COLLECT_FILTER', partial(collect_staticroot_removal, app))
def load_entrypoint(self, entry_point_group):
"""Load entrypoint.
:param entry_point_group: A name of entry point group used to load
``webassets`` bundles.
.. versionchanged:: 1.0.0b2
The *entrypoint* has been renamed to *entry_point_group*.
"""
for ep in pkg_resources.iter_entry_points(entry_point_group):
self.env.register(ep.name, ep.load())
def register_assets(app):
assets = Environment(app)
assets.debug = app.debug
assets.auto_build = True
assets.url = app.static_url_path
css_all = Bundle(*CSS_ASSETS, filters='cssmin', output='css/bundle.min.css')
assets.register('css_all', css_all)
app.logger.info("Registered assets...")
return assets
def init_assets(app):
app.config['ASSETS_DEBUG'] = settings.DEBUG
webassets = Environment(app)
webassets.config['PYSCSS_STATIC_ROOT'] = join(STATIC_FOLDER, 'scss')
webassets.config['PYSCSS_STATIC_URL'] = join(STATIC_FOLDER, 'css/main.css')
webassets.register('css', css_bundle)
webassets.register('coffee', coffee_bundle)
webassets.register('js', js_bundle)
webassets.register('swagger_js', swagger_js)
webassets.register('swagger_css', swagger_css)
def init_app(app):
"""
Initilize assets.
:param app:
"""
webassets = Environment(app)
webassets.url = app.static_url_path
webassets.register('css_all', css_all)
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
def prepare(app):
web_assets = Environment(app)
web_assets.register('css_all', *prepare_css())
web_assets.register('js_all', *prepare_js())
is_debugging = app.debug
web_assets.manifest = 'cache' if not is_debugging else False
web_assets.cache = not is_debugging
web_assets.debug = is_debugging
return app
def init(app):
assets = Environment(app)
js = Bundle(*app.config['JS_ASSETS'],
output=app.config['JS_ASSETS_OUTPUT'],
filters=app.config['JS_ASSETS_FILTERS'])
css = Bundle(*app.config['CSS_ASSETS'],
output=app.config['CSS_ASSETS_OUTPUT'],
filters=app.config['CSS_ASSETS_FILTERS'])
assets.register('js_all', js)
assets.register('css_all', css)
def init_app(app, allow_auto_build=True):
assets = Environment(app)
# on google app engine put manifest file beside code
# static folders are stored separately and there is no access to them in production
folder = os.path.abspath(os.path.dirname(__file__)) if "APPENGINE_RUNTIME" in os.environ else ""
assets.directory = os.path.join(app.static_folder, "compressed")
assets.manifest = "json:{}/manifest.json".format(assets.directory)
assets.url = app.static_url_path + "/compressed"
compress = not app.debug # and False
assets.debug = not compress
assets.auto_build = compress and allow_auto_build
assets.register('js', Bundle(*JS, filters='yui_js', output='script.%(version)s.js'))
assets.register('css', Bundle(*CSS, filters='yui_css', output='style.%(version)s.css'))
def register_assets(app):
"""Register Webassets in the app"""
_create_code_css(app)
assets = Environment(app)
bundle = Bundle('style/main.less', 'style/code.css',
filters='less,cleancss',
output='css/main.%(version)s.css')
assets.register('css', bundle)
app.add_url_rule(
'/static/fonts/bootstrap/<path:filename>',
'bootstrap_fonts',
bootstrap_fonts)
def register_assets(app):
bundles = {
'home_js': Bundle('style/js/jquery.min.js',
'style/js/bootstrap.min.js',
'style/honmaple.js',
output='style/assets/home.js',
filters='jsmin'),
'home_css': Bundle('style/css/bootstrap.min.css',
'style/honmaple.css',
output='style/assets/home.css',
filters='cssmin')
}
assets = Environment(app)
assets.register(bundles)
def init_app(app):
webassets = Environment(app)
webassets.register('css_bootstrap', css_bootstrap)
#webassets.register('css_local', css_local)
#webassets.register('js_local', js_local)
#webassets.register('js_jquery', js_jquery)
webassets.register('js_bootstrap', js_bootstrap)
#webassets.register('js_angular', js_angular)
#webassets.register('js_coffee', js_coffee)
webassets.manifest = 'cache' if not app.debug else False
webassets.cache = not app.debug
webassets.debug = app.debug
def register_assets(app):
bundles = {
'home_js': Bundle(
'style/js/jquery.min.js', #这里直接写static目录的子目录 ,如static/bootstrap是错误的
'style/js/bootstrap.min.js',
output='style/assets/home.js',
filters='jsmin'),
'home_css': Bundle(
'style/css/bootstrap.min.css',
output='style/assets/home.css',
filters='cssmin')
}
assets = Environment(app)
assets.register(bundles)
class TestEnv:
def setup(self):
self.app = Flask(__name__)
self.env = Environment(self.app)
self.env.debug = True
self.env.register('test', 'file1', 'file2')
def test_tag_available(self):
"""Jinja tag has been made available.
"""
t = self.app.jinja_env.from_string('{% assets "test" %}{{ASSET_URL}};{% endassets %}')
assert t.render() == '/static/file1;/static/file2;'
def test_from_yaml(self):
"""YAML configuration gets loaded
"""
f = open('test.yaml', 'w')
f.write("""
yamltest:
contents:
- yamlfile1
- yamlfile2
""")
f.close()
self.env.from_yaml('test.yaml')
t = self.app.jinja_env.from_string('{% assets "yamltest" %}{{ASSET_URL}};{% endassets %}')
assert t.render() == '/static/yamlfile1;/static/yamlfile2;'
os.remove('test.yaml')
def test_from_python_module(self):
"""Python configuration module gets loaded
"""
import types
module = types.ModuleType('test')
module.pytest = Bundle('pyfile1', 'pyfile2')
self.env.from_module(module)
t = self.app.jinja_env.from_string('{% assets "pytest" %}{{ASSET_URL}};{% endassets %}')
assert t.render() == '/static/pyfile1;/static/pyfile2;'
def create_app(object_name='bosphorus.settings', env='dev'):
app = Flask(__name__)
# set config
app.config.from_object(object_name)
app.config['ENV'] = env
app.config['DEBUG'] = False if env=="prod" else True
# register all custom jinja filters
for f in jinja_filters:
app.jinja_env.filters[f[0]] = f[1]
#init the cache
cache.init_app(app)
#init SQLAlchemy
db.init_app(app)
#init Orthanc
orthanc.init_app(app)
# Import and register the different asset bundles
assets_env = Environment()
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# register our blueprints
from controllers.main import main
from controllers.user import user
from controllers.studies import studies
from controllers.person import person
from utils import proxy
app.register_blueprint(main)
app.register_blueprint(user)
app.register_blueprint(person)
app.register_blueprint(studies)
app.register_blueprint(proxy)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
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 .participant import participant as participant_blueprint
app.register_blueprint(participant_blueprint, url_prefix='/participant')
return app
def register_assets():
from flask_assets import Bundle, Environment
css_vendor = Bundle("assets/css/bootstrap.min.css",
"assets/css/font-awesome.css",
"assets/css/messenger.css",
"assets/css/messenger-theme-flat.css",
"assets/css/share.min.css",
filters="cssmin",
output="assets/css/vendor.css")
js_vendor = Bundle("assets/js/jquery.min.js",
"assets/js/bootstrap.min.js",
"assets/js/messenger.min.js",
"assets/js/messenger-theme-flat.js",
output="assets/js/vendor.js")
wechat_css = Bundle("assets/css/weui.min.css",
"assets/css/weui2.min.css",
"assets/css/font-awesome.css",
"assets/css/messenger.css",
"assets/css/messenger-theme-flat.css",
"assets/css/share.min.css",
filters="cssmin",
output="assets/css/wechat.css")
wechat_js = Bundle("assets/js/zepto.min.js",
"assets/js/jquery.min.js",
"assets/js/bootstrap.min.js",
"assets/js/messenger.min.js",
"assets/js/messenger-theme-flat.js",
"assets/js/wechat/login/login.js",
output="assets/js/wechat.js")
assets = Environment()
assets.register('css_vendor', css_vendor)
assets.register('wechat_css', wechat_css)
assets.register('js_vendor', js_vendor)
assets.register('wechat_js', wechat_js)
return assets
def register_extensions(self, app):
if app.debug:
debug_toolbar = DebugToolbarExtension()
debug_toolbar.init_app(app)
db.init_app(app)
mail.init_app(app)
wtf.add_helpers(app)
s3.init_app(app)
assets = Environment(app)
assets.register(bundles)
admin.init_app(app)
register_health_check(app, db)
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
app.security = Security(app, user_datastore)
def create_app():
template_folder = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates')
static_folder = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'static')
css_bundle = Bundle(
'build/css/*.css',
output='public/main.css')
js_bundle = Bundle(
'build/js/*.js',
output='public/main.js')
fonts_bundle = Bundle(
'fonts/bootstrap/*')
app = appfactory.create_app(
'frontend',
blueprints=blueprints,
static_folder=static_folder,
template_folder=template_folder)
env = Environment(app)
env.register('css_main', css_bundle)
env.register('js_main', js_bundle)
env.register('fonts_bundle', fonts_bundle)
return app
def init():
"""
Sets up flask application object `app` and returns it.
"""
# Instantiate main app, load configs, register modules, set
# url patterns and return the `app` object.
app = Flask(__name__)
app.config.from_object(settings)
config.app = app
# Init SQLAlchemy wrapper.
config.db = SQLAlchemy(app)
if app.debug:
DebugToolbarExtension(app)
#: Wrap the `app` with `Babel` for i18n.
Babel(app)
config.cache = Cache(app)
config.bcrypt = Bcrypt(app)
# Other initializations.
for fn, values in [(set_middlewares, getattr(settings, 'MIDDLEWARES', None)),
(set_context_processors, getattr(settings, 'CONTEXT_PROCESSORS', None)),
(set_template_filters, getattr(settings, 'TEMPLATE_FILTERS', None)),
(set_before_handlers, getattr(settings, 'BEFORE_REQUESTS', None)),
(set_after_handlers, getattr(settings, 'AFTER_REQUESTS', None)),
(set_log_handlers, getattr(settings, 'LOG_HANDLERS', None)),
(set_error_handlers, getattr(settings, 'ERROR_HANDLERS', None)),
(set_blueprints, getattr(settings, 'BLUEPRINTS', None))]:
if values:
fn(app, values)
# Register all js and css files.
assets = Environment(app)
for name, bundle in webassets.loaders.YAMLLoader('assets.yml').load_bundles().items():
assets.register(name, bundle)
# URL rules.
urls.set_urls(app)
# Set flask-cli commands
import commands
return app
def create_assets(app):
js_filters = ['jsmin'] if not app.debug else []
js = Bundle(
'javascripts/app.js',
'javascripts/libs/jquery/jquery-1.11.2.js',
'javascripts/libs/jqcloud/jqcloud-1.0.4.js',
filters=js_filters,
output='js/app.js')
css_filters = ['cssmin', 'stylus'] if not app.debug else []
css = Bundle(
'stylesheets/style.css',
'stylesheets/jqcloud.css',
'stylesheets/code.css',
filters=css_filters,
output='css/style.css')
# names the assets to be used in templates
assets = Environment(app)
assets.register('js_all', js)
assets.register('css_all', css)
return assets
def init(app) -> None:
"""
Bundle projects assets.
:param app: Main application instance
:type app: flask.Flask
"""
assets = Environment(app)
assets.auto_build = app.config.get('ASSETS_AUTO_BUILD', True)
files_to_watch = []
if 'COLLECT_STATIC_ROOT' in app.config:
assets.cache = app.config['COLLECT_STATIC_ROOT']
collect = Collect()
collect.init_app(app)
collect.collect()
app.static_folder = app.config['COLLECT_STATIC_ROOT']
for key in ['js', 'css']:
assets_key = '%s_ASSETS' % key.upper()
build_files = app.config[assets_key]
files_to_watch.extend(_get_files_for_settings(app, assets_key))
bundle = Bundle(*build_files,
output=app.config['%s_OUTPUT' % assets_key],
filters=app.config['%s_FILTERS' % assets_key]
)
assets.register('%s_all' % key, bundle)
app.logger.debug('Bundling files: %s%s',
os.linesep,
os.linesep.join(build_files))
app.assets = assets
app._base_files_to_watch = files_to_watch
app.logger.info('Base assets are collected successfully.')
class InvenioAssets(object):
"""Invenio asset extension."""
def __init__(self, app=None, entrypoint='invenio_assets.bundles',
**kwargs):
"""Extension initialization."""
self.env = Environment()
self.collect = Collect()
self.entrypoint = entrypoint
if app:
self.init_app(app, **kwargs)
def init_app(self, app, **kwargs):
"""Initialize application object."""
self.init_config(app)
self.env.init_app(app)
self.collect.init_app(app)
self.init_cli(app.cli)
if self.entrypoint:
self.load_entrypoint(self.entrypoint)
app.extensions['invenio-assets'] = self
def init_config(self, app):
"""Initialize configuration."""
app.config.setdefault("REQUIREJS_BASEURL", app.static_folder)
app.config.setdefault('COLLECT_STATIC_ROOT', app.static_folder)
app.config.setdefault('COLLECT_STORAGE', 'flask_collect.storage.link')
def init_cli(self, cli):
"""Initialize CLI."""
cli.add_command(assets_cmd)
cli.add_command(npm)
cli.add_command(collect)
def load_entrypoint(self, entrypoint):
"""Load entrypoint."""
for ep in pkg_resources.iter_entry_points(entrypoint):
self.env.register(ep.name, ep.load())
def welcome(app):
assets = Environment(app)
js = Bundle(
'js/modernizr.js',
'js/jquery.js',
'js/foundation.min.js',
'js/main.js',
filters='rjsmin',
output='js/min.js'
)
assets.register('js', js)
css = Bundle(
'css/foundation.css',
'css/main.css',
filters='cssmin',
output='css/min.css'
)
assets.register('css', css)
return render_template('index.html')
def init_app(app):
assets = Environment(app)
assets.register("css_vendor", css_vendor)
assets.register("js_vendor", js_vendor)
assets.register("css_linkedlist", css_linkedlist)
assets.manifest = 'cache' if not app.debug else False
assets.cache = not app.debug
assets.debug = app.debug
def init_app(app):
debug = app.debug
webassets = Environment(app)
# add foundation sass files to sass compiler paths
webassets.config['SASS_LOAD_PATHS'] = ["../bower_components/foundation/scss/",
"."]
webassets.register('css_kb', css_kb)
webassets.register('shivs', shivs)
webassets.register('js_vendor', js_vendor)
webassets.register('js_main', js_main)
webassets.manifest = 'cache' if not debug else False
webassets.cache = not debug
webassets.debug = debug
def init_app(app):
assets = Environment(app)
styles = Bundle(
'main.scss',
filters='scss',
output='main.css',
depends='**/*.scss'
)
scripts = Bundle(
'*.js',
filters=('slimit'),
output='main.js'
)
assets.register('styles', styles)
assets.register('scripts', scripts)
# TODO: Move this config to an environment file
assets.load_path = ['service/design/styles', 'service/design/scripts']
assets.config['SASS_STYLE'] = 'compressed'
assets.url_expire = False
assets.auto_build = True
def create_app(test_config=None):
app = Flask(__name__, instance_relative_config=True)
app.config.from_object('settings')
if test_config is None:
app.config.from_pyfile('config.py', silent=True)
else:
app.config.from_mapping(test_config)
# ensure the instance folder exists
Path(app.instance_path).mkdir(parents=True, exist_ok=True)
app_pkg_dir = Path(__file__).parent
pids_dir = app_pkg_dir.with_name('tmp') / 'pids'
pids_dir.mkdir(parents=True, exist_ok=True)
pids_dir.joinpath(f'{__name__}.pid').write_text(str(os.getpid()))
def pic():
return Picture(app.config['PICS_DIR'], app.config['PHOTO_EXTS'])
log_dir = app_pkg_dir.with_name('log')
log_dir.mkdir(exist_ok=True)
fname = log_dir / 'photo_gallery.log'
log_handler = TimedRotatingFileHandler(filename=fname, when='d',
backupCount=7)
app.logger.setLevel(logging.ERROR)
app.logger.addHandler(log_handler)
app.register_error_handler(500, internal_server_error)
if app.config['ENV'] not in ['development', 'test']:
from flask_basicauth import BasicAuth
basic_auth = BasicAuth(app)
assets = Environment()
js_libs = ['jquery', 'popper', 'bootstrap', 'unitegallery', 'ug-theme-tiles']
js_libs = [f'js/{js_lib}.js' for js_lib in js_libs]
js = Bundle(*js_libs, filters='jsmin', output='js/js_all.js')
assets.register('js_all', js)
css_libs = ['bootstrap', 'style', 'unite-gallery']
css_libs = [f'css/{css_lib}.css' for css_lib in css_libs]
css = Bundle(*css_libs, filters='cssmin', output='css/css_all.css')
assets.register('css_all', css)
assets.init_app(app)
@app.route("/")
# @basic_auth.required
def index():
return render_template('index.html', folders=pic().folders())
@app.route("/<folder>")
# @basic_auth.required
def folder(folder):
pictures = pic().from_folder(folder)
return_to = request.referrer or url_for('index')
return render_template('show.html', pictures=pictures,
return_to=return_to)
# /pictures/Berlin_I/web/p1080757_12566647374_o_opt.jpg
# /pictures/Berlin_I/thumb/p1080757_12566647374_o_opt.jpg
@app.route("/pictures/<path:picture>")
def picture(picture):
if app.config['ENV'] == 'development':
pics_dir = pic().pics_dir
pic_path = pics_dir / picture
if pic_path.exists():
return send_from_directory(pics_dir, picture)
else:
abort(404)
else:
abort(404)
return app
bootstrap_css = Bundle('bootstrap/css/bootstrap.min.css')
main_css = Bundle('scss/main.scss', filters='libsass', depends='scss/*.scss', output='gen/main.css')
chart = Bundle('Chart/Chart.min.js')
openlayers_js = Bundle('OpenLayers/ol-debug.js')
openlayers_css = Bundle('OpenLayers/ol.css')
three = Bundle('three/three.min.js')
three_stl_loader = Bundle('three/STLLoader.js')
mcc_charts = Bundle('js/mcc_charts.js')
mcc_map = Bundle('js/mcc_map.js')
mcc_gl = Bundle('js/mcc_gl.js')
mcc_spectrum = Bundle('js/mcc_spectrum.js')
mcc_status = Bundle('js/mcc_status.js')
assets = Environment()
assets.register('jq_js', jquery)
assets.register('popper_js', popper)
assets.register('bs_js', bootstrap_js)
assets.register('bs_css', bootstrap_css)
assets.register('main_css', main_css)
assets.register('chart_js', chart)
assets.register('openlayers_js', openlayers_js)
assets.register('openlayers_css', openlayers_css)
assets.register('three', three)
assets.register('three_stl_loader', three_stl_loader)
assets.register('mcc_charts', mcc_charts)
assets.register('mcc_map', mcc_map)
assets.register('mcc_gl', mcc_gl)
assets.register('mcc_spectrum', mcc_spectrum)
assets.register('mcc_status', mcc_status)
def init(app):
assets = Environment(app)
# Basic CSS and Javascript:
# Available under: base_css, base_js
base_css = Bundle("css/base.css",
filters="cssmin",
output="gen/css/base.%(version)s.css")
base_js = js_bundle("scripts/base.js", "gen/scripts/base.%(version)s.js")
assets.register("base_css", base_css)
assets.register("base_js", base_js)
datetime_js = js_bundle("scripts/datetime.js",
"gen/scripts/datetime.%(version)s.js")
assets.register("datetime", datetime_js)
# CLR Overlay
# Availabe under: clr_overlay_js, clr_overlay_css
# jsmin is intentionally disabled for clr.overlay.js because the output is broken (same as below for
# playsounds)
clr_overlay_js = js_bundle("scripts/clr.overlay.js",
"gen/scripts/clr.overlay.%(version)s.js")
clr_overlay_css = Bundle("css/clr.overlay.css",
filters="cssmin",
output="gen/css/clr.overlay.%(version)s.css")
assets.register("clr_overlay_js", clr_overlay_js)
assets.register("clr_overlay_css", clr_overlay_css)
# Admin site
# Availabe under: admin_create_banphrase, admin_create_command,
# admin_create_row, admin_edit_command
admin_create_banphrase = js_bundle(
"scripts/admin/create_banphrase.js",
"gen/scripts/admin/create_banphrase.%(version)s.js")
admin_create_command = js_bundle(
"scripts/admin/create_command.js",
"gen/scripts/admin/create_command.%(version)s.js")
admin_create_row = js_bundle(
"scripts/admin/create_row.js",
"gen/scripts/admin/create_row.%(version)s.js")
admin_edit_command = js_bundle(
"scripts/admin/edit_command.js",
"gen/scripts/admin/edit_command.%(version)s.js")
assets.register("admin_create_banphrase", admin_create_banphrase)
assets.register("admin_create_command", admin_create_command)
assets.register("admin_create_row", admin_create_row)
assets.register("admin_edit_command", admin_edit_command)
notifications_subscribers = js_bundle(
"scripts/notifications/subscribers.js",
"gen/scripts/notifications/subscribers.%(version)s.js",
)
assets.register("notifications_subscribers", notifications_subscribers)
# Third party libraries
# Available under: autolinker
autolinker = js_bundle("scripts/autolinker.js",
"gen/scripts/autolinker.%(version)s.js")
assets.register("autolinker", autolinker)
# Commands
# Available under: commands_js
commands_js = js_bundle("scripts/commands.js",
"gen/scripts/commands.%(version)s.js")
assets.register("commands_js", commands_js)
# Pagination script
# Available under: paginate_js
paginate_js = js_bundle("scripts/paginate.js",
"gen/scripts/paginate.%(version)s.js")
assets.register("paginate_js", paginate_js)
# common controls for the playsound pages
playsound_common_js = js_bundle(
"scripts/playsound.common.js",
"gen/scripts/playsound.common.%(version)s.js")
assets.register("playsound_common_js", playsound_common_js)
playsound_admin_js = js_bundle(
"scripts/admin/playsound.admin.js",
output="gen/scripts/admin/playsound.admin.%(version)s.js")
assets.register("playsound_admin_js", playsound_admin_js)
playsound_admin_css = Bundle(
"css/admin/playsound.admin.css",
filters="cssmin",
output="gen/css/admin/playsound.admin.%(version)s.css")
assets.register("playsound_admin_css", playsound_admin_css)
assets.init_app(app)
WS1_CLIENT_SECRET = config['DEFAULT']['WS1_CLIENT_SECRET']
WS1_DISCOVERY_URL = config['DEFAULT']['WS1_DISCOVERY_URL']
REDIRECT_HTTPS = config['DEFAULT']['REDIRECT_HTTPS']
if REDIRECT_HTTPS.lower() == 'true':
REDIRECT_HTTPS = True
else:
REDIRECT_HTTPS = False
app = Flask(__name__)
app.secret_key = os.environ.get("SECRET_KEY") or os.urandom(24)
env = Environment(app)
js = Bundle('https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js',
'https://code.jquery.com/ui/1.12.1/jquery-ui.js', 'js/test.js')
env.register('js_all', js)
# User session management setup
# https://flask-login.readthedocs.io/en/latest
login_manager = LoginManager()
login_manager.init_app(app)
# Naive database setup
try:
init_db_command()
except sqlite3.OperationalError:
# Assume it's already been created
pass
# OAuth 2 client setup
client = WebApplicationClient(WS1_CLIENT_ID)
"libs/highcharts-release/highcharts.js",
"libs/moment/moment.js",
"js/plugins.js",
output="public/js/common.js")
weather_js = Bundle("js/weather-daily-chart.js",
output="public/js/weather_prod.js")
charts_daily_js = Bundle("js/daily_chart.js",
"js/daily_kessel_chart.js",
"js/daily_puffer_chart.js",
output="public/js/dialy_charts.js")
charts_weekly_js = Bundle("js/weekly_chart.js",
"js/weekly_ophours_chart.js",
"js/weekly_pellets_chart.js",
output="public/js/weekly_charts.js")
charts_monthly_js = Bundle("js/monthly_ophours_chart.js",
"js/monthly_pellets_chart.js",
output="public/js/monthly_charts.js")
assets = Environment()
assets.register("js_all", js)
assets.register("css_all", css)
assets.register("js_weather", weather_js)
assets.register("js_charts_daily", charts_daily_js)
assets.register("js_charts_weekly", charts_weekly_js)
assets.register("js_charts_monthly", charts_monthly_js)
css_learning_resource = Bundle(
'sass/pages/learning_resource.scss',
filters='scss',
output='stylesheets/generated/learning_resource.css',
depends='**/*.scss')
css_email_referrer = Bundle('sass/pages/email_referrer.scss',
filters='scss',
output='stylesheets/generated/email_referrer.css',
depends='**/*.scss')
css_browse = Bundle('sass/pages/browse.scss',
filters='scss',
output='stylesheets/generated/browse.css',
depends='**/*.scss')
env = Environment()
env.register('css_govuk_elements', css_govuk_elements)
env.register('css_main', css_main)
env.register('css_internal_interface', css_internal_interface)
env.register('css_rebrand', css_rebrand)
env.register('css_learning', css_learning)
env.register('css_csl_styleguide', css_csl_styleguide)
env.register('css_csl_elements', css_csl_elements)
env.register('css_learning_plan', css_learning_plan)
env.register('css_learning_record', css_learning_record)
env.register('css_digital_diagnostic', css_digital_diagnostic)
env.register('css_learning_resource', css_learning_resource)
env.register('css_email_referrer', css_email_referrer)
env.register('css_browse', css_browse)
from flask_assets import Environment, Bundle
assets = Environment()
css = Bundle("scss/style.scss",
filters='libsass, cssmin',
output='css/style.css',
depends='**/*.scss')
js = Bundle(
"js/src/flashcards.js",
"js/src/js-levenshtein.js",
filters="jsmin",
output='js/bundle.js',
)
practice = Bundle(
"js/src/practice.js",
filters="jsmin",
output='js/practice.js',
)
assets.register("css", css)
assets.register("js", js)
assets.register("practice", practice)
from flask_assets import Bundle, Environment
css_all = Bundle("css/bootstrap.min.css",
"css/main.css",
"css/bootstrap-responsive.min.css",
filters="cssmin",
output="css/all.css")
js_vendor = Bundle("js/vendor/jquery-1.8.3.min.js",
"js/vendor/bootstrap.min.js",
"js/vendor/socket.io.min.js",
output="js/vendor.js")
assets = Environment()
assets.register('css', css_all)
assets.register('js_vendor', js_vendor)
def create_app(package_name=__name__,
static_folder='front/static',
template_folder='front/templates',
**config_overrides):
static_url_path = '/assets'
app = Flask(package_name,
static_url_path=static_url_path,
static_folder=static_folder,
template_folder=template_folder)
app.config.from_object(Config)
# load stripe credentials
stripe.api_key = app.config['STRIPE_SECRET_KEY']
# load mailchimp credentials
mc.set_credentials(app.config['MAILCHIMP_USERNAME'],
app.config['MAILCHIMP_KEY'])
mc.set_unregistered_list_id(app.config['MAILCHIMP_UNREGISTERED_LIST_ID'])
mc.set_registered_list_id(app.config['MAILCHIMP_REGISTERED_LIST_ID'])
# Apply overrides
app.config.update(config_overrides)
# Initialize the database and declarative Base class
db.init_app(app)
Migrate(app, db)
app.db = db
# Setup security
app.user_db = SQLAlchemyUserDatastore(db, User, Role)
Security(app, app.user_db)
app.mail = Mail(app)
Babel(app)
Misaka(app, fenced_code=True, space_headers=True)
# TODO this needs work, but works as a stop-gap
if app.debug:
# Set up webassets so that they are precompiled for deployment
assets = Environment(app)
css = Bundle(
'css/style.sass',
#filters='sass,cssmin',
filters='sass',
depends=['css/*.sass', 'css/**/*.sass', 'css/**/**/*.sass'],
output='css/gen/style.css')
js = Bundle(
'js/*.js',
'js/modules/*.js',
#filters='jsmin',
depends=['js/*.js', 'js/**/*.js', 'js/**/**/*.js'],
output='js/gen/main.js')
assets.register('css_all', css)
assets.register('js_all', js)
app.config['JS_URLS'] = assets['js_all'].urls
app.config['CSS_URLS'] = assets['css_all'].urls
else:
hash = md5(
datetime.utcnow().isoformat().encode('utf8')).hexdigest()[:10]
app.config['JS_URLS'] = lambda: [
'{}/js/gen/main.js?{}'.format(static_url_path, hash)
]
app.config['CSS_URLS'] = lambda: [
'{}/css/gen/style.css?{}'.format(static_url_path, hash)
]
# Create the database tables.
# Flask-SQLAlchemy needs to know which
# app context to create the tables in.
with app.app_context():
db.configure_mappers()
db.create_all()
# Register blueprints
app.register_blueprint(bp)
app.register_blueprint(vendor.bp)
app.register_blueprint(customer.bp)
app.register_blueprint(checkout.bp)
app.register_blueprint(docs.bp)
if not app.debug and 'SENTRY_DSN' in app.config:
Sentry(app, dsn=app.config['SENTRY_DSN'])
return app
# -*- coding: utf-8 -*-
from flask_assets import Bundle, Environment
css = Bundle(
"libs/bootstrap/dist/css/paper/bootstrap.css",
"css/style.css",
"css/bootstrap-markdown.min.css",
filters="cssmin",
output="public/css/common.css"
)
js = Bundle(
"libs/jQuery/dist/jquery.js",
"libs/bootstrap/dist/js/bootstrap.js",
"js/bootstrap-markdown.js",
"js/plugins.js",
filters='jsmin',
output="public/js/common.js"
)
fonts = Bundle()
assets = Environment()
assets.register("js_all", js)
assets.register("css_all", css)
ASSETS.register({
# --------- common static bundles ------------
'init_js':
Bundle('js/init.js', filters="jsmin", output='gen/init.js'),
# --------- home page static bundles ------------
'index_js':
Bundle('js/home/home_page.js',
'js/ui/shapes.js',
filters="jsmin",
output='gen/index.js'),
'shapes_js':
Bundle('js/ui/shapes.js', filters="jsmin", output='gen/shapes.js'),
'index_css':
Bundle('less/common.less',
'less/navbar.less',
'less/events_page.less',
'less/home/common.less',
filters="less,cssmin",
output='gen/index.css'),
# --------- timer page static bundles ------------
'timer_timer_js':
Bundle('js/event_emitter.js',
'js/controller/user_settings_manager.js',
'js/util/extensions_and_polyfill.js',
'js/util/time_convert_format.js',
'js/ui/scramble_image_generator.js',
'js/ui/shapes.js',
'js/timer/timer_common.js',
'js/timer/timer_controller.js',
'js/timer/timer_display_manager.js',
'js/timer/timer_page.js',
'js/timer/timer_control_buttons.js',
filters="jsmin",
output='gen/timer_timer.js'),
'timer_manual_js':
Bundle('js/event_emitter.js',
'js/controller/user_settings_manager.js',
'js/util/extensions_and_polyfill.js',
'js/util/time_convert_format.js',
'js/ui/scramble_image_generator.js',
'js/ui/shapes.js',
'js/timer/timer_common.js',
'js/timer/timer_manual.js',
'js/timer/timer_control_buttons.js',
filters="jsmin",
output='gen/timer_manual.js'),
'timer_fmc_js':
Bundle('js/event_emitter.js',
'js/controller/user_settings_manager.js',
'js/util/extensions_and_polyfill.js',
'js/util/time_convert_format.js',
'js/ui/scramble_image_generator.js',
'js/ui/shapes.js',
'js/timer/timer_common.js',
'js/timer/timer_fmc.js',
'js/timer/timer_control_buttons.js',
filters="jsmin",
output='gen/timer_fmc.js'),
'timer_mbld_js':
Bundle('js/event_emitter.js',
'js/controller/user_settings_manager.js',
'js/util/extensions_and_polyfill.js',
'js/util/time_convert_format.js',
'js/ui/scramble_image_generator.js',
'js/ui/shapes.js',
'js/timer/timer_common.js',
'js/timer/timer_mbld.js',
'js/timer/timer_control_buttons.js',
filters="jsmin",
output='gen/timer_mbld.js'),
'timer_desktop_css':
Bundle('less/common.less',
'less/navbar.less',
'less/timer/common.less',
'less/timer/desktop.less',
filters="less,cssmin",
output='gen/timer_desktop.css'),
'timer_mobile_css':
Bundle('less/common.less',
'less/navbar.less',
'less/timer/common.less',
'less/timer/mobile.less',
filters="less,cssmin",
output='gen/timer_mobile.css'),
# --------- user settings page static bundles ------------
'user_settings_js':
Bundle('js/controller/user_settings_manager.js',
'js/ui/scramble_image_generator.js',
filters="jsmin",
output='gen/user_settings.js'),
'user_settings_css':
Bundle('less/common.less',
'less/navbar.less',
'less/timer/common.less',
'less/timer/desktop.less',
'less/timer/mobile.less',
'less/events_page.less',
'less/results.less',
'less/user.less',
'less/event_results.less',
'less/settings.less',
'less/home/common.less',
'css/bootstrap-social.min.css',
filters="less,cssmin",
output='gen/user_settings.css'),
# --------- the rest ------------
'app_css':
Bundle('less/common.less',
'less/navbar.less',
'less/timer/common.less',
'less/timer/desktop.less',
'less/timer/mobile.less',
'less/events_page.less',
'less/results.less',
'less/user.less',
'less/event_results.less',
'less/settings.less',
'css/bootstrap-social.min.css',
filters="less,cssmin",
output='gen/app.css'),
})
# add cross origin support
from flask_cors import CORS
CORS(app)
# bundle and register js scripts and css styles in flask
# IMPORTANT NOTE: postcss is not recognized in PyCharm's run environment
# use the command line to propagate changes to lab.scss
from flask_assets import Environment
from server.utils import bundle_modules, bundle_sheets
assets = Environment(app)
js_assets = [
'js_assets', 'scripts/jquery-3.1.1.min.js', 'scripts/sprintf.min.js',
'scripts/autosize.js', 'scripts/bootstrap.min.js'
]
js_assets = bundle_modules(js_assets, app)
assets.register(*js_assets)
css_assets = [
'css_assets', 'styles/bootstrap.css', 'styles/icomoon.css',
'styles/simple-line-icons.css'
]
css_assets = bundle_sheets(css_assets, app)
assets.register(*css_assets)
# define jinja content
from labpack.records.settings import load_settings
main_details = load_settings('copy/main.json')
menu_details = load_settings('copy/menu.json')
landing_kwargs = {'menu': menu_details}
landing_kwargs.update(**main_details)
# import request and response dependencies
from app import app
from flask import render_template
from cookitnow_web.blueprints.users.views import users_blueprint
from cookitnow_web.blueprints.recipe.views import recipe_blueprint
from flask_assets import Environment, Bundle
from .util.assets import bundles
from models.user import User
assets = Environment(app)
assets.register(bundles)
app.register_blueprint(users_blueprint, url_prefix="/users")
app.register_blueprint(recipe_blueprint, url_prefix="/recipe")
@app.errorhandler(500)
def internal_server_error(e):
return render_template('500.html'), 500
@app.route("/")
def home():
return render_template('home.html')
#!/usr/bin/env python3
import argparse
from flask import render_template
from flask_assets import Bundle, Environment
from staticpy import BASE_CONFIG, CONTEXTS, app, build_all, freezer
assets = Environment(app)
assets.register(
"scss",
Bundle(
"assets/main.scss",
filters="pyscss",
output="main.css",
depends="assets/_*.scss",
),
)
app.jinja_env.add_extension("jinja2.ext.do")
########################
# CUSTOM ROUTES
########################
@app.route("/")
def home():
"""Renders the home page."""
config = BASE_CONFIG["home"]
# Get post for Post showcase
post_context = CONTEXTS["posts"]
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
config[config_name].init_app(app)
# Set up extensions
db.init_app(app)
ma.init_app(app)
cache.init_app(app)
mail.init_app(app)
babel.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
# toolbar.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_sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .modules.contacts import contacts as modules_contacts_blueprint
app.register_blueprint(modules_contacts_blueprint, url_prefix='/account/contacts')
from .modules.search import search as modules_search_blueprint
app.register_blueprint(modules_search_blueprint, url_prefix='/')
from .modules.messages import messages as modules_messages_blueprint
app.register_blueprint(modules_messages_blueprint, url_prefix='/account/messages')
from .modules.tasks import tasks as modules_task_blueprint
app.register_blueprint(modules_task_blueprint, url_prefix='/account/tasks')
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 .modules.api import api as modules_api_blueprint
app.register_blueprint(modules_api_blueprint, url_prefix='/api/v1')
from .modules.statistics import statistics as modules_statistics_blueprint
app.register_blueprint(modules_statistics_blueprint)
from .modules.emails import emails as modules_emails_blueprint
app.register_blueprint(modules_emails_blueprint, url_prefix='/account/emails')
# External Modules
from .modules.offers import offers as modules_offers_blueprint
app.register_blueprint(modules_offers_blueprint, url_prefix='/')
@babel.localeselector
def get_locale():
if request.args.get('lang'):
session['lang'] = request.args.get('lang')
if current_user.is_authenticated:
session["lang"] = current_user.default_language
return session.get('lang', 'en')
@babel.timezoneselector
def get_timezone():
user = getattr(g, "user", None)
if user is not None:
return user.timezone
return app
css_assets = Bundle('components/angular-loading-bar/build/loading-bar.css',
'css/forge-viewer.css',
scss,
filters='cssmin', output='packed/packed.css'
)
js_assets = Bundle(
'components/jquery/dist/jquery.js',
'components/angular/angular.js',
'components/angular-ui-router/release/angular-ui-router.js',
'components/angular-animate/angular-animate.js',
'components/angular-resource/angular-resource.js',
'components/angular-loading-bar/build/loading-bar.js',
'components/materialize/dist/js/materialize.js',
# 'components/three.js/build/three.js',
'js/app.js',
'js/forge.services.js',
'js/user.services.js',
'js/main.controller.js',
'js/nav.controller.js',
'js/buckets.controller.js',
'js/viewer.controller.js',
# 'js/project-controller.js',
# 'js/routing.js',
filters='rjsmin', output='packed/packed.js')
assets = Environment(app)
assets.register('css_assets', css_assets)
assets.register('js_assets', js_assets)
from flask_assets import Environment, Bundle
assets = Environment(app)
assets.url_expire = False
assets.directory = '%s/public' % app.config.root_path
assets.load_path = ['assets']
assets.url = '/public'
assets.register('css',
Bundle(
'css/bootstrap-3.2.0.min.css',
'css/bootstrap-theme-3.2.0.min.css',
'css/font-awesome-4.3.0.min.css',
'css/datepicker3.css',
'css/bootstrap-datetimepicker.min.css',
'css/daterangepicker-bs3.css',
'css/select2-3.4.8.css',
'css/select2-bootstrap-3.4.8.css',
'css/dropzone-3.10.2.css',
Bundle(
'css/*.scss',
filters='pyscss',
output='css/app.%(version)s.css'),
output='css/all.%(version)s.css'))
assets.register('mine-css',
Bundle(
'css/bootstrap-3.2.0.min.css',
'css/bootstrap-theme-3.2.0.min.css',
'css/font-awesome-4.3.0.min.css',
'css/datepicker3.css',
'css/bootstrap-datetimepicker.min.css',
'css/jquery.Jcrop.min.css',
'css/style.css',
filters='cssmin',
output='gen/packed.css')
js = Bundle('js/jquery.min.js',
'js/popper.min.js',
'js/bootstrap.min.js',
'js/bootstrap.js',
'js/moment-with-locales.min.js',
'js/dropzone.min.js',
'js/jquery.Jcrop.min.js',
filters='jsmin',
output='gen/packed.js')
assets.register('js_all', js)
assets.register('css_all', css)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/foo')
def unoptimized():
return render_template('unoptimized.html')
@app.route('/bar')
def optimized():
#
# JS
#
vendor_files = glob.glob(location('assets/vendor/*.js'))
vendor_js = Bundle(vendor_files, filters='uglifyjs', output='js/vendor.js')
global_files = [
location('assets/js/common.js'),
location('assets/js/layout.js'),
location('assets/js/site.js'),
location('assets/js/sumo_voucher.js')
]
global_js = Bundle(global_files, filters='uglifyjs', output='js/global.js')
assets.register('vendor_js', vendor_js)
assets.register('global_js', global_js)
#
# CSS
#
dependent_files = glob.glob(location('assets/less/site/*.less'))
site_css = Bundle(location('assets/less/site/site.less'),
depends=dependent_files,
filters='less,cssmin',
output='css/site.css')
assets.register('site_css', site_css)
##################
# REGISTER HOOKS #
##################
app.register_blueprint(deploy.page_deploy)
app.register_blueprint(assets_query.page_assets_query)
app.register_blueprint(index.page_index)
app.register_blueprint(login.page_login)
app.register_blueprint(logout.page_logout)
app.register_blueprint(report.page_report)
app.register_blueprint(influxdb_m.page_influxdb_m)
app.register_blueprint(app_service.page_app_service)
app.register_blueprint(k8s.page_k8s)
app.register_blueprint(work_order.page_work_order)
app.register_blueprint(k8s_manage.page_k8s_manage)
app.register_blueprint(k8s_deploy.page_k8s_deploy)
app.register_blueprint(k8s_project_update.page_k8s_project_update)
produce.scheduler_tasks()
task_run.Run()
assets.register('js_file', module.js_files())
assets.register('css_file', module.css_files())
@app.route('/')
@limiter.exempt
def main():
return render_template('main.html')
@app.route('/webssh')
@limiter.exempt
@user_auth.login_required(grade=1)
def webssh():
tools.Async_log(g.user, request.url)
return render_template('webssh.html', url=app.config.get('WEBSSH_URL'))
from flask.ext.markdown import Markdown
from flask_security import Security, SQLAlchemyUserDatastore
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config.from_object('config')
# Assets
assets = Environment(app)
assets.url = '/static'
assets.directory = app.config['ASSETS_DEST']
less = Bundle('less/style.less', filters='less', output='gen/style.css')
assets.register('all-css', less)
# Database
db = SQLAlchemy(app)
from . import models
# Admin
from . import admin
# Markdown
Markdown(app, safe_mode='escape')
cache = Cache()
csrf = CsrfProtect()
migrate = Migrate()
manager = VersioningManager(options={'strategy': 'subquery'})
make_versioned(manager=manager, plugins=[FlaskPlugin()])
mail = Mail()
cdn = CDN()
login_manager = LoginManager()
assets = Environment()
toolbar = DebugToolbarExtension()
gocardless_client = None
pyscss = get_filter('pyscss', style='compressed')
assets.register('css_main', Bundle('css/main.scss',
output='gen/main-packed.css',
depends='css/*.scss',
filters=pyscss))
assets.register('css_admin', Bundle('css/admin.scss',
output='gen/admin-packed.css',
depends='css/*.scss',
filters=pyscss))
assets.register('css_invoice', Bundle('css/invoice.scss',
output='gen/invoice-packed.css',
depends='css/*.scss',
filters=pyscss))
assets.register('css_receipt', Bundle('css/receipt.scss',
output='gen/receipt-packed.css',
depends='css/*.scss',
filters=pyscss))
assets.register('css_schedule', Bundle('css/schedule.scss',
output='gen/schedule-packed.css',
from . import assets
# Run and configure Flask server
app = Flask(__name__)
env = os.environ.get('FLASK_ENV', 'development')
app.config.from_object('config.%sConfig' % env.capitalize())
# Database
db = SQLAlchemy(app)
from .models import User
# Set the Assets (css, js, etc.)
assets_env = Environment(app)
loader = PythonAssetsLoader(assets)
for name, bundle in loader.load_bundles().items():
assets_env.register(name, bundle)
# Load the routes
from . import routes
# Configure Flask-Security for authentication
login_manager = LoginManager()
login_manager.init_app(app)
@login_manager.user_loader
def load_user(user_id):
return User.query.get(user_id)
@login_manager.unauthorized_handler
sslify = SSLify(app)
# Setup sass auto-compiling
app.wsgi_app = SassMiddleware(
app.wsgi_app, {'databasic': ('static/sass', 'static/css', '/static/css')})
# Set up bundles
assets = Environment(app)
js_bundle = Bundle('js/lib/jquery.js',
'js/lib/jquery.validate.min.js',
'js/lib/additional-methods.min.js',
'js/lib/bootstrap.min.js',
'js/lib/Gettext.js',
filters='jsmin',
output='gen/packed.js')
assets.register('js_base', js_bundle)
js_tool = Bundle('js/lib/d3.min.js',
'js/lib/d3.layout.cloud.js',
'js/lib/d3.tip.js',
'js/lib/underscore.min.js',
'js/lib/jquery.flip.min.js',
'js/lib/highcharts.src.js',
filters='jsmin',
output='gen/packed_tool.js')
assets.register('js_tool', js_tool)
js_ctd = Bundle('js/lib/d3.min.js',
'js/lib/saveSvgAsPng.js',
'js/lib/underscore.min.js',
'js/lib/jquery.floatThead-slim.min.js',
'js/connectthedots.js',
filters='jsmin',
def create_app(configfile=None):
app = Flask(__name__)
app.secret_key = 's3cr3t'
AppConfig(app)
Bootstrap(app)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(
basedir, 'user-login.sqlite')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
REDIS_URL = 'http://localhost:6379'
urllib.parse.uses_netloc.append('redis')
url = urllib.parse.urlparse(REDIS_URL)
app.config['RQ_DEFAULT_HOST'] = url.hostname
app.config['RQ_DEFAULT_PORT'] = url.port
app.config['RQ_DEFAULT_PASSWORD'] = url.password
app.config['RQ_DEFAULT_DB'] = 0
app.config['MAIL_SERVER'] = 'smtp.sendgrid.net'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USE_SSL'] = True
app.config['MAIL_DEBUG'] = True
app.config['MAIL_USERNAME'] = ''
app.config['MAIL_PASSWORD'] = ''
# EAM : Set limit on the number of items in cache (RAM)
cache.init_app(app,
config={
'CACHE_TYPE': 'simple',
'CACHE_THRESHOLD': 1000
})
# 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)
with app.app_context():
from .frontend import frontend
app.register_blueprint(frontend)
from .content import content
app.register_blueprint(content)
app.json_encoder = MiniJSONEncoder
nav.init_app(app)
mail.init_app(app)
csrf.init_app(app)
db.init_app(app)
login_manager.init_app(app)
compress.init_app(app)
htmlmin.init_app(app)
RQ(app)
return app
# -*- coding: utf-8 -*-
import os
from datetime import timedelta
from flask import Flask, session, request, redirect, render_template, jsonify, send_file
from flask_assets import Environment, Bundle
from lib import tweet
app = Flask(__name__)
app.config['SECRET_KEY'] = os.environ['SECRET_KEY']
app.config['JSON_AS_ASCII'] = False
assets = Environment(app)
assets.url = app.static_url_path
scss = Bundle('scss/style.scss', filters='pyscss', output='css/style.css')
assets.register('style_scss', scss)
logout_page = '/logout'
login_page = '/top'
class TweetError(Exception):
pass
class TokenError(Exception):
pass
@app.before_request
def before_request():
from flask_assets import Environment, Bundle
assets = Environment()
# CSS Assets
assets.register(
"common_css",
Bundle("./css/style.css", output="./css/common.%(version)s.css"))
# Javascript Assets
assets.register(
"profile_js",
Bundle("./js/profile.js", output="./js/profile.%(version)s.min.js"))
import redis
import short_url
app = Flask(__name__)
assets = Environment(app)
javascript = Bundle(
'../bower_components/bower-webfontloader/webfont.js',
'../bower_components/snap.svg/dist/snap.svg-min.js',
'../bower_components/underscore/underscore-min.js',
'../bower_components/js-sequence-diagrams/dist/sequence-diagram-min.js',
filters='jsmin',
output='gen/packed.js'
)
assets.register('javascript', javascript)
css = Bundle(
'../bower_components/js-sequence-diagrams/dist/sequence-diagram-min.css',
filters='cssmin',
output='screen.css'
)
assets.register('css', css)
app.redis_client = redis.StrictRedis.from_url(
os.getenv('REDIS_URL'),
errors='strict'
)
@app.route('/', methods=['POST'])
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_assets import Environment, Bundle
from flask_session import Session
import spotifytools.settings as settings
app = Flask(__name__)
app.config.from_object(settings)
assets = Environment(app)
assets.url = app.static_url_path
scss = Bundle('css/main.scss', filters='pyscss', output='css/main.css')
assets.register('scss_all', scss)
Session(app)
from spotifytools import routes
extra={'rel': 'stylesheet/css'}
)
sass_bundle = Bundle(
'sass/*.scss',
'sass/lbd/*.scss',
output='dist/sass/style.min.scss'
)
js_bundle = Bundle('js/core/jquery.3.2.1.min.js',
'js/core/popper.min.js',
'js/core/bootstrap.min.js',
'js/plugins/*.js',
'js/light-bootstrap-dashboard.js',
output='dist/js/main.min.js',
extra={'rel': 'text/javascript'})
assets.register('main_js', js_bundle)
assets.register('main_scss', sass_bundle)
assets.register('main_styles', style_bundle)
style_bundle.build()
sass_bundle.build()
js_bundle.build()
bcrypt = Bcrypt(app)
CORS(app)
# def login_required(f):
# @wraps(f)
# def decorated_funtion(*args, **kwargs):
