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)