Exemple #1
0
    def contribute_to_class(self, model, name):
        super(TreeManager, self).contribute_to_class(model, name)

        if not model._meta.abstract:
            self.tree_model = _get_tree_model(model)

            self._base_manager = None
            if self.tree_model is not model:
                # _base_manager is the treemanager on tree_model
                self._base_manager = self.tree_model._tree_manager
Exemple #2
0
    def contribute_to_class(self, model, name):
        super(TreeManager, self).contribute_to_class(model, name)

        if not model._meta.abstract:
            self.tree_model = _get_tree_model(model)

            self._base_manager = None
            if self.tree_model is not model:
                # _base_manager is the treemanager on tree_model
                self._base_manager = self.tree_model._tree_manager
Exemple #3
0
    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)

            if _get_tree_model(cls) is cls:
                # HACK: _meta.get_field() doesn't work before AppCache.ready in Django>=1.8
                # ( see https://code.djangoproject.com/ticket/24231 )
                # So the only way to get existing fields is using local_fields on all superclasses.
                existing_field_names = set()
                for base in cls.mro():
                    if hasattr(base, '_meta'):
                        existing_field_names.update(
                            [f.name for f in base._meta.local_fields])

                for key in ('left_attr', 'right_attr', 'tree_id_attr',
                            'level_attr'):
                    field_name = getattr(cls._mptt_meta, key)
                    if field_name not in existing_field_names:
                        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')

                # make sure we have a tree manager somewhere
                tree_manager = None
                attrs = dir(cls)
                if "objects" in attrs and isinstance(cls.objects, TreeManager):
                    tree_manager = cls.objects

                # Go look for it somewhere else
                else:
                    for attr in sorted(attrs):
                        try:
                            # HACK: avoid using getattr(cls, attr)
                            # because it calls __get__ on descriptors, which can cause nasty side effects
                            # with more inconsiderate apps.
                            # (e.g. django-tagging's TagField is a descriptor which can do db queries on getattr)
                            # ( ref: http://stackoverflow.com/questions/27790344 )
                            obj = cls.__dict__[attr]
                        except KeyError:
                            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')

                # avoid using ManagerDescriptor, so instances can refer to self._tree_manager
                setattr(cls, '_tree_manager', tree_manager)
        return cls
Exemple #4
0
    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)

        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)

            if _get_tree_model(cls) is cls:
                # HACK: _meta.get_field() doesn't work before AppCache.ready in Django>=1.8
                # ( see https://code.djangoproject.com/ticket/24231 )
                # So the only way to get existing fields is using local_fields on all superclasses.
                existing_field_names = set()
                for base in cls.mro():
                    if hasattr(base, '_meta'):
                        existing_field_names.update(
                            [f.name for f in base._meta.local_fields])

                for key in ('left_attr', 'right_attr', 'tree_id_attr',
                            'level_attr'):
                    field_name = getattr(cls._mptt_meta, key)
                    if field_name not in existing_field_names:
                        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
            # NOTE: Django 1.10 lets models inherit managers without handholding.
            if django.VERSION < (1, 10) and not cls._meta.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')

                # make sure we have a tree manager somewhere
                tree_manager = None
                if hasattr(cls._meta, 'concrete_managers'):  # Django < 1.10
                    cls_managers = cls._meta.concrete_managers + cls._meta.abstract_managers
                    cls_managers = [r[2] for r in cls_managers]
                else:
                    cls_managers = cls._meta.managers

                for cls_manager in cls_managers:
                    if isinstance(cls_manager, TreeManager):
                        # prefer any locally defined manager (i.e. keep going if not local)
                        if cls_manager.model is cls:
                            tree_manager = cls_manager
                            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, '_default_manager')

        return cls
