def create_app():
"""Construct core Flask application with embedded Dash app."""
app = Flask(__name__, instance_relative_config=False)
app.config.from_object('config.Config')
assets = Environment()
assets.init_app(app)
with app.app_context():
# Import parts of our core Flask app
from . import routes
from .assets import compile_static_assets
# Import Dash application
from .plotlydash.dataDownload import dataDownload
# from .plotlydash.testLoad import test1
from .plotlydash.EDA import create_EDA
from .plotlydash.riskFactorAnalysis import create_RFA
# from .plotlydash.PCA import create_PCA
# from .plotlydash.page3 import create_page3
# from .plotlydash.page4 import create_page4
# tryout(app)
dataDownload(app)
create_EDA(app)
create_RFA(app)
# create_PCA(app)
# Compile static assets
compile_static_assets(assets)
return app
def create_app():
"""Construct core Flask application with embedded Dash app."""
app = Flask(__name__, instance_relative_config=False)
app.config.from_object('config.Config')
app.db = SQLAlchemy(app)
Base = automap_base()
# reflect the tables
Base.prepare(app.db.engine, reflect=True)
# MoistHist = Base.classes.MOISTHIST
# WaterHist = Base.classes.WATERHIST
assets = Environment()
assets.init_app(app)
migrate = Migrate(app,app.db)
with app.app_context():
# Import parts of our core Flask app
from . import web_plants
from .assets import compile_static_assets
from .models import WaterHist, MoistHist
app.db.create_all()
# Import Dash application
from .plotlydash.dashapp1 import create_dashboard
app = create_dashboard(app)
# Compile static assets
compile_static_assets(assets)
return app
def create_app():
"""Construct the core flask_wtforms_tutorial."""
print(Config.SQLALCHEMY_DATABASE_URI)
app = Flask(__name__, instance_relative_config=False)
app.config.from_object("config.Config")
# app.config["RECAPTCHA_PARAMETERS"] = {"size": "100%"}
images = UploadSet('images', IMAGES)
configure_uploads(app, images)
assets = Environment() # Create an assets environment
assets.init_app(app) # Initialize Flask-Assets
migrate = Migrate(app, db, render_as_batch=True)
bootstrap = Bootstrap(app)
db.init_app(app)
with app.app_context():
# Import parts of our flask_wtforms_tutorial
from .assets import compile_static_assets
from .addagtech import homeroutes
# Register Blueprints
app.register_blueprint(homeroutes.home_bp)
# Compile static assets
compile_static_assets(assets) # Execute logic
db.create_all() # Create sql tables for our data models
return app
class InvenioAssets(object):
"""Invenio asset extension."""
def __init__(self, app=None, **kwargs):
"""Extension initialization."""
self.env = Environment()
self.collect = Collect()
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)
# TODO: write .bowerrc to app.instance_folder
# bower command can by default write to app.instance_folder/bower.json
app.extensions['invenio-assets'] = self
def init_config(self, app):
"""Initialize configuration."""
app.config.setdefault("REQUIREJS_BASEURL", app.static_folder)
app.config.setdefault("REQUIREJS_CONFIG", 'js/settings.js')
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(bower)
cli.add_command(collect)
def init_app():
"""Construct core Flask application with embedded Dash app.
"""
logging.basicConfig(format=u"%(asctime)s: %(levelname)s: %(message)s",
datefmt=u"%Y/%m/%d %H:%M:%S",
level=logging.INFO)
logging.info("Application started.")
app = Flask(__name__, instance_relative_config=False)
app.config.from_object(u"config.Config")
with app.app_context():
# Import parts of our core Flask app.
from . import routes
assets = Environment()
assets.init_app(app)
if TIME_PERIOD is None or TIME_PERIOD > MAX_TIME_PERIOD:
time_period = MAX_TIME_PERIOD
else:
time_period = TIME_PERIOD
# Import Dash applications.
from .stats.stats import init_stats
app = init_stats(app, time_period=time_period)
from .trending.trending import init_trending
app = init_trending(app, time_period=time_period)
return app
def create_app():
app = Flask(__name__, instance_relative_config=False)
app.config.from_object("config.ProdConfig")
assets = Environment()
# initializate DB, Marshmallow, Bootstrap, assets, login
db.init_app(app)
ma.init_app(app)
Bootstrap(app)
assets.init_app(app)
login_manager.init_app(app)
with app.app_context():
# import needed routes from application
from .home import home
from .profile import profile
from .auth import auth
# register blueprints
app.register_blueprint(home.home_bp)
app.register_blueprint(profile.profile_bp)
app.register_blueprint(auth.auth_bp)
# create all db models
db.create_all()
return app
def create_app():
app = Flask(__name__, instance_relative_config=True)
app.config.from_object(DevelopmentConfig)
# app.config.from_pyfile('config.py', silent=True)
assets = Environment()
with app.app_context():
# add extensions
assets.init_app(app)
db.init_app(app)
bcrypt.init_app(app)
login_manager.init_app(app)
#Blueprints imports
from .main.views import main
# from .metadata.views import metadata
from .auth.views import auth
from .seafile_client.views import seafile_client
from .errors.handlers import errors
from .assets import compile_static_assets
app.register_blueprint(main)
# app.register_blueprint(metadata, url_prefix = "/metadata")
app.register_blueprint(auth, url_prefix="/auth")
app.register_blueprint(seafile_client, url_prefix="/seafile_client")
app.register_blueprint(errors, url_predix="/error")
compile_static_assets(assets)
db.create_all()
# add log handler
app.logger.addHandler(filehandle)
return app
def create_app():
"""Construct core Flask application with embedded Dash app."""
app = Flask(__name__, instance_relative_config=False)
app.config.from_object('config.Config')
db.init_app(app)
assets = Environment()
assets.init_app(app)
with app.app_context():
# Import parts of our core Flask app
from . import routes
from .assets import compile_static_assets
# Import Dash application
from .plotlydash.dashboard import create_dashboard
app = create_dashboard(app)
# Compile static assets
compile_static_assets(assets)
# Database tables
db.create_all()
return app
def init_app():
"""Initialize the core application."""
app = Flask(__name__,
instance_relative_config=False,
template_folder='templates')
app.config.from_object('config.Config')
assets = Environment(app)
assets.config['less_bin'] = '/usr/local/lib/node_modules/less/bin/lessc'
assets.init_app(app)
# Initialize Plugins
db.init_app(app)
with app.app_context():
# Include our Routes
from . import routes
from .assets import compile_static_assets
db.create_all()
# Import Dash application
from .plotlydash.dashboard import init_dashboard
app = init_dashboard(app)
compile_static_assets(assets)
return app
def create_app():
"""Construct the core application."""
app = Flask(__name__, instance_relative_config=False)
app.config.from_object('config.Config')
# Initialize Plugins
assets = Environment()
assets.init_app(app)
db.init_app(app)
migrate.init_app(app, db, render_as_batch=True)
login_manager.init_app(app)
admini.init_app(app)
with app.app_context():
# Import parts of our application
from .main import main_routes
from .auth import auth_routes
from .admin import admin_routes
from .assets import compile_static_assets
# Create database tables for our data models
db.create_all()
# Register Blueprints
app.register_blueprint(main_routes.main_bp)
app.register_blueprint(auth_routes.auth_bp)
app.register_blueprint(admin_routes.admin_bp)
# Compile static assets
if app.config['FLASK_ENV'] == 'development':
compile_static_assets(assets)
return app
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 create_app():
"""Create Flask Application"""
app = Flask(__name__, instance_relative_config=False)
# config app with things i'd normally put in app.py
app.config.from_object("config.Config")
app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get(
"DATABASE_URL", "postgres:///carabiner"
)
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
app.config["SQLALCHEMY_ECHO"] = True
app.config["DEBUG_TB_INTERCEPT_REDIRECTS"] = False
app.config["SECRET_KEY"] = os.environ.get("SECRET_KEY")
toolbar = DebugToolbarExtension(app)
# Flask-Login init
login_manager = LoginManager()
# Mail init
mail = Mail()
# Assets init
assets = Environment()
# DB init
connect_db(app)
mail.init_app(app)
login_manager.init_app(app)
assets.init_app(app)
with app.app_context():
# Import parts of our application
from .index import index
from .api_test import api_test
from .auth import auth
from .user_views import user_views
from .search_views import search_views
from .route_views import route_views
# Register Blueprints
app.register_blueprint(index.index_bp)
app.register_blueprint(api_test.api_test_bp, url_prefix="/api")
app.register_blueprint(auth.auth_bp)
app.register_blueprint(user_views.user_views)
app.register_blueprint(search_views.search_views)
app.register_blueprint(route_views.route_views)
# Compile static assets
compile_assets(assets)
return app
# Error Handlers
@app.errorhandler(404)
def page_not_found(error):
return render_template("404.html")
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 create_app(config_name=None):
app = Flask(__name__, template_folder='templates', static_folder='static')
assets = Environment(app)
assets.init_app(app)
config_name = config_name or os.getenv("APP_SETTINGS", "Config")
app_config = f'config.{config_name}'
app.config.from_object(app_config)
setup_blueprints(app)
return app
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_vendors(app):
from flask_mail import Mail
from flask_assets import Environment
from application.assets import compile_assets
from application.database import db
assets = Environment()
assets.init_app(app)
compile_assets(assets)
db.init_app(app)
db.create_all()
Mail(app)
def create_app(config_name=None):
app = Flask(__name__, template_folder='templates', static_folder='static')
assets = Environment(app)
scss = Bundle('style.scss', filters='pyscss', output='all.css')
assets.register('scss_all', scss)
assets.init_app(app)
config_name = config_name or os.getenv("APP_SETTINGS", "Config")
app_config = f'config.{config_name}'
app.config.from_object(app_config)
setup_blueprints(app)
return app
def create_app():
app = Flask(__name__)
app.config.from_object("config.Config")
assets = Environment()
assets.init_app(app)
with app.app_context():
from . import routes
from .dashboards.main import create_dashboard
app = create_dashboard(app)
return app
def create_app():
app = Flask(__name__)
assets = Environment()
assets.init_app(app)
with app.app_context():
# Register blueprints
app.register_blueprint(world.world_bp)
app.register_blueprint(usa.usa_bp)
app.register_blueprint(rest.rest_bp)
return app
def init_app():
app = Flask(__name__, instance_relative_config=False)
app.config.from_object("config")
app.config["FLATPAGES_HTML_RENDERER"] = my_markdown
assets = Environment()
assets.init_app(app)
with app.app_context():
assets.auto_build = True
from . import routes
from .plotlydash.dashboard import init_dashboard
app = init_dashboard(app, routes.pages)
return app
class TestConfigNoAppBound:
"""The application is not bound to a specific app.
"""
def setup(self):
self.env = Environment()
def test_no_app_available(self):
"""Without an application bound, we can't do much."""
assert_raises(RuntimeError, setattr, self.env, 'debug', True)
assert_raises(RuntimeError, self.env.config.get, 'debug')
def test_global_defaults(self):
"""We may set defaults even without an application, however."""
self.env.config.setdefault('FOO', 'BAR')
with Flask(__name__).test_request_context():
assert self.env.config['FOO'] == 'BAR'
def test_multiple_separate_apps(self):
"""Each app has it's own separate configuration.
"""
app1 = Flask(__name__)
self.env.init_app(app1)
# With no app yet available...
assert_raises(RuntimeError, getattr, self.env, 'url')
# ...set a default
self.env.config.setdefault('FOO', 'BAR')
# When an app is available, the default is used
with app1.test_request_context():
assert self.env.config['FOO'] == 'BAR'
# If the default is overridden for this application, it
# is still valid for other apps.
self.env.config['FOO'] = '42'
assert self.env.config['FOO'] == '42'
app2 = Flask(__name__)
with app2.test_request_context():
assert self.env.config['FOO'] == 'BAR'
def test_key_error(self):
"""KeyError is raised if a config value doesn't exist.
"""
with Flask(__name__).test_request_context():
assert_raises(KeyError, self.env.config.__getitem__, 'YADDAYADDA')
# The get() helper, on the other hand, simply returns None
assert self.env.config.get('YADDAYADDA') == None
def create_app():
"""Create Flask application."""
app = Flask(__name__, instance_relative_config=False)
app.config.from_object('config.Config')
assets = Environment()
assets.init_app(app)
with app.app_context():
from .profile import profile
from .home import home
app.register_blueprint(profile.profile_bp)
app.register_blueprint(home.home_bp)
return app
def init_app():
app = Flask(__name__, instance_relative_config=False)
app.config.from_object('config.Config')
assets = Environment()
assets.init_app(app)
with app.app_context():
from . import routes
from .assets import compile_static_assets
from .dashapp.dashboard import init_dashboard
app = init_dashboard(app)
compile_static_assets(assets)
return app
def create_app():
# construct core app object, __name__ is the default value.
app = Flask(__name__)
# pull the config file, per flask documentation
# Application configuration
app.config.from_object("project.config.Config")
# auto reload templates
app.config['TEMPLATES_AUTO_RELOAD'] = True
# Set environment for assets
assets = Environment()
# initialize database plugin
db.init_app(app)
# initialize asset plugin
assets.init_app(app)
# initialize login manager plugin
login_manager.init_app(app)
# initialize principals/roles plugin
principals.init_app(app)
# initialize routes
with app.app_context():
from . import routes
from . import auth
from .assets import compile_static_assets
# Register Blueprints
app.register_blueprint(routes.main_bp)
app.register_blueprint(auth.auth_bp)
app.register_blueprint(routes.sponsor_bp)
app.register_blueprint(routes.editor_bp)
app.register_blueprint(routes.admin_bp)
# import model class
from . import models
# Create Database Models
db.create_all()
# Compile static assets
compile_static_assets(assets)
return app
def create_app():
# start app
app = Flask(__name__)
app.config.from_object(app_config.Config)
CORS(app)
app.config["CORS_HEADERS"] = "Content-Type"
assets = Environment()
assets.init_app(app)
# state blueprints
app.register_blueprint(state_routes.state_info)
# covid blueprints
app.register_blueprint(covid_routes.covid_summary)
app.register_blueprint(covid_routes.covid_since_date)
app.register_blueprint(covid_routes.covid_since_first)
return app
def create_app():
"""Construct core Flask application with embedded Dash app."""
app = Flask(__name__)
assets = Environment()
assets.init_app(app)
with app.app_context():
# Import parts of our core Flask app
from . import routes_v51
from .assets import compile_static_assets
# Import Dash application
from .plotlydash.dashboard import create_dashboard
app = create_dashboard(app)
# Compile static assets
compile_static_assets(assets)
return app
def create_app():
"""Create Flask application."""
app = Flask(__name__, instance_relative_config=False)
app.config.from_object('config.Config')
assets = Environment() # Create an assets environment
assets.init_app(app) # Initialize Flask-Assets
with app.app_context():
# Import parts of our application
from .home import routes
from .assets import compile_static_assets
# Register Blueprints
app.register_blueprint(home.home_bp)
# Compile static assets
compile_static_assets(assets) # Execute logic
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_app():
"""Construct core Flask application with embedded Dash app."""
app = Flask(__name__, instance_relative_config=False)
app.config.from_object('config.Config')
assets = Environment()
assets.init_app(app)
with app.app_context():
# Import parts of our core Flask app
from . import routes
from .assets import compile_static_assets
# Import Dash application
from .dash.dashboard import init_dashboard
app = init_dashboard(app)
compile_static_assets(assets)
return app
def create_app():
"""Construct core Flask application with embedded Dash app."""
app = Flask(__name__, instance_relative_config=False)
app.config.from_object('config.Config')
assets = Environment()
assets.init_app(app)
with app.app_context():
# Import parts of our core Flask app
# from . import routes
from .assets import compile_static_assets
from plotlydash.dashboards import create_dashboard
create_dashboard(app)
# Compile static assets
compile_static_assets(assets)
register_blueprints(app)
return app
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']
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 create_app():
'''
Construct core Flask application with embedded Dash app.
'''
app = Flask(__name__, instance_relative_config=False)
app.config.from_object('config.Config')
assets = Environment()
assets.init_app(app)
with app.app_context():
# Import Flask routes
from . import routes
from .assets import compile_static_assets
# Import Dash application
from .plotlydash.dashboard import create_dashboard
app = create_dashboard(app)
# Compile CSS
complie_static_assets(app)
return app
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']
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 setupAssets(app):
createStorage()
assets = Environment(app)
assets.init_app(app)
assets.register("js_all", bundleJavascripts())
assets.register("css_all", bundleStylesheets())
def init(app):
assets = Environment(app)
# Basic CSS and Javascript:
# Available under: base_css, base_js
base_css = Bundle('css/base.scss', filters='pyscss',
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)
# Pleblist-related javascript
# Available under the following assets: pleblist_shared, pleblist_host, pleblist_client
pleblist_client = Bundle('scripts/pleblist.js', filters='jsmin',
output='gen/scripts/pleblist.%(version)s.js')
pleblist_shared = Bundle('scripts/pleblist.shared.js', filters='jsmin',
output='gen/scripts/pleblist.shared.%(version)s.js')
pleblist_host = Bundle(
'scripts/pleblist.host.js',
'scripts/pleblist.host.streamtip.js',
'scripts/pleblist.host.streamelements.js',
'scripts/pleblist.host.streamlabs.js',
filters='jsmin',
output='gen/scripts/pleblist.host.%(version)s.js')
assets.register('pleblist_shared', pleblist_shared)
assets.register('pleblist_client', pleblist_client)
assets.register('pleblist_host', pleblist_host)
# CLR Overlay
# Availabe under: clr_overlay_js, clr_overlay_css, clr_donations_js, clr_donations_css, clr_shared_js
clr_overlay_js = Bundle('scripts/clr.overlay.js', filters='jsmin',
output='gen/scripts/clr.overlay.%(version)s.js')
clr_overlay_css = Bundle('css/clr.overlay.scss', filters='pyscss',
output='gen/css/clr.overlay.%(version)s.css')
clr_donations_js = Bundle('scripts/clr.donations.js', filters='jsmin',
output='gen/scripts/clr.donations.%(version)s.js')
clr_donations_css = Bundle('css/clr.donations.scss', filters='pyscss',
output='gen/css/clr.donations.%(version)s.css')
clr_shared_js = Bundle('scripts/clr.shared.js', filters='jsmin',
output='gen/scripts/clr.shared.%(version)s.js')
assets.register('clr_overlay_js', clr_overlay_js)
assets.register('clr_overlay_css', clr_overlay_css)
assets.register('clr_donations_js', clr_donations_js)
assets.register('clr_donations_css', clr_donations_css)
assets.register('clr_shared_js', clr_shared_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)
# Admin CLR
admin_clr_donations_edit_js = Bundle('scripts/admin/clr/donations/edit.js',
output='gen/scripts/admin/clr/donations/edit.%(version)s.js')
assets.register('admin_clr_donations_edit_js', admin_clr_donations_edit_js)
notifications_base = Bundle('scripts/notifications/base.js', filters='jsmin',
output='gen/scripts/notifications/base.%(version)s.js')
assets.register('notifications_base', notifications_base)
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)
assets.init_app(app)
from flask import (
Flask,
jsonify,
request,
url_for,
render_template,
)
from jsonschema import validate
from flask_assets import Environment
IS_DEBUG = os.environ.get('DEBUG', 'false').lower() == 'true'
app = Flask(__name__, static_url_path='/dist', static_folder='./dist')
app.config['ASSETS_DEBUG'] = IS_DEBUG
assets = Environment()
assets.init_app(app)
class FlightService(object):
'''Data access layer extracts data from internal API.
This can be extended for external APIs in the future'''
def __init__(self, filename):
with open(filename) as f:
self.flights = json.loads(f.read())['flights']
# index the json for quick lookups
self.flights_index = {}
for index, flight in enumerate(self.flights):
self.flights_index[flight['number']] = index
def get(self, number):
