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(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):
webassets = Environment(app)
webassets.register('css_all', css_all)
webassets.register('js_vendor', js_vendor)
webassets.register('js_main', js_main)
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 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):
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):
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
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)
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 register_assets(app):
assets = Environment(app)
assets.debug = app.debug
assets.auto_build = True
assets.url = app.static_url_path
css_blog = Bundle(*BLOG_ASSETS, filters='cssmin', output='css/blog.min.css')
css_welcome = Bundle(*INDEX_ASSETS, filters='cssmin', output='css/welcome.min.css')
js_all = Bundle(*JS_ASSETS, filters='rjsmin', output='js/all.min.js')
assets.register('css_blog', css_blog)
assets.register('css_welcome', css_welcome)
assets.register('js_all', js_all)
app.logger.info("Registered assets...")
return assets
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 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)
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():
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 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 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 __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 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)
class TestUrlAndDirectoryWithInitApp(object):
"""[Regression] Make sure the automatic "directory" and "url"
values also work if the application is initialized via "init_app()".
"""
def setup(self):
self.app = Flask(__name__, static_path='/initapp_static')
self.env = Environment()
self.env.init_app(self.app)
def test(self):
"""Make sure the "url" and "directory" config values are
read from the Flask app.
"""
with self.app.test_request_context():
assert not 'url' in self.env.config
assert Bundle('foo', env=self.env).urls() == ['/initapp_static/foo']
assert not 'directory' in self.env.config
root = self.app.root_path
assert get_all_bundle_files(Bundle('foo'), self.env) == [root + '/static/foo']
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 install(cls, app):
"""Install the extension into the application."""
Environment.resolver_class = InvenioResolver
env = Environment(app)
env.url = "{0}/{1}/".format(app.static_url_path,
app.config["ASSETS_BUNDLES_DIR"])
env.directory = os.path.join(app.static_folder,
app.config["ASSETS_BUNDLES_DIR"])
env.append_path(app.static_folder)
env.auto_build = app.config.get("ASSETS_AUTO_BUILD", True)
# The filters less and requirejs don't have the same behaviour by
# default. Make sure we are respecting that.
app.config.setdefault("LESS_RUN_IN_DEBUG", True)
app.config.setdefault("REQUIREJS_RUN_IN_DEBUG", False)
# Fixing some paths as we forced the output directory with the
# .directory
app.config.setdefault("REQUIREJS_BASEURL", app.static_folder)
requirejs_config = os.path.join(env.directory,
app.config["REQUIREJS_CONFIG"])
if not os.path.exists(requirejs_config):
app.config["REQUIREJS_CONFIG"] = os.path.relpath(
os.path.join(app.static_folder,
app.config["REQUIREJS_CONFIG"]),
env.directory)
app.jinja_env.add_extension(BundleExtension)
app.context_processor(BundleExtension.inject)
def 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 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')
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 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.')
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(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 create_app(version_path,
secret_key,
session_cookie_name,
session_cookie_domain,
session_cookie_secure,
use_https,
enable_asset_pipeline,
lando_api_url,
debug=False):
"""
Create an app instance.
"""
csp = {
'default-src': "'self'",
'font-src': "'self' https://code.cdn.mozilla.net",
'style-src': "'self' https://code.cdn.mozilla.net",
'img-src': "'self' *.cloudfront.net *.gravatar.com "
"*.googleusercontent.com",
'object-src': "'none'",
'frame-ancestors': "'none'",
'manifest-src': "'none'",
'worker-src': "'none'",
'media-src': "'none'",
'frame-src': "'none'",
'base-uri': "'none'",
'report-uri': "/__cspreport__"
} # yapf: disable
initialize_logging()
app = Flask(__name__)
app.debug = debug
# Set configuration
app.config['VERSION_PATH'] = version_path
log_config_change('VERSION_PATH', version_path)
version_info = json.load(open(version_path))
logger.info('application version', extra=version_info)
this_app_version = version_info['version']
initialize_sentry(app, this_app_version)
app.config['LANDO_API_URL'] = lando_api_url
log_config_change('LANDO_API_URL', lando_api_url)
app.config['BUGZILLA_URL'] = _lookup_service_url(lando_api_url, 'bugzilla')
log_config_change('BUGZILLA_URL', app.config['BUGZILLA_URL'])
app.config['PHABRICATOR_URL'] = (_lookup_service_url(
lando_api_url, 'phabricator'))
log_config_change('PHABRICATOR_URL', app.config['PHABRICATOR_URL'])
# Set remaining configuration
app.config['SECRET_KEY'] = secret_key
app.config['SESSION_COOKIE_NAME'] = session_cookie_name
log_config_change('SESSION_COOKIE_NAME', session_cookie_name)
app.config['SESSION_COOKIE_DOMAIN'] = session_cookie_domain
log_config_change('SESSION_COOKIE_DOMAIN', session_cookie_domain)
app.config['SESSION_COOKIE_SECURE'] = session_cookie_secure
log_config_change('SESSION_COOKIE_SECURE', session_cookie_secure)
app.config['SERVER_NAME'] = session_cookie_domain
log_config_change('SERVER_NAME', session_cookie_domain)
app.config['USE_HTTPS'] = use_https
log_config_change('USE_HTTPS', use_https)
app.config['PREFERRED_URL_SCHEME'] = 'https' if use_https else 'http'
Talisman(app, content_security_policy=csp, force_https=use_https)
# Authentication
global oidc
authentication = auth.OpenIDConnect(auth.OIDCConfig())
oidc = authentication.auth(app)
# Register routes via Flask Blueprints
from landoui.pages import pages
from landoui.revisions import revisions
from landoui.dockerflow import dockerflow
app.register_blueprint(pages)
app.register_blueprint(revisions)
app.register_blueprint(dockerflow)
# Register template helpers
from landoui.template_helpers import template_helpers
app.register_blueprint(template_helpers)
# Register error pages
errorhandlers.register_error_handlers(app)
# Setup Flask Assets
assets = Environment(app)
if enable_asset_pipeline:
loader = YAMLLoader(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
'assets_src/assets.yml'))
assets.register(loader.load_bundles())
return app
return gavel
app = start_app()
app.config['DEBUG'] = os.environ.get('DEBUG', False)
import gavel.settings as settings
app.config['SQLALCHEMY_DATABASE_URI'] = settings.DB_URI
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SECRET_KEY'] = settings.SECRET_KEY
from flask_assets import Environment, Bundle
assets = Environment(app)
assets.config['pyscss_style'] = 'expanded'
assets.url = app.static_url_path
bundles = {
'scss_all':
Bundle('css/style.scss',
depends='**/*.scss',
filters=(
'pyscss',
'cssmin',
),
output='all.css'),
'admin_js':
Bundle('js/admin/jquery.tablesorter.min.js',
'js/admin/jquery.tablesorter.widgets.js',
from flask_mail import Mail
from kombu import Exchange, Queue
from celery import Celery
from py2neo import Graph
from elasticsearch import Elasticsearch
from aleph import default_settings, archive
from aleph.ext import get_init
log = logging.getLogger(__name__)
db = SQLAlchemy()
migrate = Migrate()
mail = Mail()
celery = Celery('aleph')
assets = Environment()
oauth = OAuth()
oauth_provider = oauth.remote_app('provider', app_key='OAUTH')
def create_app(config={}):
app = Flask('aleph')
app.config.from_object(default_settings)
if config.get('TESTING'):
app.config.from_envvar('ALEPH_TEST_SETTINGS', silent=True)
else:
app.config.from_envvar('ALEPH_SETTINGS', silent=True)
app.config.update(config)
app_name = app.config.get('APP_NAME')
if not app.debug and app.config.get('MAIL_ADMINS'):
from module import tools, user_auth, produce
from flask_debugtoolbar import DebugToolbarExtension
import conf
class MyFlask(Flask):
jinja_environment = conf.FlaskEchartsEnvironment
app = MyFlask(__name__)
DB = SQLAlchemy(app)
mail = Mail(app)
limiter = conf.WebLimiter()
limiter = limiter.limiter
moment = Moment(app)
assets = Environment(app)
app.config.from_pyfile('conf/main.conf')
app.config.from_pyfile('conf/sql.conf')
app.config.from_pyfile('conf/redis.conf')
app.config.get('TRAP_HTTP_EXCEPTIONS')
app.secret_key = app.config.get('SECRET_KEY')
app.debug = False
task_run = produce.SchedulerBackgroud()
toolbar = DebugToolbarExtension(app)
ssl._create_default_https_context = ssl._create_unverified_context
app.register_blueprint(Assets.page_Assets)
app.register_blueprint(assets_manage.page_assets_manage)
app.register_blueprint(publish.page_publish)
app.register_blueprint(resource_pool.page_resource_pool)
app.register_blueprint(chart_center.page_chart_center)
app.register_blueprint(examine.page_examine)
app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY') or 'DEBUGSECRETKEY'
app.config['APP_URL'] = os.environ.get('APP_URL')
app.config['MAILGUN_DOMAIN'] = os.environ.get('MAILGUN_DOMAIN')
app.config['MAILGUN_KEY'] = os.environ.get('MAILGUN_KEY')
app.config['FLASKS3_CDN_DOMAIN'] = os.environ.get('FLASKS3_CDN_DOMAIN')
app.config['FLASKS3_BUCKET_NAME'] = os.environ.get('FLASKS3_BUCKET_NAME')
app.config['FLASKS3_HEADERS'] = {'Cache-Control': 'max-age=31536000'}
app.config['FLASKS3_GZIP'] = True
app.config['FLASK_ASSETS_USE_S3'] = True
if os.environ.get('FLASK_DEBUG'):
app.config['ASSETS_DEBUG'] = True
app.config['FLASK_ASSETS_USE_S3'] = False
s3 = FlaskS3(app)
assets = Environment(app)
assets.register(
'css_all',
Bundle('main.css', output='main.%(version)s.css'),
)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'
@login_manager.user_loader
def load_user(user_id):
try:
user = User.get(User.id == user_id)
except User.DoesNotExist:
def create_app(config):
app = Flask(__name__)
config_name = config
if not isinstance(config, str):
config_name = os.getenv('FLASK_CONFIG', 'default')
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_sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
return app
model2 = load_model('model/test3.h5')
loss = {'ctc': lambda y_true, y_pred: y_pred}
optimizer = SGD(lr=0.02, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5)
model2.compile(loss=loss, optimizer=optimizer)
app = Flask(__name__)
UPLOAD_FOLDER = './UPLOADED_AUDIO'
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['TEMPLATES_AUTO_RELOAD'] = True
js = Bundle('microphoneController.js',
'jquery-3.5.1.min.js',
'recorder.js',
output='gen/main.js')
assets = Environment(app)
assets.register('main_js', js)
@app.route('/')
def index():
return render_template('index.html')
# https://blog.addpipe.com/using-recorder-js-to-capture-wav-audio-in-your-html5-web-site/
@app.route('/upload', methods=['GET', 'POST'])
def upload():
if request.method == "POST":
file = request.files['file']
filename = secure_filename(file.filename)
login_manager.init_app(application)
js = Bundle('js/helper.js',
'js/add-products.js',
'js/lettering.js',
'js/front-page.js',
'js/search.js',
'js/ajax.js',
'js/setup.js',
output='gen/main.js')
css = Bundle('css/style.css',
'css/lettering.css',
'css/vendor/pagination.css',
output='gen/style.css')
assets = Environment(application)
assets.debug = CONFIG.ASSET_DEBUG
assets.register('main_js', js)
assets.register('main_css', css)
class User(UserMixin):
pass
@login_manager.user_loader
def user_loader(username):
if username not in CONFIG.USERS:
return
# -*- coding: utf-8 -*-
"""Application assets."""
from flask_assets import Bundle, Environment
css = Bundle('libs/bootswatch-dist/css/bootstrap.css',
'css/style.css',
filters='cssmin',
output='public/css/common.css')
js = Bundle('libs/jQuery/dist/jquery.js',
'libs/bootswatch-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)
except Exception:
raise ImportError(f"Please make sure that the extension `{ext.code}` follows conventions.")
# filters
# -------
app.jinja_env.globals["DEBUG"] = app.config["DEBUG"]
app.jinja_env.globals["EXTENSIONS"] = valid_extensions
app.jinja_env.globals["SITE_TITLE"] = getenv("LNBITS_SITE_TITLE", "LNbits")
# assets
# ------
assets = Environment(app)
assets.url = app.static_url_path
assets.register("base_css", Bundle("scss/base.scss", filters="pyscss", output="css/base.css"))
# commands
# --------
@app.cli.command("migrate")
def migrate_databases():
"""Creates the necessary databases if they don't exist already; or migrates them."""
core_migrations.migrate()
for ext in valid_extensions:
try:
ext_migrations = importlib.import_module(f"lnbits.extensions.{ext.code}.migrations")
def setupAssets(app):
createStorage()
assets = Environment(app)
assets.init_app(app)
assets.register("js_all", bundleJavascripts())
assets.register("css_all", bundleStylesheets())
import os
import sqlite3
import sys
#create application
app = Flask(__name__)
app.config['SECRET_KEY']= 'GRADSCHOOLNOLIFE'
app.config.from_object(__name__)
app.config['SQLALCHEMY_DATABASE_URI']='sqlite:////Users/zengyh/myproject/21days/buddyprogram.db'
#app.config['SQLALCHEMY_DATABASE_URI']='sqlite:////Users/Yu/Desktop/buddy/buddyprogram.db'
#app.config['SQLALCHEMY_DATABASE_URI']='sqlite:////Users/bichengxu/Desktop/si699_03_developing_social_computing/21days/buddyprogram.db'
cs = Bundle('devices.min.css','bootstrap.min.css', output='gen/main.css')
assets = Environment(app)
assets.register('main_css',cs)
db = SQLAlchemy(app)
login_manager = LoginManager() #handle user session
login_manager.init_app(app)
login_manager.login_view = 'login'
# config for updating intermediate table participate
###########################
app.config.update(dict(
DATABASE=os.path.join(app.root_path, 'buddyprogram.db'),
))
app.config.from_envvar('BUDDY_SETTINGS', silent=True)
def connect_db():
rv = sqlite3.connect(app.config['DATABASE'])
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()
self.webpack = FlaskWebpackExt()
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)
self.webpack.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))
app.config.setdefault(
'WEBPACKEXT_PROJECT', 'invenio_assets.webpack:project')
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())
from flask import Flask, render_template, redirect, request, url_for, jsonify, session
from flask_assets import Bundle, Environment
import os
import sys
import subprocess
import json
app = Flask(__name__)
app.secret_key = "super secret key"
env = Environment(app)
js = Bundle('js/clarity-icons.min.js', 'js/clarity-icons-api.js',
'js/clarity-icons-element.js', 'js/custom-elements.min.js')
env.register('js_all', js)
css = Bundle('css/override.css','css/clarity-ui-dark.min.css', 'css/clarity-icons.min.css')
env.register('css_all', css)
@app.route('/')
def homepage():
return render_template('index.html')
@app.route('/health')
def health():
return jsonify(test="success")
if __name__ == '__main__':
app.run(debug=True)
import os
import chess
from flask import Flask, render_template, request, jsonify, send_from_directory, redirect
from flask_socketio import SocketIO
from flask_assets import Environment, Bundle
from database import *
app = Flask(__name__)
socketio = SocketIO(app)
assets = Environment()
assets.init_app(app)
def get_str(board):
return str(board).replace(' ', '').replace('\n', '')
@app.route('/')
def hello():
return redirect("/games", code=302)
@app.route('/favicon.ico')
def favicon():
return send_from_directory(os.path.join(app.root_path, 'static/gen/img'),
'favicon.ico',
mimetype='image/vnd.microsoft.icon')
@app.route('/new_game')
def new_game():
from app import app
from flask import render_template, redirect, url_for
from instagram_web.blueprints.users.views import users_blueprint
from instagram_web.blueprints.sessions.views import sessions_blueprint
from instagram_web.blueprints.imgs.views import imgs_blueprint
from instagram_web.blueprints.donations.views import donations_blueprint
from instagram_web.blueprints.follows.views import follows_blueprint
from flask_assets import Environment, Bundle
from .util.assets import bundles
from flask_login import LoginManager, current_user, login_required
from models.user import User
from instagram_web.util.google_oauth import oauth
assets = Environment(app)
assets.register(bundles)
app.register_blueprint(users_blueprint, url_prefix="/users")
app.register_blueprint(sessions_blueprint, url_prefix="/sessions")
app.register_blueprint(imgs_blueprint, url_prefix="/imgs")
app.register_blueprint(donations_blueprint, url_prefix="/donations")
app.register_blueprint(follows_blueprint, url_prefix="/follows")
login_manager = LoginManager()
login_manager.init_app(app)
oauth.init_app(app)
# login_manager.login_view = "sessions."
@login_manager.user_loader
def load_user(user_id):
return User.get_by_id(user_id)
from celery import Celery
from flask import Flask
from flask_assets import Environment as FlaskAssets, Bundle
from flask_migrate import Migrate
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config.from_object('config.Config')
app.secret_key = app.config['SECRET_KEY']
celery = Celery(app.name, broker=app.config['CELERY_BROKER_URL'])
celery.conf.update(app.config)
assets = FlaskAssets(app)
assets.register('js_base', Bundle(
join('js', 'jquery-1.12.4.js'),
join('js', 'bootstrap-3.3.7.js'),
filters='jsmin',
output=join('gen', 'js.%(version)s.min.js'))
)
assets.register('js_activity', Bundle(
join('js', 'activity.js'),
filters='jsmin',
output=join('gen', 'activity.%(version)s.min.js'))
)
assets.register('css_base', Bundle(
join('css', 'bootstrap.css'),
join('css', 'font-awesome.css'),
join('css', 'app.css'),
import os
from flask import Flask, send_from_directory
from flask import request, jsonify, render_template
from flask_socketio import SocketIO
from flask_assets import Environment
from flask_autoindex import AutoIndex
from fgclassifier.visualizer import actions
from fgclassifier.visualizer.options import dataset_choices, fm_choices
from fgclassifier.visualizer.options import clf_choices
from fgclassifier.utils import get_stats
app = Flask(__name__)
assets = Environment(app)
app.config['SECRECT_KEY'] = os.getenv('FLASK_SECRECT_KEY', 'keyboardcat!')
app.config['ASSETS_DEBUG'] = os.getenv('FLASK_ENV') == 'development'
socketio = SocketIO(app)
@app.route('/')
def index():
"""The Index Page"""
inputs = actions.parse_inputs(**dict(request.args.items()))
tmpl_data = {
'dataset_choices': dataset_choices,
'fm_choices': fm_choices,
'clf_choices': clf_choices,
**inputs,
**actions.predict_one(**inputs)
def __call__(cls, flask_or_import_name, project=None, directory=None,
config=None, exceptions=None, compress_html=True,
skip_views=False):
"""
Allow to register all subclasses of Juice at once
If a class doesn't have a route base, it will create a dasherize version
of the class name.
So we call it once initiating
:param flask_or_import_name: Flask instance or import name -> __name__
:param project: name of the project. If the directory and config is empty, it will guess them from here
:param directory: The directory containing your project's Views, Templates and Static
:param config: string of config object. ie: "app.config.Dev"
:param exceptions: The exceptions path to load
:param compress_html: bool - If true it will use the plugin "htmlcompress"
to remove white spaces off the html result
:param skip_views: bool - If true, it will setup everything but registering the views
"""
if isinstance(flask_or_import_name, Flask):
app = flask_or_import_name
else:
app = Flask(flask_or_import_name)
app.wsgi_app = ProxyFix(app.wsgi_app)
app.url_map.converters['regex'] = RegexConverter
if not directory:
directory = "application/%s" % project if project else "."
if not config:
config = "application.config.%s" % get_env()
app.config.from_object(config)
# Extensions to remove extra white spaces in html
if compress_html:
app.jinja_env.add_extension('juice.extras.htmlcompress.HTMLCompress')
if directory:
app.template_folder = directory + "/templates"
app.static_folder = directory + "/static"
if exceptions:
abort.map_from_module(exceptions)
cls._app = app
cls._setup_logger()
cls._add_asset_bundle(app.static_folder)
# Flask Assets
cls.assets = Environment(cls._app)
# Register templates
if cls._template_paths:
loader = [cls._app.jinja_loader] + list(cls._template_paths)
cls._app.jinja_loader = jinja2.ChoiceLoader(loader)
# Register static
if cls._static_paths:
loader = [cls._app.static_folder] + list(cls._static_paths)
cls.assets.load_path = loader
# init_app
[_app(cls._app) for _app in cls._init_apps]
# Register all views
if not skip_views:
for subcls in cls.__subclasses__():
base_route = subcls.base_route
if not base_route:
base_route = utils.dasherize(utils.underscore(subcls.__name__))
if subcls.__name__.lower() == "index":
base_route = "/"
subcls.register(cls._app, base_route=base_route)
# Load all bundles
[cls.assets.from_yaml(a) for a in cls._asset_bundles]
@cls._app.after_request
def _after_request_cleanup(response):
cls._global["__META__"] = cls._default_page_meta
return response
return cls._app
#-*- coding=utf8 -*-
'''
write by xii
'''
from flask import Flask
from flask_assets import Environment, Bundle
from config import Config
app = Flask(__name__, template_folder='./template')
app.config['SECRET_KEY'] = Config.SECRET_KEY
assets = Environment(app)
assets.url = app.static_url_path
scss = Bundle('css/base.scss',
'css/login.scss',
'css/index.scss',
filters='pyscss',
output='scss/all.css')
assets.register('scss_all', scss)
from event import socketio
from routes import main
app.register_blueprint(main)
socketio.init_app(app)
if __name__ == "__main__":
app.debug = True
socketio.run(app)
application = Flask(__name__)
application.config.from_envvar('APP_CONFIG')
application.json_encoder = AlchemyEncoder
application.cache = RedisCache(application.config['REDIS_HOST'],
application.config['REDIS_PORT'], \
default_timeout=application.config['CACHE_TIMEOUT'])
application.cache_lock = Lock(application.cache._client,
'mgtrk_worker_lock',
timeout=0.2,
blocking_timeout=0.2)
# set up authentication
bcrypt = Bcrypt(application)
# bundle js and css code
assets = Environment(application)
js = Bundle('js/core/*', filters='rjsmin', output='js/core/mgtrk-core.min.js')
assets.register('core-js', js)
css = Bundle('css/core/*',
filters='cssmin',
output='css/core/mgtrk-core.min.css')
assets.register('core-css', css)
# switch off bundling if app is in debug mode
assets.debug = application.config['FLASK_DEBUG']
# set up database
db = SQLAlchemy()
db.init_app(application)
from flask_cache import Cache
from flask_debugtoolbar import DebugToolbarExtension
from flask_login import LoginManager
from flask_assets import Environment
from gordon_cole_gen.models import User
# Setup flask cache
cache = Cache()
# init flask assets
assets_env = Environment()
debug_toolbar = DebugToolbarExtension()
login_manager = LoginManager()
login_manager.login_view = "main.login"
login_manager.login_message_category = "warning"
@login_manager.user_loader
def load_user(userid):
return User.query.get(userid)
from flask_assets import Environment, Bundle
from flask import current_app as app
assets = Environment(app)
Environment.auto_build = True
Environment.debug = False
less_bundle = Bundle('less/*.less',
filters='less,cssmin',
output='dist/css/styles.css',
extra={'rel': 'stylesheet/less'})
js_bundle = Bundle('js/*.js', filters='jsmin', output='dist/js/main.js')
assets.register('less_all', less_bundle)
assets.register('js_all', js_bundle)
if app.config['FLASK_ENV'] == 'development':
less_bundle.build(force=True)
js_bundle.build()
import sys
import os
from flask_assets import Environment, Bundle
from sass import compile as sass_compile
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)) + '/../../')
from amable import app
# Helper so we don't have to write out the assets path over and over
def assets_path(*paths):
return os.path.join(os.path.dirname(__file__), '..', 'static', *paths)
# Create a new assets environment attached to our app
assets_env = Environment(app)
# Tell assets where our assets are located
assets_env.load_path = [assets_path('css'), assets_path('jsc')]
# Register the CSS assets
assets_env.register(
'css', Bundle('application.css', filters=[], output='application.css'))
# Resgister the JS assets
assets_env.register(
'jsc', Bundle('application.js', filters=[], output='application.js'))
app.secret_key = serverParameters["_secretKey"]
else:
# Set a temporary secret key. It can be set from the database later
# The production key is set in ``overwatch.webApp.run``
app.secret_key = str(os.urandom(50))
# Enable debugging if set in configuration
if serverParameters["debug"] is True:
app.debug = True
# Setup Bcrypt
app.config["BCRYPT_LOG_ROUNDS"] = config.bcryptLogRounds
bcrypt = Bcrypt(app)
# Setup flask assets
assets = Environment(app)
# Set the Flask Assets debug mode
# Note that the bundling is _only_ performed when flask assets is _not_ in debug mode.
# Thus, we want it to follow the global debug setting unless we explicit set it otherwise.
# For more information, particularly on debugging, see the web app `README.md`. Further details
# are included in the web app utilities module where the filter is defined.
app.config["ASSETS_DEBUG"] = serverParameters[
"flaskAssetsDebug"] if not serverParameters[
"flaskAssetsDebug"] is None else serverParameters["debug"]
# Load bundles from configuration file
assets.from_yaml(
pkg_resources.resource_filename("overwatch.webApp", "flaskAssets.yaml"))
# Setup CSRF protection via flask-wtf
csrf = CSRFProtect(app)
from arxivdigest.frontend.views import topics
from arxivdigest.frontend.views.articles import topic_flag
app = Flask(__name__)
app.secret_key = secret_key
app.register_blueprint(general.mod)
app.register_blueprint(articles.mod)
app.register_blueprint(evaluation.mod)
app.register_blueprint(admin.mod, url_prefix='/admin')
app.config['max_content_length'] = config_frontend.get('max_content_length')
if topic_flag:
app.register_blueprint(topics.mod)
csrf = CSRFProtect(app)
assets = Environment(app)
if config_frontend.get('data_path', None):
data_path = config_frontend['data_path']
cache_path = os.path.join(data_path, 'cache', '.webassets-cache')
static_path = os.path.abspath(os.path.join(data_path, 'static'))
pathlib.Path(cache_path).mkdir(parents=True, exist_ok=True)
assets.cache = os.path.abspath(cache_path)
assets.directory = os.path.abspath(static_path)
app.static_folder = static_path
if os.path.exists(static_path):
shutil.rmtree(static_path)
shutil.copytree(os.path.join(app.root_path, 'static'), static_path)
"utm_medium": "email",
"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_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.7.0/css/font-awesome.min.css',
'chosen/chosen.min.css',
'resources/css/review.css',
Bundle('resources/css/style.scss',
'resources/css/bill-progress.scss',
'resources/css/bootstrap-sortable.css',
filters="jsmin",
)
js_footer = Bundle("js/main.js",
"js/map.js",
output="assets/footer.js",
filters="jsmin")
css = Bundle(
"node_modules/bulma/css/bulma.css",
"node_modules/leaflet/dist/leaflet.css",
"node_modules/leaflet.control.layers.tree/L.Control.Layers.Tree.css",
"css/style.css",
output="assets/main.css",
filters="cssmin",
)
assets = Environment(app)
client = MongoClient(settings.uri)
assets.register("head_js", js_head)
assets.register("head_def_js", js_head_defer)
assets.register("footer_js", js_footer)
assets.register("main_css", css)
@app.route("/")
def index():
return render_template("index.html")
@app.route("/table")
def table():
def init(app):
assets = Environment(app)
# Basic CSS and Javascript:
# Available under: base_css, base_js
base_css = Bundle(
"css/base.scss", filters="pyscss,cssmin", output="gen/css/base.%(version)s.css"
)
base_js = Bundle(
"scripts/base.js", filters="jsmin", output="gen/scripts/base.%(version)s.js"
)
assets.register("base_css", base_css)
assets.register("base_js", base_js)
datetime_js = Bundle(
"scripts/datetime.js",
filters="jsmin",
output="gen/scripts/datetime.%(version)s.js",
)
assets.register("datetime", datetime_js)
# Admin site
# Availabe under: admin_create_banphrase, admin_create_command,
# admin_create_row, admin_edit_command
admin_create_banphrase = Bundle(
"scripts/admin/create_banphrase.js",
filters="jsmin",
output="gen/scripts/admin/create_banphrase.%(version)s.js",
)
admin_create_command = Bundle(
"scripts/admin/create_command.js",
filters="jsmin",
output="gen/scripts/admin/create_command.%(version)s.js",
)
admin_create_row = Bundle(
"scripts/admin/create_row.js",
filters="jsmin",
output="gen/scripts/admin/create_row.%(version)s.js",
)
admin_edit_command = Bundle(
"scripts/admin/edit_command.js",
filters="jsmin",
output="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 = Bundle(
"scripts/notifications/subscribers.js",
filters="jsmin",
output="gen/scripts/notifications/subscribers.%(version)s.js",
)
assets.register("notifications_subscribers", notifications_subscribers)
# Third party libraries
# Available under: autolinker
autolinker = Bundle(
"scripts/autolinker.js",
filters="jsmin",
output="gen/scripts/autolinker.%(version)s.js",
)
assets.register("autolinker", autolinker)
# Commands
# Available under: commands_js
commands_js = Bundle(
"scripts/commands.js",
filters="jsmin",
output="gen/scripts/commands.%(version)s.js",
)
assets.register("commands_js", commands_js)
# Pagination script
# Available under: paginate_js
paginate_js = Bundle(
"scripts/paginate.js",
filters="jsmin",
output="gen/scripts/paginate.%(version)s.js",
)
assets.register("paginate_js", paginate_js)
# range slider for semantic UI
range_slider_js = Bundle(
"scripts/range.js", filters="jsmin", output="gen/scripts/range.%(version)s.js"
)
assets.register("range_slider_js", range_slider_js)
range_slider_css = Bundle(
"css/range.css", filters="cssmin", output="gen/css/range.%(version)s.css"
)
assets.register("range_slider_css", range_slider_css)
assets.init_app(app)
def create_app(config):
app = Flask(__name__)
config_name = config
if not isinstance(config, str):
config_name = os.getenv('FLASK_CONFIG', 'default')
app.config.from_object(Config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# Connected to Azure database
if os.getenv('SHOULD_USE_AZURE'):
param_string = "DRIVER={};SERVER={};DATABASE={};UID={};PWD={}".format(
os.getenv('SQL_SERVER') or "{SQL Server}",
os.getenv('AZURE_SERVER'), os.getenv('AZURE_DATABASE'),
os.getenv('AZURE_USERNAME'), os.getenv('AZURE_PASS'))
params = urllib.parse.quote_plus(param_string)
app.config[
'SQLALCHEMY_DATABASE_URI'] = "mssql+pyodbc:///?odbc_connect=%s" % params
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
# 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_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 .room_request import room_request as room_request_blueprint
app.register_blueprint(room_request_blueprint, url_prefix='/room-request')
from .staff import staff as staff_blueprint
app.register_blueprint(staff_blueprint, url_prefix='/staff')
db.app = app
return app
