def test_database_url(self): app = Flask(__name__) app.config['DATABASE'] = 'sqlite:///nugget.db' database = FlaskDB(app) Model = database.Model self.assertTrue(isinstance(Model._meta.database, SqliteDatabase)) self.assertEqual(Model._meta.database.database, 'nugget.db') # If a value is specified, it trumps config value. database = FlaskDB(app, 'sqlite:///nuglets.db') Model = database.Model self.assertEqual(Model._meta.database.database, 'nuglets.db')
def database_setup(working_dir: str, app: Flask = None): storage.init(working_dir) db_path = os.path.join(working_dir, "db.sqlite") database.init(db_path) if app: FlaskDB(app, database) database.connect() models = [ Job, Project, ProjectBenchmark, ProjectModel, ProjectData, ProjectLossProfile, ProjectPerfProfile, ProjectOptimization, ProjectOptimizationModifierPruning, ProjectOptimizationModifierQuantization, ProjectOptimizationModifierLRSchedule, ProjectOptimizationModifierTrainable, ] database.create_tables( models=models, safe=True, ) for model in models: model.raw("PRAGMA foreign_keys=ON").execute() database.start() database.close()
def test_database_url(self): app = Flask(__name__) app.config['DATABASE'] = 'sqlite:///nugget.db' database = FlaskDB(app) Model = database.Model self.assertTrue(isinstance(Model._meta.database, SqliteDatabase)) self.assertEqual(Model._meta.database.database, 'nugget.db')
def test_deferred_database(self): app = Flask(__name__) app.config.update({ 'DATABASE': { 'name': ':memory:', 'engine': 'peewee.SqliteDatabase' } }) # Defer initialization of the database. database = FlaskDB() # Ensure we can access the Model attribute. Model = database.Model model_db = Model._meta.database # Because the database is not initialized, the models will point # to an uninitialized Proxy object. self.assertTrue(isinstance(model_db, Proxy)) self.assertRaises(AttributeError, lambda: model_db.database) class User(database.Model): username = CharField(unique=True) # Initialize the database with our Flask app. database.init_app(app) # Ensure the `Model` property points to the same object as it # did before. PostInitModel = database.Model self.assertTrue(Model is PostInitModel) # Ensure that the proxy is initialized. self.assertEqual(model_db.database, ':memory:') # Ensure we can use our database. User.create_table() for username in ['charlie', 'huey', 'zaizee']: User.create(username=username) self.assertEqual(User.select().count(), 3) users = User.select().order_by(User.username) self.assertEqual([user.username for user in users], ['charlie', 'huey', 'zaizee']) self.assertEqual(User._meta.database, database.database)
def test_deferred_database(self): app = Flask(__name__) app.config.update({ 'DATABASE': { 'name': ':memory:', 'engine': 'peewee.SqliteDatabase'}}) # Defer initialization of the database. database = FlaskDB() # Ensure we can access the Model attribute. Model = database.Model model_db = Model._meta.database # Because the database is not initialized, the models will point # to an uninitialized Proxy object. self.assertTrue(isinstance(model_db, Proxy)) self.assertRaises(AttributeError, lambda: model_db.database) class User(database.Model): username = CharField(unique=True) # Initialize the database with our Flask app. database.init_app(app) # Ensure the `Model` property points to the same object as it # did before. PostInitModel = database.Model self.assertTrue(Model is PostInitModel) # Ensure that the proxy is initialized. self.assertEqual(model_db.database, ':memory:') # Ensure we can use our database. User.create_table() for username in ['charlie', 'huey', 'zaizee']: User.create(username=username) self.assertEqual(User.select().count(), 3) users = User.select().order_by(User.username) self.assertEqual( [user.username for user in users], ['charlie', 'huey', 'zaizee']) self.assertEqual(User._meta.database, database.database)
def test_database(self): app = Flask(__name__) app.config.update({ 'DATABASE': { 'name': ':memory:', 'engine': 'peewee.SqliteDatabase'}}) database = FlaskDB(app) Model = database.Model self.assertTrue(isinstance(Model._meta.database, SqliteDatabase)) self.assertEqual(Model._meta.database.database, ':memory:') # Multiple calls reference the same object. self.assertTrue(database.Model is Model)
def create_app(config_name): _app = Flask(__name__) _app.config.from_object(config[config_name]) _app.json_encoder = JSONEncoder config[config_name].init_app(_app) CORS(_app, supports_credentials=True) FlaskDB(_app, db) from .app1 import app1 _app.register_blueprint(app1, url_prefix='/app1/v1') from .app2 import app2 _app.register_blueprint(app2, url_prefix='/app2/v1') if config[config_name].swagger_config.get("template"): swagger = Swagger(_app, config=config[config_name].swagger_config, template=config[config_name].swagger_config.get("template")) else: swagger = Swagger(_app, config=config[config_name].swagger_config) return _app
def create_app(config_name): app = Flask(__name__, static_folder="../../dist/static", template_folder="../../dist") FlaskDB( app, db ) # 解决peewee不自动关闭连接池连接,参见https://www.cnblogs.com/xueweihan/p/6698456.html CORS(app, supports_credentials=True) app.config.from_object(config[config_name]) config[config_name].init_app(app) from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .search import search as search_blueprint app.register_blueprint(search_blueprint, url_prefix='/search') from .login import login as login_blueprint app.register_blueprint(login_blueprint, url_prefix='/login') from .weather import weather as weather_blueprint app.register_blueprint(weather_blueprint, url_prefix='/weather') from .bookmarks import bookmarks as bookmarks_blueprint app.register_blueprint(bookmarks_blueprint, url_prefix='/bookmarks') from .console import console as console_blueprint app.register_blueprint(console_blueprint, url_prefix='/console') from .script import script as script_blueprint app.register_blueprint(script_blueprint, url_prefix='/script') from .privilege import privilege as privilege_blueprint app.register_blueprint(privilege_blueprint, url_prefix='/privilege') from .app_price_monitor import app_price_monitor as app_price_monitor_blueprint app.register_blueprint(app_price_monitor_blueprint, url_prefix='/app') from .push import push as push_blueprint app.register_blueprint(push_blueprint, url_prefix='/push') return app
def initialize_database(args, admin_user, admin_pw): ''' Initialize ampt_manager database. Create initial database tables from model definitions. This is used during creation of new app instance/config. ''' ampt_db = SqliteDatabase(app.config['DATABASE']) database = FlaskDB(app, ampt_db) # Create tables from peewee models for model in MODEL_LIST: # If told to force initialization, drop existing tables. Fail silently # if force option specified but no tables exist. if args.force: model.drop_table(fail_silently=True) model.create_table() # Create default admin user pw_hash = bcrypt.generate_password_hash(admin_pw) initial_user = User() initial_user.username=admin_user initial_user.display_name='Admin User' initial_user.password=pw_hash initial_user.email='root@localhost' initial_user.save() # Create local probe generator ProbeGenerator.create(name='Local', address='localhost', port=settings.probe_generator_default_port, auth_key='', active=False, created_by=initial_user, last_modified_by=initial_user)
# -*- coding: utf-8 -*- from flask import Flask from flask_cors import * from app import create from app.models import create_table, db from config import * from playhouse.flask_utils import FlaskDB import sys app = Flask(__name__) FlaskDB(app, db) # from app import novel CORS(app, supports_credentials=True) # app.register_blueprint(novel.app, url_prefix="/erolight") app = create(app) if __name__ == "__main__": if len(sys.argv) is not 1: create_table() app.run(port=WEB_PORT, host=WEB_ADDRESS, debug=True)
from flask import Flask, url_for from flask_cors import CORS from playhouse.flask_utils import FlaskDB app = Flask(__name__) CORS(app, supports_credentials=True) app.config['SERVER_NAME'] = "127.0.0.1:5000" db_wrapper = FlaskDB(app, 'sqlite:///db.sqlite') from app.views import auth_bp, post_bp, banking_mock_bp, banking_bp app.register_blueprint(auth_bp, url_prefix="/api/auth") app.register_blueprint(post_bp, url_prefix="/api/posts") app.register_blueprint(banking_mock_bp, url_prefix="/api/banking_mock") app.register_blueprint(banking_bp, url_prefix="/api/banking") app.secret_key = "beep" with app.app_context(): print(url_for('auth.register'))
import importlib import logging.config import click from flask import Flask, jsonify from flask.cli import with_appcontext from werkzeug.contrib.cache import RedisCache from playhouse.flask_utils import FlaskDB from celery import Celery from app import settings db = FlaskDB() def create_app(config_test=None): logging.config.dictConfig(settings.LOGGING) app = Flask(__name__) app.config.from_object(settings) if config_test: app.config.update(config_test) db.init_app(app) app.db = db app.cache = RedisCache(host=settings.REDIS_HOST, port=settings.REDIS_PORT, db=settings.REDIS_DB)
import os import logging from flask import Flask from playhouse.flask_utils import FlaskDB from flask_admin import Admin from hse_arch.admin import init_admin # from hse_arch.api import init_app db = FlaskDB() # Создаем обертку над БД admin = Admin() # Создаем обертку над админкой # restful_api = Api() # не уверен, что это делается здесь # auth = Auth() # не уверен, что это делается здесь # peewee_api = RestAPI() # не уверен, что это делается здесь config = { "production": "config.ProductionConfig", "development": "config.DevelopmentConfig", "testing": "config.TestingConfig", "default": "config.Config" } # TODO: https://damyanon.net/post/flask-series-configuration/ - возможно, стоит использовать env переменную def create_app(config_class): from hse_arch.models.category import Category from hse_arch.models.customer import Customer from hse_arch.models.order import Order, OrderItem from hse_arch.models.product import Product, ProductIngredient, Ingredient from hse_arch.models.producers import Producer from hse_arch.models.user import User app = Flask(__name__) # Создаем экземпляр класса Flask-приложения
from flask_login import UserMixin from peewee import * from flask_admin.contrib.peewee import ModelView from playhouse.flask_utils import FlaskDB from playhouse.hybrid import hybrid_property from playhouse.sqlite_ext import * from digital_library.app import app, admin db_wrapper = FlaskDB(app) database = db_wrapper.database # TODO: add types validation class BaseModel(db_wrapper.Model): admin_view = None # `id` field is created by peewee class TAG(BaseModel): Name = TextField(unique=True) class USER( BaseModel, UserMixin ): # if a method is implemented in BaseModel then this method is used Email = TextField(unique=True) FirstName = TextField()
# List of supported EventMonitor types MONITOR_TYPES = [ ('bro', 'Bro sensor'), ('snort', 'Snort sensor'), ('suricata', 'Suricata sensor'), ] # List of supported probe IP protocols PROBE_PROTOCOLS = [ ('tcp', 'TCP'), ('udp', 'UDP'), ] # Support logs from event monitors that don't include IP protocol LOG_PROBE_PROTOCOLS = PROBE_PROTOCOLS + [('unspecified', 'Unspecified')] ampt_db = SqliteDatabase(app.config['DATABASE']) database = FlaskDB(app, ampt_db) class BaseModel(database.Model): pass class User(BaseModel, UserMixin): username = CharField(max_length=75, unique=True, help_text='User name') display_name = CharField(max_length=75, help_text='User name') password = CharField(max_length=255, help_text='Password') email = CharField(max_length=150, unique=True, help_text='User email address') active = BooleanField(default=True) def check_password(self, password): 'Verify supplied user password against stored hash' return bcrypt.check_password_hash(self.password, password)
def create_app(config_name): app = Flask(__name__, static_folder="../../dist/static", template_folder="../../dist") FlaskDB( app, db ) # 解决peewee不自动关闭连接池连接,参见https://www.cnblogs.com/xueweihan/p/6698456.html CORS(app, supports_credentials=True) from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .widget import widget as widget_blueprint app.register_blueprint(widget_blueprint, url_prefix='/widget') from .cloud_drive import cloud_drive as cloud_drive_blueprint app.register_blueprint(cloud_drive_blueprint, url_prefix='/cloudDrive') from .search import search as search_blueprint app.register_blueprint(search_blueprint, url_prefix='/search') from .login import login as login_blueprint app.register_blueprint(login_blueprint, url_prefix='/login') from .weather import weather as weather_blueprint app.register_blueprint(weather_blueprint, url_prefix='/weather') from .bookmarks import bookmarks as bookmarks_blueprint app.register_blueprint(bookmarks_blueprint, url_prefix='/bookmarks') from .console import console as console_blueprint app.register_blueprint(console_blueprint, url_prefix='/console') from .script import script as script_blueprint app.register_blueprint(script_blueprint, url_prefix='/script') from .privilege import privilege as privilege_blueprint app.register_blueprint(privilege_blueprint, url_prefix='/privilege') from .app_price_monitor import app_price_monitor as app_price_monitor_blueprint app.register_blueprint(app_price_monitor_blueprint, url_prefix='/app') from .push import push as push_blueprint app.register_blueprint(push_blueprint, url_prefix='/push') from .gold_price_monitor import gold_price_monitor as gold_price_monitor_blueprint app.register_blueprint(gold_price_monitor_blueprint, url_prefix='/gold') from .notes import notes as notes_blueprint app.register_blueprint(notes_blueprint, url_prefix='/notes') from .short_url import short_url as short_url_blueprint app.register_blueprint(short_url_blueprint, url_prefix='/s') from .image_hosting import image_hosting as image_hosting_blueprint app.register_blueprint(image_hosting_blueprint, url_prefix='/imageHosting') from .translator import translator as translator_blueprint app.register_blueprint(translator_blueprint, url_prefix='/translator') from .wallpapers import wallpapers as wallpapers_blueprint app.register_blueprint(wallpapers_blueprint, url_prefix='/wallpapers') from .stock import stock as stock_blueprint app.register_blueprint(stock_blueprint, url_prefix='/stock') from .fund import fund as fund_blueprint app.register_blueprint(fund_blueprint, url_prefix='/fund') from .news import news as news_blueprint app.register_blueprint(news_blueprint, url_prefix='/news') return app
from flask import Flask app = Flask(__name__) from flask_cors import CORS CORS(app) from flask_jwt_extended import JWTManager app.config['JWT_SECRET_KEY'] = 'jwt-secret-string' # change before running jwt = JWTManager(app) from playhouse.flask_utils import FlaskDB from peewee import SqliteDatabase db = SqliteDatabase('/home/sinity/dev/pwrank/db') # change before running db_wrapper = FlaskDB(app, db) from flask_restful import Api from resource import * api = Api(app) api.add_resource(AuthResource, '/auth') api.add_resource(UserResource, '/auth/user/<uuid:uid>') api.add_resource(UserCollectionResource, '/auth/user') api.add_resource(RankingResource, '/ranking/<uuid:uid>') api.add_resource(RankingCollectionResource, '/ranking') api.add_resource(CompareResource, '/compare/<uuid:ranking_uid>')
{ 'x': [1, 2, 3], 'y': [2, 4, 5], 'type': 'bar', 'name': u'Montréal' }, ], 'layout': { 'title': 'Dash Data Visualization' } }) ]) # FlaskDB is a wrapper for a peewee database that sets up pre/post-request # hooks for managing database connections. flask_db = FlaskDB(flask_app) # The `database` is the actual peewee database, as opposed to flask_db which is # the wrapper. database = flask_db.database # Configure micawber with the default OEmbed providers (YouTube, Flickr, etc). # We'll use a simple in-memory cache so that multiple requests for the same # video don't require multiple network requests. oembed_providers = bootstrap_basic(OEmbedCache()) class Entry(flask_db.Model): title = CharField() slug = CharField(unique=True) content = TextField()
from flask_login import LoginManager from playhouse.flask_utils import FlaskDB from flask_bcrypt import Bcrypt login_manager = LoginManager() database = FlaskDB() bcrypt = Bcrypt()
# the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # Cellcfg is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Cellcfg. If not, see <http://www.gnu.org/licenses/>. ########################################################################### import importlib from flask import Flask from playhouse.flask_utils import FlaskDB from .proxy import ReverseProxied from cellconfig import conf, db app = Flask(__name__) app.wsgi_app = ReverseProxied(app.wsgi_app) app.config.update(dict(conf.items(__package__))) database = FlaskDB(app, db) import views import views_admin import api import event if conf.has_option(__package__, 'PLUGIN'): for plugin in conf.get(__package__, 'PLUGIN').split(':'): importlib.import_module(plugin, package=__package__)
app = Flask(__name__, ) env = os.environ.get("FLASK_ENV") try: app.config.from_pyfile(f"config/{env}.py") except Exception as e: print(f"{e.__class__.__name__}: {e}") CORS(supports_credentials=True).init_app(app) if app.config["DATABASE_TYPE"] == "mysql": database = pe.MySQLDatabase(app.config["DATABASE"], **app.config["DATABASE_CONF"]) if app.config["DATABASE_TYPE"] == "sqlite": database = pe.SqliteDatabase(app.config["SQLITE_DB"], pragmas=app.config["SQLITE_CONF"]) db = FlaskDB(app, database) from apps import * from common.db.init import db_cli app.cli.add_command(db_cli) """ 函数模板 """ from common.libs.UrlManager import UrlManager app.add_template_global(UrlManager.buildStaticUrl, "buildStaticUrl") app.add_template_global(UrlManager.buildUrl, "buildUrl") if __name__ == "__main__": app.run()
# -*- coding: utf-8 -*- import json from playhouse.flask_utils import FlaskDB dbcourse_wrapper = FlaskDB(database='mysql://*****:*****@databaseip:port/database_instance') STATUS_VALID = 1 STATUS_INVALID = 0 class CourseBaseModel(dbcourse_wrapper.Model): def __str__(self): r = {} for k in self._data.keys(): try: r[k] = str(getattr(self, k)) except: r[k] = json.dumps(getattr(self, k)) # return str(r) return json.dumps(r, ensure_ascii=False)
from playhouse.flask_utils import FlaskDB flask_db = FlaskDB()
# -*- coding: utf-8 -*- import datetime import os from marshmallow_peewee import * from peewee import * from playhouse.flask_utils import FlaskDB from package.base.app import webapp if os.environ.get('FLASK_ENV') == 'development': import logging logger = logging.getLogger('peewee') logger.addHandler(logging.StreamHandler()) logger.setLevel(logging.DEBUG) # 会被存入webapp.config供FlaskDB使用 DATABASE = 'postgresql://*****:*****@localhost:5432/test' # 将当前文件的以大写字母开头的字符串存入webapp.config webapp.config.from_object(__name__) flask_db = FlaskDB(webapp) database = flask_db.database
import datetime, functools from flask import Flask, session, redirect, url_for, escape, request, jsonify from peewee import * from playhouse.flask_utils import FlaskDB app = Flask(__name__) # Set the secret key to some random bytes. Keep this really secret! app.secret_key = b'_5#y2L"F4Q8z\n\xec]/' database = SqliteDatabase("test.db") db_wrap = FlaskDB(app, database=database) class Role(db_wrap.Model): id = AutoField() name = CharField(default="ordinary_user", help_text="角色名") def __repr__(self): return "<Role: {}>".format(self.name) class User(db_wrap.Model): id = AutoField() nickname = CharField(default="null") username = CharField(index=True, unique=True) password = CharField(help_text="密码") create_time = DateTimeField( default=datetime.datetime.now, help_text="账号创建时间") def to_data(self): return {
from datetime import datetime, timedelta from threading import Lock from peewee import DateTimeField, CharField, SmallIntegerField, IntegerField, \ DoubleField, BooleanField, InsertQuery from playhouse.flask_utils import FlaskDB from playhouse.migrate import migrate, MySQLMigrator from playhouse.pool import PooledMySQLDatabase from playhouse.shortcuts import RetryOperationalError from pgpool.config import cfg_get from pgpool.utils import cmp_bool log = logging.getLogger(__name__) flaskDb = FlaskDB() request_lock = Lock() db_schema_version = 4 webhook_queue = None class MyRetryDB(RetryOperationalError, PooledMySQLDatabase): pass # Reduction of CharField to fit max length inside 767 bytes for utf8mb4 charset class Utf8mb4CharField(CharField): def __init__(self, max_length=191, *args, **kwargs): self.max_length = max_length
def peewee_setup(request, app, tmpdir, realdburl): from peewee import ( TextField, DateTimeField, IntegerField, BooleanField, ForeignKeyField, CharField, ) from playhouse.flask_utils import FlaskDB if realdburl: engine_mapper = { "postgres": "peewee.PostgresqlDatabase", "mysql": "peewee.MySQLDatabase", } db_url, db_info = _setup_realdb(realdburl) pieces = urlsplit(db_url) db_config = { "name": pieces.path[1:], "engine": engine_mapper[pieces.scheme.split("+")[0]], "user": pieces.username, "passwd": pieces.password, "host": pieces.hostname, } else: f, path = tempfile.mkstemp(prefix="flask-security-test-db", suffix=".db", dir=str(tmpdir)) db_config = {"name": path, "engine": "peewee.SqliteDatabase"} app.config["DATABASE"] = db_config db = FlaskDB(app) class Role(db.Model, RoleMixin): name = CharField(unique=True, max_length=80) description = TextField(null=True) class User(db.Model, UserMixin): email = TextField() username = TextField() security_number = IntegerField(null=True) password = TextField(null=True) last_login_at = DateTimeField(null=True) current_login_at = DateTimeField(null=True) tf_primary_method = TextField(null=True) tf_totp_secret = TextField(null=True) tf_phone_number = TextField(null=True) us_totp_secrets = TextField(null=True) us_phone_number = TextField(null=True) last_login_ip = TextField(null=True) current_login_ip = TextField(null=True) login_count = IntegerField(null=True) active = BooleanField(default=True) confirmed_at = DateTimeField(null=True) class UserRoles(db.Model): """ Peewee does not have built-in many-to-many support, so we have to create this mapping class to link users to roles.""" user = ForeignKeyField(User, backref="roles") role = ForeignKeyField(Role, backref="users") name = property(lambda self: self.role.name) description = property(lambda self: self.role.description) with app.app_context(): for Model in (Role, User, UserRoles): Model.drop_table() Model.create_table() def tear_down(): if realdburl: db.close_db(None) _teardown_realdb(db_info) else: db.close_db(None) os.close(f) os.remove(path) request.addfinalizer(tear_down) return PeeweeUserDatastore(db, User, Role, UserRoles)
# third-party imports from flask import Flask from peewee import * from playhouse.flask_utils import FlaskDB # db variable initialization app = Flask(__name__) app.config.from_object('config') db = FlaskDB(app) database = db.database from app import views, models
from flask import Flask, render_template, request, redirect, url_for, flash from flask_login import LoginManager, logout_user, login_required, login_user from playhouse.flask_utils import FlaskDB, get_object_or_404 from wtfpeewee.orm import model_form from my_forms import * from config import POST_PER_PAGE as ppp application = Flask(__name__) application.config.from_object('config') #bootstrap = Bootstrap(application) login_manager = LoginManager() login_manager.session_protection = 'strong' login_manager.login_view = '/login' flask_db = FlaskDB(application) database = flask_db.database login_manager.init_app(application) from models import * @application.route('/login/', methods=['GET', 'POST']) def login(): form = LoginForm() if request.method == 'GET': u = User.select().count() if u != 0: form = LoginForm() return render_template('login.html', form=form) else: content = 'There are no users, please create a user'
# The secret key is used internally by Flask to encrypt session data stored # in cookies. Make this unique for your app. SECRET_KEY = 'shhh, secret!' # This is used by micawber, which will attempt to generate rich media # embedded objects with maxwidth=800. SITE_WIDTH = 800 # Create a Flask WSGI app and configure it using values from the module. app = Flask(__name__) app.config.from_object(__name__) # FlaskDB is a wrapper for a peewee database that sets up pre/post-request # hooks for managing database connections. flask_db = FlaskDB(app) # The `database` is the actual peewee database, as opposed to flask_db which is # the wrapper. database = flask_db.database # Configure micawber with the default OEmbed providers (YouTube, Flickr, etc). # We'll use a simple in-memory cache so that multiple requests for the same # video don't require multiple network requests. oembed_providers = bootstrap_basic(OEmbedCache()) class Entry(flask_db.Model): title = CharField() slug = CharField(unique=True) content = TextField()
from flask import Flask, abort, render_template, make_response, request, redirect, url_for from flask_login import LoginManager, UserMixin, login_required, login_user, logout_user, current_user from playhouse.flask_utils import FlaskDB from peewee import CharField, DateField from authomatic import Authomatic from authomatic.adapters import WerkzeugAdapter import config # Configure the Flask application instance. app = Flask(__name__) app.config["DATABASE"] = config.database app.config["SECRET_KEY"] = config.flask_secret # http://peewee.readthedocs.org/en/latest/peewee/playhouse.html#flask-utils database = FlaskDB(app) # http://flask-login.readthedocs.org/en/latest/#flask.ext.login.LoginManager login_manager = LoginManager() login_manager.init_app(app) # http://peterhudec.github.io/authomatic/reference/classes.html#authomatic.Authomatic authomatic = Authomatic(config.authomatic_config, config.authomatic_secret) # Super quick user model with peewee class User(UserMixin, database.Model): auth_provider = CharField() auth_id = CharField() name = CharField(null=True)