def create_app():
app = Flask(__name__)
db.init_app(app)
app.register_blueprint(user, url_prefix="/api")
return app, db
def create_app(setting):
app = Flask(__name__, static_path='/static')
load_configs(app, setting)
register_blueprints(app)
db.init_app(app)
db.app = app
return app
def init_extensions(app):
db.init_app(app)
cors.init_app(app, resources={
r"/*": {
"origins": "*"
},
})
jwt.init_app(app)
ma.init_app(app)
def initialize_app(app):
log.info("Test log")
configure_app(app)
blueprint = Blueprint('api', __name__, url_prefix='/api')
api.init_app(blueprint)
api.add_namespace(interactions)
api.add_namespace(metadata)
app.register_blueprint(blueprint)
db.init_app(app)
log.info("finished initialize")
def register_extensions(app):
"""Register Flask extensions."""
cors.init_app(app)
webpack.init_app(app)
socketio.init_app(app, message_queue='redis://')
db.init_app(app)
if not get_debug_flag():
scheduler.init_app(app)
scheduler.start()
scheduler.run_job('missingcheck')
def initialize_app(flask_app):
configure_app(flask_app)
blueprint = Blueprint('api', __name__, url_prefix='/api')
api.init_app(blueprint)
api.add_namespace(blog_posts_namespace)
api.add_namespace(blog_categories_namespace)
flask_app.register_blueprint(blueprint)
db.init_app(flask_app)
def register_extensions(app):
heroku.init_app(app)
travis.init_app(app)
db.init_app(app)
api.init_app(app)
lm.init_app(app)
mail.init_app(app)
bcrypt.init_app(app)
celery.config_from_object(app.config)
assets.init_app(app)
def register_extensions(app):
travis.init_app(app)
db.init_app(app)
api.init_app(app)
lm.init_app(app)
mail.init_app(app)
bcrypt.init_app(app)
celery.config_from_object(app.config)
assets.init_app(app)
babel.init_app(app)
def create_app():
app = Flask(__name__, instance_relative_config=False)
app.config.from_object(config.DevConfig)
db.init_app(app)
redis_store.init_app(app)
from app.lost_and_found import lost_and_found
app.register_blueprint(lost_and_found)
return app
def register_extensions(app):
"""Register extensions with the Flask application."""
travis.init_app(app)
db.init_app(app)
lm.init_app(app)
mail.init_app(app)
bcrypt.init_app(app)
assets.init_app(app)
babel.init_app(app)
rq.init_app(app)
migrate.init_app(app, db)
def create_app(config=Config):
app = Flask(__name__)
app.config.from_object(config)
db.init_app(app)
ma.init_app(ma)
migrate.init_app(app, db)
from . import auditlog
app.register_blueprint(auditlog.bp, url_prefix='/api')
return app
def register_extensions(app):
"""Register extensions with the Flask application."""
travis.init_app(app)
db.init_app(app)
lm.init_app(app)
mail.init_app(app)
bcrypt.init_app(app)
assets.init_app(app)
babel.init_app(app)
rq.init_app(app)
migrate.init_app(app, db)
limiter.init_app(app)
def register_extensions(app: Flask):
"""Register Flask-Plugin modules"""
assets.init_app(app)
db.init_app(app)
cache.init_app(app)
mail.init_app(app)
migrate.init_app(app, db)
marshmallow.init_app(app)
login.init_app(app)
login.blueprint_login_views = {'auth': '/login'}
from app.blueprints.term import events # necessary for socketio
socketio.init_app(app, async_mode=None)
def setUp(self):
app.app.config['TESTING'] = True
self.db_fd, app.app.config['BASE_DIR'] = tempfile.mkstemp()
app.app.config[
'SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + app.app.config[
'BASE_DIR']
app.app.config['DEBUG'] = False
self.app = app.app.test_client()
with app.app.app_context():
db.init_app(app.app)
db.create_all()
def create_app(config=Config):
app = Flask(__name__)
app.config.from_object(config)
db.init_app(app)
migrate.init_app(app, db)
jwt.init_app(app)
ma.init_app(app)
register_blueprints(app)
return app
def init_extensions(app):
if app.config['REPO_ENGINE'] == 'MYSQL':
db.init_app(app)
cors.init_app(app, resources={
r"/*": {
"origins": "*"
},
})
jwt.init_app(app)
ma.init_app(app)
mail.init_app(app)
def register_extensions(app):
""" All extensions used by the application are registered here """
# Register database
db.init_app(app)
# Flask Babel for translations
babel = Babel(app)
@babel.localeselector
def get_locale():
accept_languages = app.config.get('ACCEPT_LANGUAGES')
return request.accept_languages.best_match(accept_languages)
# Flask Login
login_manager.setup_app(app)
def initialize_app(flask_app):
configure_app(flask_app)
blueprint = Blueprint('api', __name__, url_prefix='/api')
api.init_app(blueprint)
# api.add_namespace(ip_vpn_voice_namespace)
flask_app.register_blueprint(blueprint)
db.init_app(flask_app)
@app.route('/')
def redirecttoapi():
return redirect('/api', 302)
def client():
app.config['TESTING'] = True
app.config['CSRF_ENABLED'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = TEST_DATABASE_URI
db.init_app(app)
yield client
with app.app_context():
print("Tearing down test.db...")
Link.query.filter_by(Text="new").delete()
db.session.commit()
return app.test_client()
def init_db():
db.init_app(flask_app)
db.create_all()
if db.session.query(models.Settings).count() == 0:
config_model = models.Settings()
db.session.add(config_model)
db.session.commit()
pass
it = threads.Loader(flask_app, manager)
it.start()
it.join(1.0)
# socketio.start_background_task(target = check_loaded_bots)
pass
def create_app():
app = Flask(__name__,
static_folder=r_path('static'),
template_folder=r_path('templates'))
if getattr(sys, 'frozen', False):
basedir = os.path.dirname(sys.executable)
else:
basedir = os.path.abspath(os.path.dirname(__file__))
# bootstrap = Bootstrap(app)
pagedown = PageDown(app)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + r_path(
'data.sqlite')
# Autoreload if templates change
app.config['TEMPLATES_AUTO_RELOAD'] = True
# flask_upload settings
# app.config['MAX_CONTENT_LENGTH'] = 500 * 1024 * 1024 # Remove Upload limit. FIX ISSUE
app.config['UPLOADED_FILES_DEST'] = r_path('static/multimedia')
app.config['UPLOADED_FILES_ALLOW'] = mdal
app.config['SECRET_KEY'] = os.urandom(24)
# Intiating extensions before registering blueprints
moment = Moment(app)
qrc = QRcode(app)
configure_uploads(app, files)
login_manager.init_app(app)
db.init_app(app)
datepicker(
app, local=['static/css/jquery-ui.min.css', 'static/jquery-ui.min.js'])
colorpicker(app, local=['static/css/spectrum.css', 'static/spectrum.js'])
fontpicker(app,
local=[
'static/jquery-ui.min.js', 'static/css/jquery-ui.min.css',
'static/webfont.js', 'static/webfont.select.js',
'static/css/webfont.select.css'
])
lessc(app)
minify(app,
js=True,
cache=True,
fail_safe=True,
bypass=['/touch/<int:a>', '/serial/<int:t_id>', '/display'])
gtts(app=app, route=True)
gtranslator.init_app(app)
# Register blueprints
app.register_blueprint(administrate)
app.register_blueprint(core)
app.register_blueprint(cust_app)
app.register_blueprint(errorsh_app)
app.register_blueprint(manage_app)
app.jinja_env.add_extension('jinja2.ext.loopcontrols')
return app
def create_app():
app = Flask(__name__)
app.config['SECRET_KEY'] = b"d[12;/[d/2rqpl20rk02KPWDMK923#5U_))%FqwKO^A"
basedir = os.path.abspath(os.path.dirname(__file__))
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(
basedir, 'data.sqlite')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['CSRF_ENABLED'] = True
db.init_app(app)
migrate.init_app(app, db, render_as_batch=True)
return app
def create_app():
app = Flask(__name__,
template_folder='website/templates',
static_folder='website/static')
app.config.from_object(Config)
db.init_app(app)
# Registering website routes
for blueprint in blueprints:
app.register_blueprint(blueprint)
app.register_blueprint(api_v1)
return app
def connect_database(app: 'Flask'):
is_prod = os.environ.get('IS_HEROKU', False)
if is_prod:
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL']
app.config['SQLALCHEMY_ECHO'] = False
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
else:
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@localhost/FoodDB'
app.config['SQLALCHEMY_ECHO'] = True # para spam de sqlalchemy colocar el True
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
db.init_app(app)
ma.init_app(app)
return db
def create_app():
app = Flask(__name__)
app.config.from_object(Config)
db.init_app(app)
migrate.init_app(app, db)
api = create_api(app)
jwt = JWTManager(app)
mail.init_app(app)
return app
def create_app(conf=None):
app = Flask(__name__)
# Init DB
db.init_app(app)
# Register blueprints
from app.main.views import main
app.register_blueprint(main)
from app.admin import create_admin
admin=create_admin(app)
return app
def create_app(app_config: object = Config()) -> Flask:
"""Create new application object"""
# App creation
app = Flask(__name__)
app.config.from_object(app_config)
# DB app initialization
db.init_app(app)
# API registration
register(app)
return app
def create_app():
app = Flask(__name__, instance_relative_config=False)
app.config.from_object(Config)
with app.app_context():
db.init_app(app)
migrate.init_app(app, db)
app.register_blueprint(home_blueprint)
app.register_blueprint(programs_blueprint)
app.register_blueprint(organizations_blueprint)
app.cli.add_command(update_lat_lon)
return app
def create_app(config=None):
app = Flask(__name__)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = get_db_url()
app.config['JWT_SECRET'] = "JWT_SECRET_KEY"
if config is not None:
app.config.update(config)
api = create_api()
db.init_app(app)
api.init_app(app)
return app
def initialize_app(flask_app):
configure_app(flask_app)
blueprint = Blueprint('api', __name__, url_prefix='/api/v1')
api.init_app(blueprint)
api.add_namespace(sms_namespace)
api.add_namespace(at_sms_log_namespace)
api.add_namespace(balance_namespace)
api.add_namespace(broadcasts_namespace)
api.add_namespace(broadcast_message_namespace)
api.add_namespace(broadcast_subscription_namespace)
flask_app.register_blueprint(blueprint)
db.init_app(flask_app)
def create_app(config_name):
"""
The create_app() function is the application factory,
which takes as an argument the name of a
configuration to use for the application.
"""
app = Flask(__name__)
app.config.from_object(config[config_name])
app.register_blueprint(auth_blueprint)
app.register_blueprint(api_v1_blueprint)
db.init_app(app)
jwt.init_app(app)
redis_client.init_app(app)
return app
def create_app(config=None):
app = Flask(__name__)
# If no config file is passed in on the command line:
if config is None:
#config = os.path.join(app.root_path, os.environ.get('FLASK_APPLICATION_SETTINGS'))
config = os.path.join(os.path.dirname( __file__ ), "../config/", "config.cfg")
app.config.from_pyfile(config)
# Secret key needed to use sessions.
app.secret_key = app.config['SECRET_KEY']
app.mail = Mail(app)
# Initialize SQL Alchemy and Flask-Login
# Instantiate the Bcrypt extension
db.init_app(app)
if (app.config['CREATE_SCHEMA']):
with app.app_context():
db.create_all()
login_manager.init_app(app)
bcrypt.init_app(app)
# CSRF protection
csrf.init_app(app)
# Web assets (js, less)
assets = Environment(app)
js = Bundle('js/main.js',
filters='jsmin', output='gen/bundle.js')
assets.register('js_all', js)
# Automatically tear down SQLAlchemy
@app.teardown_request
def shutdown_session(exception=None):
db.session.remove()
@app.before_request
def before_request():
g.user = current_user
app.register_blueprint(unauthenticated)
app.register_blueprint(authenticated)
app.register_blueprint(users)
return app
def create_app(config):
_app = Flask(__name__)
_app.config.from_object(config)
_app.secret_key = config.secret_key
CORS(_app, resources={r"/*": {"origins": "*"}})
from app.views.library import library
from app.views.admin import admin
from app.views.verify import verify
from app.views.volunteer import volunteer
from app.views.home import home
_app.register_blueprint(home, url_prefix="/")
_app.register_blueprint(library, url_prefix="/library")
_app.register_blueprint(admin, url_prefix="/admin")
_app.register_blueprint(verify, url_prefix="/verify")
_app.register_blueprint(volunteer, url_prefix="/volunteer")
from app.v1.controllers.libraries import libraries_api
from app.v1.controllers.maps import maps_api
from app.v1.controllers.users import users_api
from app.v1.controllers.admin import admin_api
from app.v1.controllers.signin import signin_api
from app.v1.controllers.match import match_api
from app.v1.controllers.speakerinfo import speaker_api
from app.v1.controllers.logger import logger_api
_app.register_blueprint(libraries_api, url_prefix='/api/v1/library')
add_request_hook(libraries_api)
_app.register_blueprint(maps_api, url_prefix='/api/v1/map')
add_request_hook(maps_api)
_app.register_blueprint(users_api, url_prefix='/api/v1/user')
add_request_hook(users_api)
_app.register_blueprint(admin_api, url_prefix="/api/v1/admin")
add_request_hook(admin_api)
_app.register_blueprint(signin_api, url_prefix='/api/v1/signin')
add_request_hook(signin_api)
_app.register_blueprint(match_api, url_prefix='/api/v1/match')
add_request_hook(match_api)
_app.register_blueprint(speaker_api, url_prefix="/api/v1/speaker")
add_request_hook(speaker_api)
_app.register_blueprint(logger_api, url_prefix='/api/v1/logger')
db.init_app(_app)
Migrate(_app, db)
add_before_and_after_hook(_app)
return _app
def create_app():
"""Creates a app.
:returns: app
"""
# 设置日志
app.logger.addHandler(server_log)
app.register_blueprint(auth, url_prefix='/auth')
app.register_blueprint(exam, url_prefix='/exam')
app.register_blueprint(answers, url_prefix='/answers')
app.register_blueprint(show, url_prefix='/show')
# app.logger.addHandler(error_log)
# 注册 Flask-SQLAlchemy
# 这个对象在其他地方想要使用
# SQLAlchemy(app)
db.init_app(app)
return app
def create_app(test_config=None):
# create and configure app
app = Flask(__name__, instance_relative_config=True)
app.config.from_mapping(SECRET_KEY='dev',
SQLALCHEMY_DATABASE_URI='sqlite:////tmp/dev.db',
SQLALCHEMY_TRACK_MODIFICATIONS='False')
if test_config is None:
#load the instance config, if it exists, when not testing
app.config.from_pyfile('config.py', silent=True)
else:
#load the tes config if passed in
app.config.from_mapping(test_config)
# ensure the instance folder exists
try:
os.makedirs(app.instance_path)
except OSError:
pass
# test route
@app.route('/testing')
def testresponse():
return ('Testing! Testing! Testing!')
# index page
@app.route('/')
def index():
return render_template('index.html')
# maintenance page
@app.route('/maintenance')
def maintenance():
return render_template('maintenance.html')
@app.route('/dashboard')
def dashboard():
return redirect(url_for('maintenance'))
db.init_app(app)
app.cli.add_command(init_database_command)
from . import auth
app.register_blueprint(auth.bp)
return app
def create_app(config_name):
app = Flask(__name__, instance_relative_config=True)
app.config.from_object(app_config[config_name])
# Blueprints registering
app.register_blueprint(auth_api)
# Init application database
db.init_app(app)
# Init e-mail config
mail.init_app(app)
# Enable CORS for our application
CORS(app)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
db.init_app(app)
api.init_app(app)
app.register_blueprint(api_v1)
app.register_blueprint(home_bp)
if app.debug:
app.logger.setLevel("DEBUG")
else:
app.logger.setLevel("INFO")
app.app_context().push()
return app
def create_app(config=None):
app = Flask(__name__)
# If no config file is passed in on the command line:
# if config is None:
# config = os.path.join(app.root_path, os.environ.get('FLASK_APPLICATION_SETTINGS'))
# app.config.from_pyfile(config)
# Secret key needed to use sessions.
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/easytransfer.db'
app.config['SECRET_KEY'] = 'gi3mHUx8hcLoQrnqP1XOkSORrjxZVkST'
app.secret_key = app.config['SECRET_KEY']
# Initialize SQL Alchemy and Flask-Login
# Instantiate the Bcrypt extension
db.init_app(app)
login_manager.init_app(app)
bcrypt.init_app(app)
# CSRF protection
# csrf.init_app(app)
# Web assets (js, less)
assets = Environment(app)
js = Bundle('js/main.js',
filters='jsmin', output='gen/bundle.js')
assets.register('js_all', js)
# Automatically tear down SQLAlchemy
@app.teardown_request
def shutdown_session(exception=None):
db.session.remove()
@app.before_request
def before_request():
g.user = current_user
app.register_blueprint(unauthenticated)
app.register_blueprint(authenticated)
app.register_blueprint(users)
return app
def create_app(config=None):
app = Flask(__name__)
# If no config file is passed in on the command line:
if config is None:
config = os.path.join(app.root_path, os.environ.get("FLASK_APPLICATION_SETTINGS"))
app.config.from_pyfile(config)
# Secret key needed to use sessions.
app.secret_key = app.config["SECRET_KEY"]
# Initialize SQL Alchemy and Flask-Login
# Instantiate the Bcrypt extension
db.init_app(app)
login_manager.init_app(app)
bcrypt.init_app(app)
# CSRF protection
csrf.init_app(app)
# Web assets (js, less)
assets = Environment(app)
js = Bundle("js/main.js", filters="jsmin", output="gen/bundle.js")
assets.register("js_all", js)
# Automatically tear down SQLAlchemy
@app.teardown_request
def shutdown_session(exception=None):
db.session.remove()
@app.before_request
def before_request():
g.user = current_user
app.register_blueprint(unauthenticated)
app.register_blueprint(authenticated)
app.register_blueprint(users)
# app.register_blueprint(upload)
return app
def create_app(conf_type):
app = Flask(__name__)
app.config.from_object(config[conf_type])
db.init_app(app)
csrf.init_app(app)
login_manager.init_app(app)
session.init_app(app, prefixed_store)
from .resources import v1
from .main.views import main
# Add resource routes
v1.api.add_resource(v1.Publication, '/publication', '/publication/<int:id>')
v1.api.add_resource(v1.Upload, '/upload', '/upload/<string:filename>')
# Register blueprints
app.register_blueprint(v1.blueprint, url_prefix="/api/v1.0")
app.register_blueprint(main)
return app
def create_app(config=None):
app = Flask(__name__)
# If no config file is passed in on the command line:
if config is None:
config = os.path.join(app.root_path, os.environ.get('FLASK_APPLICATION_SETTINGS'))
app.config.from_pyfile(config)
# Secret key needed to use sessions.
app.secret_key = app.config['SECRET_KEY']
# Initialize SQL Alchemy and Flask-Login
# Instantiate the Bcrypt extension
db.init_app(app)
login_manager.init_app(app)
bcrypt.init_app(app)
# Automatically tear down SQLAlchemy
@app.teardown_request
def shutdown_session(exception=None):
db.session.remove()
@app.before_request
def before_request():
g.user = current_user
# URLs
app.add_url_rule('/', 'index', index)
app.add_url_rule('/login/', 'login', login_view, methods=['GET', 'POST'])
app.add_url_rule('/home/', 'home', home)
app.add_url_rule('/users/create/', 'user_create', user_create, methods=['GET', 'POST'])
app.add_url_rule('/logout/', 'logout', logout_view)
return app
def register_extensions(app):
db.init_app(app)
celery.init_app(app)
bootstrap.init_app(app)
moment.init_app(app)
import os
import sys
from flask import Flask
from app.database import db
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///../db/dbTest.db'
db.init_app(app)
with app.app_context():
db.create_all()
def dropdb():
db.init_app(current_app)
db.drop_all()
def createdb():
db.init_app(current_app)
db.create_all()
def configure_db(self):
db.init_app(self.app)
def register_extensions(app):
heroku.init_app(app)
db.init_app(app)
lm.init_app(app)
bcrypt.init_app(app)
def register_extensions(app):
bcrypt.init_app(app)
login_manager.init_app(app)
db.init_app(app)
