def install(cls, app): """Install the extension into the application.""" Environment.resolver_class = InvenioResolver env = Environment(app) env.url = "{0}/{1}/".format(app.static_url_path, app.config["ASSETS_BUNDLES_DIR"]) env.directory = os.path.join(app.static_folder, app.config["ASSETS_BUNDLES_DIR"]) env.append_path(app.static_folder) env.auto_build = app.config.get("ASSETS_AUTO_BUILD", True) # The filters less and requirejs don't have the same behaviour by # default. Make sure we are respecting that. app.config.setdefault("REQUIREJS_RUN_IN_DEBUG", False) # Fixing some paths as we forced the output directory with the # .directory app.config.setdefault("REQUIREJS_BASEURL", app.static_folder) requirejs_config = os.path.join(env.directory, app.config["REQUIREJS_CONFIG"]) if not os.path.exists(requirejs_config): app.config["REQUIREJS_CONFIG"] = os.path.relpath( os.path.join(app.static_folder, app.config["REQUIREJS_CONFIG"]), env.directory) app.jinja_env.add_extension(BundleExtension) app.context_processor(BundleExtension.inject)
def install(cls, app): """Install the extension into the application.""" Environment.resolver_class = InvenioResolver env = Environment(app) env.url = "{0}/{1}/".format(app.static_url_path, app.config["ASSETS_BUNDLES_DIR"]) env.directory = os.path.join(app.static_folder, app.config["ASSETS_BUNDLES_DIR"]) env.append_path(app.static_folder) env.auto_build = app.config.get("ASSETS_AUTO_BUILD", True) # The filters less and requirejs don't have the same behaviour by # default. Make sure we are respecting that. app.config.setdefault("LESS_RUN_IN_DEBUG", True) app.config.setdefault("REQUIREJS_RUN_IN_DEBUG", False) # Fixing some paths as we forced the output directory with the # .directory app.config.setdefault("REQUIREJS_BASEURL", app.static_folder) requirejs_config = os.path.join(env.directory, app.config["REQUIREJS_CONFIG"]) if not os.path.exists(requirejs_config): app.config["REQUIREJS_CONFIG"] = os.path.relpath( os.path.join(app.static_folder, app.config["REQUIREJS_CONFIG"]), env.directory) app.jinja_env.add_extension(BundleExtension) app.context_processor(BundleExtension.inject)
def 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) moment.init_app(app) rq.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(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 .task import task as task_blueprint app.register_blueprint(task_blueprint, url_prefix='/task') if config_name == 'production': from app.jobs.doc_cache import doc_cache # Create cron jobs doc_cache.cron('0 0 12 * * *', 'cache_job') @rq.exception_handler def send_alert_to_ops(job, *exc_info): print(job) print(exc_info) return app
def register_assets(app): assets = Environment(app) assets.url = app.static_url_path assets.directory = app.static_folder assets.append_path('assets') scss = Bundle('scss/main.scss', filters='pyscss', output='main.css', depends=('scss/*.scss')) assets.register('scss_all', scss)
def create_app(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 init_assets(app): coffee_bundle = Bundle( *coffeeScripts, filters='coffeescript', output='js/coffee.js') js_bundle = Bundle( #lib_js_bundle, coffee_bundle, #filters='yui_js', output='js/main.min.js') clientCoffee = Bundle( *clientCoffeeScripts, filters='coffeescript', output='js/client.v1.js') # FIXME - still don't understand why these JS bundles arent compiling .... clientJs = Bundle( #lib_js_bundle, clientCoffee, #filters='yui_js', output='js/client.min.js') #app.config['ASSETS_DEBUG'] = settings.DEBUG app.config['ASSETS_DEBUG'] = False flaskAssets = Environment(app) print 'assets dir is: ', flaskAssets.directory print 'root path: ', app.root_path flaskAssets.append_path(app.root_path+'/app') flaskAssets.append_path(app.static_folder) flaskAssets.config['PYSCSS_STATIC_ROOT'] = join(STATIC_FOLDER, 'scss') flaskAssets.config['PYSCSS_STATIC_URL'] = join(STATIC_FOLDER, 'css/main.css') flaskAssets.config['PYSCSS_DEBUG'] = app.debug flaskAssets.register('css', css_bundle) flaskAssets.register('coffee', coffee_bundle) flaskAssets.register('js', js_bundle) flaskAssets.register('clientcoffee', clientCoffee) #flaskAssets.register('clientjs', clientJs) # webassets.manifest = 'cache' if not app.debug else False # webassets.cache = not app.debug #flaskAssets.cache = False flaskAssets.debug = app.debug #flaskAssets.debug = False for bundle, name in externalBundles: flaskAssets.register(name, bundle)
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_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 .participant import participant as participant_blueprint app.register_blueprint(participant_blueprint, url_prefix='/participant') return app
def create_app(): app = Flask(__name__) bcrypt.init_app(app) config_name = os.environ.get('FLASK_ENV', 'production') config = config_map[config_name] app.config.from_object(config) config.init_app(app) db.init_app(app) login_manager.init_app(app) register_template_filters(app) register_context_processors(app) assets_env = Environment(app) assets_env.append_path(os.path.join(basedir, 'assets/scripts')) assets_env.append_path(os.path.join(basedir, 'assets/styles')) assets_env.append_path(os.path.join(basedir, 'assets/vendor')) assets_env.url_expire = True assets_env.register('app_css', assets.app_css) assets_env.register('app_js', assets.app_js) assets_env.register('vendor_css', assets.vendor_css) assets_env.register('vendor_js', assets.vendor_js) from app.main import main as main_blueprint app.register_blueprint(main_blueprint) from app.usuario import usuario as usuario_blueprint app.register_blueprint(usuario_blueprint, url_prefix='/usuarios') from app.porto import porto as porto_blueprint app.register_blueprint(porto_blueprint, url_prefix='/portos') from app.empresa import empresa as empresa_blueprint app.register_blueprint(empresa_blueprint, url_prefix='/empresas') from app.relatorio import relatorio as relatorio_blueprint app.register_blueprint(relatorio_blueprint, url_prefix='/relatorios') from app.navio import navio as navio_blueprint app.register_blueprint(navio_blueprint, url_prefix='/navios') from app.viagem import viagem as navio_blueprint app.register_blueprint(navio_blueprint, url_prefix='/viagens') 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_enviroment): app = Flask(__name__) app.config.from_object(config[config_enviroment]) db.init_app(app) login_manager.init_app(app) csrf.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) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # not using sqlalchemy event system, hence disabling it config[config_enviroment].init_app(app) # Create app blueprints from app.main import main_bp app.register_blueprint(main_bp) from app.account import account_bp app.register_blueprint(account_bp, url_prefix='/account') return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) # not using sqlalchemy education 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) # jwt.init_app(app) compress.init_app(app) # RQ(app) cors.init_app(app, resources={r"/v1/*": {"origins": "*"}}) # configure_uploads(app, [photos, docs]) # patch_request_class(app, 10 * 1024 * 1024) # swagger.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 # 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 .api.blockchain import blockchain as blockchain_blueprint app.register_blueprint(blockchain_blueprint, url_prefix='/v1/vote') return app
migrate = Migrate(app, db) ma = Marshmallow(app) manager = Manager(app) manager.add_command('runserver', Server()) manager.add_command( 'shell', Shell(make_context=lambda: { 'app': app, 'db_session': db_session })) manager.add_command('db', MigrateCommand) manager.add_command('init', Init()) environment = Environment(app) environment.append_path(str(cwd / 'static')) environment.append_path(str(cwd / 'bower_components')) version = subprocess.check_output(['git', 'describe', '--tags', '--always'], cwd=str(cwd)).decode( sys.stdout.encoding).strip() app.config['SECRET_KEY'] = config['SECRET_KEY'] app.config['SESSION_PROTECTION'] = 'strong' app.config['SOCIAL_AUTH_LOGIN_URL'] = '/login' app.config['SOCIAL_AUTH_LOGIN_REDIRECT_URL'] = '/?logged_in=1' app.config['SOCIAL_AUTH_USER_MODEL'] = 'models.User' app.config['SOCIAL_AUTH_AUTHENTICATION_BACKENDS'] = ( 'social_core.backends.google.GoogleOAuth2', ) app.config['SOCIAL_AUTH_FIELDS_STORED_IN_SESSION'] = ['keep'] app.config['SOCIAL_AUTH_GOOGLE_OAUTH2_AUTH_EXTRA_ARGUMENTS'] = {
class TestUrlAndDirectory(TempEnvironmentHelper): """By default, the 'url' and 'directory' settings of webassets are not used in Flask-Assets; that is, the values are automatically handled based on the configuration of the Flask app and the modules used. The user can disable the automatic handling by setting these values if he needs to for some reason. Let's test the different scenarios to ensure everything works. """ def setup(self): TempEnvironmentHelper.setup(self) self.app = Flask(__name__, static_path='/app_static') from tests import test_module if not Blueprint: self.module = Module(test_module.__name__, name='module', static_path='/mod_static') self.app.register_module(self.module) else: self.blueprint = Blueprint('module', test_module.__name__, static_url_path='/mod_static', static_folder='static') self.app.register_blueprint(self.blueprint) self.env = Environment(self.app) def test_config_values_not_set_by_default(self): assert not 'directory' in self.env.config assert not 'url' in self.env.config assert_raises(KeyError, self.env.config.__getitem__, 'directory') assert_raises(KeyError, self.env.config.__getitem__, 'url') def test_directory_auto(self): """Test how we resolve file references through the Flask static system by default (if no custom 'env.directory' etc. values have been configured manually). """ assert not 'directory' in self.env.config root = self.app.root_path assert get_all_bundle_files(Bundle('foo'), self.env) == [root + '/static/foo'] # Modules prefixes in paths are handled specifically. assert get_all_bundle_files(Bundle('module/bar'), self.env) == [root + '/test_module/static/bar'] # Prefixes that aren't valid module names are just considered # subfolders of the main app. assert get_all_bundle_files(Bundle('nomodule/bar'), self.env) == [root + '/static/nomodule/bar'] # In case the name of a app-level subfolder conflicts with a # module name, you can always use this hack: assert get_all_bundle_files(Bundle('./module/bar'), self.env) == [root + '/static/module/bar'] # Custom static folder self.app.static_folder = '/' assert get_all_bundle_files(Bundle('foo'), self.env) == ['/foo'] def test_url_auto(self): """Test how urls are generated via the Flask static system by default (if no custom 'env.url' etc. values have been configured manually). """ assert not 'url' in self.env.config assert Bundle('foo', env=self.env).urls() == ['/app_static/foo'] # Urls for files that point to a module use that module's url prefix. assert Bundle('module/bar', env=self.env).urls() == ['/mod_static/bar'] # Try with a prefix that's not actually a valid module assert Bundle('nomodule/bar', env=self.env).urls() == ['/app_static/nomodule/bar'] # [Regression] Ensure that any request context we may have added # to the stack has been removed. from flask import _request_ctx_stack assert _request_ctx_stack.top is None def test_custom_load_path(self): """A custom load_path is configured - this will affect how we deal with source files. """ self.env.append_path(self.tempdir, '/custom/') self.create_files(['foo', 'module/bar']) assert get_all_bundle_files(Bundle('foo'), self.env) == [self.path('foo')] # We do not recognize references to modules. assert get_all_bundle_files(Bundle('module/bar'), self.env) == [self.path('module/bar')] assert Bundle('foo', env=self.env).urls() == ['/custom/foo'] assert Bundle('module/bar', env=self.env).urls() == ['/custom/module/bar'] # [Regression] With a load path configured, generating output # urls still works, and it still uses the flask system. self.env.debug = False self.env.url_expire = False assert Bundle('foo', output='out', env=self.env).urls() == ['/app_static/out'] def test_custom_directory_and_url(self): """Custom directory/url are configured - this will affect how we deal with output files.""" # Create source source file, make it findable (by default, # static_folder) is set to a fixed subfolder of the test dir (why?) self.create_files({'a': ''}) self.app.static_folder = self.tempdir # Setup custom directory/url pair for output self.env.directory = self.tempdir self.env.url = '/custom' self.env.debug = False # Return build urls self.env.url_expire = False # No query strings assert Bundle('a', output='foo', env=self.env).urls() == ['/custom/foo'] # We do not recognize references to modules. assert Bundle('a', output='module/bar', env=self.env).urls() == ['/custom/module/bar'] def test_existing_request_object_used(self): """[Regression] Check for a bug where the url generation code of Flask-Assets always added a dummy test request to the context stack, instead of using the existing one if there is one. We test this by making the context define a custom SCRIPT_NAME prefix, and then we check if it affects the generated urls, as it should. """ with self.app.test_request_context( '/', environ_overrides={'SCRIPT_NAME': '/yourapp'}): assert Bundle('foo', env=self.env).urls() == ['/yourapp/app_static/foo'] def test_glob(self): """Make sure url generation works with globs.""" self.app.static_folder = self.tempdir self.create_files({'a.js': 'foo', 'b.js': 'bar'}) assert list(sorted(self.mkbundle('*.js', env=self.env).urls())) == [ '/app_static/a.js', '/app_static/b.js']
# Set up extensions mail.init_app(app) db.init_app(app) login_manager.init_app(app) csrf.init_app(app) compress.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)
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): 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]) 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): 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_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.jinja_loader = my_loader db = SQLAlchemy(app) Markdown(app, extensions=['footnotes']) pages = FlatPages(app) manager = Manager(app) # Scss assets = Environment(app) assets.url_expire = True assets.auto_build = True assets.append_path('sni/assets') assets.cache = 'sni/assets/.webassets-cache' scss = Bundle('scss/__main__.scss', filters='pyscss', output='css/main.css', depends=['scss/*.scss']) assets.register('scss_all', scss) assets.debug = False app.config['ASSETS_DEBUG'] = False cache = Cache(app, config={'CACHE_TYPE': 'simple'}) if not app.debug: import logging
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__) 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
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
'sni/templates/podcast/']), ]) app.jinja_loader = my_loader db = SQLAlchemy(app) Markdown(app, extensions=['footnotes']) pages = FlatPages(app) manager = Manager(app) # Scss assets = Environment(app) assets.url_expire = True assets.auto_build = True assets.append_path('sni/assets') assets.cache = 'sni/assets/.webassets-cache' scss = Bundle('scss/__main__.scss', filters='pyscss', output='css/main.css', depends=['scss/*.scss']) assets.register('scss_all', scss) assets.debug = False app.config['ASSETS_DEBUG'] = False cache = Cache(app, config={'CACHE_TYPE': 'simple'}) if not app.debug: import logging from logging.handlers import RotatingFileHandler file_handler = RotatingFileHandler('tmp/snilog.csv',
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
class TestUrlAndDirectory(TempEnvironmentHelper): """By default, the 'url' and 'directory' settings of webassets are not used in Flask-Assets; that is, the values are automatically handled based on the configuration of the Flask app and the modules used. The user can disable the automatic handling by setting these values if he needs to for some reason. Let's test the different scenarios to ensure everything works. """ def setup(self): TempEnvironmentHelper.setup(self) self.app = Flask(__name__, static_path='/app_static') from tests import test_module if not Blueprint: self.module = Module(test_module.__name__, name='module', static_path='/mod_static') self.app.register_module(self.module) else: self.blueprint = Blueprint('module', test_module.__name__, static_url_path='/mod_static', static_folder='static') self.app.register_blueprint(self.blueprint) self.env = Environment(self.app) def test_config_values_not_set_by_default(self): assert not 'directory' in self.env.config assert not 'url' in self.env.config assert_raises(KeyError, self.env.config.__getitem__, 'directory') assert_raises(KeyError, self.env.config.__getitem__, 'url') def test_directory_auto(self): """Test how we resolve file references through the Flask static system by default (if no custom 'env.directory' etc. values have been configured manually). """ assert not 'directory' in self.env.config root = self.app.root_path assert get_all_bundle_files(Bundle('foo'), self.env) == [root + '/static/foo'] # Modules prefixes in paths are handled specifically. assert get_all_bundle_files(Bundle('module/bar'), self.env) == [ root + '/test_module/static/bar' ] # Prefixes that aren't valid module names are just considered # subfolders of the main app. assert get_all_bundle_files(Bundle('nomodule/bar'), self.env) == [ root + '/static/nomodule/bar' ] # In case the name of a app-level subfolder conflicts with a # module name, you can always use this hack: assert get_all_bundle_files(Bundle('./module/bar'), self.env) == [root + '/static/module/bar'] # Custom static folder self.app.static_folder = '/' assert get_all_bundle_files(Bundle('foo'), self.env) == ['/foo'] def test_url_auto(self): """Test how urls are generated via the Flask static system by default (if no custom 'env.url' etc. values have been configured manually). """ assert not 'url' in self.env.config assert Bundle('foo', env=self.env).urls() == ['/app_static/foo'] # Urls for files that point to a module use that module's url prefix. assert Bundle('module/bar', env=self.env).urls() == ['/mod_static/bar'] # Try with a prefix that's not actually a valid module assert Bundle('nomodule/bar', env=self.env).urls() == ['/app_static/nomodule/bar'] # [Regression] Ensure that any request context we may have added # to the stack has been removed. from flask import _request_ctx_stack assert _request_ctx_stack.top is None def test_custom_load_path(self): """A custom load_path is configured - this will affect how we deal with source files. """ self.env.append_path(self.tempdir, '/custom/') self.create_files(['foo', 'module/bar']) assert get_all_bundle_files(Bundle('foo'), self.env) == [self.path('foo')] # We do not recognize references to modules. assert get_all_bundle_files(Bundle('module/bar'), self.env) == [self.path('module/bar')] assert Bundle('foo', env=self.env).urls() == ['/custom/foo'] assert Bundle('module/bar', env=self.env).urls() == ['/custom/module/bar'] # [Regression] With a load path configured, generating output # urls still works, and it still uses the flask system. self.env.debug = False self.env.url_expire = False assert Bundle('foo', output='out', env=self.env).urls() == ['/app_static/out'] def test_custom_directory_and_url(self): """Custom directory/url are configured - this will affect how we deal with output files.""" # Create source source file, make it findable (by default, # static_folder) is set to a fixed subfolder of the test dir (why?) self.create_files({'a': ''}) self.app.static_folder = self.tempdir # Setup custom directory/url pair for output self.env.directory = self.tempdir self.env.url = '/custom' self.env.debug = False # Return build urls self.env.url_expire = False # No query strings assert Bundle('a', output='foo', env=self.env).urls() == ['/custom/foo'] # We do not recognize references to modules. assert Bundle('a', output='module/bar', env=self.env).urls() == ['/custom/module/bar'] def test_existing_request_object_used(self): """[Regression] Check for a bug where the url generation code of Flask-Assets always added a dummy test request to the context stack, instead of using the existing one if there is one. We test this by making the context define a custom SCRIPT_NAME prefix, and then we check if it affects the generated urls, as it should. """ with self.app.test_request_context( '/', environ_overrides={'SCRIPT_NAME': '/yourapp'}): assert Bundle('foo', env=self.env).urls() == ['/yourapp/app_static/foo'] def test_glob(self): """Make sure url generation works with globs.""" self.app.static_folder = self.tempdir self.create_files({'a.js': 'foo', 'b.js': 'bar'}) assert list(sorted(self.mkbundle('*.js', env=self.env).urls())) == [ '/app_static/a.js', '/app_static/b.js' ]