def __mapper_args__(cls):
ret = {'polymorphic_identity': unicode(cls.__name__)}
if not has_inherited_table(cls) and cls.__polymorphic__:
ret['polymorphic_on'] = cls.row_type
elif has_inherited_table(cls) and not cls.__polymorphic__:
raise Exception('Please specify __polymorphic__=\'single\' or __polymorphic__=\'join\' on base class')
return ret
def __mapper_args__(cls):
ret = {'polymorphic_identity': unicode(cls.__name__)}
if not has_inherited_table(cls) and cls.__polymorphic__:
ret['polymorphic_on'] = cls.row_type
elif has_inherited_table(cls) and not cls.__polymorphic__:
raise Exception('Please specify __polymorphic__=\'single\' or __polymorphic__=\'join\' on base class')
return ret
def test_has_inherited_table_doesnt_consider_base(self):
class A(Base):
__tablename__ = 'a'
id = Column(Integer, primary_key=True)
assert not has_inherited_table(A)
class B(A):
__tablename__ = 'b'
id = Column(Integer, ForeignKey('a.id'), primary_key=True)
assert has_inherited_table(B)
def test_has_inherited_table_doesnt_consider_base(self):
class A(Base):
__tablename__ = "a"
id = Column(Integer, primary_key=True)
assert not has_inherited_table(A)
class B(A):
__tablename__ = "b"
id = Column(Integer, ForeignKey("a.id"), primary_key=True)
assert has_inherited_table(B)
def test_has_inherited_table(self, registry):
@registry.mapped
class Foo:
__tablename__ = "foo"
id = sa.Column(sa.Integer, primary_key=True)
@registry.mapped
class Bar(Foo):
__tablename__ = "bar"
id = sa.Column(sa.ForeignKey("foo.id"), primary_key=True)
with self._expect_warning("has_inherited_table"):
is_true(legacy_decl.has_inherited_table(Bar))
with self._expect_warning("has_inherited_table"):
is_false(legacy_decl.has_inherited_table(Foo))
def __tablename__(cls):
"""Set the tablename to be the lowercase of the class name.
Reference: http://docs.sqlalchemy.org/en/rel_0_9/orm/extensions/declarative.html#controlling-table-inheritance-with-mixins # noqa
"""
if has_inherited_table(cls) and BasicBase not in cls.__bases__:
return None
return cls.__name__.lower()
def id(cls):
if has_inherited_table(cls):
return Column(
Integer, ForeignKey('%s.id' % parent_table,
onupdate='CASCADE', ondelete='CASCADE'),
primary_key=True)
else:
return Column(Integer, primary_key=True)
def id(cls):
if has_inherited_table(cls):
return Column(
Integer, ForeignKey('%s.id' % parent_table,
onupdate='CASCADE', ondelete='CASCADE'),
primary_key=True)
else:
return Column(Integer, primary_key=True)
def __tablename__(cls):
"""
"""
if has_inherited_table(cls):
return None
return cls.__name__.lower()
def my_attr(cls):
if decl.has_inherited_table(cls):
id = Column(ForeignKey('a.my_attr'), primary_key=True)
asserted['b'].add(id)
else:
id = Column(Integer, primary_key=True)
asserted['a'].add(id)
return id
def uuid(cls):
parent_tablename = get_parent_tablename_by_bases(cls.__bases__)
if has_inherited_table(cls) and parent_tablename != '':
return Column(ForeignKey(parent_tablename + '.uuid'),
primary_key=True)
else:
return Column(UUID(as_uuid=True),
ColumnDefault(uuid.uuid4),
primary_key=True)
def id(cls):
if has_inherited_table(cls):
if JoinedTableInheritanceMixin in cls.mro():
for base in cls.__bases__:
if hasattr(base, 'id'):
return Column(Integer, ForeignKey(base.id), primary_key=True, autoincrement=False)
if SingleTableInheritanceMixin in cls.mro():
return None
return Column(Integer, primary_key=True)
def __tablename__(cls):
"""Generate a __tablename__ attr for every model that does not have
inherited tables.
Ensures table names match the model name without needing to declare it.
"""
if has_inherited_table(cls):
return None
return cls.__name__.lower()
def __mapper_args__(cls):
if not has_inherited_table(cls):
ret = {
'polymorphic_identity': 'default',
'polymorphic_on': cls.type,
}
else:
ret = {'polymorphic_identity': cls.__name__}
return ret
def __mapper_args__(cls):
if not has_inherited_table(cls):
ret = {
'polymorphic_identity': 'default',
'polymorphic_on': cls.type,
}
else:
ret = {'polymorphic_identity': cls.__name__}
return ret
def __mapper_args__(cls):
if not has_inherited_table(cls):
ret = {
"polymorphic_identity": "default",
"polymorphic_on": cls.type,
}
else:
ret = {"polymorphic_identity": cls.__name__}
return ret
def __table_args__(cls):
if has_inherited_table(cls):
return tuple()
else:
names = list(get_primary_keys(parent_cls).keys())
return (sa.schema.ForeignKeyConstraint(names, [
'%s.%s' % (parent_cls.__tablename__, name)
for name in names
], **foreign_key_args), )
def __tablename__(cls):
"""Set the tablename as the class name in snake_case.
Pattern from:
http://docs.sqlalchemy.org/en/latest/orm/extensions/declarative/mixins.html#controlling-table-inheritance-with-mixins
"""
if has_inherited_table(cls):
return None
return inflection.underscore(cls.__name__)
def _get_parent_table_class(cls):
if not has_inherited_table(cls):
# Safety against recursion
return None
base_classes = [b for b in cls.__bases__ if b.__tablename__]
if len(base_classes) > 1:
# For simplicity at present, only allow join configurations IFF there's only one parent table class
raise Exception('Can only inherit from one base class with defined table')
return base_classes[0]
def _get_parent_table_class(cls):
if not has_inherited_table(cls):
# Safety against recursion
return None
base_classes = [b for b in cls.__bases__ if b.__tablename__]
if len(base_classes) > 1:
# For simplicity at present, only allow join configurations IFF there's only one parent table class
raise Exception('Can only inherit from one base class with defined table')
return base_classes[0]
def __mapper_args__(cls):
if has_inherited_table(cls):
if SingleTableInheritanceMixin in cls.mro():
top_class = cls.__bases__[0]
if cls.__tablename__ != top_class.__tablename__:
raise Exception(f'Model `{cls.__name__}` should not define attribute `__tablename__` due to single heritance')
polymorphic_identity = cls.__lation__.get('polymorphic_identity')
if polymorphic_identity == top_class.__lation__.get('polymorphic_identity'):
raise Exception(f'Model `{cls.__name__}` should define attribute `__lation__.polymorphic_identity` with non-duplicate value. Duplicate value `{polymorphic_identity}` was detected.')
return {
'polymorphic_on': cls.discriminator,
'polymorphic_identity': cls.__lation__['polymorphic_identity'],
}
def create_permissions(app,
created_models,
verbosity,
db=DEFAULT_DB_ALIAS,
**kwargs):
#print 'create perm for app:', app
app_models = []
for k, v in vars(app).items():
if k not in Base._decl_class_registry:
continue
if v not in Base._decl_class_registry.values():
continue
if hasattr(
app,
'__package__') and app.__package__ + '.models' != v.__module__:
continue
app_models.append((k, v))
if not app_models:
return
searched_perms = list()
searched_codenames = set()
for k, klass in sorted(app_models, key=lambda x: x[0]):
if klass.__mapper__.polymorphic_on is not None:
if has_inherited_table(klass):
# ignore polymorphic subclasses
continue
elif klass.__subclasses__():
# ignore base if subclass is present
continue
for perm in _get_all_permissions(klass._meta):
if perm.codename in searched_codenames:
continue
searched_perms.append(perm)
searched_codenames.add(perm.codename)
session = orm.sessionmaker()
all_perms = session.query(auth_app.Permission).all()
all_codenames = set(p.codename for p in all_perms)
perms = [
perm for perm in searched_perms if perm.codename not in all_codenames
]
session.add_all(perms)
session.commit()
if verbosity >= 2:
for perm in perms:
print("Adding permission '%s:%s'" % (perm.resource, perm.codename))
def __table_args__(cls):
if has_inherited_table(cls):
return tuple()
else:
names = list(get_primary_keys(parent_cls).keys())
return (
sa.schema.ForeignKeyConstraint(
names,
[
'%s.%s' % (parent_cls.__tablename__, name)
for name in names
],
**foreign_key_args
),
)
def create_permissions(app, created_models, verbosity, db=DEFAULT_DB_ALIAS,
**kwargs):
#print 'create perm for app:', app
app_models = []
for k, v in vars(app).items():
if k not in Base._decl_class_registry:
continue
if v not in Base._decl_class_registry.values():
continue
if hasattr(app, '__package__') and app.__package__ + '.models' != v.__module__:
continue
app_models.append( (k,v) )
if not app_models:
return
searched_perms = list()
searched_codenames = set()
for k, klass in sorted(app_models, key=lambda x: x[0]):
if klass.__mapper__.polymorphic_on is not None:
if has_inherited_table(klass):
# ignore polymorphic subclasses
continue
elif klass.__subclasses__():
# ignore base if subclass is present
continue
for perm in _get_all_permissions(klass._meta):
if perm.codename in searched_codenames:
continue
searched_perms.append(perm)
searched_codenames.add(perm.codename)
session = orm.sessionmaker()
all_perms = session.query(auth_app.Permission).all()
all_codenames = set(p.codename for p in all_perms)
perms = [
perm for perm in searched_perms
if perm.codename not in all_codenames
]
session.add_all(perms)
session.commit()
if verbosity >= 2:
for perm in perms:
print("Adding permission '%s:%s'" % (perm.resource, perm.codename))
def __tablename__(cls):
table_name = None
if has_inherited_table(cls):
if cls.__polymorphic__ == 'single':
# Single implies we are extending an existing table
# in which case SQLAlchemy should not be provided a new one
return None
elif cls.__polymorphic__ == 'join':
parent = _get_parent_table_class(cls)
table_name = "{}{}".format(parent.__name__, cls.__name__)
# hack to make sure we can redefine id in a subclass
cls.id = Column(tt.ObjectID(), ForeignKey("{}.id".format(parent.__tablename__)), primary_key=True)
else:
table_name = cls.__name__
return convert_to_underscore(table_name)
def __tablename__(cls):
table_name = None
if has_inherited_table(cls):
if cls.__polymorphic__ == 'single':
# Single implies we are extending an existing table
# in which case SQLAlchemy should not be provided a new one
return None
elif cls.__polymorphic__ == 'join':
parent = _get_parent_table_class(cls)
table_name = "{}{}".format(parent.__name__, cls.__name__)
# hack to make sure we can redefine id in a subclass
cls.id = Column(tt.ObjectID(), ForeignKey("{}.id".format(parent.__tablename__)), primary_key=True)
else:
table_name = cls.__name__
return convert_to_underscore(table_name)
def add_constraints_and_attributes(mapper, class_):
if has_inherited_table(class_):
return
table = class_.__table__
if class_.key_columns is not None:
elements = []
for col_name in class_.key_columns:
elements.append((getattr(class_, col_name), '='))
elements.append(('period', '&&'))
table.append_constraint(ExcludeConstraint(*elements))
if class_.value_columns is None:
exclude = {'id', 'period'}
exclude.update(class_.key_columns)
class_.value_columns = [
c.name for c in table.c if c.name not in exclude
]
table.append_constraint(CheckConstraint("period != 'empty'::tsrange"))
def __tablename__(self):
if (has_inherited_table(self) and Common not in self.__bases__):
return None
return self.__name__.lower()
def __mapper_args__(cls):
if has_inherited_table(cls):
return {'polymorphic_identity': cls.__name__.lower()}
return {'polymorphic_on': cls.row_type}
def __table_args__(cls):
if has_inherited_table(cls):
return None
else:
return (UniqueConstraint(*cls.pks), )
def __mapper_args__(cls):
if has_inherited_table(cls):
return {'polymorphic_identity': cls.__name__.lower()}
else:
return {'polymorphic_on': cls.subclass}
def __tablename__(cls):
if decl.has_inherited_table(cls) and TableNameMixin \
not in cls.__bases__:
return None
return cls.__name__.lower()
def __tablename__(cls):
if decl.has_inherited_table(cls) and TableNameMixin \
not in cls.__bases__:
return None
return cls.__name__.lower()
def receive_before_flush(sess, _flush_context, _instances):
for x in sess.dirty:
if has_inherited_table(x.__class__) or is_parent_table(x.__class__):
x.updated_at = datetime.datetime.now()
def create_permissions(app,
created_models,
verbosity,
db=DEFAULT_DB_ALIAS,
**kwargs):
app_models = []
for k, v in vars(app).items():
if k not in orm.Base._decl_class_registry:
continue
if v not in orm.Base._decl_class_registry.values():
continue
if hasattr(
app,
'__package__') and app.__package__ + '.models' != v.__module__:
continue
app_models.append((k, v))
if not app_models:
return
try:
Permission = getattr(auth_app, 'Permission')
except:
return
searched_perms = list()
ctypes = set()
searched_codenames = set()
for k, klass in sorted(app_models, key=lambda x: x[0]):
if klass.__mapper__.polymorphic_on is not None:
if has_inherited_table(klass):
# ignore polymorphic subclasses
continue
elif klass.__subclasses__():
# ignore base if subclass is present
continue
if not klass._meta.permission_resources:
# no resource types
continue
ctypes.update(klass._meta.permission_resources)
for perm in _get_all_permissions(klass._meta):
if perm['codename'] in searched_codenames:
continue
searched_perms.append(perm)
searched_codenames.add(perm['codename'])
if not ctypes:
return
#connection = connections[db]
session = orm.sessionmaker()
all_perms = session.query(Permission.codename) \
.filter(Permission.resource.in_(ctypes)) \
.all()
all_perms = set([perm[0] for perm in all_perms])
perms = [
perm for perm in searched_perms if perm['codename'] not in all_perms
]
session.execute(Permission.__table__.insert(), perms)
session.flush()
if verbosity >= 2:
for perm in perms:
print("Adding permission '%s:%s'" %
(perm['resource'], perm['codename']))
def __table_args__(cls):
if has_inherited_table(cls):
return (UniqueConstraint(*cls.pks), {'schema': 'ofx'})
else:
return {'schema': 'ofx'}
def __tablename__(self):
if (has_inherited_table(self) and
Common not in self.__bases__):
return None
return self.__name__.lower()
def __mapper_args__(cls):
if has_inherited_table(cls):
return {'polymorphic_identity': cls.__name__.lower()}
else:
return {'polymorphic_on': cls.subclass}
def __tablename__(cls):
if decl.has_inherited_table(cls):
return None
return cls.__name__.lower()
def __table_args__(cls):
if has_inherited_table(cls):
return (UniqueConstraint(*cls.pks),)
else:
return None
def create_permissions(app, created_models, verbosity, db=DEFAULT_DB_ALIAS,
**kwargs):
app_models = []
for k, v in vars(app).items():
if k not in orm.Base._decl_class_registry:
continue
if v not in orm.Base._decl_class_registry.values():
continue
if hasattr(app, '__package__') and app.__package__ + '.models' != v.__module__:
continue
app_models.append( (k,v) )
if not app_models:
return
try:
Permission = getattr(auth_app, 'Permission')
except:
return
searched_perms = list()
ctypes = set()
searched_codenames = set()
for k, klass in sorted(app_models, key=lambda x: x[0]):
if klass.__mapper__.polymorphic_on is not None:
if has_inherited_table(klass):
# ignore polymorphic subclasses
continue
elif klass.__subclasses__():
# ignore base if subclass is present
continue
if not klass._meta.permission_resources:
# no resource types
continue
ctypes.update(klass._meta.permission_resources)
for perm in _get_all_permissions(klass._meta):
if perm['codename'] in searched_codenames:
continue
searched_perms.append(perm)
searched_codenames.add(perm['codename'])
if not ctypes:
return
#connection = connections[db]
session = orm.sessionmaker()
all_perms = session.query(Permission.codename) \
.filter(Permission.resource.in_(ctypes)) \
.all()
all_perms = set([perm[0] for perm in all_perms])
perms = [
perm for perm in searched_perms
if perm['codename'] not in all_perms
]
session.execute(Permission.__table__.insert(), perms)
session.flush()
if verbosity >= 2:
for perm in perms:
print("Adding permission '%s:%s'" % (perm['resource'],
perm['codename']))
def __tablename__(cls):
if decl.has_inherited_table(cls):
return None
return cls.__name__.lower()
