def register(meta, cls, **kwargs):
"""
For the weird cases when you need to add tree-ness to an *existing*
class. For other cases you should subclass MPTTModel instead of calling this.
"""
if not issubclass(cls, models.Model):
raise ValueError, "register() expects a Django model class argument"
if not hasattr(cls, '_mptt_meta'):
cls._mptt_meta = MPTTOptions(**kwargs)
abstract = getattr(cls._meta, 'abstract', False)
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:
if not issubclass(cls, MPTTModel):
bases = list(cls.__bases__)
# strip out bases that are strict superclasses of MPTTModel.
# (i.e. Model, object)
# this helps linearize the type hierarchy if possible
for i in range(len(bases)-1, -1, -1):
if issubclass(MPTTModel, bases[i]):
del bases[i]
bases.insert(0, MPTTModel)
cls.__bases__ = tuple(bases)
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 tree manager, if there isn't one already
if not abstract:
tree_manager_attr = cls._mptt_meta.tree_manager_attr
manager = getattr(cls, tree_manager_attr, None)
if (not manager) or manager.model != cls:
if not manager:
manager = TreeManager()
else:
# manager.model might already be set if this is a proxy model
# (in that case, we need to create a new manager, or _base_manager will be wrong)
manager = manager.__class__()
manager.contribute_to_class(cls, tree_manager_attr)
manager.init_from_model(cls)
setattr(cls, '_tree_manager', manager)
return cls
def forwards(self, orm):
cls = orm.Party
cls._mptt_meta = MPTTOptions(left_attr="tree_left", level_attr="tree_level", right_attr="tree_right")
tree_manager = TreeManager()
tree_manager.contribute_to_class(cls, "_tree_manager")
tree_manager.init_from_model(cls)
tree_manager.rebuild()
def register(meta, cls, **kwargs):
"""
For the weird cases when you need to add tree-ness to an *existing*
class. For other cases you should subclass MPTTModel instead of calling this.
"""
if not issubclass(cls, models.Model):
raise ValueError(_("register() expects a Django model class argument"))
if not hasattr(cls, '_mptt_meta'):
cls._mptt_meta = MPTTOptions(**kwargs)
abstract = getattr(cls._meta, 'abstract', False)
# For backwards compatibility with existing libraries, we copy the
# _mptt_meta options into _meta.
# This was removed in 0.5 but added back in 0.5.1 since it caused compatibility
# issues with django-cms 2.2.0.
# some discussion is here: https://github.com/divio/django-cms/issues/1079
# This stuff is still documented as removed, and WILL be removed again in the next release.
# All new code should use _mptt_meta rather than _meta for tree attributes.
attrs = set(['left_attr', 'right_attr', 'tree_id_attr', 'level_attr', 'parent_attr',
'tree_manager_attr', 'order_insertion_by'])
warned_attrs = set()
class _MetaSubClass(cls._meta.__class__):
def __getattr__(self, attr):
if attr in attrs:
if attr not in warned_attrs:
warned_attrs.add(attr)
return getattr(cls._mptt_meta, attr)
return super(_MetaSubClass, self).__getattr__(attr)
cls._meta.__class__ = _MetaSubClass
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:
if not issubclass(cls, MPTTModel):
bases = list(cls.__bases__)
# strip out bases that are strict superclasses of MPTTModel.
# (i.e. Model, object)
# this helps linearize the type hierarchy if possible
for i in range(len(bases) - 1, -1, -1):
if issubclass(MPTTModel, bases[i]):
del bases[i]
bases.insert(0, MPTTModel)
cls.__bases__ = tuple(bases)
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 tree manager, if there isn't one already
if not abstract:
manager = getattr(cls, 'objects', None)
if manager is None:
manager = cls._default_manager._copy_to_model(cls)
manager.contribute_to_class(cls, 'objects')
elif manager.model != cls:
# manager was inherited
manager = manager._copy_to_model(cls)
manager.contribute_to_class(cls, 'objects')
if hasattr(manager, 'init_from_model'):
manager.init_from_model(cls)
# make sure we have a tree manager somewhere
tree_manager = TreeManager()
tree_manager.contribute_to_class(cls, '_tree_manager')
tree_manager.init_from_model(cls)
# avoid using ManagerDescriptor, so instances can refer to self._tree_manager
setattr(cls, '_tree_manager', tree_manager)
# for backwards compatibility, add .tree too (or whatever's in tree_manager_attr)
tree_manager_attr = cls._mptt_meta.tree_manager_attr
if tree_manager_attr != 'objects':
another = getattr(cls, tree_manager_attr, None)
if another is None:
# wrap with a warning on first use
from django.db.models.manager import ManagerDescriptor
class _WarningDescriptor(ManagerDescriptor):
def __init__(self, manager):
self.manager = manager
self.used = False
def __get__(self, instance, type=None):
if instance != None:
raise AttributeError("Manager isn't accessible via %s instances" % type.__name__)
if not self.used:
self.used = True
return self.manager
setattr(cls, tree_manager_attr, _WarningDescriptor(manager))
elif hasattr(another, 'init_from_model'):
another.init_from_model(cls)
return cls
def register(meta, cls, **kwargs):
"""
For the weird cases when you need to add tree-ness to an *existing*
class. For other cases you should subclass MPTTModel instead of calling this.
"""
if not issubclass(cls, models.Model):
raise ValueError(_("register() expects a Django model class argument"))
if not hasattr(cls, '_mptt_meta'):
cls._mptt_meta = MPTTOptions(**kwargs)
abstract = getattr(cls._meta, 'abstract', False)
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:
if not issubclass(cls, MPTTModel):
bases = list(cls.__bases__)
# strip out bases that are strict superclasses of MPTTModel.
# (i.e. Model, object)
# this helps linearize the type hierarchy if possible
for i in range(len(bases) - 1, -1, -1):
if issubclass(MPTTModel, bases[i]):
del bases[i]
bases.insert(0, MPTTModel)
cls.__bases__ = tuple(bases)
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 tree manager, if there isn't one already
if not abstract:
manager = getattr(cls, 'objects', None)
if manager is None:
manager = cls._default_manager._copy_to_model(cls)
manager.contribute_to_class(cls, 'objects')
elif manager.model != cls:
# manager was inherited
manager = manager._copy_to_model(cls)
manager.contribute_to_class(cls, 'objects')
if hasattr(manager, 'init_from_model'):
manager.init_from_model(cls)
# make sure we have a tree manager somewhere
tree_manager = None
for attr in sorted(dir(cls)):
try:
obj = getattr(cls, attr)
except AttributeError:
continue
if isinstance(obj, TreeManager):
tree_manager = obj
# prefer any locally defined manager (i.e. keep going if not local)
if obj.model is cls:
break
if tree_manager and tree_manager.model is not cls:
tree_manager = tree_manager._copy_to_model(cls)
elif tree_manager is None:
tree_manager = TreeManager()
tree_manager.contribute_to_class(cls, '_tree_manager')
tree_manager.init_from_model(cls)
# avoid using ManagerDescriptor, so instances can refer to self._tree_manager
setattr(cls, '_tree_manager', tree_manager)
return cls
def register(meta, cls, **kwargs):
"""
For the weird cases when you need to add tree-ness to an *existing*
class. For other cases you should subclass MPTTModel instead of calling this.
"""
if not issubclass(cls, models.Model):
raise ValueError, "register() expects a Django model class argument"
if not hasattr(cls, '_mptt_meta'):
cls._mptt_meta = MPTTOptions(**kwargs)
abstract = getattr(cls._meta, 'abstract', False)
# 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:
if not issubclass(cls, MPTTModel):
bases = list(cls.__bases__)
# strip out bases that are strict superclasses of MPTTModel.
# (i.e. Model, object)
# this helps linearize the type hierarchy if possible
for i in range(len(bases) - 1, -1, -1):
if issubclass(MPTTModel, bases[i]):
del bases[i]
bases.insert(0, MPTTModel)
cls.__bases__ = tuple(bases)
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 tree manager, if there isn't one already
if not abstract:
tree_manager_attr = cls._mptt_meta.tree_manager_attr
manager = getattr(cls, tree_manager_attr, None)
if (not manager) or manager.model != cls:
if not manager:
manager = TreeManager()
else:
# manager.model might already be set if this is a proxy model
# (in that case, we need to create a new manager, or _base_manager will be wrong)
manager = manager.__class__()
manager.contribute_to_class(cls, tree_manager_attr)
manager.init_from_model(cls)
setattr(cls, '_tree_manager', manager)
return cls
def register(meta, cls, **kwargs):
"""
For the weird cases when you need to add tree-ness to an *existing*
class. For other cases you should subclass MPTTModel instead of calling this.
"""
if not issubclass(cls, models.Model):
raise ValueError(
_("register() expects a Django model class argument"))
if not hasattr(cls, '_mptt_meta'):
cls._mptt_meta = MPTTOptions(**kwargs)
abstract = getattr(cls._meta, 'abstract', False)
# For backwards compatibility with existing libraries, we copy the
# _mptt_meta options into _meta.
# This was removed in 0.5 but added back in 0.5.1 since it caused compatibility
# issues with django-cms 2.2.0.
# some discussion is here: https://github.com/divio/django-cms/issues/1079
# This stuff is still documented as removed, and WILL be removed again in the next release.
# All new code should use _mptt_meta rather than _meta for tree attributes.
attrs = set([
'left_attr', 'right_attr', 'tree_id_attr', 'level_attr',
'parent_attr', 'tree_manager_attr', 'order_insertion_by'
])
warned_attrs = set()
class _MetaSubClass(cls._meta.__class__):
def __getattr__(self, attr):
if attr in attrs:
if attr not in warned_attrs:
warnings.warn(
"%s._meta.%s is deprecated and will be removed in mptt 0.6"
% (cls.__name__, attr),
#don't use DeprecationWarning, that gets ignored by default
UserWarning,
)
warned_attrs.add(attr)
return getattr(cls._mptt_meta, attr)
return super(_MetaSubClass, self).__getattr__(attr)
cls._meta.__class__ = _MetaSubClass
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:
if not issubclass(cls, MPTTModel):
bases = list(cls.__bases__)
# strip out bases that are strict superclasses of MPTTModel.
# (i.e. Model, object)
# this helps linearize the type hierarchy if possible
for i in range(len(bases) - 1, -1, -1):
if issubclass(MPTTModel, bases[i]):
del bases[i]
bases.insert(0, MPTTModel)
cls.__bases__ = tuple(bases)
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 tree manager, if there isn't one already
if not abstract:
manager = getattr(cls, 'objects', None)
if manager is None:
manager = cls._default_manager._copy_to_model(cls)
manager.contribute_to_class(cls, 'objects')
elif manager.model != cls:
# manager was inherited
manager = manager._copy_to_model(cls)
manager.contribute_to_class(cls, 'objects')
if hasattr(manager, 'init_from_model'):
manager.init_from_model(cls)
# make sure we have a tree manager somewhere
tree_manager = TreeManager()
tree_manager.contribute_to_class(cls, '_tree_manager')
tree_manager.init_from_model(cls)
# avoid using ManagerDescriptor, so instances can refer to self._tree_manager
setattr(cls, '_tree_manager', tree_manager)
# for backwards compatibility, add .tree too (or whatever's in tree_manager_attr)
tree_manager_attr = cls._mptt_meta.tree_manager_attr
if tree_manager_attr != 'objects':
another = getattr(cls, tree_manager_attr, None)
if another is None:
# wrap with a warning on first use
from django.db.models.manager import ManagerDescriptor
class _WarningDescriptor(ManagerDescriptor):
def __init__(self, manager):
self.manager = manager
self.used = False
def __get__(self, instance, type=None):
if instance != None:
raise AttributeError(
"Manager isn't accessible via %s instances"
% type.__name__)
if not self.used:
warnings.warn(
'Implicit manager %s.%s will be removed in django-mptt 0.6. '
' Explicitly define a TreeManager() on your model to remove this warning.'
% (cls.__name__, tree_manager_attr),
DeprecationWarning)
self.used = True
return self.manager
setattr(cls, tree_manager_attr,
_WarningDescriptor(manager))
elif hasattr(another, 'init_from_model'):
another.init_from_model(cls)
return cls
def register(meta, cls, **kwargs):
"""
For the weird cases when you need to add tree-ness to an *existing*
class. For other cases you should subclass MPTTModel instead of calling this.
"""
if not issubclass(cls, models.Model):
raise ValueError(
_("register() expects a Django model class argument"))
if not hasattr(cls, '_mptt_meta'):
cls._mptt_meta = MPTTOptions(**kwargs)
abstract = getattr(cls._meta, 'abstract', False)
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:
if not issubclass(cls, MPTTModel):
bases = list(cls.__bases__)
# strip out bases that are strict superclasses of MPTTModel.
# (i.e. Model, object)
# this helps linearize the type hierarchy if possible
for i in range(len(bases) - 1, -1, -1):
if issubclass(MPTTModel, bases[i]):
del bases[i]
bases.insert(0, MPTTModel)
cls.__bases__ = tuple(bases)
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 tree manager, if there isn't one already
if not abstract:
manager = getattr(cls, 'objects', None)
if manager is None:
manager = cls._default_manager._copy_to_model(cls)
manager.contribute_to_class(cls, 'objects')
elif manager.model != cls:
# manager was inherited
manager = manager._copy_to_model(cls)
manager.contribute_to_class(cls, 'objects')
if hasattr(manager, 'init_from_model'):
manager.init_from_model(cls)
# make sure we have a tree manager somewhere
tree_manager = None
for attr in sorted(dir(cls)):
try:
obj = getattr(cls, attr)
except AttributeError:
continue
if isinstance(obj, TreeManager):
tree_manager = obj
# prefer any locally defined manager (i.e. keep going if not local)
if obj.model is cls:
break
if tree_manager and tree_manager.model is not cls:
tree_manager = tree_manager._copy_to_model(cls)
elif tree_manager is None:
tree_manager = TreeManager()
tree_manager.contribute_to_class(cls, '_tree_manager')
tree_manager.init_from_model(cls)
# avoid using ManagerDescriptor, so instances can refer to self._tree_manager
setattr(cls, '_tree_manager', tree_manager)
return cls
def register(meta, cls, **kwargs):
"""
For the weird cases when you need to add tree-ness to an *existing*
class. For other cases you should subclass MPTTModel instead of calling this.
"""
if not issubclass(cls, models.Model):
raise ValueError(_("register() expects a Django model class argument"))
if not hasattr(cls, "_mptt_meta"):
cls._mptt_meta = MPTTOptions(**kwargs)
abstract = getattr(cls._meta, "abstract", False)
# For backwards compatibility with existing libraries, we copy the
# _mptt_meta options into _meta.
# This was removed in 0.5 but added back in 0.5.1 since it caused compatibility
# issues with django-cms 2.2.0.
# some discussion is here: https://github.com/divio/django-cms/issues/1079
# This stuff is still documented as removed, and WILL be removed again in the next release.
# All new code should use _mptt_meta rather than _meta for tree attributes.
attrs = (
"left_attr",
"right_attr",
"tree_id_attr",
"level_attr",
"parent_attr",
"tree_manager_attr",
"order_insertion_by",
)
warned_attrs = set()
class _MetaSubClass(cls._meta.__class__):
def __getattr__(self, attr):
if attr in attrs:
if attr not in warned_attrs:
warnings.warn(
"%s._meta.%s is deprecated and will be removed in mptt 0.6" % (cls.__name__, attr),
# don't use DeprecationWarning, that gets ignored by default
UserWarning,
)
warned_attrs.add(attr)
return getattr(cls._mptt_meta, attr)
return super(_MetaSubClass, self).__getattr__(attr)
cls._meta.__class__ = _MetaSubClass
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:
if not issubclass(cls, MPTTModel):
bases = list(cls.__bases__)
# strip out bases that are strict superclasses of MPTTModel.
# (i.e. Model, object)
# this helps linearize the type hierarchy if possible
for i in xrange(len(bases) - 1, -1, -1):
if issubclass(MPTTModel, bases[i]):
del bases[i]
bases.insert(0, MPTTModel)
cls.__bases__ = tuple(bases)
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 tree manager, if there isn't one already
if not abstract:
manager = getattr(cls, "objects", None)
if manager is None:
manager = cls._default_manager._copy_to_model(cls)
manager.contribute_to_class(cls, "objects")
elif manager.model != cls:
# manager was inherited
manager = manager._copy_to_model(cls)
manager.contribute_to_class(cls, "objects")
if hasattr(manager, "init_from_model"):
manager.init_from_model(cls)
# make sure we have a tree manager somewhere
tree_manager = None
for attr in sorted(dir(cls)):
try:
obj = getattr(cls, attr)
except AttributeError:
continue
if isinstance(obj, TreeManager):
tree_manager = obj
# prefer any locally defined manager (i.e. keep going if not local)
if obj.model is cls:
break
if tree_manager and tree_manager.model is not cls:
tree_manager = tree_manager._copy_to_model(cls)
elif tree_manager is None:
tree_manager = TreeManager()
tree_manager.contribute_to_class(cls, "_tree_manager")
tree_manager.init_from_model(cls)
# avoid using ManagerDescriptor, so instances can refer to self._tree_manager
setattr(cls, "_tree_manager", tree_manager)
return cls
def register(meta, cls, **kwargs):
"""
For the weird cases when you need to add tree-ness to an *existing*
class. For other cases you should subclass MPTTModel instead of calling this.
"""
if not issubclass(cls, models.Model):
raise ValueError(_("register() expects a Django model class argument"))
if not hasattr(cls, '_mptt_meta'):
cls._mptt_meta = MPTTOptions(**kwargs)
abstract = getattr(cls._meta, 'abstract', False)
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:
if not issubclass(cls, MPTTModel):
bases = list(cls.__bases__)
# strip out bases that are strict superclasses of MPTTModel.
# (i.e. Model, object)
# this helps linearize the type hierarchy if possible
for i in range(len(bases) - 1, -1, -1):
if issubclass(MPTTModel, bases[i]):
del bases[i]
bases.insert(0, MPTTModel)
cls.__bases__ = tuple(bases)
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 tree manager, if there isn't one already
if not abstract:
manager = getattr(cls, 'objects', None)
if manager is None:
manager = cls._default_manager._copy_to_model(cls)
manager.contribute_to_class(cls, 'objects')
if hasattr(manager, 'init_from_model'):
manager.init_from_model(cls)
# make sure we have a tree manager somewhere
if not isinstance(manager, TreeManager):
manager = TreeManager()
manager.contribute_to_class(cls, '_tree_manager')
manager.init_from_model(cls)
# avoid using ManagerDescriptor, so instances can refer to self._tree_manager
setattr(cls, '_tree_manager', manager)
# for backwards compatibility, add .tree too (or whatever's in tree_manager_attr)
tree_manager_attr = cls._mptt_meta.tree_manager_attr
if tree_manager_attr != 'objects':
another = getattr(cls, tree_manager_attr, None)
if another is None:
# wrap with a warning on first use
from django.db.models.manager import ManagerDescriptor
class _WarningDescriptor(ManagerDescriptor):
def __init__(self, manager):
self.manager = manager
self.used = False
def __get__(self, instance, type=None):
if instance != None:
raise AttributeError("Manager isn't accessible via %s instances" % type.__name__)
if not self.used:
warnings.warn(
'Implicit manager %s.%s will be removed in django-mptt 0.6. '
' Explicitly define a TreeManager() on your model to remove this warning.'
% (cls.__name__, tree_manager_attr),
DeprecationWarning
)
self.used = True
return self.manager
setattr(cls, tree_manager_attr, _WarningDescriptor(manager))
elif hasattr(another, 'init_from_model'):
another.init_from_model(cls)
return cls