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)