def __new__(cls, classname, bases, dict_):
tablename = dict_.get('__tablename__')
if not tablename and not dict_.get('__table__') \
and _DeclarativeMeta.has_primary_key(dict_):
dict_['__tablename__'] = strings.pluralize(
strings.snakecase(classname))
return DeclarativeMeta.__new__(cls, classname, bases, dict_)
def __new__(cls, cls_name, cls_bases, cls_dict):
if cls_dict.get("__type_name__", None) is None:
cls_dict["__type_name__"] = cls_name
if cls_dict.get("_type_info", None) is None:
cls_dict["_type_info"] = _type_info = TypeInfo()
for k, v in cls_dict.items():
if (not k.startswith('__')) and isinstance(v, Column):
_type_info[k] = _process_item(v)
table = cls_dict.get('__table__', None)
if not (table is None):
for c in table.c:
_type_info[c.name] = _process_item(c)
# mixin inheritance
for b in cls_bases:
for k,v in vars(b).items():
if isinstance(v, Column):
_type_info[k] = _process_item(v)
# same table inheritance
for b in cls_bases:
table = getattr(b, '__table__', None)
if not (table is None):
for c in table.c:
_type_info[c.name] = _process_item(c)
return DeclarativeMeta.__new__(cls, cls_name, cls_bases, cls_dict)
def __new__(mcs, name, bases, dct):
# Set __events__ to expected default so that it's updatable when
# initializing. E.g. if class definition sets __events__=None but
# defines decorated events, then we want the final __events__ attribute
# to reflect the registered events. If set to anything that's
# non-empty/non-dict will lead to an error if decorated events defined.
if not dct.get('__events__'):
dct['__events__'] = {}
if '__bind_key__' not in dct:
base_dcts = [dct] + [base.__dict__ for base in bases]
for base in base_dcts:
if '__bind_key__' in base:
dct['__bind_key__'] = base['__bind_key__']
break
cls = DeclarativeMeta.__new__(mcs, name, bases, dct)
# Determine if should set __tablename__.
# This is being done after DeclarativeMeta.__new__()
# as the class is needed to accommodate @declared_attr columns.
if should_set_tablename(cls):
# Set to underscore version of class name.
cls.__tablename__ = camelcase_to_underscore(name)
return cls
def __new__(cls, name, bases, d):
# if tablename is set explicitly, move it to the cache attribute so
# that future subclasses still have auto behavior
if '__tablename__' in d:
d['_cached_tablename'] = d.pop('__tablename__')
return DeclarativeMeta.__new__(cls, name, bases, d)
def __new__(cls, name, bases, d):
# if tablename is set explicitly, move it to the cache attribute so
# that future subclasses still have auto behavior
if '__tablename__' in d:
d['_cached_tablename'] = d.pop('__tablename__')
return DeclarativeMeta.__new__(cls, name, bases, d)
def __new__(cls, name, bases, d):
tablename = d.get('__tablename__')
has_pks = any(v.primary_key for k, v in d.items()
if isinstance(v, Column))
# generate a table name automatically if it's missing and the
# class dictionary declares a primary key. We cannot always
# attach a primary key to support model inheritance that does
# not use joins. We also don't want a table name if a whole
# table is defined
if not tablename and d.get('__table__') is None and has_pks:
def _join(match):
word = match.group()
if len(word) > 1:
return ('_%s_%s' % (word[:-1], word[-1])).lower()
return '_' + word.lower()
d['__tablename__'] = cls._camelcase_re.sub(_join, name).lstrip('_')
if '__table_cls__' not in d:
d['__table_cls__'] = Table
return DeclarativeMeta.__new__(cls, name, bases, d)
def __new__(cls, cls_name, cls_bases, cls_dict):
if cls_dict.get("__type_name__", None) is None:
cls_dict["__type_name__"] = cls_name
if cls_dict.get("_type_info", None) is None:
cls_dict["_type_info"] = _type_info = TypeInfo()
# mixin inheritance
for b in cls_bases:
for k, v in vars(b).items():
if _is_interesting(k, v):
_type_info[k] = _process_item(v)
# same table inheritance
for b in cls_bases:
table = getattr(b, '__table__', None)
if not (table is None):
for c in table.c:
_type_info[c.name] = _process_item(c)
# include from table
table = cls_dict.get('__table__', None)
if not (table is None):
for c in table.c:
_type_info[c.name] = _process_item(c)
# own attributes
for k, v in cls_dict.items():
if _is_interesting(k, v):
_type_info[k] = _process_item(v)
return DeclarativeMeta.__new__(cls, cls_name, cls_bases, cls_dict)
def __new__(cls, cls_name, cls_bases, cls_dict):
if cls_dict.get("__type_name__", None) is None:
cls_dict["__type_name__"] = cls_name
if cls_dict.get("_type_info", None) is None:
cls_dict["_type_info"] = _type_info = TypeInfo()
# mixin inheritance
for b in cls_bases:
for k,v in vars(b).items():
if _is_interesting(k,v):
_type_info[k] = _process_item(v)
# same table inheritance
for b in cls_bases:
table = getattr(b, '__table__', None)
if not (table is None):
for c in table.c:
_type_info[c.name] = _process_item(c)
# include from table
table = cls_dict.get('__table__', None)
if not (table is None):
for c in table.c:
_type_info[c.name] = _process_item(c)
# own attributes
for k, v in cls_dict.items():
if _is_interesting(k,v):
_type_info[k] = _process_item(v)
return DeclarativeMeta.__new__(cls, cls_name, cls_bases, cls_dict)
def __new__(mcs, name, bases, dct):
# Set __events__ to expected default so that it's updatable when
# initializing. E.g. if class definition sets __events__=None but
# defines decorated events, then we want the final __events__ attribute
# to reflect the registered events. If set to anything that's
# non-empty/non-dict will lead to an error if decorated events defined.
if not dct.get('__events__'):
dct['__events__'] = {}
if '__bind_key__' not in dct:
base_dcts = [dct] + [base.__dict__ for base in bases]
for base in base_dcts:
if '__bind_key__' in base:
dct['__bind_key__'] = base['__bind_key__']
break
cls = DeclarativeMeta.__new__(mcs, name, bases, dct)
# Determine if should set __tablename__.
# This is being done after DeclarativeMeta.__new__()
# as the class is needed to accommodate @declared_attr columns.
if should_set_tablename(cls):
# Set to underscore version of class name.
cls.__tablename__ = camelcase_to_underscore(name)
return cls
def __new__(cls, cls_name, cls_bases, cls_dict):
if cls_dict.get("__type_name__", None) is None:
cls_dict["__type_name__"] = cls_name
if cls_dict.get("_type_info", None) is None:
parse_cls_dict(cls_dict)
return DeclarativeMeta.__new__(cls, cls_name, cls_bases, cls_dict)
def __new__(self, name, bases, attrs):
cls = DeclarativeMeta.__new__(self, name, bases, attrs)
for base in bases:
if issubclass(base, CacheMixinBase) and hasattr(cls, '_hook'):
cls._hook.add_table(cls)
break
return cls
def __new__(cls, cls_name, cls_bases, cls_dict):
if cls_dict.get("__type_name__", None) is None:
cls_dict["__type_name__"] = cls_name
if cls_dict.get("_type_info", None) is None:
parse_cls_dict(cls_dict)
return DeclarativeMeta.__new__(cls, cls_name, cls_bases, cls_dict)
def __new__(metatype, name, bases, namespace):
meta = namespace.pop('meta', None)
if not meta:
return DeclarativeMeta.__new__(metatype, name, bases, namespace)
elif not isinstance(meta, dict):
meta = dict(meta.__dict__)
schema = meta.pop('schema')
if not isinstance(schema, Schema):
schema = Schema(schema)
namespace['_spire_schema'] = schema
namespace['metadata'] = schema.metadata
abstract = meta.pop('abstract', False)
tablename = meta.pop('tablename', None)
mapper_params = {}
for param in MAPPER_PARAMS:
if param in meta:
mapper_params[param] = meta.pop(param)
if mapper_params:
namespace['__mapper_args__'] = mapper_params
table_args = []
for param in ('constraints', 'indexes'):
if param in meta:
table_args.extend(meta.pop(param))
if meta:
meta = dict((key, value) for key, value in meta.iteritems()
if key[0] != '_')
if meta:
table_args.append(meta)
if table_args:
namespace['__table_args__'] = tuple(table_args)
if not tablename:
tablename = name.lower()
if '__tablename__' not in namespace and not abstract:
namespace['__tablename__'] = tablename
model = DeclarativeMeta.__new__(metatype, name, bases, namespace)
return model
def __new__(cls, name, bases, dictionary):
if '__mapper_args__' in dictionary.keys():
dictionary['__mapper_args__']['polymorphic_identity'] = to_unicode(
name)
else:
dictionary['__mapper_args__'] = dict(
polymorphic_identity=to_unicode(name))
return DeclarativeMeta.__new__(cls, name, bases, dictionary)
def __new__(metatype, name, bases, namespace):
meta = namespace.pop('meta', None)
if not meta:
return DeclarativeMeta.__new__(metatype, name, bases, namespace)
elif not isinstance(meta, dict):
meta = dict(meta.__dict__)
schema = meta.pop('schema')
if not isinstance(schema, Schema):
schema = Schema(schema)
namespace['_spire_schema'] = schema
namespace['metadata'] = schema.metadata
abstract = meta.pop('abstract', False)
tablename = meta.pop('tablename', None)
mapper_params = {}
for param in MAPPER_PARAMS:
if param in meta:
mapper_params[param] = meta.pop(param)
if mapper_params:
namespace['__mapper_args__'] = mapper_params
table_args = []
for param in ('constraints', 'indexes'):
if param in meta:
table_args.extend(meta.pop(param))
if meta:
meta = dict((key, value) for key, value in meta.iteritems() if key[0] != '_')
if meta:
table_args.append(meta)
if table_args:
namespace['__table_args__'] = tuple(table_args)
if not tablename:
tablename = name.lower()
if '__tablename__' not in namespace and not abstract:
namespace['__tablename__'] = tablename
model = DeclarativeMeta.__new__(metatype, name, bases, namespace)
return model
def __new__(metatype, name, bases, namespace):
meta = namespace.pop("meta", None)
if not meta:
return DeclarativeMeta.__new__(metatype, name, bases, namespace)
elif not isinstance(meta, dict):
meta = dict(meta.__dict__)
schema = meta.pop("schema")
if not isinstance(schema, Schema):
schema = Schema(schema)
namespace["_spire_schema"] = schema
namespace["metadata"] = schema.metadata
abstract = meta.pop("abstract", False)
tablename = meta.pop("tablename", None)
mapper_params = {}
for param in MAPPER_PARAMS:
if param in meta:
mapper_params[param] = meta.pop(param)
if mapper_params:
namespace["__mapper_args__"] = mapper_params
table_args = []
for param in ("constraints", "indexes"):
if param in meta:
table_args.extend(meta.pop(param))
if meta:
meta = dict((key, value) for key, value in meta.iteritems() if key[0] != "_")
if meta:
table_args.append(meta)
if table_args:
namespace["__table_args__"] = tuple(table_args)
if not tablename:
tablename = name.lower()
if "__tablename__" not in namespace and not abstract:
namespace["__tablename__"] = tablename
model = DeclarativeMeta.__new__(metatype, name, bases, namespace)
return model
def __new__(self, name, bases, attrs):
cls = DeclarativeMeta.__new__(self, name, bases, attrs)
from core import CacheMixinBase
for base in bases:
if issubclass(base, CacheMixinBase) and hasattr(cls, "_hook"):
cls._hook.add(cls)
break
return cls
def construct_bare(class_: DeclarativeMeta) -> "SQLClass":
"""
Returns an object of type *class_*, without invoking the class'
constructor.
"""
obj = class_.__new__(class_)
manager = getattr(class_, instrumentation.ClassManager.MANAGER_ATTR)
setattr(obj, manager.STATE_ATTR, state.InstanceState(obj, manager))
return obj
def __new__(cls, name, bases, d):
if _should_set_tablename(bases, d):
def _join(match):
word = match.group()
if len(word) > 1:
return ('_%s_%s' % (word[:-1], word[-1])).lower()
return '_' + word.lower()
d['__tablename__'] = _camelcase_re.sub(_join, name).lstrip('_')
return DeclarativeMeta.__new__(cls, name, bases, d)
def __new__(cls, name, bases, d):
# if tablename is set explicitly, move it to the cache attribute so
# that future subclasses still have auto behavior
if '__tablename__' in d:
table = d['__tablename__']
if not isinstance(table, declared_attr):
d.pop('__tablename__')
d['_cached_tablename'] = table
return DeclarativeMeta.__new__(cls, name, bases, d)
def __new__(cls, name, bases, dct):
# set __tablename__ (if not defined) to underscore version of class name
if not dct.get("__tablename__") and not dct.get("__table__") is not None and has_primary_key(dct):
dct["__tablename__"] = camelcase_to_underscore(name)
# set __events__ to expected default so that it's updatable when initializing
# e.g. if class definition sets __events__=None but defines decorated events,
# then we want the final __events__ attribute to reflect the registered events.
# if set to anything that's non-empty/non-dict will lead to an error if decorated events defined
if not dct.get("__events__"):
dct["__events__"] = {}
return DeclarativeMeta.__new__(cls, name, bases, dct)
def __new__(cls, name, bases, d):
tablename = d.get('__tablename__')
# generate a table name automatically if it's missing and the
# class dictionary declares a primary key. We cannot always
# attach a primary key to support model inheritance that does
# not use joins. We also don't want a table name if a whole
# table is defined
if not tablename and d.get('__table__') is None and _defines_primary_key(d):
def _join(match):
word = match.group()
if len(word) > 1:
return ('_%s_%s' % (word[:-1], word[-1])).lower()
return '_' + word.lower()
d['__tablename__'] = _camelcase_re.sub(_join, name).lstrip('_')
return DeclarativeMeta.__new__(cls, name, bases, d)
def __new__(cls, name, bases, d):
if '__tablename__' not in d and '__table__' not in d and '__abstract__' not in d:
d['__tablename__'] = get_table_name(name)
default_table_args = d.pop('__default_table_args__',
BaseModel.__default_table_args__)
table_args = d.pop('__table_args__', {})
if isinstance(table_args, dict):
table_args = merge_dicts(default_table_args, table_args)
elif isinstance(table_args, tuple):
table_args = list(table_args)
if isinstance(table_args[-1], dict):
table_args[-1] = merge_dicts(default_table_args,
table_args[-1])
else:
table_args.append(default_table_args)
table_args = tuple(table_args)
d['__table_args__'] = table_args
return DeclarativeMeta.__new__(cls, name, bases, d)
def __new__(cls, name, bases, d):
tablename = d.get('__tablename__')
# generate a table name automatically if it's missing and the
# class dictionary declares a primary key. We cannot always
# attach a primary key to support model inheritance that does
# not use joins. We also don't want a table name if a whole
# table is defined
if not tablename and not d.get('__table__') and \
_defines_primary_key(d):
def _join(match):
word = match.group()
if len(word) > 1:
return ('_%s_%s' % (word[:-1], word[-1])).lower()
return '_' + word.lower()
d['__tablename__'] = _camelcase_re.sub(_join, name).lstrip('_')
return DeclarativeMeta.__new__(cls, name, bases, d)
def __new__(mcs, name, bases, dct):
# Determine if primary key is defined for dct or any of its bases.
base_dcts = [dct] + [base.__dict__ for base in bases]
if (not dct.get('__tablename__') and dct.get('__table__') is None
and any([has_primary_key(base) for base in base_dcts])):
# Set to underscore version of class name.
dct['__tablename__'] = camelcase_to_underscore(name)
# Set __events__ to expected default so that it's updatable when
# initializing. E.g. if class definition sets __events__=None but
# defines decorated events, then we want the final __events__ attribute
# to reflect the registered events. If set to anything that's
# non-empty/non-dict will lead to an error if decorated events defined.
if not dct.get('__events__'):
dct['__events__'] = {}
return DeclarativeMeta.__new__(mcs, name, bases, dct)
def __new__(cls, name, bases, d):
if d.get("__abstract_inherit__"):
inherit = d['__abstract_inherit__'][0].__dict__
d['super'] = {}
for key in inherit:
if hasattr(inherit[key], '__module__'):
module = str(inherit[key].__module__)
if module.startswith('sqlalchemy'):
continue
if key not in d:
d[key] = inherit[key]
elif key in d and type(inherit[key]) == types.FunctionType:
if not d['super'].get(key):
d['super'][key] = list()
d['super'][key].append(inherit[key])
return DeclarativeMeta.__new__(cls, name, bases, d)
def __new__(mcs, name, bases, dct):
# Determine if primary key is defined for dct or any of its bases.
base_dcts = [dct] + [base.__dict__ for base in bases]
if (not dct.get('__tablename__')
and dct.get('__table__') is None
and any([has_primary_key(base) for base in base_dcts])):
# Set to underscore version of class name.
dct['__tablename__'] = camelcase_to_underscore(name)
# Set __events__ to expected default so that it's updatable when
# initializing. E.g. if class definition sets __events__=None but
# defines decorated events, then we want the final __events__ attribute
# to reflect the registered events. If set to anything that's
# non-empty/non-dict will lead to an error if decorated events defined.
if not dct.get('__events__'):
dct['__events__'] = {}
return DeclarativeMeta.__new__(mcs, name, bases, dct)
def __new__(cls, name, bases, d):
if _should_set_tablename(bases, d):
def _camel_to_snake(name):
""" Convert a CamelCase string to snake_case """
if not name:
return ""
if len(name) == 1:
return name.lower()
return (name[0]
+ "".join([("_" + c) \
if prev.islower() and c.isupper() \
or prev.islower() and c.isdigit() and (next.isdigit() or next.isupper()) \
or (prev.isdigit() or prev.isupper()) and c.isupper() and next.islower() \
else c \
for prev, c, next in zip(name[:-2], name[1:-1], name[2:])])
+ ("_" + name[-1]
if name[-2:-1].islower() and (name[-1].isupper() or name[-1].isdigit())
else name[-1])).lower()
d['__tablename__'] = _camel_to_snake(name)
return DeclarativeMeta.__new__(cls, name, bases, d)
def __new__(mcs, name, bases, attrs):
for n, v in attrs.items():
attrName = n[1:]
if isinstance(v, Column) and n.startswith('_') and not attrs.has_key(attrName):
v.key = attrName
v.name = attrName
# Add dynamic property
setter = ModelPropertySetter(n)
attrs[attrName] = hybrid_property(
ModelPropertyGetter(n), setter, None, ModelPropertyExpression(n) )
# Add external-key property
info = getattr(v, 'info')
if info and 'model' in info:
columnName = info['column'] if 'column' in info else 'i'
attrs[info['get']] = property(
ExternalKeyProperty(attrName, info['model'], columnName) )
return DeclarativeMeta.__new__(mcs, name, bases, attrs)
def __new__(cls, cls_name, cls_bases, cls_dict):
if cls_dict.get("__type_name__", None) is None:
cls_dict["__type_name__"] = cls_name
if cls_dict.get("_type_info", None) is None:
cls_dict["_type_info"] = _type_info = TypeInfo()
for k, v in cls_dict.items():
if not k.startswith('__'):
if isinstance(v, Column):
if v.type in _type_map:
rpc_type = _type_map[v.type]
elif type(v.type) in _type_map:
rpc_type = _type_map[type(v.type)]
else:
raise Exception("soap_type was not found. maybe "
"_type_map needs a new entry.")
_type_info[k]=rpc_type
return DeclarativeMeta.__new__(cls, cls_name, cls_bases, cls_dict)
def __new__(mcs, name, bases, dct):
cls = DeclarativeMeta.__new__(mcs, name, bases, dct)
return cls
def __new__(cls, name, bases, attrs):
name = cls._calculate_polymorphic_name(name, bases, attrs)
return DeclarativeMeta.__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, dic):
if _should_set_tablename(bases, dic):
dic['__tablename__'] = _get_table_name(name)
return DeclarativeMeta.__new__(cls, name, bases, dic)
def __new__(cls, name, bases, namespace):
namespace[
'_ally_type'] = None # Makes the type None in order to avoid mistakes by inheriting the type from a model
return DeclarativeMeta.__new__(cls, name, bases, namespace)
def __new__(cls, name, bases, d):
d["__module__"] = "dbcut.generated_models"
c = DeclarativeMeta.__new__(cls, name, bases, d)
register_new_model(c)
return c
def __new__(cls, clsname, bases, dct):
dct['__tablename__'] = clsname.lower()
return DeclarativeMeta.__new__(cls, clsname, bases, dct)
def __new__(cls, name, bases, dictionary):
if '__mapper_args__' in dictionary.keys():
dictionary['__mapper_args__']['polymorphic_identity'] = to_unicode(name)
else:
dictionary['__mapper_args__'] = dict(polymorphic_identity=to_unicode(name))
return DeclarativeMeta.__new__(cls, name, bases, dictionary)
def __new__(self, name, bases, d):
return DeclarativeMeta.__new__(self, name, bases, d)
def __new__(mcs, name, bases, attrs):
attrs.setdefault('__tablename__', name.lower())
attrs.setdefault('id', Column(Integer, primary_key=True))
return DeclarativeMeta.__new__(mcs, name, bases, attrs)
def __new__(mcs, name, bases, dct):
cls = DeclarativeMeta.__new__(mcs, name, bases, dct)
return cls
def __new__(cls, name, bases, d):
if '__tablename__' in d:
d['_cached_tablename'] = d.pop('__tablename__')
return DeclarativeMeta.__new__(cls, name, bases, d)
def __new__(cls, name, bases, namespace):
namespace['_ally_type'] = None # Makes the type None in order to avoid mistakes by inheriting the type from a model
return DeclarativeMeta.__new__(cls, name, bases, namespace)
def __new__(mcs, name, bases, attrs):
attrs.setdefault('__tablename__', name.lower())
attrs.setdefault('id', Column(Integer, primary_key=True))
return DeclarativeMeta.__new__(mcs, name, bases, attrs)
