def __init__(self,
import_name,
config_file=None,
debug=None,
use_flask_uuid=False,
*args,
**kwargs):
"""Create an instance of Flask app.
See original documentation for Flask.
Arguments:
import_name (str): Name of the application package.
config_file (str): Path to a config file that needs to be loaded.
Should be in a form of Python module.
debug (bool): Override debug value.
use_flask_uuid (bool): Turn on Flask-UUID extension if set to True.
"""
super(CustomFlask, self).__init__(import_name, *args, **kwargs)
if config_file:
self.config.from_pyfile(config_file)
if debug is not None:
self.debug = debug
if use_flask_uuid:
FlaskUUID(self)
def gen_app(config_path=None, debug=None):
""" Generate a Flask app for Hind with all configurations done and connections established.
In the Flask app returned, blueprints are not registered.
"""
app = Flask(import_name=__name__)
FlaskUUID(app)
app.secret_key = os.urandom(24)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'index.login'
@login_manager.user_loader
def load_user(user_id):
return db_user.get_by_id(id=user_id)
load_config(app)
# Database connections
from hind import db
db.init_db_connection(app.config['SQLALCHEMY_DATABASE_URI'])
# Error handling
from hind.webserver.errors import init_error_handlers
init_error_handlers(app)
return app
def create_app():
app = Flask(__name__,
static_url_path=STATIC_PATH,
static_folder=STATIC_FOLDER,
template_folder=TEMPLATE_FOLDER)
# Configuration
app.config.from_object('acousticbrainz.config')
# Error handling and logging
handler = RotatingFileHandler(app.config['LOG_FILE'])
handler.setLevel(logging.INFO)
app.logger.addHandler(handler)
# Memcached
if 'MEMCACHED_SERVERS' in app.config:
from acousticbrainz import cache
cache.init(app.config['MEMCACHED_SERVERS'],
app.config['MEMCACHED_NAMESPACE'],
debug=1 if app.debug else 0)
# Extensions
FlaskUUID(app)
# MusicBrainz
import musicbrainzngs
musicbrainzngs.set_useragent(app.config['MUSICBRAINZ_USERAGENT'], __version__)
if app.config['MUSICBRAINZ_HOSTNAME']:
musicbrainzngs.set_hostname(app.config['MUSICBRAINZ_HOSTNAME'])
# OAuth
from acousticbrainz.login import login_manager, provider
login_manager.init_app(app)
provider.init(app.config['MUSICBRAINZ_CLIENT_ID'],
app.config['MUSICBRAINZ_CLIENT_SECRET'])
# Error handling
import errors
errors.init_error_handlers(app)
# Blueprints
from acousticbrainz.views.index import index_bp
from acousticbrainz.views.data import data_bp
from acousticbrainz.views.api import api_bp
from acousticbrainz.views.stats import stats_bp
from acousticbrainz.views.login import login_bp
from acousticbrainz.views.user import user_bp
from acousticbrainz.views.datasets import datasets_bp
app.register_blueprint(index_bp)
app.register_blueprint(data_bp)
app.register_blueprint(api_bp)
app.register_blueprint(stats_bp)
app.register_blueprint(login_bp, url_prefix='/login')
app.register_blueprint(user_bp, url_prefix='/user')
app.register_blueprint(datasets_bp, url_prefix='/datasets')
return app
def create_app():
app = Flask(__name__)
# Configuration
sys.path.append(
os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
import default_config
app.config.from_object(default_config)
import config
app.config.from_object(config)
# Logging
from webserver.loggers import init_loggers
init_loggers(app)
# Database connection
from db import init_db_engine
init_db_engine(app.config['SQLALCHEMY_DATABASE_URI'])
# Extensions
from flask_uuid import FlaskUUID
FlaskUUID(app)
# MusicBrainz
import musicbrainzngs
from db import SCHEMA_VERSION
musicbrainzngs.set_useragent(app.config['MUSICBRAINZ_USERAGENT'],
SCHEMA_VERSION)
if app.config['MUSICBRAINZ_HOSTNAME']:
musicbrainzngs.set_hostname(app.config['MUSICBRAINZ_HOSTNAME'])
# OAuth
from webserver.login import login_manager, provider
login_manager.init_app(app)
provider.init(app.config['MUSICBRAINZ_CLIENT_ID'],
app.config['MUSICBRAINZ_CLIENT_SECRET'])
# Error handling
from webserver.errors import init_error_handlers
init_error_handlers(app)
# Static files
import static_manager
static_manager.read_manifest()
# Template utilities
app.jinja_env.add_extension('jinja2.ext.do')
from webserver import utils
app.jinja_env.filters['date'] = utils.reformat_date
app.jinja_env.filters['datetime'] = utils.reformat_datetime
app.context_processor(
lambda: dict(get_static_path=static_manager.get_static_path))
_register_blueprints(app)
return app
def create_app():
app = Flask(__name__)
# Configuration
sys.path.append(
os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
import config
app.config.from_object(config)
# Redis (cache)
from brainzutils import cache
try:
cache.init(
host=app.config["REDIS_HOST"],
port=app.config["REDIS_PORT"],
namespace=app.config["REDIS_NAMESPACE"],
)
except KeyError as e:
logging.error(
"Redis is not defined in config file. Error: {}".format(e))
raise
# Logging
from webserver.loggers import init_loggers
init_loggers(app)
# Extensions
from flask_uuid import FlaskUUID
FlaskUUID(app)
# Error handling
from webserver.errors import init_error_handlers
init_error_handlers(app)
# Template utilities
app.jinja_env.add_extension('jinja2.ext.do')
from webserver import utils
app.jinja_env.filters['date'] = utils.reformat_date
app.jinja_env.filters['datetime'] = utils.reformat_datetime
# Blueprints
from webserver.views.index import index_bp
from webserver.views.api import api_bp
app.register_blueprint(index_bp)
app.register_blueprint(api_bp)
@app.before_request
def before_request():
db.init_db_engine(app.config['SQLALCHEMY_DATABASE_URI'])
@app.teardown_request
def teardown_request(exception):
pass
return app
def create_app(web=True):
""" Create the flask app
:param web: If True, this app is for the webserver, and should load blueprints and templating.
Set to False for celery
:return: the flask app
"""
app = Flask(__name__)
# Configuration
sys.path.append(
os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
import config
app.config.from_object(config)
# Logging
from webserver.loggers import init_loggers
init_loggers(app)
# Extensions
from flask_uuid import FlaskUUID
FlaskUUID(app)
# Error handling
from webserver.errors import init_error_handlers
init_error_handlers(app)
if web:
# Template utilities
app.jinja_env.add_extension('jinja2.ext.do')
from webserver import utils
app.jinja_env.filters['date'] = utils.reformat_date
app.jinja_env.filters['datetime'] = utils.reformat_datetime
# Blueprints
from webserver.views.index import index_bp
from webserver.views.api import api_bp
app.register_blueprint(index_bp)
app.register_blueprint(api_bp)
@app.before_request
def before_request():
db.init_db_engine(app.config['SQLALCHEMY_DATABASE_URI'])
@app.teardown_request
def teardown_request(exception):
pass
return app
def create_app(debug=None):
app = Flask(__name__)
# Configuration files
import critiquebrainz.default_config
app.config.from_object(critiquebrainz.default_config)
app.config.from_pyfile(os.path.join(
os.path.dirname(os.path.realpath(__file__)), "..", "config.py"),
silent=True)
if debug is not None:
app.debug = debug
# Error handling
from critiquebrainz.ws.errors import init_error_handlers
init_error_handlers(app)
# Logging
from critiquebrainz import loggers
loggers.init_loggers(app)
from flask_uuid import FlaskUUID
FlaskUUID(app)
from critiquebrainz.data import db
db.init_app(app)
# Memcached
if 'MEMCACHED_SERVERS' in app.config:
from critiquebrainz import cache
cache.init(app.config['MEMCACHED_SERVERS'],
app.config['MEMCACHED_NAMESPACE'],
debug=1 if app.debug else 0)
app.config['JSONIFY_PRETTYPRINT_REGULAR'] = False
# Blueprints
from critiquebrainz.ws.oauth.views import oauth_bp
from critiquebrainz.ws.review.views import review_bp
from critiquebrainz.ws.user.views import user_bp
app.register_blueprint(oauth_bp, url_prefix='/oauth')
app.register_blueprint(review_bp, url_prefix='/review')
app.register_blueprint(user_bp, url_prefix='/user')
return app
def create_app():
app = Flask(__name__)
# Configuration
sys.path.append(
os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
import config
app.config.from_object(config)
# Logging
from webserver.loggers import init_loggers
init_loggers(app)
# Extensions
from flask_uuid import FlaskUUID
FlaskUUID(app)
# Error handling
from webserver.errors import init_error_handlers
init_error_handlers(app)
# Template utilities
app.jinja_env.add_extension('jinja2.ext.do')
from webserver import utils
app.jinja_env.filters['date'] = utils.reformat_date
app.jinja_env.filters['datetime'] = utils.reformat_datetime
# Blueprints
from webserver.views.index import index_bp
from webserver.views.api import api_bp
app.register_blueprint(index_bp)
app.register_blueprint(api_bp)
@app.before_request
def before_request():
db.init_db_connection(app.config['SQLALCHEMY_DATABASE_URI'])
@app.teardown_request
def teardown_request(exception):
pass
return app
def create_app(debug=None, config_path=None):
app = CustomFlask(import_name=__name__,
use_flask_uuid=True,
use_debug_toolbar=True)
# Configuration
root_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "..")
app.config.from_pyfile(os.path.join(root_path, 'default_config.py'))
app.config.from_pyfile(os.path.join(root_path, 'custom_config.py'),
silent=True)
if config_path:
app.config.from_pyfile(config_path)
if debug is not None:
app.debug = debug
# Logging
from webserver.loggers import init_loggers
init_loggers(app)
# Database connection
from db import init_db_engine
init_db_engine(app.config['SQLALCHEMY_DATABASE_URI'])
# Memcached
if 'MEMCACHED_SERVERS' in app.config:
from db import cache
cache.init(app.config['MEMCACHED_SERVERS'],
app.config['MEMCACHED_NAMESPACE'],
debug=1 if app.debug else 0)
# Extensions
from flask_uuid import FlaskUUID
FlaskUUID(app)
# MusicBrainz
import musicbrainzngs
from db import SCHEMA_VERSION
musicbrainzngs.set_useragent(app.config['MUSICBRAINZ_USERAGENT'],
SCHEMA_VERSION)
if app.config['MUSICBRAINZ_HOSTNAME']:
musicbrainzngs.set_hostname(app.config['MUSICBRAINZ_HOSTNAME'])
# OAuth
from webserver.login import login_manager, provider
login_manager.init_app(app)
provider.init(app.config['MUSICBRAINZ_CLIENT_ID'],
app.config['MUSICBRAINZ_CLIENT_SECRET'])
# Error handling
from webserver.errors import init_error_handlers
init_error_handlers(app)
# Static files
import static_manager
static_manager.read_manifest()
# Template utilities
app.jinja_env.add_extension('jinja2.ext.do')
from webserver import utils
app.jinja_env.filters['date'] = utils.reformat_date
app.jinja_env.filters['datetime'] = utils.reformat_datetime
app.context_processor(
lambda: dict(get_static_path=static_manager.get_static_path))
_register_blueprints(app)
# Admin section
from flask_admin import Admin
from webserver.admin import views as admin_views
admin = Admin(app, index_view=admin_views.HomeView(name='Admin'))
admin.add_view(admin_views.AdminsView(name='Admins'))
return app
def create_app():
app = Flask(__name__)
# Configuration
sys.path.append(
os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
import config
app.config.from_object(config)
# Logging
from webserver.loggers import init_loggers
init_loggers(app)
# Database connection
from db import init_db_engine
init_db_engine(app.config['SQLALCHEMY_DATABASE_URI'])
# Memcached
if 'MEMCACHED_SERVERS' in app.config:
from db import cache
cache.init(app.config['MEMCACHED_SERVERS'],
app.config['MEMCACHED_NAMESPACE'],
debug=1 if app.debug else 0)
# Extensions
from flask_uuid import FlaskUUID
FlaskUUID(app)
# MusicBrainz
import musicbrainzngs
from db import SCHEMA_VERSION
musicbrainzngs.set_useragent(app.config['MUSICBRAINZ_USERAGENT'],
SCHEMA_VERSION)
if app.config['MUSICBRAINZ_HOSTNAME']:
musicbrainzngs.set_hostname(app.config['MUSICBRAINZ_HOSTNAME'])
# OAuth
from webserver.login import login_manager, provider
login_manager.init_app(app)
provider.init(app.config['MUSICBRAINZ_CLIENT_ID'],
app.config['MUSICBRAINZ_CLIENT_SECRET'])
# Error handling
from webserver.errors import init_error_handlers
init_error_handlers(app)
# Static files
import static_manager
static_manager.read_manifest()
# Template utilities
app.jinja_env.add_extension('jinja2.ext.do')
from webserver import utils
app.jinja_env.filters['date'] = utils.reformat_date
app.jinja_env.filters['datetime'] = utils.reformat_datetime
app.context_processor(
lambda: dict(get_static_path=static_manager.get_static_path))
# Blueprints
from webserver.views.index import index_bp
from webserver.views.data import data_bp
from webserver.views.api import api_bp
from webserver.views.stats import stats_bp
from webserver.views.login import login_bp
from webserver.views.user import user_bp
from webserver.views.datasets import datasets_bp
app.register_blueprint(index_bp)
app.register_blueprint(data_bp)
app.register_blueprint(api_bp)
app.register_blueprint(stats_bp)
app.register_blueprint(login_bp, url_prefix='/login')
app.register_blueprint(user_bp, url_prefix='/user')
app.register_blueprint(datasets_bp, url_prefix='/datasets')
return app
import logging
from os import path
from flask import Flask
from flask_login import LoginManager
from flask_uuid import FlaskUUID
from flask_marshmallow import Marshmallow
login_manager = LoginManager()
login_manager.login_view = 'auth.login'
login_manager.login_message = u'Autenticação requerida para acessar a página.'
login_manager.login_message_category = 'info'
flask_uuid = FlaskUUID()
ma = Marshmallow()
def create_app(mode=None):
"""
Application Factory for Flask
:param mode:
:return:
"""
if mode:
instance_path = path.join(path.abspath(path.dirname(__file__)),
"%s_instance" % mode)
app = Flask('brain',
instance_path=instance_path,
instance_relative_config=True)
# !/usr/bin/python3
import logging
import os
# import uuid
import time
# import json
from flask_uuid import FlaskUUID
from flask_cors import CORS
from flask import Flask, jsonify, request # , make_response, request, abort
from logging.handlers import RotatingFileHandler
from database_lib import DatabaseManager
app = Flask(__name__)
FlaskUUID(app)
CORS(app)
# *********************** USERS METHODS *********************** #
@app.route('/insert-user', methods=['POST'])
def insert_user():
"""."""
print('Post request {}'.format(request.json))
logger.info('Post request {}'.format(request.json))
data = request.json['data'] if request.json['type'] == 'insert_user' else ''
if data:
result = db.insert_user(data['username'], data['password'],
data['email'])
return jsonify({'data': result}), 201
def create_app(debug=None):
app = CustomFlask(
import_name=__name__,
use_flask_uuid=True,
)
# Configuration
load_config(app)
if debug is not None:
app.debug = debug
if app.debug and app.config['SECRET_KEY']:
app.init_debug_toolbar()
# Logging
app.init_loggers(file_config=app.config.get('LOG_FILE'),
email_config=app.config.get('LOG_EMAIL'),
sentry_config=app.config.get('LOG_SENTRY')
)
# Database connection
from db import init_db_engine
init_db_engine(app.config['SQLALCHEMY_DATABASE_URI'])
# Cache
if 'REDIS_HOST' in app.config and\
'REDIS_PORT' in app.config and\
'REDIS_NAMESPACE' in app.config and\
'REDIS_NS_VERSIONS_LOCATION' in app.config:
if not os.path.exists(app.config['REDIS_NS_VERSIONS_LOCATION']):
os.makedirs(app.config['REDIS_NS_VERSIONS_LOCATION'])
from brainzutils import cache
cache.init(
host=app.config['REDIS_HOST'],
port=app.config['REDIS_PORT'],
namespace=app.config['REDIS_NAMESPACE'],
ns_versions_loc=app.config['REDIS_NS_VERSIONS_LOCATION'])
else:
raise Exception('One or more redis cache configuration options are missing from config.py')
# Extensions
from flask_uuid import FlaskUUID
FlaskUUID(app)
# MusicBrainz
import musicbrainzngs
from db import SCHEMA_VERSION
musicbrainzngs.set_useragent(app.config['MUSICBRAINZ_USERAGENT'], SCHEMA_VERSION)
if app.config['MUSICBRAINZ_HOSTNAME']:
musicbrainzngs.set_hostname(app.config['MUSICBRAINZ_HOSTNAME'])
# OAuth
from webserver.login import login_manager, provider
login_manager.init_app(app)
provider.init(app.config['MUSICBRAINZ_CLIENT_ID'],
app.config['MUSICBRAINZ_CLIENT_SECRET'])
# Error handling
from webserver.errors import init_error_handlers
init_error_handlers(app)
# Static files
import static_manager
static_manager.read_manifest()
# Template utilities
app.jinja_env.add_extension('jinja2.ext.do')
from webserver import utils
app.jinja_env.filters['date'] = utils.reformat_date
app.jinja_env.filters['datetime'] = utils.reformat_datetime
app.context_processor(lambda: dict(get_static_path=static_manager.get_static_path))
_register_blueprints(app)
# Admin section
from flask_admin import Admin
from webserver.admin import views as admin_views
admin = Admin(app, index_view=admin_views.HomeView(name='Admin'))
admin.add_view(admin_views.AdminsView(name='Admins'))
@ app.before_request
def before_request_gdpr_check():
# skip certain pages, static content and the API
if request.path == url_for('index.gdpr_notice') \
or request.path == url_for('login.logout') \
or request.path.startswith('/_debug') \
or request.path.startswith('/static') \
or request.path.startswith(API_PREFIX):
return
# otherwise if user is logged in and hasn't agreed to gdpr,
# redirect them to agree to terms page.
elif current_user.is_authenticated and current_user.gdpr_agreed is None:
return redirect(url_for('index.gdpr_notice', next=request.full_path))
return app
def create_app():
app = Flask(__name__, static_url_path='/static')
app.config.from_object('application.config.Config')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.url_map.strict_slashes = False
# client = KafkaClient(hosts="kafka1:19092")
# app.topic = client.topics['example_topic']
CORS(app)
with app.app_context():
jwt = JWTManager(app)
blacklist = set()
flask_uuid = FlaskUUID()
flask_uuid.init_app(app)
app.register_blueprint(auth.auth)
app.register_blueprint(home.mod)
app.register_blueprint(courses.mod)
app.register_blueprint(platforms.mod)
app.register_blueprint(publishers.mod)
app.register_blueprint(profile.mod)
app.register_blueprint(releaseTypes.mod)
# app.register_blueprint(search.mod)
app.register_blueprint(tags.mod)
app.register_blueprint(agreements.mod)
@jwt.user_claims_loader
def add_claims_to_access_token(identity):
return {
'public_id': identity
}
@jwt.token_in_blacklist_loader
def check_if_token_in_blacklist(decrypted_token):
jti = decrypted_token['jti']
return jti in blacklist
@app.before_request
def clear_trailing():
from flask import redirect, request
rp = request.path
if rp != '/' and rp.endswith('/'):
return redirect(rp[:-1])
@app.teardown_request
def remove_db_session(exception):
db_session.remove()
@app.route('/api/v1/user/logout', methods=['GET'])
@jwt_required
def logout():
jti = get_raw_jwt()['jti']
blacklist.add(jti)
return jsonify({"msg": "Successfully logged out"}), 200
@app.route('/test', methods=['GET', 'POST'])
@jwt_required
def test():
claims = get_jwt_claims()
return jsonify({"msg": claims}), 200
return app
def create_app(debug=None, config_path=None):
app = create_app_with_configuration(config_path)
if debug is not None:
app.debug = debug
if app.debug and app.config['SECRET_KEY']:
app.init_debug_toolbar()
# Logging
from webserver.loggers import init_loggers
init_loggers(app)
# Database connection
from db import init_db_engine
init_db_engine(app.config['SQLALCHEMY_DATABASE_URI'])
# Cache
if 'REDIS_HOST' in app.config and\
'REDIS_PORT' in app.config and\
'REDIS_NAMESPACE' in app.config and\
'REDIS_NS_VERSIONS_LOCATION' in app.config:
if not os.path.exists(app.config['REDIS_NS_VERSIONS_LOCATION']):
os.makedirs(app.config['REDIS_NS_VERSIONS_LOCATION'])
from brainzutils import cache
cache.init(host=app.config['REDIS_HOST'],
port=app.config['REDIS_PORT'],
namespace=app.config['REDIS_NAMESPACE'],
ns_versions_loc=app.config['REDIS_NS_VERSIONS_LOCATION'])
else:
raise Exception(
'One or more redis cache configuration options are missing from custom_config.py'
)
# Extensions
from flask_uuid import FlaskUUID
FlaskUUID(app)
# MusicBrainz
import musicbrainzngs
from db import SCHEMA_VERSION
musicbrainzngs.set_useragent(app.config['MUSICBRAINZ_USERAGENT'],
SCHEMA_VERSION)
if app.config['MUSICBRAINZ_HOSTNAME']:
musicbrainzngs.set_hostname(app.config['MUSICBRAINZ_HOSTNAME'])
# OAuth
from webserver.login import login_manager, provider
login_manager.init_app(app)
provider.init(app.config['MUSICBRAINZ_CLIENT_ID'],
app.config['MUSICBRAINZ_CLIENT_SECRET'])
# Error handling
from webserver.errors import init_error_handlers
init_error_handlers(app)
# Static files
import static_manager
static_manager.read_manifest()
# Template utilities
app.jinja_env.add_extension('jinja2.ext.do')
from webserver import utils
app.jinja_env.filters['date'] = utils.reformat_date
app.jinja_env.filters['datetime'] = utils.reformat_datetime
app.context_processor(
lambda: dict(get_static_path=static_manager.get_static_path))
_register_blueprints(app)
# Admin section
from flask_admin import Admin
from webserver.admin import views as admin_views
admin = Admin(app, index_view=admin_views.HomeView(name='Admin'))
admin.add_view(admin_views.AdminsView(name='Admins'))
return app
def create_app(debug=None):
app = Flask(__name__)
# Configuration files
import critiquebrainz.default_config
app.config.from_object(critiquebrainz.default_config)
app.config.from_pyfile(os.path.join(
os.path.dirname(os.path.realpath(__file__)), "..", "config.py"),
silent=True)
if debug is not None:
app.debug = debug
# Error handling
from critiquebrainz.frontend.errors import init_error_handlers
init_error_handlers(app)
# Logging
from critiquebrainz import loggers
loggers.init_loggers(app)
if app.debug:
# Debug toolbar
from flask_debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
app.config['DEBUG_TB_TEMPLATE_EDITOR_ENABLED'] = True
from flask_uuid import FlaskUUID
FlaskUUID(app)
from critiquebrainz.data import db
db.init_app(app)
# Memcached
if 'MEMCACHED_SERVERS' in app.config:
from critiquebrainz import cache
cache.init(app.config['MEMCACHED_SERVERS'],
app.config['MEMCACHED_NAMESPACE'],
debug=1 if app.debug else 0)
import critiquebrainz.frontend.babel
babel.init_app(app)
import critiquebrainz.frontend.login
login.login_manager.init_app(app)
from critiquebrainz.frontend.login.provider import MusicBrainzAuthentication
login.mb_auth = MusicBrainzAuthentication(
name='musicbrainz',
client_id=app.config['MUSICBRAINZ_CLIENT_ID'],
client_secret=app.config['MUSICBRAINZ_CLIENT_SECRET'],
authorize_url="https://musicbrainz.org/oauth2/authorize",
access_token_url="https://musicbrainz.org/oauth2/token",
base_url="https://musicbrainz.org/")
# APIs
from critiquebrainz.frontend.apis import mbspotify
mbspotify.init(app.config['MBSPOTIFY_BASE_URI'],
app.config['MBSPOTIFY_ACCESS_KEY'])
from critiquebrainz.frontend.apis import musicbrainz
musicbrainz.init(app.config['MUSICBRAINZ_USERAGENT'],
critiquebrainz.__version__,
hostname=app.config['MUSICBRAINZ_HOSTNAME'])
# Template utilities
app.jinja_env.add_extension('jinja2.ext.do')
from critiquebrainz.utils import reformat_date, reformat_datetime, track_length
app.jinja_env.filters['date'] = reformat_date
app.jinja_env.filters['datetime'] = reformat_datetime
app.jinja_env.filters['track_length'] = track_length
app.jinja_env.filters['entity_details'] = musicbrainz.get_entity_by_id
# Blueprints
from critiquebrainz.frontend.views import frontend_bp
from critiquebrainz.frontend.review.views import review_bp
from critiquebrainz.frontend.search.views import search_bp
from critiquebrainz.frontend.artist.views import artist_bp
from critiquebrainz.frontend.release_group.views import release_group_bp
from critiquebrainz.frontend.event.views import event_bp
from critiquebrainz.frontend.mapping.views import mapping_bp
from critiquebrainz.frontend.user.views import user_bp
from critiquebrainz.frontend.profile.views import profile_bp
from critiquebrainz.frontend.profile.applications.views import profile_apps_bp
from critiquebrainz.frontend.login.views import login_bp
from critiquebrainz.frontend.oauth.views import oauth_bp
from critiquebrainz.frontend.reports.views import reports_bp
from critiquebrainz.frontend.log.views import log_bp
app.register_blueprint(frontend_bp)
app.register_blueprint(review_bp, url_prefix='/review')
app.register_blueprint(search_bp, url_prefix='/search')
app.register_blueprint(artist_bp, url_prefix='/artist')
app.register_blueprint(release_group_bp, url_prefix='/release-group')
app.register_blueprint(event_bp, url_prefix='/event')
app.register_blueprint(mapping_bp, url_prefix='/mapping')
app.register_blueprint(user_bp, url_prefix='/user')
app.register_blueprint(profile_bp, url_prefix='/profile')
app.register_blueprint(profile_apps_bp, url_prefix='/profile/applications')
app.register_blueprint(login_bp, url_prefix='/login')
app.register_blueprint(oauth_bp, url_prefix='/oauth')
app.register_blueprint(reports_bp, url_prefix='/reports')
app.register_blueprint(log_bp, url_prefix='/log')
return app
from flask_sqlalchemy import SQLAlchemy from flask_uuid import FlaskUUID db = SQLAlchemy() uuid_ = FlaskUUID()
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
'DATABASE_URL') or "sqlite:///token.db"
app.config['SECRET_KEY'] = '12345'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# creating database object
db = SQLAlchemy(app)
# creating migrate object
migrate = Migrate(app, db)
# creating API object
api = Api(app)
# initializing UUID
flask_uuid = FlaskUUID()
flask_uuid.init_app(app)
# creating a table name pin_table which has two columns one id which is primary key and the other pin for all the unique
# that would be generated
class pin_table(db.Model):
id = db.Column('id', db.Integer, primary_key=True)
s_n = db.Column(db.String(12), unique=True, nullable=False)
pin = db.Column(db.String(15), unique=True, nullable=False)
def __init__(self, pin, s_n):
self.pin = pin
self.s_n = s_n
def bootstrap_app(app):
app.json_encoder = JSONEncoder
app.config["RESTFUL_JSON"] = {"cls": app.json_encoder}
FlaskUUID(app)
from bettercrative.quizzes.routes import quizzes
from bettercrative.errors.routes import errors
app.register_blueprint(users)
app.register_blueprint(classrooms)
app.register_blueprint(main)
app.register_blueprint(quizzes)
app.register_blueprint(errors)
app.register_error_handler(400, bad_request)
app.register_error_handler(401, unauthorized)
app.register_error_handler(403, forbidden)
app.register_error_handler(404, not_found)
app.jinja_env.globals.update(get_alphabet_index=get_alphabet_index)
app.jinja_env.globals.update(append_form=append_form)
app.jinja_env.globals.update(find_selected_answer=find_selected_answer)
return app
db = SQLAlchemy()
migrate = Migrate()
bcrypt = Bcrypt()
login_manager = LoginManager()
login_manager.login_view = 'users.login'
login_manager.login_message_category = 'users.info'
mail = Mail()
qrcode = QRcode()
uuid = FlaskUUID()
oauth = OAuth()
import logging
import os
import dotenv
import redis
from flask_uuid import FlaskUUID
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
import faker
from celery import Celery
from flask import Flask
dotenv.load_dotenv()
flask_app = Flask(__name__)
FlaskUUID(flask_app)
celery_app = Celery(broker=os.getenv("REDIS_CELERY_URL"))
redis_conn = redis.Redis.from_url(os.getenv("REDIS_URL"))
fake = faker.Faker()
logging.basicConfig(level="INFO")
logger = logging.getLogger("geo_redis")
engine = create_engine(os.path.join(os.getenv("POSTGRES_URL"),
os.getenv("DATABASE_NAME")),
pool_size=10,
max_overflow=20)
base = declarative_base(bind=engine)
Session = sessionmaker(bind=engine)
session = Session()
def create_app(debug=None, config_path=None):
app = CustomFlask(
import_name=__name__,
use_flask_uuid=True,
)
# Configuration
app.config.from_pyfile(
os.path.join(os.path.dirname(os.path.realpath(__file__)), '..',
'default_config.py'))
app.config.from_pyfile(os.path.join(
os.path.dirname(os.path.realpath(__file__)), '..', 'custom_config.py'),
silent=True)
if config_path:
app.config.from_pyfile(config_path)
if debug is not None:
app.debug = debug
if app.debug and app.config['SECRET_KEY']:
app.init_debug_toolbar()
# Redis (cache)
from brainzutils import cache
try:
cache.init(
host=app.config["REDIS_HOST"],
port=app.config["REDIS_PORT"],
namespace=app.config["REDIS_NAMESPACE"],
)
except KeyError as e:
logging.error(
"Redis is not defined in config file. Error: {}".format(e))
raise
# Logging
app.init_loggers(file_config=app.config.get('LOG_FILE'),
sentry_config=app.config.get('LOG_SENTRY'))
# Extensions
from flask_uuid import FlaskUUID
FlaskUUID(app)
# Error handling
from messybrainz.webserver.errors import init_error_handlers
init_error_handlers(app)
# Template utilities
app.jinja_env.add_extension('jinja2.ext.do')
from messybrainz.webserver import utils
app.jinja_env.filters['date'] = utils.reformat_date
app.jinja_env.filters['datetime'] = utils.reformat_datetime
# Blueprints
from messybrainz.webserver.views.index import index_bp
from messybrainz.webserver.views.api import api_bp
app.register_blueprint(index_bp)
app.register_blueprint(api_bp)
db.init_db_engine(app.config['SQLALCHEMY_DATABASE_URI'])
return app
import os
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_uuid import FlaskUUID
from .config import CONFIG_BY_NAME
db = SQLAlchemy() # pylint: disable=invalid-name
uuid = FlaskUUID() # pylint: disable=invalid-name
def create_app(config_name=os.getenv("DOCAPI_ENV", "dev")):
print("create app", config_name)
app = Flask(__name__)
app.config.from_object(CONFIG_BY_NAME[config_name])
db.init_app(app)
uuid.init_app(app)
@app.after_request
def add_header(response):
response.headers["Access-Control-Allow-Origin"] = "*"
return response
return app
def configure_uuid(graph):
"""
Register the UUID converter.
"""
return FlaskUUID(graph.flask)
from werkzeug.utils import secure_filename
from models.user import User
from models.image import Image
from models.container import Container
from models.dockerfile import Dockerfile
from database import mongo
from util import deserialize_json
log = logging.Logger("webdock")
app = Flask(__name__)
app.config["MONGO_URI"] = "mongodb://localhost:27017/webdock"
mongo.init_app(app)
m_uuid = FlaskUUID()
m_uuid.init_app(app)
from routers.user import user_api
from routers.dockers import docker_api
from routers.dockerfile import dockerfile_api
from routers.payment import payment_api
from routers.admin import admin_api
from routers.api import api_api
from routers.userfile import userfile_api
app.register_blueprint(user_api)
app.register_blueprint(docker_api)
app.register_blueprint(dockerfile_api)
app.register_blueprint(payment_api)
app.register_blueprint(admin_api)
