def __init__(self, config, Model=None, engine_config_prefix=''):
self.Model = model.make_declarative_base() if Model is None else Model
self.config = config
engine_config = self.config['engine']
self.engine = engine_from_config(engine_config, prefix=engine_config_prefix)
session_config = self.config.get('session', {})
session_config['bind'] = self.engine
session_config.setdefault('autocommit', False)
session_config.setdefault('autoflush', True)
session_config.setdefault('query_cls', query.Query)
self.session = orm.scoped_session(orm.sessionmaker())
self.session.configure(**session_config)
if self.Model:
model.extend_declarative_base(self.Model, self.session)
def __init__(
self,
db_config=DevConfig.DATABASE,
ModelBases=[
BaseAuthModel,
# BaseCommunityModel, BaseGeoModel,
# BaseProblemModel,
IntertwineModel
]):
DSM = DataSessionManager
if DSM.engine is None:
DSM.engine = create_engine(db_config)
# Create tables if they don't exist
for ModelBase in ModelBases:
ModelBase.metadata.create_all(DSM.engine)
if DSM.session_factory is None:
DSM.session_factory = sessionmaker(bind=DSM.engine)
if DSM.session is None:
DSM.session = scoped_session(DSM.session_factory)
extend_declarative_base(IntertwineModel, session=DSM.session)
def session(db, request):
"""Create new database session for a test"""
connection = db.engine.connect()
transaction = connection.begin()
options = dict(bind=connection, binds={})
session = db.create_scoped_session(options=options)
extend_declarative_base(IntertwineModel, session=session)
db.session = session
def teardown():
Trackable.clear_all()
transaction.rollback()
connection.close()
session.remove()
request.addfinalizer(teardown)
assert session is not None
return session
Base platform for intertwine.
"""
import flask
from alchy import Manager
from alchy.model import extend_declarative_base, make_declarative_base
from flask_bootstrap import Bootstrap
from .bases import BaseIntertwineMeta, BaseIntertwineModel
from .__metadata__ import * # noqa
# Set up base model and database connection, and attach query property
IntertwineModel = make_declarative_base(Base=BaseIntertwineModel,
Meta=BaseIntertwineMeta)
intertwine_db = Manager(Model=IntertwineModel)
extend_declarative_base(IntertwineModel, session=intertwine_db.session)
from . import auth, communities, content, geos, main, problems, signup # noqa
IntertwineModel.initialize_table_model_map()
def create_app(name=None, config=None):
"""Creates an app based on a config file
Args:
config: Configuration
Returns:
Flask: a Flask app
from alchy import Manager
from alchy.model import extend_declarative_base
modname = __name__.split('.')[-1]
blueprint = Blueprint(modname, __name__, template_folder='templates')
login_manager = LoginManager()
# Must come later as we use blueprint and query property in views
from . import views
# Must come later as we use login_manager in models
from . import models
# Attach to the database
auth_db = Manager(Model=models.BaseAuthModel)
# Attach query property to BaseProblemModel
extend_declarative_base(models.BaseAuthModel, session=auth_db.session)
# Setup Flask Login/Security
auth_users = SQLAlchemyUserDatastore(auth_db, models.User, models.Role)
security = Security()
@blueprint.record_once
def on_load(state):
login_manager.init_app(state.app)
# config=DevConfig,
auth_db.config.update(state.app.config)
auth_db.create_all()
security.init_app(app=state.app, datastore=auth_users)
# -*- coding: utf-8 -*-
from flask import Blueprint
from alchy import Manager
from alchy.model import extend_declarative_base
from . import models
blueprint = Blueprint(models.Geo.blueprint_name(),
__name__,
template_folder='templates',
static_folder='static')
geo_db = Manager(Model=models.BaseGeoModel)
# Attach query property to base model
extend_declarative_base(models.BaseGeoModel, session=geo_db.session)
# Must come later as we use blueprint and query property in views
from . import views # noqa
@blueprint.record_once
def on_load(state):
# Set up database tables
geo_db.config.update(state.app.config)
geo_db.create_all()
# -*- coding: utf-8 -*-
from flask import Blueprint
from alchy import Manager
from alchy.model import extend_declarative_base
from . import models
blueprint = Blueprint(models.Community.blueprint_name(), __name__,
template_folder='templates', static_folder='static')
community_db = Manager(Model=models.BaseCommunityModel)
# Attach query property to base model
extend_declarative_base(models.BaseCommunityModel,
session=community_db.session)
# Must come later as we use blueprint and query property in views
from . import views
@blueprint.record_once
def on_load(state):
# Set up database tables
community_db.config.update(state.app.config)
community_db.create_all()
# -*- coding: utf-8 -*-
from flask import Blueprint
from alchy import Manager
from alchy.model import extend_declarative_base
from . import models
blueprint = Blueprint(models.Problem.blueprint_name(), __name__,
template_folder='templates', static_folder='static')
problem_db = Manager(Model=models.BaseProblemModel)
# Attach query property to BaseProblemModel
extend_declarative_base(models.BaseProblemModel, session=problem_db.session)
# Must come later as we use blueprint and query property in views
from . import views
@blueprint.record_once
def on_load(state):
# Set up database tables
problem_db.config.update(state.app.config)
problem_db.create_all()
# -*- coding: utf-8 -*-
from flask import Blueprint
from alchy import Manager
from alchy.model import extend_declarative_base
from . import models
blueprint = Blueprint(models.Content.blueprint_name(),
__name__,
template_folder='templates',
static_folder='static')
content_db = Manager(Model=models.BaseContentModel)
# Attach query property to BaseProblemModel
extend_declarative_base(models.BaseContentModel, session=content_db.session)
# Must come later as we use blueprint and query property in views
from . import views
@blueprint.record_once
def on_load(state):
# Set up database tables
content_db.config.update(state.app.config)
content_db.create_all()
