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
コード例 #2
0
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
コード例 #3
0
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
コード例 #4
0
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)
コード例 #5
0
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
コード例 #6
0
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
コード例 #7
0
ファイル: __init__.py プロジェクト: nguacon01/form_2D
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
コード例 #8
0
ファイル: __init__.py プロジェクト: schlinkertc/businesses
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
コード例 #9
0
ファイル: __init__.py プロジェクト: mrussell42/temp-srv
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
コード例 #10
0
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
コード例 #11
0
ファイル: factory.py プロジェクト: merky/bosphorus
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
コード例 #12
0
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")
コード例 #13
0
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())
コード例 #14
0
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
コード例 #15
0
ファイル: ext.py プロジェクト: tiborsimko/invenio-assets
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())
コード例 #16
0
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)
コード例 #17
0
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
コード例 #18
0
ファイル: __init__.py プロジェクト: callistachang/SLMDash
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
コード例 #19
0
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
コード例 #20
0
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
コード例 #21
0
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
コード例 #22
0
ファイル: __init__.py プロジェクト: Savithamark/User_Profile
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
コード例 #23
0
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
コード例 #24
0
ファイル: __init__.py プロジェクト: pwdel/flasksecurity
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
コード例 #25
0
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
コード例 #26
0
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
コード例 #27
0
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
コード例 #28
0
ファイル: factory.py プロジェクト: IMAGE-ET/bosphorus
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
コード例 #29
0
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
コード例 #30
0
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
コード例 #31
0
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']
コード例 #32
0
ファイル: ext.py プロジェクト: jmartinm/invenio-assets
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())
コード例 #33
0
ファイル: __init__.py プロジェクト: tylerjwoods/covid19_flask
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 
コード例 #34
0
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']
コード例 #35
0
ファイル: ext.py プロジェクト: krzysztof/invenio-assets
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())
コード例 #36
0
ファイル: assets.py プロジェクト: brettalanmeyer/ping-pong
def setupAssets(app):
	createStorage()
	assets = Environment(app)
	assets.init_app(app)
	assets.register("js_all", bundleJavascripts())
	assets.register("css_all", bundleStylesheets())
コード例 #37
0
ファイル: assets.py プロジェクト: jardg/pajbot
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)
コード例 #38
0
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):