def create_app(config_object, env):
'''An application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
:param config_object: The configuration object to use.
:param env: A string, the current environment. Either "dev" or "prod"
'''
app = Flask(__name__)
app.config.from_object(config_object)
app.config['ENV'] = env
# Initialize SQLAlchemy
db.init_app(app)
# Register bcrypt
bcrypt.init_app(app)
# Register asset bundles
assets_env.init_app(app)
assets_loader = PythonLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# Register blueprints
from flask_boilerplate.modules import public, member
app.register_blueprint(public.blueprint)
app.register_blueprint(member.blueprint)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. zeus.settings.ProdConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
"""
app = Flask(__name__, static_url_path='/static')
app.config.from_object(object_name)
db.init_app(app)
login_manager.init_app(app)
mail.init_app(app)
# Import and register the different assets bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# Loading the Blueprint in controllers defined by main.py - Handles routing
app.register_blueprint(main_blueprint)
app.register_blueprint(user_blueprint)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# FIXME: init arango
# db.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(authors)
return app
def includeme(config):
config.include('pyramid_webassets')
env = config.get_webassets_env()
# Configure the static views
if env.url_expire is not False:
# Cache for one year (so-called "far future" Expires)
config.add_static_view(env.url, env.directory, cache_max_age=31536000)
else:
config.add_static_view(env.url, env.directory)
# Set up a predicate and subscriber to set CORS headers on asset responses
config.add_subscriber_predicate('asset_request', AssetRequest)
config.add_subscriber(asset_response_subscriber,
pyramid.events.NewResponse,
asset_request=True)
loader = PythonLoader(config.registry.settings.get('h.assets', __name__))
bundles = loader.load_bundles()
for bundle_name in bundles:
log.info('name: ' + str(bundle_name))
config.add_webasset(bundle_name, bundles[bundle_name])
from deform.field import Field
resource_registry = WebassetsResourceRegistry(config.get_webassets_env())
Field.set_default_resource_registry(resource_registry)
config.registry.resources = resource_registry
def create_app(config_object, env):
'''An application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
:param config_object: The configuration object to use.
:param env: A string, the current environment. Either "dev" or "prod"
'''
app = Flask(__name__)
app.config.from_object(config_object)
app.config['ENV'] = env
# Initialize SQLAlchemy
db.init_app(app)
# Register bcrypt
bcrypt.init_app(app)
# Register asset bundles
assets_env.init_app(app)
assets_loader = PythonLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# Register blueprints
from flask_boilerplate.modules import public, member
app.register_blueprint(public.blueprint)
app.register_blueprint(member.blueprint)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. resrv.settings.ProdConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
humanize.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
return app
def create_app(object_name, env="prod"):
"""
A flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Inputs: ::\n
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config['ENV'] = env
# Init the cache
cache.init_app(app)
# Init debug toolbar
debug_toolbar.init_app(app)
# Init Mongo engine
# mongoengine.connect(config.MONGODB_FRONTEND_DB_NAME, host=config.MONGODB_HOST, port=config.MONGODB_PORT)
app.config['MONGODB_DB'] = config.MONGODB_FRONTEND_DB_NAME
app.config['MONGODB_HOST'] = config.MONGODB_HOST
app.config['MONGODB_PORT'] = config.MONGODB_PORT
db.init_app(app)
# Init login_manager
login_manager.init_app(app)
login_manager.login_view = "main.login"
login_manager.refresh_view = "main.login"
# Init current to track current project/experiment
current.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# register all the blueprints
from controllers import (main, error, dashboard, new_experiment,
new_project, account_settings, project,
experiment, targets, setup)
app.register_blueprint(main)
app.register_blueprint(error, url_prefix="/error")
app.register_blueprint(dashboard, url_prefix="/dashboard")
app.register_blueprint(new_experiment, url_prefix="/new_experiment")
app.register_blueprint(new_project, url_prefix="/new_project")
app.register_blueprint(account_settings, url_prefix="/account_settings")
app.register_blueprint(project, url_prefix="/project")
app.register_blueprint(experiment, url_prefix="/experiment")
app.register_blueprint(targets, url_prefix="/targets")
app.register_blueprint(setup, url_prefix="/setup")
return app
def _setup_assets_bundler(app):
assets.init_app(app)
# Loads and registers assets bundles
bundles = PythonLoader("assets_bundles").load_bundles()
for name, bundle in bundles.iteritems():
assets.register(name, bundle)
def create_app(object_name='bosphorus.settings', env='dev'):
app = create_barebones_app(object_name, env)
# Import and register the different asset bundles
assets_env = Environment()
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# register our blueprints
from controllers.main import main
from controllers.user import user
from controllers.studies import studies
from controllers.person import person
from controllers.protocol import protocol
from utils import proxy
app.register_blueprint(main)
app.register_blueprint(user)
app.register_blueprint(person)
app.register_blueprint(studies)
app.register_blueprint(protocol)
app.register_blueprint(proxy)
return app
def create_app(object_name, env="dev"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. mobsec.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config['ENV'] = env
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
return app
def create_app(object_name, env="prod"):
app = Flask(__name__)
app.config.from_object(object_name)
app.config['ENV'] = env
db.init_app(app)
mail.init_app(app)
security = Security(app, user_datastore)
@security.context_processor
def security_context_processor():
return dict(admin_base_template=admin.base_template,
admin_view=admin.index_view,
h=admin_helpers)
admin.init_app(app)
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
with app.app_context():
register_models()
import pacioli.views.admin_views
import pacioli.views.bookkeeping_views
import pacioli.views.accounting_views
import pacioli.views.ofx_views
import pacioli.views.amazon_views
import pacioli.views.payroll_views
return app
def create_app():
app = Flask(__name__)
prod = True
if prod:
app.config.from_object('settings.ProdConfig')
app.config['ENV'] = 'prod'
app.config['DEBUG'] = False
# initialize the cache
# cache.init_app(app)
else:
app.config.from_object('settings.DevConfig')
app.config['ENV'] = 'dev'
app.config['DEBUG'] = True
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles (see templates)
assets_env.init_app(app)
assets_loader = AssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# if not prod:
# print 'bundle=%s' % name
return app
def register_extensions(app):
# initialize SQLAlchemy
db.init_app(app)
# initialize the cache
cache.init_app(app)
# initialize security
ds = SQLAlchemyUserDatastore(db, User, Role)
security.init_app(app, datastore=ds,
register_form=forms.ExtendedRegisterForm)
# initialize bootstrap resource
bootstrap.init_app(app)
# initialize the debug tool bar
#debug_toolbar.init_app(app)
# Initialize social
social_ds = SQLAlchemyConnectionDatastore(db, Connection)
social.init_app(app, social_ds)
#Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
return None
def includeme(config):
config.include('pyramid_webassets')
env = config.get_webassets_env()
# Configure the static views
if env.url_expire is not False:
# Cache for one year (so-called "far future" Expires)
config.add_static_view(env.url, env.directory, cache_max_age=31536000)
else:
config.add_static_view(env.url, env.directory)
# Set up a predicate and subscriber to set CORS headers on asset responses
config.add_subscriber_predicate('asset_request', AssetRequest)
config.add_subscriber(
asset_response_subscriber,
pyramid.events.NewResponse,
asset_request=True
)
loader = PythonLoader(config.registry.settings.get('h.assets', __name__))
bundles = loader.load_bundles()
for bundle_name in bundles:
log.info('name: ' + str(bundle_name))
config.add_webasset(bundle_name, bundles[bundle_name])
from deform.field import Field
resource_registry = WebassetsResourceRegistry(config.get_webassets_env())
Field.set_default_resource_registry(resource_registry)
config.registry.resources = resource_registry
def create_app(object_name, env="prod"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config['ENV'] = env
#init the cache
cache.init_app(app)
#init SQLAlchemy
db.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# register our blueprints
from controllers.main import main
app.register_blueprint(main)
return app
def create_app():
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. hummingbirdexport.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
return app
def get_bundles():
"""Returns all registered bundles.
.. note:: Returns only bundles from the assets module, you shouldn't register them anywhere else
"""
loader = PythonAssetsLoader(__name__)
return loader.load_bundles()
def test_load_bundles(self):
import types
module = types.ModuleType('test')
module.foo = Bundle('bar')
loader = PythonLoader(module)
bundles = loader.load_bundles()
assert len(bundles) == 1
assert list(bundles.values())[0].contents[0] == 'bar'
def test_load_bundles(self):
import types
module = types.ModuleType('test')
module.foo = Bundle('bar')
loader = PythonLoader(module)
bundles = loader.load_bundles()
assert len(bundles) == 1
assert list(bundles.values())[0].contents[0] == 'bar'
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. mothership.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
@app.before_first_request
def _run_on_start():
init_db()
csrf = CsrfProtect(app)
@app.template_filter('datetime')
def datetimeformat(value, format='%d/%m/%y %H:%M %p'):
return datetime.datetime.utcfromtimestamp(value).strftime(format)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
# debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(campaigns)
app.register_blueprint(graphs)
app.register_blueprint(fuzzers)
csrf.exempt(fuzzers)
try:
os.mkdir(app.config['DATA_DIRECTORY'])
except FileExistsError:
pass
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. mothership.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
@app.before_first_request
def _run_on_start():
init_db()
csrf = CsrfProtect(app)
@app.template_filter('datetime')
def datetimeformat(value, format='%d/%m/%y %H:%M %p'):
return datetime.datetime.utcfromtimestamp(value).strftime(format)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
# debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(campaigns)
app.register_blueprint(graphs)
app.register_blueprint(fuzzers)
csrf.exempt(fuzzers)
try:
os.mkdir(app.config['DATA_DIRECTORY'])
except FileExistsError:
pass
return app
def _configure_assets(app):
from flask.ext.assets import Environment
assets = Environment(app)
pyload = PythonLoader('config.assets')
bundles = pyload.load_bundles()
assets.register('main_js', bundles['main_js'])
assets.register('main_css', bundles['main_css'])
def create_app(config='', **config_kwargs):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
config: the path of config file
config_kwargs: overrides
Default config read from flocka/config_default.py
See FiftyFlask docs
"""
app = Flask(__name__)
config = config if os.path.isfile(config) else None
app.configure(config, **config_kwargs)
# Cache
cache.init_app(app)
# Logging
app.logger.addHandler(logging.StreamHandler(sys.stderr))
# Debug toolbar
debug_toolbar.init_app(app)
# SQLAlchemy
db.init_app(app)
# Flask Login
login_manager.init_app(app)
# FiftyTables
FiftyTables(app)
# Alembic
migrate.init_app(app, db)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# Register our blueprints
from controllers import main, branches
app.register_blueprint(main.main_bp)
app.register_blueprint(branches.branched_bp)
# Jinja extensions
app.jinja_env.add_extension('jinja2.ext.do')
app.jinja_env.add_extension('jinja2.ext.loopcontrols')
return app
def create_app(config='', **config_kwargs):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
config: the path of config file
config_kwargs: overrides
Default config read from appname/config_default.py
See FiftyFlask docs
"""
app = Flask(__name__)
config = config if os.path.isfile(config) else None
app.configure(config, **config_kwargs)
# Cache
cache.init_app(app)
# Logging
app.logger.addHandler(logging.StreamHandler(sys.stderr))
# Debug toolbar
debug_toolbar.init_app(app)
# SQLAlchemy
db.init_app(app)
# Flask Login
login_manager.init_app(app)
# FiftyTables
FiftyTables(app)
# Alembic
migrate.init_app(app, db)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# Register our blueprints
from controllers import main, widgets
app.register_blueprint(main.main_bp)
app.register_blueprint(widgets.widgets_bp)
# Jinja extensions
app.jinja_env.add_extension('jinja2.ext.do')
app.jinja_env.add_extension('jinja2.ext.loopcontrols')
return app
def load_bundles(self, module):
"""
Load predefined bundles from a YAML file.
See bundles.yaml for an example.
"""
# Load bundles from YAML file
loader = PythonLoader(module)
bundles = loader.load_bundles()
# Register the bundles with the environment
self.register(bundles)
def load_bundles(self, module):
"""
Load predefined bundles from a YAML file.
See bundles.yaml for an example.
"""
# Load bundles from YAML file
loader = PythonLoader(module)
bundles = loader.load_bundles()
# Register the bundles with the environment
self.register(bundles)
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. impression.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
if cache:
# initialize the cache
cache.init_app(app)
if debug_toolbar:
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
if assets_env:
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
main_controller.before_request(before_app_request)
app.register_blueprint(main_controller)
admin_controller.before_request(before_app_request)
app.register_blueprint(admin_controller)
file_controller.before_request(before_app_request)
app.register_blueprint(file_controller)
# Add theme support
# themes2.init_themes(app, app_identifier="...")
themes2.init_themes(app, app_identifier='impression')
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. pele.settings.ProductionConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config.from_pyfile('../settings.cfg') # override
# register converters
app.url_map.converters['list'] = ListConverter
# set debug logging level
if app.config.get('DEBUG', False):
app.logger.setLevel(logging.DEBUG)
cors.init_app(app)
app.wsgi_app = ReverseProxied(app.wsgi_app, app.config)
app.es_client = get_es_client(app.config)
app.es_util = QueryES(app.es_client, logger=app.logger)
# init extensions
cache.init_app(app)
debug_toolbar.init_app(app)
bcrypt.init_app(app)
db.init_app(app)
login_manager.init_app(app)
limiter.init_app(app)
mail.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in list(assets_loader.load_bundles().items()):
assets_env.register(name, bundle)
# register our blueprints
from .controllers.main import main
app.register_blueprint(main)
from .controllers.api_v01 import services as api_v01
app.register_blueprint(api_v01)
app.register_blueprint(apidoc.apidoc)
return app
def create_app(environment_name='dev'):
app = Flask(__name__)
config = configurations[environment_name]
app.config.from_object(config)
db.init_app(app)
csrf.init_app(app)
# need render_as_batch to correctly generate migrations for sqlite
migrate.init_app(app, db, render_as_batch=True)
login_manager.init_app(app)
mail.init_app(app)
checkout.init_app(app)
assets_env.init_app(app)
rq2.init_app(app)
debug_toolbar.init_app(app)
cache.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
if app.config["SENTRY_DSN"]: # pragma: no cover
sentry_sdk.init(dsn=app.config["SENTRY_DSN"],
integrations=[
FlaskIntegration(),
SqlalchemyIntegration(),
RqIntegration()
])
@app.errorhandler(401)
def unauthorized_error(error):
return render_template('errors/401.html'), 401 # pragma: no cover
@app.errorhandler(404)
def not_found_error(error):
return render_template('errors/404.html'), 404
@app.errorhandler(500)
def internal_error(error):
return render_template('errors/500.html'), 500 # pragma: no cover
app.register_blueprint(product_bp, url_prefix='/product')
app.register_blueprint(store_bp)
app.register_blueprint(user_bp)
app.register_blueprint(checkout_bp)
app.register_blueprint(landing_bp)
# Admin tools
app.register_blueprint(rq_blueprint, url_prefix="/rq")
csrf.exempt(rq_blueprint)
return app
def register_extensions(app):
# init the cache
cache.init_app(app)
# init debug toolbar
debug_toolbar.init_app(app)
# init SQLAlchemy
db.init_app(app)
# init login manager
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
"""
app = Flask(__name__)
@app.route('/uploads/<filename>')
def uploaded_file(filename):
return send_from_directory('/home/ahmad/workspace/python/Flask-CRUD/uploads/', filename)
Bootstrap(app)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
db.app = app
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
with app.app_context():
assets_env.load_path = [
os.path.join(os.path.join(os.path.dirname(__file__), os.pardir), 'node_modules'),
os.path.join(os.path.dirname(__file__), 'static'),
]
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(categories)
app.register_blueprint(products)
app.register_blueprint(catalogs)
return app
def create_app(object_name, env="prod"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. ivy_3dprint_site.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config['ENV'] = env
#init the cache
cache.init_app(app)
#init SQLAlchemy
db.init_app(app)
#int Flask-admin
admin = Admin(app)
from controllers.admin import UserView, ProductView
from models import User, Tag, Lang, Photo, Product, \
File, Sample, Contact, About
from forms import CKTextAdmin
admin.add_view(UserView(User))
admin.add_view(ModelView(Tag))
admin.add_view(ModelView(Lang))
admin.add_view(ModelView(Photo))
admin.add_view(ModelView(File))
admin.add_view(ProductView(Product))
admin.add_view(CKTextAdmin(Sample))
admin.add_view(CKTextAdmin(Contact))
admin.add_view(CKTextAdmin(About))
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# register our blueprints
from controllers.main import main
app.register_blueprint(main)
return app
def create_app(object_name, env="prod"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config['ENV'] = env
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
mail = Mail(app)
security = Security(app, user_datastore)
@security.context_processor
def security_context_processor():
return dict(
admin_base_template=admin.base_template,
admin_view=admin.index_view,
h=admin_helpers,
)
admin.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
return app
def create_app(object_name, env="prod"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
upload_path = os.path.join(app.instance_path, app.config["SILVERFLASK_UPLOAD_FOLDER"])
app.config["SILVERFLASK_ABSOLUTE_UPLOAD_PATH"] = upload_path
app.storage_backend = LocalFileStorageBackend(upload_path)
app.config['ENV'] = env
db.init_app(app)
logger.debug("DB Initialized")
# init the cache
cache.init_app(app)
debug_toolbar.init_app(app)
from silverflask.models import User
user_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(user_adapter, app)
user_manager.enable_login_without_confirm_email = True
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in list(assets_loader.load_bundles().items()):
assets_env.register(name, bundle)
# register our blueprints
from silverflask.controllers.main import main
from silverflask.controllers.main import setup_processors
setup_processors(app)
from silverflask.controllers.cms import bp as cms_bp
app.register_blueprint(main)
app.register_blueprint(cms_bp, url_prefix='/admin')
with app.app_context():
db.create_all()
return app
def create_app(environment_name='dev'):
app = Flask(__name__)
app.config.from_object(configurations[environment_name])
# init extensions
db.init_app(app)
csrf.init_app(app)
login_manager.init_app(app)
migrate.init_app(app, db, render_as_batch=True)
mail.init_app(app)
checkout.init_app(app)
rq2.init_app(app)
debug_toolbar.init_app(app)
cache.init_app(app)
# assets bundling
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register blueprints
app.register_blueprint(products, url_prefix="/product")
app.register_blueprint(user_bp)
app.register_blueprint(store_bp)
app.register_blueprint(checkout_bp)
app.register_blueprint(landing_bp)
app.register_blueprint(rq_blueprint, url_prefix="/rq")
# errors monitoring
if app.config.get("SENTRY_DSN"):
sentry_sdk.init(
dsn=app.config["SENTRY_DSN"],
integrations=[FlaskIntegration(), SqlalchemyIntegration()]
)
# errors handling
@app.errorhandler(401)
def unauthorized_error(error):
return render_template('errors/401.html'), 401
@app.errorhandler(404)
def not_found_error(error):
return render_template('errors/404.html'), 404
@app.errorhandler(500)
def internal_error(error):
return render_template('errors/500.html'), 500
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config_name)
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
login_manager.init_app(app)
app.register_blueprint(main)
app.register_blueprint(admin, url_prefix='/admin')
return app
def create_app(environment_name='dev'):
app = Flask(__name__)
app.config.from_object(configurations[environment_name])
db.init_app(app)
csrf.init_app(app)
login_manager.init_app(app)
migrate.init_app(app, db, render_as_batch=True)
# mail.init_app(app)
checkout.init_app(app)
assets_env.init_app(app)
rq2.init_app(app)
debug_toolbar.init_app(app)
cache.init_app(app)
if app.config.get('SENTRY_DSN'):
sentry_sdk.init(
dsn=app.config['SENTRY_DSN'],
integrations=[FlaskIntegration(),
SqlalchemyIntegration()],
send_default_pii=True,
traces_sample_rate=1.0) # pragma: no cover
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
app.register_blueprint(products, url_prefix='/product')
app.register_blueprint(user_bp)
app.register_blueprint(store_bp, url_prefix='/store')
app.register_blueprint(checkout_bp)
app.register_blueprint(landing_bp)
app.register_blueprint(rq_blueprint, url_prefix='/rq')
csrf.exempt(rq_blueprint)
@app.errorhandler(401)
def unauthorized_error(error):
return render_template('errors/401.html'), 401 # pragma: no cover
@app.errorhandler(404)
def not_found_error(error):
return render_template('errors/404.html'), 404
@app.errorhandler(500)
def internal_error(error):
return render_template('errors/500.html'), 500 # pragma: no cover
return app
def create_app(object_name, env="prod"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. neogameserver.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config["ENV"] = env
admin = Admin(app, name="neogameserver", template_mode="bootstrap3")
admin.add_view(NeoModelView(User, db.session))
admin.add_view(NeoModelView(Subscription, db.session))
admin.add_view(NeoModelView(MinecraftProduct, db.session))
admin.add_view(NeoModelView(VentriloProduct, db.session))
admin.add_view(NeoModelView(OrderProduct, db.session))
admin.add_view(NeoModelView(HostServer, db.session))
admin.add_view(NeoModelView(Port, db.session))
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(adminviews)
return app
def create_app(object_name):
app = Flask(__name__)
app.config.from_object(object_name)
cache.init_app(app)
debug_toolbar.init_app(app)
db.init_app(app)
login_manager.init_app(app)
assets_env.init_app(app)
assets_loader = PythonLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
app.register_blueprint(main)
return app
def test_path(self):
"""[bug] Regression test: Python loader does not leave
sys.path messed up.
"""
old_path = sys.path[:]
loader = PythonLoader('sys')
assert sys.path == old_path
def create_app(object_name, env="prod"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config['ENV'] = env
#init the cache
cache.init_app(app)
#init SQLAlchemy
db.init_app(app)
# connect to the database
mongo.init_app(app)
# init admin views
import flask.ext.admin
admin = flask.ext.admin.Admin(app, u'用户管理系统')
babel = Babel(app)
@babel.localeselector
def get_locale():
return 'zh'
with app.app_context():
admin.add_view(OperatorView(mongo.db.operator, u'专员管理'))
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# register our blueprints
from controllers.main import main
app.register_blueprint(main)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. {{cookiecutter.app_name}}.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
if cache:
# initialize the cache
cache.init_app(app)
if debug_toolbar:
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
if assets_env:
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
main_controller.before_request(before_app_request)
app.register_blueprint(main_controller)
admin_controller.before_request(before_app_request)
app.register_blueprint(admin_controller)
file_controller.before_request(before_app_request)
app.register_blueprint(file_controller)
return app
def run_flask():
app = Flask(__name__)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(keyphrases)
app.run(host="0.0.0.0", debug=True)
return app
def includeme(config):
config.include('pyramid_webassets')
config.add_static_view('css', 'h:css')
config.add_static_view('js', 'h:js')
config.add_static_view('lib', 'h:lib')
config.add_static_view('images', 'h:images')
loader = PythonLoader(config.registry.settings.get('h.assets', __name__))
bundles = loader.load_bundles()
for name in bundles:
config.add_webasset(name, bundles[name])
from deform.field import Field
resource_registry = WebassetsResourceRegistry(config.get_webassets_env())
Field.set_default_resource_registry(resource_registry)
config.registry.resources = resource_registry
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
# Fix for NginX
app.wsgi_app = ProxyFix(app.wsgi_app)
# initialize the cache
cache.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
mail.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(g)
app.register_blueprint(p)
app.register_blueprint(ev)
# configure uploads
configure_uploads(app, (
flyers,
press,
))
return app
def includeme(config):
config.include('pyramid_webassets')
config.add_static_view('css', 'h:css')
config.add_static_view('js', 'h:js')
config.add_static_view('lib', 'h:lib')
config.add_static_view('images', 'h:images')
loader = PythonLoader(config.registry.settings.get('h.assets', __name__))
bundles = loader.load_bundles()
for name in bundles:
config.add_webasset(name, bundles[name])
from deform.field import Field
resource_registry = WebassetsResourceRegistry(config.get_webassets_env())
Field.set_default_resource_registry(resource_registry)
config.registry.resources = resource_registry
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. {{cookiecutter.repo_name}}.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
#initialize CORS
CORS(app, resources={r"/*":{"origins":"*"}})
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
#initialize migration
migrate.init_app(app, db)
#initialize socket
# socketio.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(api)
return app
def configure_extensions(app):
db.init_app(app)
login_manager.setup_app(app)
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
@login_manager.user_loader
def load_user(userid):
return User.query.get(userid)
@app.before_request
def before_request():
g.user = current_user
def _setup_assets_env(self, ns, log):
env = self.env
if env is None:
assert not (ns.module and ns.config)
if ns.module:
env = PythonLoader(ns.module).load_environment()
if ns.config:
env = YAMLLoader(ns.config).load_environment()
return env
def create_app(object_name, env="prod"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. squall.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config["ENV"] = env
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# initialize MongoDB
mongo.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(algorithms, url_prefix="/algorithms")
app.register_blueprint(data, url_prefix="/data")
app.register_blueprint(experiments, url_prefix="/experiments")
app.register_blueprint(tags, url_prefix="/tags")
return app
def create_app(object_name, env="prod"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. fv_prov_es.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.wsgi_app = ReverseProxied(app.wsgi_app)
app.config.from_object(object_name)
app.config['ENV'] = env
#init extensions
cache.init_app(app)
debug_toolbar.init_app(app)
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# register our blueprints
from controllers.main import main
app.register_blueprint(main)
from controllers.services_v01 import services as services_v01
app.register_blueprint(services_v01)
from controllers.services_v02 import services as services_v02
app.register_blueprint(services_v02)
app.register_blueprint(apidoc.apidoc)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. trading.settings.ProdConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(portfolio, url_prefix="/api/v1")
app.register_blueprint(search, url_prefix="/api/v1")
app.register_blueprint(quotes, url_prefix="/api/v1")
api.init_app(app)
@app.errorhandler(404)
def page_not_found(e):
return app.send_static_file('index.html')
return app
def create_app(object_name, env="prod"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. fv_prov_es.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.wsgi_app = ReverseProxied(app.wsgi_app)
app.config.from_object(object_name)
app.config['ENV'] = env
#init extensions
cache.init_app(app)
debug_toolbar.init_app(app)
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# register our blueprints
from controllers.main import main
app.register_blueprint(main)
from controllers.services_v01 import services as services_v01
app.register_blueprint(services_v01)
from controllers.services_v02 import services as services_v02
app.register_blueprint(services_v02)
app.register_blueprint(apidoc.apidoc)
return app
def create_app(object_name, env="development"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
:argument string object_name: Object name
:argument string env: Environment
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config['ENV'] = env
configure_logging(app)
# init the cache
cache.init_app(app)
# init debug toolbar
debug_toolbar.init_app(app)
# init notifications object
notifications = Notifications()
notifications.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register index blueprint
from app.controllers.index import index
app.register_blueprint(index)
# register api blueprints
api_prefix = "/{0}".format(app.config['API_VERSION'])
from app.controllers.errors import errors
app.register_blueprint(errors, url_prefix=api_prefix)
from app.controllers.status import status
app.register_blueprint(status, url_prefix=api_prefix)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. flaskheartbeat.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
#API resources
api = Api(app)
api.add_resource(HeartbeatReceiver,
"/api/heartbeat/<string:deviceID>/<int:statuscode>")
return app
def create_app(object_name='bosphorus.settings', env='dev'):
app = Flask(__name__)
# set config
app.config.from_object(object_name)
app.config['ENV'] = env
app.config['DEBUG'] = False if env=="prod" else True
# register all custom jinja filters
for f in jinja_filters:
app.jinja_env.filters[f[0]] = f[1]
#init the cache
cache.init_app(app)
#init SQLAlchemy
db.init_app(app)
#init Orthanc
orthanc.init_app(app)
# Import and register the different asset bundles
assets_env = Environment()
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# register our blueprints
from controllers.main import main
from controllers.user import user
from controllers.studies import studies
from controllers.person import person
from utils import proxy
app.register_blueprint(main)
app.register_blueprint(user)
app.register_blueprint(person)
app.register_blueprint(studies)
app.register_blueprint(proxy)
return app
