def __new__(cls, name, bases, attrs): # whether base classes should be filtered cls.hide_bases = False # only filter bases if this wasn't invoked by the ModelMiddleware # class, which is a super class for all custom middleware, and the # one we are using as a filter key if not (name == 'ModelMiddleware'): if not (ModelMiddleware in bases): cls.hide_bases = True if cls.hide_bases: # replace the original bases with filtered ones to fool Django's inheritance bases = _filter_bases(bases, ModelMiddleware) # set the middleware options under Klass._middle if attrs.has_key('Middle'): midopts = attrs['Middle'] assert type( midopts ) == types.ClassType, "Middle attribute of %s model must be a class, not a %s object" % ( name, type(midopts)) opts = {} opts.update([(k, v) for k, v in midopts.__dict__.items() if not k.startswith('_')]) attrs["_middle"] = opts attrs.pop('Middle') return ModelBase.__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, attrs): """ We must define our Typeclasses as proxies. We also store the path directly on the class, this is required by managers. """ # storage of stats attrs["typename"] = name attrs["path"] = "%s.%s" % (attrs["__module__"], name) # typeclass proxy setup if "Meta" not in attrs: class Meta(object): proxy = True app_label = attrs.get("__applabel__", "typeclasses") attrs["Meta"] = Meta attrs["Meta"].proxy = True new_class = ModelBase.__new__(cls, name, bases, attrs) # attach signals signals.post_save.connect(call_at_first_save, sender=new_class) signals.pre_delete.connect(remove_attributes_on_delete, sender=new_class) return new_class
def __new__(cls, name, bases, attrs): # redefine the related name in the foreign key to TournamentNode, # so classes with the same name (from different apps) won't clash try: from tms.models import TournamentNode except ImportError: pass else: if (TournamentNode in bases and not ('Meta' in attrs and getattr(attrs['Meta'], 'proxy', False))): attrs['tournamentnode_ptr'] = models.OneToOneField( TournamentNode, related_name="%(app_label)s_%(class)s_related", parent_link=True ) # add leaf class manager to all subclasses (unless they define their own) if 'objects' not in attrs: attrs['objects'] = ThisTypeOnlyManager() NewNodeType = ModelBase.__new__(cls, name, bases, attrs) type_id = NewNodeType.get_id() def node_init(self, *args, **kwargs): # TODO: preserve custom init method? models.Model.__init__(self, *args, **kwargs) if not self.type_id: self.type_id = type_id NewNodeType.__init__ = node_init node_types[type_id] = NewNodeType return NewNodeType
def __new__(mcs, name, bases, attrs): """ Instantiation of the State type. When this type is created, also create a logging model if required. """ if name != "StateModel" and "Machine" in attrs: attrs["state"] = StateField( max_length=100, default="0", verbose_name=_("state id"), machine=attrs["Machine"], ) # Wrap __unicode__ for state model if "__str__" in attrs: old_unicode = attrs["__str__"] def new_unicode(self): return "{} ({})".format( old_unicode(self), self.Machine.get_state(self.state).description) attrs["__str__"] = new_unicode # Call class constructor of parent return ModelBase.__new__(mcs, name, bases, attrs)
def __new__(cls, name, bases, attrs): """ Instantiation of the State type. When this type is created, also create a logging model if required. """ if name != 'StateModel' and 'Machine' in attrs: attrs['state'] = StateField(max_length=100, default='0', verbose_name=_('state id'), machine=attrs['Machine']) # Wrap __unicode__ for state model if '__unicode__' in attrs: old_unicode = attrs['__unicode__'] def new_unicode(self): return '%s (%s)' % (old_unicode(self), self.Machine.get_state( self.state).description) attrs['__unicode__'] = new_unicode # Call class constructor of parent return ModelBase.__new__(cls, name, bases, attrs)
def __new__(c, name, bases, attrs): new_unicode = u'' if '__unicode__' in attrs: old_unicode = attrs['__unicode__'] def new_unicode(self): """New Unicode""" return u'%s (%s)' % (old_unicode(self), self.get_state_info().description) attrs['__unicode__'] = new_unicode attrs['__module__'] = state_model.__module__ values = { 'model_name': state_model.__name__, 'field_name': field_name.capitalize() } class_name = conf.LOG_MODEL_NAME % values # Make sure that for Python2, class_name is a 'str' object. # In Django 1.7, `field_name` returns a unicode object, causing # `class_name` to be unicode as well. if sys.version_info[0] == 2: class_name = str(class_name) return ModelBase.__new__(c, class_name, bases, attrs)
def __new__(cls, *args, **kwargs): warnings.warn( 'TranslatableModelBase metaclass is deprecated and will ' 'be removed. Hvad no longer uses a custom metaclass so conflict ' 'resolution is no longer required, TranslatableModelBase can be ' 'dropped.', DeprecationWarning) return ModelBase.__new__(cls, *args, **kwargs)
def __new__(mcs, name, bases, attrs): new_unicode = "" if "__str__" in attrs: old_unicode = attrs["__str__"] def new_unicode(self): """New Unicode""" return "{} ({})".format( old_unicode(self), self.get_state_info().description ) attrs["__str__"] = new_unicode attrs["__module__"] = state_model.__module__ values = { "model_name": state_model.__name__, "field_name": field_name.capitalize(), } class_name = conf.LOG_MODEL_NAME.format(**values) # Make sure that for Python2, class_name is a 'str' object. # In Django 1.7, `field_name` returns a unicode object, causing # `class_name` to be unicode as well. if sys.version_info[0] == 2: class_name = str(class_name) return ModelBase.__new__(mcs, class_name, bases, attrs)
def __new__(cls, name, bases, attrs): # inject Profile fields for k, v in cls.base_fields.items(): if k not in attrs: attrs[k] = cls.base_fields[k] model = ModelBase.__new__(cls, name, bases, attrs) _profiles.append(model) return model
def __new__(cls, name, bases, attrs): # inject PageBase fields for k, v in cls.base_fields.items(): if k not in attrs: attrs[k] = cls.base_fields[k] page_cls = ModelBase.__new__(cls, name, bases, attrs) register(page_cls) return page_cls
def __new__(cls, name, bases, attrs): bases = list(bases) new_class = ModelBase.__new__(cls, name, tuple(bases), attrs) if new_class._meta.abstract: pass return new_class
def __new__(cls, name, bases, attrs): # inject PageBase fields for k, v in cls.base_fields.items(): if k not in attrs: attrs[k] = cls.base_fields[k] page_cls = ModelBase.__new__(cls, name, bases, attrs) register(page_cls) return page_cls
def __new__(cls, name, bases, attrs): bases = list(bases) new_class = ModelBase.__new__(cls, name, tuple(bases), attrs) if new_class._meta.abstract: pass return new_class
def __new__(cls, name, bases, attrs): new_class = ModelBase.__new__(cls, name, bases, attrs) if hasattr(new_class, 'FreeAdmin'): new_class.add_to_class('_admin', FreeAdminWrapper(new_class.FreeAdmin)) else: new_class.add_to_class('_admin', FreeAdminWrapper()) return new_class
def __new__(cls, name, bases, attrs): from freenasUI.freeadmin.site import site new_class = ModelBase.__new__(cls, name, bases, attrs) if new_class._meta.abstract: pass elif hasattr(new_class, 'FreeAdmin'): site.register(new_class, freeadmin=new_class.FreeAdmin) return new_class
def __new__(cls, name, bases, attrs): from freenasUI.freeadmin.site import site new_class = ModelBase.__new__(cls, name, bases, attrs) if new_class._meta.abstract: pass elif hasattr(new_class, 'FreeAdmin'): site.register(new_class, freeadmin=new_class.FreeAdmin) return new_class
def __new__(c, name, bases, attrs): # Rename class name = '%sVoteSummary' % model._meta.object_name # This attribute is required for a model to function properly in Django. attrs['__module__'] = model.__module__ vote_summary_model = ModelBase.__new__(c, name, bases, attrs) return vote_summary_model
def __new__(c, name, bases, attrs): # Rename class name = '%sVoteSummary' % model._meta.object_name # This attribute is required for a model to function properly in Django. attrs['__module__'] = model.__module__ vote_summary_model = ModelBase.__new__(c, name, bases, attrs) return vote_summary_model
def __new__(c, name, bases, attrs): # Rename class name = 'Historical%s' % model._meta.object_name # This attribute is required for a model to function properly. attrs['__module__'] = self._module or model.__module__ # Copy attributes from base class attrs.update(self.copy_fields(model)) return ModelBase.__new__(c, name, bases, attrs)
def __new__(cls, name, bases, attrs): super_new = ModelBase.__new__(cls, name, bases, attrs) module_name = camel_to_underscore(name) model_module = sys.modules[cls.__module__] app_label = super_new.__module__.split('.')[-2] db_table = '%s_%s' % (app_label, module_name) if not getattr(super_new._meta, 'proxy', False): super_new._meta.db_table = db_table return super_new
def __new__(cls, name, bases, attrs): super_new = ModelBase.__new__(cls, name, bases, attrs) module_name = camel_to_underscore(name) model_module = sys.modules[cls.__module__] app_label = super_new.__module__.split('.')[-2] db_table = '%s_%s' % (app_label, module_name) if not getattr(super_new._meta, 'proxy', False): super_new._meta.db_table = db_table return super_new
def __new__(cls, name, bases, attrs): """ We must define our Typeclasses as proxies. We also store the path directly on the class, this is required by managers. """ # storage of stats attrs["typename"] = name attrs["path"] = "%s.%s" % (attrs["__module__"], name) def _get_dbmodel(bases): """Recursively get the dbmodel""" if not hasattr(bases, "__iter__"): bases = [bases] for base in bases: if base._meta.proxy or base._meta.abstract: for kls in base._meta.parents: return _get_dbmodel(kls) return base dbmodel = _get_dbmodel(bases) # typeclass proxy setup # first check explicit __applabel__ on the typeclass, then figure # it out from the dbmodel if dbmodel and "__applabel__" not in attrs: # find the app-label in one of the bases, usually the dbmodel attrs["__applabel__"] = dbmodel._meta.app_label if "Meta" not in attrs: class Meta: proxy = True app_label = attrs.get("__applabel__", "typeclasses") attrs["Meta"] = Meta attrs["Meta"].proxy = True new_class = ModelBase.__new__(cls, name, bases, attrs) # django doesn't support inheriting proxy models so we hack support for # it here by injecting `proxy_for_model` to the actual dbmodel. # Unfortunately we cannot also set the correct model_name, because this # would block multiple-inheritance of typeclasses (Django doesn't allow # multiple bases of the same model). if dbmodel: new_class._meta.proxy_for_model = dbmodel # Maybe Django will eventually handle this in the future: # new_class._meta.model_name = dbmodel._meta.model_name # attach signals signals.post_save.connect(call_at_first_save, sender=new_class) signals.pre_delete.connect( remove_attributes_on_delete, sender=new_class) return new_class
def __new__(cls, name, bases, attrs): from freenasUI.freeadmin.site import site bases = list(bases) appPool.hook_model_new(name, bases, attrs) new_class = ModelBase.__new__(cls, name, tuple(bases), attrs) if new_class._meta.abstract: pass elif hasattr(new_class, 'FreeAdmin'): site.register(new_class, freeadmin=new_class.FreeAdmin) return new_class
def __new__(c, name, bases, attrs): # Rename class name = '%sRating' % model._meta.object_name # This attribute is required for a model to function properly in Django. attrs['__module__'] = model.__module__ rating_model = ModelBase.__new__(c, name, bases, attrs) _rating_models[rating_model.get_model_name()] = rating_model return rating_model
def __new__(cls, name, bases, attrs): from freenasUI.freeadmin.site import site bases = list(bases) appPool.hook_model_new(name, bases, attrs) new_class = ModelBase.__new__(cls, name, tuple(bases), attrs) if new_class._meta.abstract: pass elif hasattr(new_class, 'FreeAdmin'): site.register(new_class, freeadmin=new_class.FreeAdmin) return new_class
def __new__(*args, **kwargs): new_class = ModelBase.__new__(*args, **kwargs) new_manager = RowCacheManager() if not hasattr(new_class, 'objects'): # Attach a new manager. new_manager.contribute_to_class(new_class, 'objects') new_class._default_manager = new_manager else: # Mix in the manager into the existing one. if new_class.objects.__class__ != RowCacheManager and RowCacheManager not in new_class.objects.__class__.__bases__: new_class.objects.__class__.__bases__ = (RowCacheManager,) + new_class.objects.__class__.__bases__ return new_class
def __new__(c, name, bases, attrs): # Rename class name = '%sRating' % model._meta.object_name # This attribute is required for a model to function properly in Django. attrs['__module__'] = model.__module__ rating_model = ModelBase.__new__(c, name, bases, attrs) _rating_models[rating_model.get_model_name()] = rating_model return rating_model
def __new__(*args, **kwargs): new_class = ModelBase.__new__(*args, **kwargs) new_manager = RowCacheManager() if not hasattr(new_class, 'objects'): # Attach a new manager. new_manager.contribute_to_class(new_class, 'objects') new_class._default_manager = new_manager else: # Mix in the manager into the existing one. if new_class.objects.__class__ != RowCacheManager and RowCacheManager not in new_class.objects.__class__.__bases__: new_class.objects.__class__.__bases__ = ( RowCacheManager, ) + new_class.objects.__class__.__bases__ return new_class
def __new__(c, name, bases, attrs): # Rename class name = '%sVote' % model._meta.object_name # This attribute is required for a model to function # properly in Django. attrs['__module__'] = model.__module__ vote_model = ModelBase.__new__(c, name, bases, attrs) _vote_models[vote_model.get_model_name()] = vote_model return vote_model
def __new__(cls, name, bases, attrs): """ Instantiation of the State type. When this type is created, also create a logging model if required. """ if name != 'StateModel' and 'Machine' in attrs: attrs['state'] = StateField(max_length=100, default='0', verbose_name=_('state id'), machine=attrs['Machine']) # Call class constructor of parent return ModelBase.__new__(cls, name, bases, attrs)
def __new__(c, name, bases, attrs): # Rename class name = '%sVote' % model._meta.object_name # This attribute is required for a model to function # properly in Django. attrs['__module__'] = model.__module__ vote_model = ModelBase.__new__(c, name, bases, attrs) _vote_models[vote_model.get_model_name()] = vote_model return vote_model
def __new__(c, name, bases, attrs): if '__unicode__' in attrs: old_unicode = attrs['__unicode__'] def new_unicode(self): return '%s (%s)' % (old_unicode(self), self.get_state_info().description) attrs['__unicode__'] = new_unicode attrs['__module__'] = state_model.__module__ values = {'model_name': state_model.__name__, 'field_name': field_name.capitalize()} class_name = conf.LOG_MODEL_NAME % values return ModelBase.__new__(c, class_name, bases, attrs)
def __new__(cls, name, bases, attrs, **kwds): new_class = ModelBase.__new__(cls, name, bases, attrs, **kwds) aldjemy_attrs = {} for attr_name, attr in attrs.items(): if callable(attr) or isinstance(attr, property): aldjemy_attrs[attr_name] = attr new_class.aldjemy_mixin = type( 'AldjemyMixin_' + name, (object,), aldjemy_attrs, ) return new_class
def __new__(c, name, bases, attrs): if '__unicode__' in attrs: old_unicode = attrs['__unicode__'] def new_unicode(self): return '%s (%s)' % (old_unicode(self), self.get_state_info().description) attrs['__unicode__'] = new_unicode attrs['__module__'] = state_model.__module__ values = {'model_name': state_model.__name__, 'field_name': field_name.capitalize()} class_name = conf.LOG_MODEL_NAME % values return ModelBase.__new__(c, class_name, bases, attrs)
def __new__(cls, name, bases, attrs, **kwargs): new_class = ModelBase.__new__(cls, name, bases, attrs, **kwargs) aldjemy_attrs = {} for attr_name, attr in attrs.items(): if callable(attr) or isinstance(attr, property): aldjemy_attrs[attr_name] = attr new_class.aldjemy_mixin = type( "AldjemyMixin_" + name, (object, ), aldjemy_attrs, ) return new_class
def __new__(cls, name, bases, attrs): super_new = ModelBase.__new__(cls, name, bases, attrs) module_name = camel_to_underscore(name) app_label = super_new.__module__.split('.')[-2] db_table = '%s_%s' % (app_label, module_name) django_default = '%s_%s' % (app_label, name.lower()) if not getattr(super_new._meta, 'proxy', False): db_table_is_default = django_default == super_new._meta.db_table # Don't overwrite when people customize the db_table if db_table_is_default: super_new._meta.db_table = db_table return super_new
def __new__(cls, name, bases, attrs): super_new = ModelBase.__new__(cls, name, bases, attrs) module_name = camel_to_underscore(name) app_label = super_new.__module__.split('.')[-2] db_table = '%s_%s' % (app_label, module_name) django_default = '%s_%s' % (app_label, name.lower()) if not getattr(super_new._meta, 'proxy', False): db_table_is_default = django_default == super_new._meta.db_table # Don't overwrite when people customize the db_table if db_table_is_default: super_new._meta.db_table = db_table return super_new
def __new__(cls, name, bases, attrs): Model = ModelBase.__new__(cls, name, bases, attrs) history = getattr(Model, "History", None) if history: history = history.__dict__ if not "model" in history: history["model"] = False if not "fields" in history: history["fields"] = [] else: # raise "Please add History subclass to your model" history = {"model": False, "fields": []} Model._history = history add_signals(Model) return Model
def __new__(cls, name, bases, attrs): scopes_bases = filter(None, [attrs.get('Scopes')] + [getattr(b, 'Scopes', None) for b in bases]) attrs['Scopes'] = type('ScopesFor' + name, tuple(scopes_bases), {}) ScopedQuerySet = type('ScopedQuerySetFor' + name, (QuerySet, attrs['Scopes']), {}) ScopedManager = type('ScopedManagerFor' + name, (models.Manager, attrs['Scopes']), { 'use_for_related_fields': True, 'get_query_set': lambda self: ScopedQuerySet(self.model, using = self._db) }) attrs['objects'] = ScopedManager() return ModelBase.__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, attrs): Model = ModelBase.__new__(cls, name, bases, attrs) history = getattr(Model, 'History', None) if history: history = history.__dict__ if not 'model' in history: history['model'] = False if not 'fields' in history: history['fields'] = [] else: #raise "Please add History subclass to your model" history = {'model': False, 'fields': []} Model._history = history add_signals(Model) return Model
def __new__(c, name, bases, attrs): new_unicode = u"" if "__unicode__" in attrs: old_unicode = attrs["__unicode__"] def new_unicode(self): """New Unicode""" return u"%s (%s)" % (old_unicode(self), self.get_state_info().description) attrs["__unicode__"] = new_unicode attrs["__module__"] = state_model.__module__ values = {"model_name": state_model.__name__, "field_name": field_name.capitalize()} class_name = conf.LOG_MODEL_NAME % values return ModelBase.__new__(c, class_name, bases, attrs)
def __new__(meta, class_name, bases, class_dict): """ Create subclasses of MPTTModel. This: - adds the MPTT fields to the class - adds a TreeManager to the model """ mptt_opts = class_dict.pop('MPTTMeta', None) class_dict['_mptt_meta'] = MPTTOptions(mptt_opts) cls = ModelBase.__new__(meta, class_name, bases, class_dict) # For backwards compatibility with existing libraries, we copy the # _mptt_meta options into _meta. # This will be removed in 0.5. # All new code should use _mptt_meta rather than _meta for tree attributes. for attr in ('left_attr', 'right_attr', 'tree_id_attr', 'level_attr', 'parent_attr', 'tree_manager_attr', 'order_insertion_by'): setattr(cls._meta, attr, getattr(cls._mptt_meta, attr)) try: MPTTModel except NameError: # We're defining the base class right now, so don't do anything # We only want to add this stuff to the subclasses. # (Otherwise if field names are customized, we'll end up adding two # copies) pass else: for key in ('left_attr', 'right_attr', 'tree_id_attr', 'level_attr'): field_name = getattr(cls._mptt_meta, key) try: cls._meta.get_field(field_name) except models.FieldDoesNotExist: field = models.PositiveIntegerField(db_index=True, editable=False) field.contribute_to_class(cls, field_name) # Add a custom tree manager manager = TreeManager(cls._mptt_meta) manager.contribute_to_class(cls, cls._mptt_meta.tree_manager_attr) setattr(cls, '_tree_manager', getattr(cls, cls._mptt_meta.tree_manager_attr)) # Set up signal receivers model_signals.post_init.connect(signals.post_init, sender=cls) model_signals.pre_save.connect(signals.pre_save, sender=cls) return cls
def __new__(cls, name, bases, attrs): cls = ModelBase.__new__(cls, name, bases, attrs) instances_added = False for instance_name, key in cls.get_enum_instances_map().items(): get_fn = classproperty( partial(_enum_cached_get_fn, instance_name = instance_name, key = key) ) setattr(cls, instance_name, get_fn) instances_added = True #if instances_added: # from django.db.models.signals import post_migrate # post_migrate.connect(cls.insert_enum_instances) return cls
def __new__(cls, name, bases, attrs): path = attrs.pop('path', 'config.json') try: extrafields = {} with open(path) as config_file: loaded_attrs = json.load(config_file) userfields = loaded_attrs['userfields'].items() for field_name, field_props in userfields: field_type = field_props.pop('type', 'charfield') extrafields[str(field_name)] = field_mapping[field_type](**field_props) extrafields['extra_fields_set'] = extrafields.keys() attrs.update(extrafields) except IOError: pass except Exception as e: raise return ModelBase.__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, attrs): new_class = ModelBase.__new__(cls, name, bases, attrs) # six.with_metaclass() inserts an extra class called 'NewBase' in the # inheritance tree: Model -> NewBase -> object. But the initialization # should be executed only once for a given model class. # attrs will never be empty for classes declared in the standard way # (ie. with the `class` keyword). This is quite robust. if name == 'NewBase' and attrs == {}: return new_class # We do not need to initialize here for Django 1.7 (anylink.apps does # this instead). if django.VERSION[:2] >= (1, 7): return new_class do_anylink_extension_setup(new_class) return new_class
def __new__(cls, name, bases, attrs): Model = ModelBase.__new__(cls, name, bases, attrs) history = getattr(Model, 'History', None) if history: history = history.__dict__ if not 'model' in history: history['model'] = False if not 'fields' in history: history['fields'] = [] else: #raise "Please add History subclass to your model" history = { 'model': False, 'fields': [] } Model._history = history add_signals(Model) return Model
def __new__(cls, name, bases, attrs): """ Instantiation of the State type. When this type is created, also create logging model if required. """ if name != 'StateModel' and 'Machine' in attrs: attrs['state'] = StateField(max_length=64, default='0', verbose_name=_('state id'), machine=attrs['Machine']) # Wrap __unicode__ for state model if '__unicode__' in attrs: old_unicode = attrs['__unicode__'] def new_unicode(self): return '%s (%s)' % (old_unicode(self), self.Machine.get_state(self.state).description) attrs['__unicode__'] = new_unicode # Call class constructor of parent return ModelBase.__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, attrs): """ Instantiation of the State type. When this type is created, also create a logging model if required. """ if name != "StateModel" and "Machine" in attrs: attrs["state"] = StateField( max_length=100, default="0", verbose_name=_("state id"), machine=attrs["Machine"] ) # Wrap __unicode__ for state model if "__unicode__" in attrs: old_unicode = attrs["__unicode__"] def new_unicode(self): return "%s (%s)" % (old_unicode(self), self.Machine.get_state(self.state).description) attrs["__unicode__"] = new_unicode # Call class constructor of parent return ModelBase.__new__(cls, name, bases, attrs)
def __new__(c, name, bases, attrs): new_unicode = u"" if "__unicode__" in attrs: old_unicode = attrs["__unicode__"] def new_unicode(self): """New Unicode""" return u"%s (%s)" % (old_unicode(self), self.get_state_info().description) attrs["__unicode__"] = new_unicode attrs["__module__"] = state_model.__module__ values = {"model_name": state_model.__name__, "field_name": field_name.capitalize()} class_name = conf.LOG_MODEL_NAME % values # Make sure that for Python2, class_name is a 'str' object. # In Django 1.7, `field_name` returns a unicode object, causing # `class_name` to be unicode as well. if sys.version_info[0] == 2: class_name = str(class_name) return ModelBase.__new__(c, class_name, bases, attrs)
def __new__(cls, name, bases, attrs): """ We must define our Typeclasses as proxies. We also store the path directly on the class, this is required by managers. """ # storage of stats attrs["typename"] = name attrs["path"] = "%s.%s" % (attrs["__module__"], name) # typeclass proxy setup if "Meta" not in attrs: class Meta(object): proxy = True app_label = attrs.get("__applabel__", "typeclasses") attrs["Meta"] = Meta attrs["Meta"].proxy = True new_class = ModelBase.__new__(cls, name, bases, attrs) # attach signals signals.post_save.connect(post_save, sender=new_class) signals.pre_delete.connect(remove_attributes_on_delete, sender=new_class) return new_class
def __new__(cls, name, bases, attrs): for k, v in attrs.items(): if isinstance(v, Field): cls.base_fields[k] = attrs.pop(k) return ModelBase.__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, dct): new_class = ModelBase.__new__(cls, name, bases, dct) if 'historized_model' in dct: ## Retrieve the spied upon model spied_model = dct['historized_model'] try: field_list = dct['history_fields'] except: field_list = None ## Register the model used for historisation into the spied-upon model's Meta class. spied_model._meta.history_model = new_class ## Copy basic fields for field in spied_model._meta.fields: ## Check this field should be historised if field_list and not field.name in field_list: continue ## PK handling if field.primary_key: _field = copy.copy(field) if field.__class__.__name__ == 'AutoField': # note: an autofield is always the PK _field = models.IntegerField(max_length = 100) if field.name == 'id': _field.name = 'history_id' _field.primary_key = False if _field.unique: _field.unique = False _field.history_field = True _field.null = True new_class.add_to_class(_field.name, _field) def __getOldPK(self): return getattr(self, self._meta.HOP) new_class.history_old_pk = property(__getOldPK) new_class._meta.HOP = _field.name continue ## FK handling if field.__class__.__name__ == 'ForeignKey': _field = models.ForeignKey(Essence, blank=True, null=True, related_name = r'history_' + field.name + r'_avatar_set') _field.history_field = True _field.name = field.name new_class.add_to_class(_field.name, _field) continue ## Casual fields handling _field = copy.copy(field) _field.history_field = True if _field.unique: _field.unique = False new_class.add_to_class(_field.name, _field) ## Copy many to many fields for mm in spied_model._meta.many_to_many: ## Check this field should be historised if field_list and not mm.name in field_list: continue _mm = models.ManyToManyField(Essence, null = True, blank = True, related_name = r'history_' + mm.name + r'_avatar_set') _mm.history_field = True _mm.name = mm.name new_class.add_to_class(_mm.name, _mm) ## Create a relationship to the current version object new_class.add_to_class('history_active_object', models.ForeignKey(spied_model, blank = True, null = True, related_name = 'version_set')) ## Create an optional relationship to another version objet new_class.add_to_class('history_linked_to_version', models.ForeignKey(new_class, blank = True, null = True, related_name = 'history_used_by_version_set')) ## Register the signal listener #pre_save.connect( before_save_event_handler, sender = spied_model) #post_save.connect(after_save_event_handler, sender = spied_model) #pre_delete.connect(before_delete_event_handler, sender = spied_model) #ready_to_delete.connect(before_delete_event_handler, sender = spied_model) ## Add attributes to the spied upon object spied_model.current_version = property(_getCurrentVersion) spied_model.current_avatar = property(_getCurrentVersionObject) spied_model.essence = property(_getObjectEssence) spied_model.modifications = property(_diffWithCurrentVersion) ## Add helper functions to the spied upon object spied_model.history_revert_to = _revert_instance_to_version spied_model.history_cancel_latest_commit = _revert_latest_commit spied_model.history_fork = _fork spied_model.history_merge = _merge ## Delete overload, but we must take into account an optional overload by the user himself spied_model.history_delete = spied_model.delete def delete(self): ready_to_delete.send(sender = spied_model, instance=self) self.history_delete() spied_model.delete = delete ## End : return the model return new_class
def __new__(cls, name, bases, attrs): # inject UserBase fields for k, v in cls.base_fields.items(): if k not in attrs: attrs[k] = cls.base_fields[k] return ModelBase.__new__(cls, 'User', bases, attrs)
def __new__(cls, name, bases, attrs): ret = ModelBase.__new__(cls, name, bases, attrs) if hasattr(ret, 'init_related_lookup'): ret.init_related_lookup() return ret
def __new__(cls, name, bases, attr): klass = ModelBase.__new__(cls, name, bases, attr) klass.validate_meta() klass._meta.__class__ = RollEngineOptions return klass
def _create_public_model(self, cls, name, bases, attrs, origin_cls): from publisher.base import Publisher, PublicPublisher # because of model inheritance: rebased = [] for base in bases: if issubclass(base, Publisher) and base in self.registry: # model inheritance ? rebases inherited model to his # public version if there is a public version base = base.PublicModel if not base: # inherited model isnt't registered yet, escape, we will try # it again in next round return rebased.append(base) if not rebased: rebased = list(bases) if not PublicPublisher in rebased: # append PublicPublisher to bases - we want to use some methods he # contains rebased.append(PublicPublisher) for attr, value in attrs.items(): if isinstance(value, RelatedField): self.other = value.rel.to # is this still required...? if isinstance(self.other, basestring): def resolve_other(field, model, cls): self.other = model # all standards models are already created in this time, so it # should'nt do any lazy operation add_lazy_relation(origin_cls, value, self.other, resolve_other) # get model to which points this relation model = get_model(self.other._meta.app_label, self.other._meta.object_name.lower(), False) if issubclass(model, Publisher): # it is a subclass of Publisher, change relation relation_public_name = PublisherManager.PUBLISHER_MODEL_NAME % self.other._meta.object_name to = model.PublicModel or relation_public_name attrs[attr].rel.to = to if isinstance(attrs[attr].rel, ManyToOneRel) and \ attrs[attr].rel.field_name and attrs[attr].rel.field_name.endswith('_ptr'): attrs[attr].rel.field_name = "%spublic_ptr" % attrs[attr].rel.field_name.split('_ptr')[0] # mark it as public model, so we can recognize it when required attrs['_is_public_model'] = lambda self: True # construct class public_name = PublisherManager.PUBLISHER_MODEL_NAME % name table_name = "%spublic" % (origin_cls._meta.db_table) if not "Meta" in attrs: class Meta: db_table = table_name attrs["Meta"] = Meta else: meta = attrs["Meta"] if not hasattr(meta, "db_table"): setattr(meta, "db_table", table_name) public_cls = ModelBase.__new__(cls, public_name, tuple(rebased), attrs) # add mark_delete field to public models, maybe will be better to move this # into PublicModel class, since it exists now if not 'mark_delete' in [field.name for field in public_cls._meta.local_fields]: field = models.BooleanField(default=False, editable=False) public_cls.add_to_class('mark_delete', field) # create links between standard and public models if not origin_cls in self.inherited: origin_cls.add_to_class('public', models.OneToOneField(public_cls, related_name="origin", null=True, blank=True, editable=False)) else: # this model gets inherited from some other - create link with special name here # so, if model haves inherited_public relation, it is an inherited model origin_cls.add_to_class('inherited_public', models.OneToOneField(public_cls, related_name="inherited_origin", null=True, blank=True, editable=False)) return True
def __new__(mcs, name, bases, attrs): if not 'I18nModel' in [b.__name__ for b in bases]: # This is not a I18nModel subclass, so ignore it return ModelBase.__new__(mcs, name, bases, attrs) attr_meta = attrs.get('Meta', None) # First determine what the source model is (and throw if unknown) # The most straightforward method is to just look for ``source_model`` # attribute in model's Meta options: source = getattr(attr_meta, 'source_model', None) # Remove the source_model attribute if any, pass on exception try: del attrs['Meta'].source_model except AttributeError: pass if source and type(source) in [str, unicode]: # The source is a string, so we need to find out what the developer # meant by that. Possibly a class or a model. if '.' in source: # There's a dot in the name, so this is a model name in # ``app.Model`` format, most likely. source = get_model(source.split('.')[0], source.split('.')[1]) else: # Otherwise, let's assume that developer meant just class name. # Let's try to get it as a class. source = get_class(source, attrs['__module__'],) if source is None and name.endswith('I18N'): # There wasn't a ``source_model`` attribute among the Meta options, # but there's still hope. The model name ends with ``I18N``, so # we can assume that it follows the ``SourceNameI18N`` pattern, and # stripping ``I18N`` part would give us the ``SourceName``. base_name = name[:-4] source = get_class( base_name, attrs['__module__'] ) if not source: # There is still no source for some reason... oh well, time to throw raise ImproperlyConfigured('Please specify the source model') # Now we need to find out what fields from the source model should # be translated. And those should be copied to our model. # First look at the ``translation_fields`` Meta options fields = getattr(attr_meta, 'translation_fields', []) # Remove translation_fields attribute if any, pass on exception try: del attrs['Meta'].translation_fields except AttributeError: pass if not fields: # No fields were found, so let's grab all CharField, SlugField, # and TextField from the source model. fields = [f.name for f in source._meta.fields if type(f) in [models.TextField, models.CharField, models.SlugField]] unique_fields = [] # We have the field names we need to copy, so let's copy them over # into our new model. for field in source._meta.fields: if field.name in fields: attrs[field.name] = copy.deepcopy(field) if field._unique: # We don't allow unique fields in translations. attrs[field.name]._unique = False unique_fields.append(field.name) # Add unique_together to Meta if hasattr(attr_meta, 'unique_together'): if type(attrs['Meta'].unique_together[0]) in (str, unicode): attrs['Meta'].unique_together = ( attrs['Meta'].unique_together, ('i18n_source', 'i18n_language')) else: attrs['Meta'].unique_together += ('i18n_source', 'i18n_language') else: attrs['Meta'].unique_together = (('i18n_source', 'i18n_language'),) # Also include unique fields in unique_together if needed if unique_fields: for field in unique_fields: attrs['Meta'].unique_together += (('i18n_language', field),) # Let's also add a reference to the original model attrs['i18n_source'] = models.ForeignKey(source, related_name='translations', editable=False, verbose_name=_('source')) return ModelBase.__new__(mcs, name, bases, attrs)
def __new__(cls, name, bases, attrs): for k, v in attrs.items(): if isinstance(v, Field): cls.base_fields[k] = attrs.pop(k) return ModelBase.__new__(cls, name, bases, attrs)