Exemple #5
0
    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)

            is_cls_tree_model = _get_tree_model(cls) is cls

            if is_cls_tree_model:
                # HACK: _meta.get_field() doesn't work before AppCache.ready in Django>=1.8
                # ( see https://code.djangoproject.com/ticket/24231 )
                # So the only way to get existing fields is using local_fields on all superclasses.
                existing_field_names = set()
                for base in cls.mro():
                    if hasattr(base, "_meta"):
                        existing_field_names.update(
                            [f.name for f in base._meta.local_fields]
                        )

                mptt_meta = cls._mptt_meta
                indexed_attrs = (mptt_meta.tree_id_attr,)
                field_names = (
                    mptt_meta.left_attr,
                    mptt_meta.right_attr,
                    mptt_meta.tree_id_attr,
                    mptt_meta.level_attr,
                )

                for field_name in field_names:
                    if field_name not in existing_field_names:
                        field = models.PositiveIntegerField(
                            db_index=field_name in indexed_attrs, editable=False
                        )
                        field.contribute_to_class(cls, field_name)

                # Add an index_together on tree_id_attr and left_attr, as these are very
                # commonly queried (pretty much all reads).
                index_together = (cls._mptt_meta.tree_id_attr, cls._mptt_meta.left_attr)
                if index_together not in cls._meta.index_together:
                    cls._meta.index_together += (index_together,)

            # Add a tree manager, if there isn't one already
            if not abstract:
                # make sure we have a tree manager somewhere
                tree_manager = None
                # Use the default manager defined on the class if any
                if cls._default_manager and isinstance(
                    cls._default_manager, TreeManager
                ):
                    tree_manager = cls._default_manager
                else:
                    for cls_manager in cls._meta.managers:
                        if isinstance(cls_manager, TreeManager):
                            # prefer any locally defined manager (i.e. keep going if not local)
                            if cls_manager.model is cls:
                                tree_manager = cls_manager
                                break

                if is_cls_tree_model:
                    idx_together = (
                        cls._mptt_meta.tree_id_attr,
                        cls._mptt_meta.left_attr,
                    )

                    if idx_together not in cls._meta.index_together:
                        cls._meta.index_together += (idx_together,)

                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")

                # avoid using ManagerDescriptor, so instances can refer to self._tree_manager
                setattr(cls, "_tree_manager", tree_manager)
        return cls
Exemple #6
0
    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)

            if _get_tree_model(cls) is cls:
                # HACK: _meta.get_field() doesn't work before AppCache.ready in Django>=1.8
                # ( see https://code.djangoproject.com/ticket/24231 )
                # So the only way to get existing fields is using local_fields on all superclasses.
                existing_field_names = set()
                for base in cls.mro():
                    if hasattr(base, "_meta"):
                        existing_field_names.update([f.name for f in base._meta.local_fields])

                for key in ("left_attr", "right_attr", "tree_id_attr", "level_attr"):
                    field_name = getattr(cls._mptt_meta, key)
                    if field_name not in existing_field_names:
                        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")

                # make sure we have a tree manager somewhere
                tree_manager = None
                attrs = dir(cls)
                if "objects" in attrs and isinstance(cls.objects, TreeManager):
                    tree_manager = cls.objects

                # Go look for it somewhere else
                else:
                    for attr in sorted(attrs):
                        try:
                            # HACK: avoid using getattr(cls, attr)
                            # because it calls __get__ on descriptors, which can cause nasty side effects
                            # with more inconsiderate apps.
                            # (e.g. django-tagging's TagField is a descriptor which can do db queries on getattr)
                            # ( ref: http://stackoverflow.com/questions/27790344 )
                            obj = cls.__dict__[attr]
                        except KeyError:
                            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")

                # avoid using ManagerDescriptor, so instances can refer to self._tree_manager
                setattr(cls, "_tree_manager", tree_manager)
        return cls
Exemple #7
0
    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)

            if _get_tree_model(cls) is cls:
                # HACK: _meta.get_field() doesn't work before AppCache.ready in Django>=1.8
                # ( see https://code.djangoproject.com/ticket/24231 )
                # So the only way to get existing fields is using local_fields on all superclasses.
                existing_field_names = set()
                for base in cls.mro():
                    if hasattr(base, '_meta'):
                        existing_field_names.update([f.name for f in base._meta.local_fields])

                for key in ('left_attr', 'right_attr', 'tree_id_attr', 'level_attr'):
                    field_name = getattr(cls._mptt_meta, key)
                    if field_name not in existing_field_names:
                        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:
                # make sure we have a tree manager somewhere
                tree_manager = None
                if hasattr(cls._meta, 'concrete_managers'):  # Django < 1.10
                    cls_managers = cls._meta.concrete_managers + cls._meta.abstract_managers
                    cls_managers = [r[2] for r in cls_managers]
                else:
                    cls_managers = cls._meta.managers

                for cls_manager in cls_managers:
                    if isinstance(cls_manager, TreeManager):
                        # prefer any locally defined manager (i.e. keep going if not local)
                        if cls_manager.model is cls:
                            tree_manager = cls_manager
                            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')

                # avoid using ManagerDescriptor, so instances can refer to self._tree_manager
                setattr(cls, '_tree_manager', tree_manager)
        return cls
Exemple #8
0
 def tree_model(self):
     return _get_tree_model(self.model)