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)
