def create_app(config_object=None, db_name=None): # pragma: no cover app = Flask(__name__) from dotenv import load_dotenv load_dotenv(".env") if config_object is None: app.config.from_object('config.BaseConfiguration') else: app.config.from_object(config_object) if not app.logger.handlers: stream_handler = StreamHandler() app.logger.addHandler(stream_handler) if app.debug: app.logger.setLevel("DEBUG") app.config["DEBUG_TB_INTERCEPT_REDIRECTS"] = False app.config["DEBUG_TB_PROFILER_ENABLED"] = os.environ.get( "PROFILER", "False") == 'True' app.config['RQ_DEFAULT_URL'] = os.environ.get("REDIS_URL") else: app.logger.setLevel("DEBUG") RQ(app) Bootstrap(app) DebugToolbarExtension(app) from chatbot.views import chatbot_bp app.register_blueprint(chatbot_bp) return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # not using sqlalchemy event system, hence disabling it config[config_name].init_app(app) # Set up extensions db.init_app(app) login_manager.init_app(app) compress.init_app(app) RQ(app) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify SSLify(app) # Create app blueprints # from .main import main as main_blueprint # app.register_blueprint(main_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') return app
def set_up_extensions(app): csrf.init_app(app) db.init_app(app) login_manager.init_app(app) mail.init_app(app) compress.init_app(app) RQ(app)
def create_app(config): app = Flask(__name__) config_name = config if not isinstance(config, str): config_name = os.getenv('FLASK_CONFIG', 'default') app.config.from_object(Config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False Config[config_name].init_app(app) # Set up extensions db.init_app(app) RQ(app) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify SSLify(app) # Register api blueprints app.register_blueprint(api_v1) return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # not using sqlalchemy event system, hence disabling it config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) RQ(app) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask.ext.sslify import SSLify SSLify(app) # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') from .data import data as data_blueprint app.register_blueprint(data_blueprint, url_prefix='/data') from .request import request_blueprint app.register_blueprint(request_blueprint, url_prefix='/request') @app.after_request def add_header(response): response.cache_control.max_age = 0 return response return app
def create_app(configfile=None): app = Flask(__name__) AppConfig(app) Bootstrap(app) sql_dir = os.path.join(basedir, 'tmp/') app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join( sql_dir, 'user-login.sqlite') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False REDIS_URL = 'http://localhost:6379' urllib.parse.uses_netloc.append('redis') url = urllib.parse.urlparse(REDIS_URL) app.config['RQ_DEFAULT_HOST'] = url.hostname app.config['RQ_DEFAULT_PORT'] = url.port app.config['RQ_DEFAULT_PASSWORD'] = url.password app.config['RQ_DEFAULT_DB'] = 0 # EAM : Set limit on the number of items in cache (RAM) cache.init_app(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) assets_env.register('browser_js', browser_js) assets_env.register('browser_css', browser_css) assets_env.register('tabular_ensemble_js', tabular_ensemble_js) assets_env.register('tabular_rs1_js', tabular_rs1_js) assets_env.register('tabular_rs2_js', tabular_rs2_js) assets_env.register('request_new_ensemble_js', request_new_ensemble_js) assets_env.register('tabular_css', tabular_css) with app.app_context(): from .frontend import frontend #app.register_blueprint(frontend, url_prefix="/portal") app.register_blueprint(frontend) from .content import content app.register_blueprint(content) #app.register_blueprint(content, url_prefix="/portal") app.json_encoder = MiniJSONEncoder nav.init_app(app) mail.init_app(app) csrf.init_app(app) db.init_app(app) login_manager.init_app(app) compress.init_app(app) htmlmin.init_app(app) RQ(app) return app
def create_app(config): app = Flask(__name__) config_name = config if not isinstance(config, str): config_name = os.getenv('FLASK_CONFIG', 'default') app.config.from_object(Config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # not using sqlalchemy event system, hence disabling it Config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) RQ(app) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify SSLify(app) # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') from .volunteer import volunteer as volunteer_blueprint app.register_blueprint(volunteer_blueprint, url_prefix='/volunteer') from .staff import staff as staff_blueprint app.register_blueprint(staff_blueprint, url_prefix='/staff') return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True # not using sqlalchemy event system, hence disabling it config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) RQ(app) # setup the celery client celery = Celery(app, broker=app.config['CELERY_BROKER_URL']) celery.conf.update(app.config) # Register Jinja template functions from .template_utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask.ext.sslify import SSLify SSLify(app) # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') from .tools import tools as tools_blueprint app.register_blueprint(tools_blueprint, url_prefix='/tools') from .projects import projects as projects_blueprint app.register_blueprint(projects_blueprint, url_prefix='/projects') return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # not using sqlalchemy event system, hence disabling it config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) RQ(app) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify SSLify(app) # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') from .inventory import inventory as inventory_blueprint app.register_blueprint(inventory_blueprint, url_prefix='/inventory') from .provisioning import provisioning as provisioning_blueprint app.register_blueprint(provisioning_blueprint, url_prefix='/provisioning') from .rtd import rtd as provisioning_rtd app.register_blueprint(provisioning_rtd, url_prefix='/rtd') return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) # Set up extensions bootstrap.init_app(app) moment.init_app(app) mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) RQ(app) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask.ext.sslify import SSLify SSLify(app) # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') from .diary import diary as diary_blueprint app.register_blueprint(diary_blueprint, url_prefix='/diary') from .video import video as video_blueprint app.register_blueprint(video_blueprint, url_prefix='/video') from .survey import survey as survey_blueprint app.register_blueprint(survey_blueprint, url_prefix='/survey') return app
def create_app(config_name): app = Flask(__name__) with app.app_context(): app.config.from_object(config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) RQ(app) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify SSLify(app) # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .adtributor import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') from .adtributor import contributor as contributor_blueprint app.register_blueprint(contributor_blueprint, url_prefix='/contributor') db.app = app return app
def create_app(config=None): app = Flask(__name__) # read .envs and configuration class app = read_env(app, config) # define logging patterns app = setup_logger(app) # register view blueprints from project.home.views import app_blueprint from project.user.views import user_blueprint app.register_blueprint(app_blueprint) app.register_blueprint(user_blueprint) # setup apps DebugToolbarExtension(app) Bcrypt(app) RQ(app) basic_auth = BasicAuth(app) db.init_app(app) # register admin view from project.user.models.user import User from project.user.models.role import Role from project.user.models.user_roles import UserRoles from project.admin.views import ModelView, SuperSecretPage from project.user.admin.views import UserView admin = Admin(app, name='Admin Panel', template_mode='bootstrap3') admin.add_view(UserView(User, db.session, basic_auth, endpoint="users")) admin.add_view(ModelView(Role, db.session, basic_auth, endpoint="roles")) admin.add_view(SuperSecretPage(name="Secret")) # register api endpoints from project.api.v1.user import User api = Api(app, prefix='/api/v1/') api.add_resource(User, 'users/', endpoint='api.v1.users') # import custom login manager functions from project.user.login_manager import load_user_from_request, load_user login_manager = LoginManager(app) login_manager.login_view = "user.login" login_manager.user_loader(load_user) login_manager.request_loader(load_user_from_request) # default flashed messages category login_manager.login_message_category = 'info' login_manager.needs_refresh_message_category = 'info' # jinja extensions app.jinja_env.add_extension('jinja2.ext.do') return app
def create_app(config_name, main=True): app = Flask(__name__) app.config.from_object(config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # not using sqlalchemy event system, hence disabling it config[config_name].init_app(app) # Set up extensions db.init_app(app) db.sessionmaker(autoflush=False) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) RQ(app) socketio.init_app(app, message_queue=app.config['SOCKETIO_MESSAGE_QUEUE']) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask.ext.sslify import SSLify SSLify(app) # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # not using sqlalchemy event system, hence disabling it config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) csrf.init_app(app) compress.init_app(app) RQ(app) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask.ext.sslify import SSLify SSLify(app) # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .SnEMechs import SnEMechs as SnEMechs_blueprint app.register_blueprint(SnEMechs_blueprint, url_prefix='/Sn_1+Sn_2+E1+E2+Mechanisms') return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False config[config_name].init_app(app) mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) RQ(app) from app.utils import register_template_utils register_template_utils(app) assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify SSLify(app) from app.main.views import main_blueprint app.register_blueprint(main_blueprint) from app.account.views import account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from app.admin.views import admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # not using sqlalchemy event system, hence disabling it config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) csrf.init_app(app) oauth.init_app(app) RQ(app) api = Api(app) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify SSLify(app) # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .api.auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') from app.api.docs import docs as docs_blueprint app.register_blueprint(docs_blueprint) from flasgger import APISpec, Schema, Swagger, fields spec = APISpec( title='REST API', version='1.0.0', plugins=[ 'apispec.ext.flask', 'apispec.ext.marshmallow', ], ) app.config['SWAGGER'] = {'title': 'REST API', 'uiversion': 3} swagger = Swagger(app, template={ 'swagger': '3.0', 'info': { 'title': 'REST API', 'version': '1.0' } }) from app.api.v1.building import Building, BuildingList building_view = Building.as_view('Building') app.add_url_rule('/v1/buildings/<int:building_id>', view_func=building_view) building_list_view = BuildingList.as_view('BuildingList') app.add_url_rule('/v1/buildings', view_func=building_list_view) with app.test_request_context(): spec.add_path(view=building_view) spec.add_path(view=building_list_view) return app
from .models import db # NOQA # Configure the app coaster.app.init_app(app) db.init_app(app) db.app = app migrate = Migrate(app, db) app.geoip = None if 'GEOIP_PATH' in app.config: if not os.path.exists(app.config['GEOIP_PATH']): app.logger.warn("GeoIP database missing at " + app.config['GEOIP_PATH']) else: app.geoip = geoip2.database.Reader(app.config['GEOIP_PATH']) RQ(app) baseframe.init_app(app, requires=[ 'baseframe-bs3', 'jquery.autosize', 'jquery.liblink', 'jquery.wnumb', 'jquery.nouislider', 'baseframe-firasans', 'fontawesome>=4.3.0', 'bootstrap-multiselect', 'nprogress', 'ractive', 'jquery.appear', 'hammer' ]) # TinyMCE has to be loaded by itself, unminified, or it won't be able to find its assets app.assets.register( 'js_tinymce', assets.require('!jquery.js', 'tinymce.js>=4.0.0', 'jquery.tinymce.js>=4.0.0')) app.assets.register(
def create_app(config): app = Flask(__name__) config_name = config if not isinstance(config, str): config_name = os.getenv('FLASK_CONFIG', 'default') app.config.from_object(Config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # not using sqlalchemy event system, hence disabling it Config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) #compress.init_app(app) RQ(app) migrate.init_app(app, db) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) import click from app.models import Role, User @app.cli.command("create_user") @click.argument("name") def create_super_user(name): Role.insert_roles() admin_query = Role.query.filter_by(name='Administrator') if admin_query.first() is not None: if User.query.filter_by(email='*****@*****.**').first() is None: user = User( first_name='Admin', last_name='Account', password='******', confirmed=True, email='*****@*****.**') db.session.add(user) db.session.commit() print('Added administrator {}'.format(user.full_name())) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it ''' if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify SSLify(app) ''' # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') from .student import student as student_blueprint app.register_blueprint(student_blueprint, url_prefix='/student') from .professor import professor as professor_blueprint app.register_blueprint(professor_blueprint, url_prefix='/professor') return app
def create_app(): app = Flask(__name__) app.config.from_object(config) RQ(app) return app
# from flask_login import LoginManager # login_manager = LoginManager() from flask_migrate import Migrate migrate = Migrate() from flask_cache import Cache cache = Cache() from flask_debugtoolbar import DebugToolbarExtension debug_toolbar = DebugToolbarExtension() from flask_bootstrap import Bootstrap bootstrap = Bootstrap() from rq_dashboard import RQDashboard from recruit_app.user.admin import check_if_admin rqDashboard = RQDashboard(auth_handler=check_if_admin) from flask_admin import Admin admin = Admin() from flask_mail import Mail mail = Mail() from flask_rq import RQ rq = RQ()
def create_app(config): app = Flask(__name__) config_name = config if not isinstance(config, str): config_name = os.getenv('FLASK_CONFIG', 'default') app.config.from_object(Config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # not using sqlalchemy event system, hence disabling it Config[config_name].init_app(app) app.config['UPLOADED_IMAGES_DEST'] = '/home/ubuntu/flaskapp/flask-base/appstatic/photo/' if \ not os.environ.get('UPLOADED_IMAGES_DEST') else os.path.dirname(os.path.realpath(__file__)) + os.environ.get( 'UPLOADED_IMAGES_DEST') app.config['UPLOADED_DOCS_DEST'] = '/home/ubuntu/flaskapp/flask-base/appstatic/docs/' if \ not os.environ.get('UPLOADED_DOCS_DEST') else os.path.dirname(os.path.realpath(__file__)) + os.environ.get( 'UPLOADED_DOCS_DEST') app.config['docs'] = app.config['UPLOADED_DOCS_DEST'] # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) RQ(app) configure_uploads(app, images) configure_uploads(app, docs) share.init_app(app) CKEditor(app) moment.init_app(app) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify SSLify(app) # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .api import blueprint as api_blueprint app.register_blueprint(api_blueprint) from .public import public as public_blueprint app.register_blueprint(public_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') from .blog import blog as blog_blueprint app.register_blueprint(blog_blueprint, url_prefix='/blog') return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) RQ(app) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask.ext.sslify import SSLify SSLify(app) # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint) from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint) from .bulk_resource import bulk_resource as bulk_resource_blueprint app.register_blueprint(bulk_resource_blueprint) from .descriptor import descriptor as descriptor_blueprint app.register_blueprint(descriptor_blueprint) from .single_resource import single_resource as single_resource_blueprint app.register_blueprint(single_resource_blueprint) from .suggestion import suggestion as suggestion_blueprint app.register_blueprint(suggestion_blueprint) from .contact import contact as contact_blueprint app.register_blueprint(contact_blueprint) @app.before_request def br(): from flask import request g.tlf = request.path[1:].split('/', 1)[0] from .models import Locale Locale.check_locale(g.tlf) @app.after_request def ar(response): #if not tlf(g.tlf): pass #abort(404) return response return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) RQ(app) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask.ext.sslify import SSLify SSLify(app) # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') from .bulk_resource import bulk_resource as bulk_resource_blueprint app.register_blueprint(bulk_resource_blueprint, url_prefix='/bulk-resource') from .descriptor import descriptor as descriptor_blueprint app.register_blueprint(descriptor_blueprint, url_prefix='/descriptor') from .single_resource import single_resource as single_resource_blueprint app.register_blueprint(single_resource_blueprint, url_prefix='/single-resource') from .suggestion import suggestion as suggestion_blueprint app.register_blueprint(suggestion_blueprint, url_prefix='/suggestion') from .contact import contact as contact_blueprint app.register_blueprint(contact_blueprint, url_prefix='/contact') return app
def create_app(config): app = Flask(__name__) config_name = config if not isinstance(config, str): config_name = os.getenv("FLASK_CONFIG", "default") app.config.from_object(Config[config_name]) app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False # not using sqlalchemy event system, hence disabling it Config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) RQ(app) configure_uploads(app, images) configure_uploads(app, docs) CKEditor(app) share.init_app(app) Bootstrap(app) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ["assets/styles", "assets/scripts"] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register("app_css", app_css) assets_env.register("app_js", app_js) assets_env.register("vendor_css", vendor_css) assets_env.register("vendor_js", vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config["SSL_DISABLE"]: from flask_sslify import SSLify SSLify(app) # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .public import public as public_blueprint app.register_blueprint(public_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix="/account") from .question import question as question_blueprint app.register_blueprint(question_blueprint, url_prefix="/question") from .answer import answer as answer_blueprint app.register_blueprint(answer_blueprint, url_prefix="/answer") from .project import project as project_blueprint app.register_blueprint(project_blueprint, url_prefix="/project") from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix="/admin") from .organisations import organisations as organisations_blueprint app.register_blueprint(organisations_blueprint, url_prefix="/organisations") from .blog import blog app.register_blueprint(blog, url_prefix="/blog") return app
def create_app(config_name): app = Flask(__name__, static_folder='static') app.config.from_object(config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # not using sqlalchemy event system, hence disabling it config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) csrf.init_app(app) oauth.init_app(app) oauthclient.init_app(app) RQ(app) db.app = app cors = CORS(app, resources={ r"/api/v1/*": { "origins": "*" }, r"/auth/oauth/*": { "origins": "*" } }) api = Api(app) babel.init_app(app) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not os.environ.get('SSL_DISABLE'): from flask_sslify import SSLify SSLify(app) # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .api.auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') from app.api.docs import docs as docs_blueprint app.register_blueprint(docs_blueprint) from flasgger import APISpec, Schema, Swagger, fields spec = APISpec( title='Bhagavad Gita API', version='1.0.0', plugins=[ 'apispec.ext.flask', 'apispec.ext.marshmallow', ], ) app.config['SWAGGER'] = {'title': 'Bhagavad Gita API', 'uiversion': 3} swagger = Swagger(app, template={ 'swagger': '2.0', 'info': { 'title': 'Bhagavad Gita API', 'version': '1.0' } }) from app.api.v1.verse import VerseList, VerseListByChapter, VerseByChapter from app.api.v1.chapter import Chapter, ChapterList verse_list_view = VerseList.as_view('VerseList') app.add_url_rule('/api/v1/verses', view_func=verse_list_view) verse_list_chapter_view = VerseListByChapter.as_view('VerseListChapter') app.add_url_rule('/api/v1/chapters/<int:chapter_number>/verses', view_func=verse_list_chapter_view) verse_chapter_view = VerseByChapter.as_view('VerseChapter') app.add_url_rule( '/api/v1/chapters/<int:chapter_number>/verses/<string:verse_number>', view_func=verse_chapter_view) chapter_view = Chapter.as_view('Chapter') app.add_url_rule('/api/v1/chapters/<int:chapter_number>', view_func=chapter_view) chapter_list_view = ChapterList.as_view('ChapterList') app.add_url_rule('/api/v1/chapters', view_func=chapter_list_view) def _force_https(): if not app.debug: from flask import _request_ctx_stack if _request_ctx_stack is not None: reqctx = _request_ctx_stack.top reqctx.url_adapter.url_scheme = 'https' app.before_request(_force_https) with app.test_request_context(): spec.add_path(view=verse_list_view) spec.add_path(view=verse_list_chapter_view) spec.add_path(view=verse_chapter_view) spec.add_path(view=chapter_view) spec.add_path(view=chapter_list_view) return app
app.register_blueprint(lastuser_core.lastuser_core) app.register_blueprint(lastuser_oauth.lastuser_oauth) app.register_blueprint(lastuser_ui.lastuser_ui) from . import views # NOQA assets['lastuser-oauth.js'][version] = lastuser_oauth.lastuser_oauth_js, assets['lastuser-oauth.css'][version] = lastuser_oauth.lastuser_oauth_css # Configure the app coaster.app.init_app(app) db.init_app(app) db.app = app # To make it work without an app context migrate = Migrate(app, db) RQ(app) # Pick up RQ configuration from the app baseframe.init_app(app, requires=['lastuser-oauth'], ext_requires=[ 'baseframe-bs3', 'fontawesome>=4.0.0', 'jquery.cookie', 'timezone' ]) lastuser_oauth.lastuser_oauth.init_app(app) lastuser_oauth.mailclient.mail.init_app(app) lastuser_oauth.views.login.oid.init_app(app) # Register some login providers if app.config.get('OAUTH_TWITTER_KEY') and app.config.get( 'OAUTH_TWITTER_SECRET'): login_registry['twitter'] = providers.TwitterProvider(
import os from flask import Flask from flask_rq import RQ app = Flask(__name__) rq = RQ(app) app.config['ghuser'] = os.environ.get('GH_USERNAME') app.config['ghpassword'] = os.environ.get('GH_PASSWORD') app.config['ghrepository'] = os.environ.get('GH_REPOSITORY') app.config['RQ_DEFAULT_URL'] = os.environ.get('REDIS_URL', 'redis://') app.config['ROLLBAR_ACCESS_TOKEN'] = os.environ.get('ROLLBAR_ACCESS_TOKEN') import ghinbox.webhooks # noqa import ghinbox.requestid # noqa
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # not using sqlalchemy event system, hence disabling it #'C:/Users/oem/Desktop/marketplace/marketplace/app/static/frontend/images/' #'C:/Users/oem/Desktop/marketplace/marketplace/appstatic/docs/' app.config['UPLOADED_IMAGES_DEST'] = basedir + 'static/frontend/images' if \ not os.environ.get('UPLOADED_IMAGES_DEST') else os.path.dirname(os.path.realpath(__file__)) + os.environ.get( 'UPLOADED_IMAGES_DEST') app.config['UPLOADED_DOCS_DEST'] = basedir + 'static/docs' if \ not os.environ.get('UPLOADED_DOCS_DEST') else os.path.dirname(os.path.realpath(__file__)) + os.environ.get( 'UPLOADED_DOCS_DEST') app.config['docs'] = app.config['UPLOADED_DOCS_DEST'] app.config['CKEDITOR_SERVE_LOCAL'] = True app.config['CKEDITOR_HEIGHT'] = 400 app.config['CKEDITOR_FILE_UPLOADER'] = 'upload' app.config['CKEDITOR_ENABLE_CSRF'] = True # if you want to enable CSRF protect, uncomment this line app.config['UPLOADED_PATH'] = os.path.join(basedir, 'uploads') #app.config['WHOOSH_BASE']='whoosh' config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) RQ(app) configure_uploads(app, (images)) configure_uploads(app, docs) ckeditor = CKEditor(app) share.init_app(app) moment.init_app(app) jwt.init_app(app) sess.init_app(app) whooshee.init_app(app) # whooshee = Whooshee(app) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask_sslify import SSLify SSLify(app) # Create app blueprints from .blueprints.public import public as public_blueprint app.register_blueprint(public_blueprint) from .blueprints.seo_world import seo_world as seo_world_blueprint app.register_blueprint(seo_world_blueprint) from .blueprints.main import main as main_blueprint app.register_blueprint(main_blueprint) from .blueprints.account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .blueprints.admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') from .blueprints.marketplace import marketplace as marketplace_blueprint app.register_blueprint(marketplace_blueprint, url_prefix='/marketplace') from .blueprints.organisations import organisations as organisations_blueprint app.register_blueprint(organisations_blueprint, url_prefix='/organisations') from .blueprints.sitemaps import sitemaps as sitemaps_blueprint app.register_blueprint(sitemaps_blueprint) from .blueprints.api import api as apis_blueprint app.register_blueprint(apis_blueprint, url_prefix='/api') # main_api.init_app(app) app.jinja_env.globals.update(json_load=json_load, image_size=image_size, get_cart=get_cart) @app.before_request def before_request(): try: session['cart_id'] except: u = uuid.uuid4() user_agent = request.headers.get('User-Agent') if user_agent is not None: user_agent = user_agent.encode('utf-8') base = 'cart: {0}|{1}|{2}'.format(_get_remote_addr(), user_agent, u) if str is bytes: base = text_type(base, 'utf-8', errors='replace') # pragma: no cover h = sha512() h.update(base.encode('utf8')) session['cart_id'] = h.hexdigest() @app.cli.command() def reindex(): with app.app_context(): whooshee.reindex() @app.cli.command() def routes(): """'Display registered routes""" rules = [] for rule in app.url_map.iter_rules(): methods = ','.join(sorted(rule.methods)) rules.append((rule.endpoint, methods, str(rule))) sort_by_rule = operator.itemgetter(2) for endpoint, methods, rule in sorted(rules, key=sort_by_rule): route = '{:50s} {:25s} {}'.format(endpoint, methods, rule) print(route) @app.template_filter('product') def product(o): """check if object is user""" from app.models import MProduct return o.__class__ == MProduct return app
def create_app(config_name, url_prefix=""): app = Flask(__name__, static_url_path=url_prefix + "/static", subdomain_matching=True) app.config.from_object(config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # not using sqlalchemy event system, hence disabling it config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) # csrf.init_app(app) CSRFProtect(app) compress.init_app(app) RQ(app) # admin.init_app(app) # admin.add_view(ModelView(User, db.session)) # admin.add_view(ModelView(OralHistory, db.session)) # jsglue.init_app(app, url_prefix=url_prefix) # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True assets_env.register('app_css', app_css) assets_env.register('app_js', app_js) assets_env.register('vendor_css', vendor_css) assets_env.register('vendor_js', vendor_js) # Configure SSL if platform supports it if not app.debug and not app.testing and not app.config['SSL_DISABLE']: from flask.ext.sslify import SSLify SSLify(app) hypothesis_service = os.environ.get('HYPOTHESIS_SERVICE', 'http://localhost:5000') hyp_client = HypothesisClient( authority=os.environ['HYPOTHESIS_AUTHORITY'], client_id=os.environ['HYPOTHESIS_CLIENT_ID'], client_secret=os.environ['HYPOTHESIS_CLIENT_SECRET'], jwt_client_id=os.environ['HYPOTHESIS_JWT_CLIENT_ID'], jwt_client_secret=os.environ['HYPOTHESIS_JWT_CLIENT_SECRET'], service=hypothesis_service) app.hypothesis_client = hyp_client # Create app blueprints from .main import main as main_blueprint app.register_blueprint(main_blueprint, url_prefix=url_prefix) from .account import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix=url_prefix + '/account') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix=url_prefix + '/admin') from .experimental import experimental as experimental_blueprint app.register_blueprint(experimental_blueprint, url_prefix=url_prefix + '/experimental') return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # not using sqlalchemy event system, hence disabling it app.config['OAUTH_CREDENTIALS'] = { 'google': { 'id': '767868202462-3v28oqcun0fnd0vc89uh7in4mbi7fg4o.apps.googleusercontent.com', 'secret': 'KfvqdFDqYYn9hXDFeC3BmImD' }, 'facebook': { 'id': '1357352657745486', 'secret': '52e5d34fef41614988fbd1a7e33deab2' }, 'twitter': { 'id': 'NzD4SB1S9Ulod1k1cqZGH5g6J ', 'secret': 'CLXzCpbe0NxY8mOzgBtgRNWJjltJth2urwR7EkBzr365EUNEWO' } } config[config_name].init_app(app) # Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.init_app(app) moment.init_app(app) ckeditor.init_app(app) RQ(app) babel.init_app(app) photos = UploadSet('photos', IMAGES) configure_uploads(app, photos) patch_request_class(app) app.config['CKEDITOR_ENABLE_CSRF'] = True app.config['CKEDITOR_FILE_UPLOADER'] = '/admin/upload' # Register Jinja template functions from .utils import register_template_utils register_template_utils(app) # Set up asset pipeline assets_env = Environment(app) dirs = ['assets/styles', 'assets/scripts'] for path in dirs: assets_env.append_path(os.path.join(basedir, path)) assets_env.url_expire = True # assets_env.register('app_css', app_css) # assets_env.register('app_js', app_js) # assets_env.register('vendor_css', vendor_css) # assets_env.register('vendor_js', vendor_js) # assets_env.register('skye_css', vendor_css) # assets_env.register('skye_js', vendor_js) # Configure SSL if platform supports it #if not app.debug and not app.testing and not app.config['SSL_DISABLE']: # from flask.ext.sslify import SSLify # SSLify(app) # # Create app blueprints from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') # customer blue_print from .customer import customer as customer_blueprint app.register_blueprint(customer_blueprint, url_prefix='/customer') # home blue_print from .home import home as home_blueprint app.register_blueprint(home_blueprint) # publisher blue_print from .publisher import publisher as publisher_blueprint app.register_blueprint(publisher_blueprint, url_prefix='/publisher') # home blue_print from .auth import account as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/account') from .social import social as account_blueprint app.register_blueprint(account_blueprint, url_prefix='/social_login') # csrf.exempt(api_blueprint) return app