def make_declarative_base(self):
"""Creates the declarative base."""
base = declarative_base(cls=(JSONSerializableBase, Model),
name='Model',
metaclass=_BoundDeclarativeMeta)
base.query = _QueryProperty(self)
return base
def make_declarative_base(self):
from flask.ext.sqlalchemy import _BoundDeclarativeMeta, _QueryProperty
base = declarative_base(cls=MyModel,
name='MyModel',
metaclass=_BoundDeclarativeMeta)
base.query = _QueryProperty(self)
return base
def make_declarative_base(self):
"""Creates the declarative base."""
base = declarative_base(cls=Model,
name='Model',
metaclass=ModelDeclarativeMeta)
base.query = _QueryProperty(self)
return base
def make_declarative_base(self, *args):
"""Creates the declarative base."""
base = declarative_base(cls=_Model,
name='Model',
metadata=self.metadata,
metaclass=_BoundDeclarativeMeta)
base.query = _QueryProperty(self)
return base
def make_declarative_base(self, metadata=None):
"""Hack to pass customized constructor"""
base = declarative_base(cls=Model,
name='Model',
metaclass=_BoundDeclarativeMeta,
constructor=_customized_constructor)
base.query = _QueryProperty(self)
return base
def make_declarative_base(self, metadata=None):
"""Creates the declarative base."""
base = fsqla.declarative_base(
cls=fsqla.Model,
name='Model',
metadata=metadata,
metaclass=TableArgsMeta(
fsqla._BoundDeclarativeMeta,
{'mysql_engine': 'InnoDB'} ) )
base.query = fsqla._QueryProperty(self)
return base
def _patch_metadata():
naming_convention = {
'fk': ('fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s'
'_%(referred_column_0_name)s'),
'pk': 'pk_%(table_name)s',
'ix': 'ix_%(table_name)s_%(column_0_name)s',
'ck': 'ck_%(table_name)s_%(constraint_name)s',
'uq': 'uq_%(table_name)s_%(column_0_name)s',
}
metadata = MetaData(naming_convention=naming_convention)
base = declarative_base(cls=sqlalchemy.Model, name='Model',
metaclass=sqlalchemy._BoundDeclarativeMeta,
metadata=metadata)
base.query = sqlalchemy._QueryProperty(db)
db.Model = base
def _patch_metadata():
naming_convention = {
'fk': ('fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s'
'_%(referred_column_0_name)s'),
'pk':
'pk_%(table_name)s',
'ix':
'ix_%(table_name)s_%(column_0_name)s',
'ck':
'ck_%(table_name)s_%(constraint_name)s',
'uq':
'uq_%(table_name)s_%(column_0_name)s',
}
metadata = MetaData(naming_convention=naming_convention)
base = declarative_base(cls=sqlalchemy.Model,
name='Model',
metaclass=sqlalchemy._BoundDeclarativeMeta,
metadata=metadata)
base.query = sqlalchemy._QueryProperty(db)
db.Model = base
def make_declarative_base(self):
"""Creates the declarative base."""
base = declarative_base(cls=Model, name='Model',
metaclass=ModelDeclarativeMeta)
base.query = _QueryProperty(self)
return base
def to_dict(model):
""" converts a sqlalchemy model to a dictionary """
# first we get the names of all the columns on your model
columns = [c.key for c in sqlalchemy.orm.class_mapper(model.__class__).columns]
# then we return their values in a dict
return dict((c, getattr(model, c)) for c in columns)
# setup our base mapper and database metadata
metadata = db.MetaData()
base = declarative_base(cls=BaseMapper,
metaclass=_BoundDeclarativeMeta,
metadata=metadata,
name='Model')
base.query = _QueryProperty(db)
db.Model = base
class Report(base):
""" associative table for voting on things """
reporter_id = db.Column(
db.Integer, db.ForeignKey("user.id"), primary_key=True)
reporter = db.relationship('User', foreign_keys=[reporter_id])
reportee_id = db.Column(
db.Integer, db.ForeignKey("thing.id"), primary_key=True)
reportee = db.relationship('Thing')
reason = db.Column(db.String(255))
model_classes = []
if app.config.get("AUTOGENERATE_MODEL_ADMIN", True):
# We have to hook in to the db.Model metaclass to keep track of any table
# classes we define
class _AdminBoundDeclarativeMeta(sqlalchemy._BoundDeclarativeMeta):
def __init__(self, name, bases, d):
super(self.__class__, self).__init__(name, bases, d)
if name != "Model":
m = re.search(r'\.(.*)\.models', self.__module__)
categoryName = m.group(1)
model_classes.append((self, categoryName))
db.Model = sqlalchemy.declarative_base(cls=sqlalchemy.Model,
name="Model", mapper=sqlalchemy.signalling_mapper,
metaclass=_AdminBoundDeclarativeMeta)
db.Model.query = sqlalchemy._QueryProperty(db)
# Automatically include views, files and APIs
include_files = set(["views.py", "models.py", "api.py"])
for root, dirname, files in os.walk(app.config["BASEDIR"]):
for filename in files:
if filename in include_files:
relative = os.path.relpath(os.path.join(root, filename))[:-3]
module = ".".join(relative.split(os.sep))
__import__(module, level=-1)
for cls, categoryName in model_classes:
admin.add_view(SecuredModelView(cls, db.session,
category=categoryName))
from sqlalchemy.ext import declarative
import sqlalchemy
from eisitirio import app
from eisitirio.database import custom_model
DB = flask_sqlalchemy.SQLAlchemy(app.APP)
# Awkward hack to use a custom model class. Flask-SQLAlchemy 3.0 (in beta as of
# 2016-01-11) has a model_class parameter to the above constructor, which should
# be used once v3.0 is released as stable.
DB.Model = declarative.declarative_base(
cls=custom_model.CustomModel,
name='Model'.encode('us-ascii'),
metadata=None,
metaclass=custom_model.CustomModelMeta
)
DB.Model.query = flask_sqlalchemy._QueryProperty(DB) # pylint: disable=protected-access
@sqlalchemy.event.listens_for(sqlalchemy.Table, "column_reflect")
def column_reflect(_, unused, column_info):
"""Change the presented types of columns to avoid confusing alembic."""
if isinstance(column_info['type'], mysql.TINYINT):
column_info['type'] = sqlalchemy.Boolean()
if isinstance(column_info['type'], mysql.MEDIUMTEXT):
column_info['type'] = sqlalchemy.UnicodeText(length=65536)
if isinstance(column_info['type'], mysql.TEXT):
column_info['type'] = sqlalchemy.UnicodeText(length=256)
from wega.db.core import db
from flask.ext.sqlalchemy import BaseQuery, _QueryProperty
class Base(db.Model):
__abstract__ = True
def __init__(self, **kwargs):
for col_name in self.__table__.columns.keys():
setattr(self, col_name, kwargs.get(col_name))
Base.query_class = BaseQuery
Base.query = _QueryProperty(db)
class Product(Base):
__tablename__ = 'product'
id = db.Column(db.Integer, index=True, primary_key=True)
name = db.Column(db.String(255), index=True, nullable=False)
price = db.Column(db.Float(precision=2), index=True, nullable=False)
image_name = db.Column(db.String(255), index=True)
description = db.Column(db.String(1000))
composition = db.relationship('Composition')
#size = db.Column(db.Integer, index=True)
class Fiber(Base):
__tablename__ = 'fiber'
model_classes = []
if app.config.get("AUTOGENERATE_MODEL_ADMIN", True):
# We have to hook in to the db.Model metaclass to keep track of any table
# classes we define
class _AdminBoundDeclarativeMeta(sqlalchemy._BoundDeclarativeMeta):
def __init__(self, name, bases, d):
super(self.__class__, self).__init__(name, bases, d)
if name != "Model":
model_classes.append(self)
db.Model = sqlalchemy.declarative_base(
cls=sqlalchemy.Model,
name="Model",
mapper=sqlalchemy.signalling_mapper,
metaclass=_AdminBoundDeclarativeMeta)
db.Model.query = sqlalchemy._QueryProperty(db)
# Automatically include views, files and APIs
include_files = set(["views.py", "models.py", "api.py"])
for root, dirname, files in os.walk(app.config["BASEDIR"]):
for filename in files:
if filename in include_files:
relative = os.path.relpath(os.path.join(root, filename))[:-3]
module = ".".join(relative.split(os.sep))
__import__(module, level=-1)
for cls in model_classes:
admin.add_view(SecuredModelView(cls, db.session, category="CRUD"))
def make_declarative_base(self, *args):
"""Creates the declarative base."""
base = declarative_base(cls=_Model, name='Model', metadata=self.metadata,
metaclass=_BoundDeclarativeMeta)
base.query = _QueryProperty(self)
return base
def make_declarative_base(self):
from flask.ext.sqlalchemy import _BoundDeclarativeMeta, _QueryProperty
base = declarative_base(cls=MyModel, name='MyModel', metaclass=_BoundDeclarativeMeta)
base.query = _QueryProperty(self)
return base
