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