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)
from sqlalchemy import orm, types, Column, ForeignKey from sqlalchemy.ext.hybrid import hybrid_property from alchy import model, query from alchy.types import DeclarativeEnum Model = model.make_declarative_base() class Foo(Model): __tablename__ = 'foo' _id = Column(types.Integer(), primary_key=True) string = Column(types.String()) number = Column(types.Integer()) boolean = Column(types.Boolean(), default=True) deferred1_col1 = orm.deferred(Column(types.Boolean()), group='deferred_1') deferred1_col2 = orm.deferred(Column(types.Boolean()), group='deferred_1') deferred2_col3 = orm.deferred(Column(types.Boolean()), group='deferred_2') deferred2_col4 = orm.deferred(Column(types.Boolean()), group='deferred_2') bars = orm.relationship('Bar', lazy=True) quxs = orm.relationship('Qux', lazy=True) __advanced_search__ = { 'foo_string': lambda value: Foo.string.like('%{0}%'.format(value)), 'foo_number': lambda value: Foo.number == value }
class TestMultipleEngineBinds(TestBase): class config(object): binds = [ 'sqlite:///bind0.test.db', 'sqlite:///bind1.test.db', 'sqlite:///bind2.test.db' ] SQLALCHEMY_DATABASE_URI = binds[0] SQLALCHEMY_BINDS = { 'bind1': binds[1], 'bind2': { 'SQLALCHEMY_DATABASE_URI': binds[2] } } Model = model.make_declarative_base() class Bind0(Model): _id = Column(types.Integer(), primary_key=True) class Bind1(Model): __bind_key__ = 'bind1' _id = Column(types.Integer(), primary_key=True) class Bind2(Model): __bind_key__ = 'bind2' _id = Column(types.Integer(), primary_key=True) def setUp(self): self.db = manager.Manager(config=self.config, Model=self.Model) self.db.create_all() self.engine0 = self.db.engine self.engine1 = self.db.get_engine('bind1') self.engine2 = self.db.get_engine('bind2') def tearDown(self): for db in glob.glob('*.test.db'): os.remove(db) def test_bind_engines(self): """Test that each bind engine is accessible and configured properly.""" self.assertEqual( str(self.db.engine.url), self.config.binds[0]) self.assertEqual( str(self.db.get_engine('bind1').url), self.config.binds[1]) self.assertEqual( str(self.db.get_engine('bind2').url), self.config.binds[2]) def test_bind_tables(self): """Test that tables are created in the proper database.""" self.assertEqual( self.engine0.execute('select * from bind0').fetchall(), []) self.assertEqual( self.engine1.execute('select * from bind1').fetchall(), []) self.assertEqual( self.engine2.execute('select * from bind2').fetchall(), []) try: self.engine0.execute('select * from bind1') except Exception as e: self.assertIn('no such table', str(e)) try: self.engine0.execute('select * from bind2') except Exception as e: self.assertIn('no such table', str(e)) try: self.engine1.execute('select * from bind0') except Exception as e: self.assertIn('no such table', str(e)) try: self.engine1.execute('select * from bind2') except Exception as e: self.assertIn('no such table', str(e)) try: self.engine2.execute('select * from bind0') except Exception as e: self.assertIn('no such table', str(e)) try: self.engine2.execute('select * from bind1') except Exception as e: self.assertIn('no such table', str(e)) def test_bind_inserts(self): """Test that records are inserted into the proper database when using models.""" self.db.add_commit(self.Bind0()) self.db.add_commit(self.Bind1()) self.db.add_commit(self.Bind2()) self.assertTrue(self.Bind0.query.count() > 0) self.assertEqual( self.Bind0.query.count(), self.engine0.execute('select count(*) from bind0').fetchone()[0]) self.assertTrue(self.Bind1.query.count() > 0) self.assertEqual( self.Bind1.query.count(), self.engine1.execute('select count(*) from bind1').fetchone()[0]) self.assertTrue(self.Bind2.query.count() > 0) self.assertEqual( self.Bind2.query.count(), self.engine2.execute('select count(*) from bind2').fetchone()[0]) def test_create_drop_all_by_bind(self): """Test that create/drop all can be used to target a specific bind.""" self.db.drop_all(bind='bind1') self.assertEqual( self.engine0.execute('select * from bind0').fetchall(), []) self.assertEqual( self.engine2.execute('select * from bind2').fetchall(), []) try: self.engine1.execute('select * from bind1') except Exception as e: self.assertIn('no such table', str(e)) self.db.create_all(bind='bind1') self.assertEqual( self.engine1.execute('select * from bind1').fetchall(), []) self.db.drop_all(bind=['bind1', 'bind2']) try: self.engine1.execute('select * from bind1') except Exception as e: self.assertIn('no such table', str(e)) try: self.engine2.execute('select * from bind2') except Exception as e: self.assertIn('no such table', str(e)) self.db.create_all(bind=['bind1', 'bind2']) self.assertEqual( self.engine1.execute('select * from bind1').fetchall(), []) self.assertEqual( self.engine2.execute('select * from bind2').fetchall(), []) def test_reflect(self): """Test that existing database tables can be reflected.""" rdb = manager.Manager( config={'SQLALCHEMY_DATABASE_URI': self.config.binds[0]}) self.assertEqual(len(rdb.metadata.tables), 0) rdb.reflect() self.assertEqual(len(rdb.metadata.tables), 1) self.assertIn('bind0', rdb.metadata.tables)
# -*- coding: utf-8 -*- from alchy.model import ModelBase, make_declarative_base from flask_security import UserMixin, RoleMixin from sqlalchemy import orm, types, Column, ForeignKey, Table from . import login_manager from ..bases import AutoTableMixin BaseAuthModel = make_declarative_base(Base=ModelBase, # Meta=Trackable ) roles_users = Table('roles_users', BaseAuthModel.metadata, Column('user_id', types.Integer(), ForeignKey('users.id')), Column('role_id', types.Integer(), ForeignKey('roles.id'))) class Role(AutoTableMixin, RoleMixin, BaseAuthModel): """Allows users to have different roles""" __tablename__ = 'roles' id = Column(types.Integer, primary_key=True) name = Column(types.String, unique=True) description = Column(types.String) def __init__(self, name, description='', permissions=None): self.name = name self.description = description def __repr__(self):
from sqlalchemy import orm, types, Column, ForeignKey from sqlalchemy.ext.hybrid import hybrid_property from alchy import model, query from alchy.types import DeclarativeEnum Model = model.make_declarative_base() class FooQuery(query.QueryModel): __search_filters__ = { 'foo_string': lambda value: Foo.string.contains(value), 'foo_string2': lambda value: Foo.string2.contains(value), 'foo_number': lambda value: Foo.number == value, 'bar_string': lambda value: Foo.bars.any(Bar.string.contains(value)) } __advanced_search__ = ['foo_string', 'foo_string2', 'foo_number'] __simple_search__ = ['foo_string', 'foo_string2', 'bar_string'] class Foo(Model): __tablename__ = 'foo' query_class = FooQuery _id = Column(types.Integer(), primary_key=True) string = Column(types.String()) string2 = Column(types.String()) number = Column(types.Integer()) boolean = Column(types.Boolean(), default=True) deferred1_col1 = orm.deferred(Column(types.Boolean()), group='deferred_1')
# -*- coding: utf-8 -*- """ 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:
# -*- coding: utf-8 -*- import re from collections import namedtuple from alchy.model import ModelBase, make_declarative_base from sqlalchemy import (orm, types, Column, ForeignKey, Index, PrimaryKeyConstraint, ForeignKeyConstraint) from intertwine.utils.mixins import AutoTablenameMixin, KeyedUp BaseGeoDataModel = make_declarative_base(Base=ModelBase) class State(KeyedUp, AutoTablenameMixin, BaseGeoDataModel): STATE = 'state' TERRITORY = 'territory' FEDERAL_DISTRICT = 'federal district' name = Column(types.String(60), unique=True) # Texas stusps = Column(types.String(2), unique=True) # TX statefp = Column(types.String(2), primary_key=True) # 48 statens = Column(types.String(8), unique=True) # 01779801 KEYED_UP_FIELDS = ('name', 'stusps', 'statefp', 'statens') TERRITORIES = {'PR', 'AS', 'GU', 'MP', 'UM', 'VI'} SMALL_TERRITORIES = {'AS', 'GU', 'MP', 'UM', 'VI'} STATES_WITH_MCDS = { # Additional beyond STATES_WITH_MCDS_AS_GOVERNMENTAL_UNITS: # 'AR', 'IA', 'LA', 'MD', 'MS', 'NC', 'TN', 'VA', 'WV', 'PR',