django-fast-treenode 2.0.11__py3-none-any.whl → 2.1.1__py3-none-any.whl

treenode/models/closure.py

@@ -11,16 +11,17 @@ Features:
 - Implements cached queries for improved performance.
 - Provides bulk operations for inserting, moving, and deleting nodes.
 
-Version: 2.0.11
+Version: 2.1.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
 
 from django.db import models, transaction
+from django.db.models.signals import pre_save, post_save
 
 from ..managers import ClosureModelManager
-from ..cache import cached_method, treenode_cache
+from ..signals import disable_signals
 
 
 class ClosureModel(models.Model):
@@ -44,6 +45,14 @@ class ClosureModel(models.Model):
 
     depth = models.PositiveIntegerField()
 
+    node = models.OneToOneField(
+        'TreeNodeModel',
+        related_name="tn_closure",
+        on_delete=models.CASCADE,
+        null=True,
+        blank=True,
+    )
+
     objects = ClosureModelManager()
 
     class Meta:
@@ -53,6 +62,7 @@ class ClosureModel(models.Model):
         unique_together = (("parent", "child"),)
         indexes = [
             models.Index(fields=["parent", "child"]),
+            models.Index(fields=["child", "parent"]),
             models.Index(fields=["parent", "child", "depth"]),
         ]
 
@@ -63,39 +73,34 @@ class ClosureModel(models.Model):
     # ----------- Methods of working with tree structure ----------- #
 
     @classmethod
-    def clear_cache(cls):
-        """Clear cache for this model only."""
-        treenode_cache.invalidate(cls._meta.label)
-
-    @classmethod
-    @cached_method
     def get_ancestors_pks(cls, node, include_self=True, depth=None):
         """Get the ancestors pks list."""
         options = dict(child_id=node.pk, depth__gte=0 if include_self else 1)
         if depth:
             options["depth__lte"] = depth
-        queryset = cls.objects.filter(**options).order_by('depth')
+        queryset = cls.objects.filter(**options)\
+            .order_by('depth')\
+            .values_list('parent_id', flat=True)
         return list(queryset.values_list("parent_id", flat=True))
 
     @classmethod
-    @cached_method
     def get_descendants_pks(cls, node, include_self=False, depth=None):
         """Get a list containing all descendants."""
         options = dict(parent_id=node.pk, depth__gte=0 if include_self else 1)
         if depth:
             options.update({'depth__lte': depth})
-        queryset = cls.objects.filter(**options)
-        return list(queryset.values_list("child_id", flat=True))
+        queryset = cls.objects.filter(**options)\
+            .order_by('depth')\
+            .values_list('child_id', flat=True)
+        return queryset
 
     @classmethod
-    @cached_method
     def get_root(cls, node):
         """Get the root node pk for the current node."""
         queryset = cls.objects.filter(child=node).order_by('-depth')
-        return queryset.firts().parent if queryset.count() > 0 else None
+        return queryset.first().parent if queryset.count() > 0 else None
 
     @classmethod
-    @cached_method
     def get_depth(cls, node):
         """Get the node depth (how deep the node is in the tree)."""
         result = cls.objects.filter(child__pk=node.pk).aggregate(
@@ -104,7 +109,6 @@ class ClosureModel(models.Model):
         return result if result is not None else 0
 
     @classmethod
-    @cached_method
     def get_level(cls, node):
         """Get the node level (starting from 1)."""
         return cls.objects.filter(child__pk=node.pk).aggregate(
@@ -116,8 +120,6 @@ class ClosureModel(models.Model):
         """Add a node to a Closure table."""
         # Call bulk_create passing a single object
         cls.objects.bulk_create([node], batch_size=1000)
-        # Clear cache
-        cls.clear_cache()
 
     @classmethod
     @transaction.atomic
@@ -125,20 +127,17 @@ class ClosureModel(models.Model):
         """Move a nodes (node and its subtree) to a new parent."""
         # Call bulk_update passing a single object
         cls.objects.bulk_update(nodes, batch_size=1000)
-        # Clear cache
-        cls.clear_cache()
 
     @classmethod
     @transaction.atomic
     def delete_all(cls):
         """Clear the Closure Table."""
-        # Clear cache
-        cls.clear_cache()
         cls.objects.all().delete()
 
     def save(self, force_insert=False, *args, **kwargs):
         """Save method."""
-        super().save(force_insert, *args, **kwargs)
-        self._meta.model.clear_cache()
+        with (disable_signals(pre_save, self._meta.model),
+              disable_signals(post_save, self._meta.model)):
+            super().save(force_insert, *args, **kwargs)
 
 # The End

treenode/models/factory.py

@@ -10,7 +10,7 @@ Features:
 - Dynamically creates and assigns a Closure Model for each TreeNodeModel.
 - Facilitates the management of hierarchical relationships.
 
-Version: 2.0.0
+Version: 2.1.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
@@ -18,7 +18,7 @@ Email: timurkady@yandex.com
 
 import sys
 from django.db import models
-from .closure import ClosureModel  # Используем готовый ClosureModel
+from .closure import ClosureModel
 
 
 class TreeFactory(models.base.ModelBase):
@@ -61,11 +61,21 @@ class TreeFactory(models.base.ModelBase):
                 on_delete=models.CASCADE,
             ),
 
+            "node": models.OneToOneField(
+                cls._meta.model,
+                related_name="tn_closure",
+                on_delete=models.CASCADE,
+                null=True,
+                blank=True,
+            ),
+
             "__module__": cls.__module__
         }
+
         closure_model = type(closure_name, (ClosureModel,), fields)
         setattr(sys.modules[cls.__module__], closure_name, closure_model)
 
         cls.closure_model = closure_model
 
+
 # The End

treenode/models/mixins/__init__.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+from .ancestors import TreeNodeAncestorsMixin
+from .children import TreeNodeChildrenMixin
+from .descendants import TreeNodeDescendantsMixin
+from .family import TreeNodeFamilyMixin
+from .logical import TreeNodeLogicalMixin
+from .node import TreeNodeNodeMixin
+from .properties import TreeNodePropertiesMixin
+from .roots import TreeNodeRootsMixin
+from .siblings import TreeNodeSiblingsMixin
+from .tree import TreeNodeTreeMixin
+
+
+__all__ = [
+    "TreeNodeAncestorsMixin", "TreeNodeChildrenMixin", "TreeNodeFamilyMixin",
+    "TreeNodeDescendantsMixin", "TreeNodeLogicalMixin", "TreeNodeNodeMixin",
+    "TreeNodePropertiesMixin", "TreeNodeRootsMixin", "TreeNodeSiblingsMixin",
+    "TreeNodeTreeMixin"
+]
+
+
+# The End

treenode/models/mixins/ancestors.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+"""
+TreeNode Ancestors Mixin
+
+Version: 2.1.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+from django.db import models
+from ...cache import treenode_cache, cached_method
+
+
+class TreeNodeAncestorsMixin(models.Model):
+    """TreeNode Ancestors Mixin."""
+
+    class Meta:
+        """Moxin Meta Class."""
+
+        abstract = True
+
+    @cached_method
+    def get_ancestors_queryset(self, include_self=True, depth=None):
+        """Get the ancestors queryset (ordered from root to parent)."""
+        qs = self._meta.model.objects.filter(tn_closure__child=self.pk)
+
+        if depth is not None:
+            qs = qs.filter(tn_closure__depth__lte=depth)
+
+        if include_self:
+            qs = qs | self._meta.model.objects.filter(pk=self.pk)
+
+        return qs.distinct().order_by("tn_closure__depth")
+
+    @cached_method
+    def get_ancestors_pks(self, include_self=True, depth=None):
+        """Get the ancestors pks list."""
+        cache_key = treenode_cache.generate_cache_key(
+            label=self._meta.label,
+            func_name=getattr(self, "get_ancestors_queryset").__name__,
+            unique_id=self.pk,
+            arg={
+                "include_self": include_self,
+                "depth": depth
+            }
+        )
+        queryset = treenode_cache.get(cache_key)
+        if queryset is not None:
+            return list(queryset.values_list("id", flat=True))
+        elif hasattr(self, "closure_model"):
+            return self.closure_model.get_ancestors_pks(
+                self, include_self, depth
+            )
+        return []
+
+    def get_ancestors(self, include_self=True, depth=None):
+        """Get a list with all ancestors (ordered from root to self/parent)."""
+        queryset = self.get_ancestors_queryset(include_self, depth)
+        return list(queryset)
+
+    def get_ancestors_count(self, include_self=True, depth=None):
+        """Get the ancestors count."""
+        return len(self.get_ancestors_pks(include_self, depth))
+
+# The End

treenode/models/mixins/children.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+"""
+TreeNode Children Mixin
+
+Version: 2.1.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+from django.db import models
+from treenode.cache import cached_method
+
+
+class TreeNodeChildrenMixin(models.Model):
+    """TreeNode Ancestors Mixin."""
+
+    class Meta:
+        """Moxin Meta Class."""
+
+        abstract = True
+
+    def add_child(self, position=None, **kwargs):
+        """
+        Add a child to the node.
+
+        position:
+        Can be 'first-child', 'last-child', 'sorted-child' or integer value.
+
+        Parameters:
+        **kwargs – Object creation data that will be passed to the inherited
+          Node model
+        instance – Instead of passing object creation data, you can pass
+          an already-constructed (but not yet saved) model instance to be
+          inserted into the tree.
+
+        Returns:
+        The created node object. It will be save()d by this method.
+        """
+        if isinstance(position, int):
+            priority = position
+            parent = self
+        else:
+            if position not in ['first-child', 'last-child', 'sorted-child']:
+                raise ValueError(f"Invalid position format: {position}")
+            parent, priority = self._meta.model._get_place(self, position)
+
+        instance = kwargs.get("instance")
+        if instance is None:
+            instance = self._meta.model(**kwargs)
+        instance.tn_parent = parent
+        instance.tn_priority = priority
+        instance.save()
+        return instance
+
+    @cached_method
+    def get_children_pks(self):
+        """Get the children pks list."""
+        return list(self.get_children_queryset().values_list("id", flat=True))
+
+    @cached_method
+    def get_children_queryset(self):
+        """Get the children queryset with prefetch."""
+        return self.tn_children.prefetch_related('tn_children')
+
+    def get_children(self):
+        """Get a list containing all children."""
+        return list(self.get_children_queryset())
+
+    def get_children_count(self):
+        """Get the children count."""
+        return len(self.get_children_pks())
+
+    def get_first_child(self):
+        """Get the first child node or None if it has no children."""
+        return self.get_children_queryset().first() if self.is_leaf else None
+
+    def get_last_child(self):
+        """Get the last child node or None if it has no children."""
+        return self.get_children_queryset().last() if self.is_leaf else None
+
+# The End

treenode/models/mixins/descendants.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+"""
+TreeNode Descendants Mixin
+
+Version: 2.1.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+from django.db import models
+from treenode.cache import treenode_cache, cached_method
+
+
+class TreeNodeDescendantsMixin(models.Model):
+    """TreeNode Descendants Mixin."""
+
+    class Meta:
+        """Moxin Meta Class."""
+
+        abstract = True
+
+    @cached_method
+    def get_descendants_queryset(self, include_self=False, depth=None):
+        """Get the descendants queryset."""
+        queryset = self._meta.model.objects\
+            .annotate(min_depth=models.Min("parents_set__depth"))\
+            .filter(parents_set__parent=self.pk)
+
+        if depth is not None:
+            queryset = queryset.filter(min_depth__lte=depth)
+        if include_self and not queryset.filter(pk=self.pk).exists():
+            queryset = queryset | self._meta.model.objects.filter(pk=self.pk)
+
+        return queryset.order_by("min_depth", "tn_priority")
+
+    @cached_method
+    def get_descendants_pks(self, include_self=False, depth=None):
+        """Get the descendants pks list."""
+        cache_key = treenode_cache.generate_cache_key(
+            label=self._meta.label,
+            func_name=getattr(self, "get_descendants_queryset").__name__,
+            unique_id=self.pk,
+            arg={
+                "include_self": include_self,
+                "depth": depth
+            }
+        )
+        queryset = treenode_cache.get(cache_key)
+        if queryset is not None:
+            return list(queryset.values_list("id", flat=True))
+        elif hasattr(self, "closure_model"):
+            return self.closure_model.get_descendants_pks(
+                self, include_self, depth
+            )
+        return []
+
+    def get_descendants(self, include_self=False, depth=None):
+        """Get a list containing all descendants."""
+        queryset = self.get_descendants_queryset(include_self, depth)
+        return list(queryset)
+
+    def get_descendants_count(self, include_self=False, depth=None):
+        """Get the descendants count."""
+        return len(self.get_descendants_pks(include_self, depth))
+
+# The End

treenode/models/mixins/family.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+"""
+TreeNode Descendants Mixin
+
+Version: 2.1.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+from django.db import models
+from treenode.cache import cached_method
+
+
+class TreeNodeFamilyMixin(models.Model):
+    """TreeNode Family Mixin."""
+
+    class Meta:
+        """Moxin Meta Class."""
+
+        abstract = True
+
+    @cached_method
+    def get_family_queryset(self):
+        """
+        Return node family.
+
+        Return a QuerySet containing the ancestors, itself and the descendants,
+        in tree order.
+        """
+        model = self._meta.model
+        queryset = model.objects.filter(
+            models.Q(tn_closure__child=self.pk) |
+            models.Q(tn_closure__parent=self.pk) |
+            models.Q(pk=self.pk)
+        ).distinct().order_by("tn_closure__depth", "tn_parent", "tn_priority")
+        return queryset
+
+    @cached_method
+    def get_family_pks(self):
+        """
+        Return node family.
+
+        Return a pk-list containing the ancestors, the model itself and
+        the descendants, in tree order.
+        """
+        pks = self.get_family_queryset().values_list("id", flat=True)
+        return list(pks)
+
+    def get_family(self):
+        """
+        Return node family.
+
+        Return a list containing the ancestors, the model itself and
+        the descendants, in tree order.
+        """
+        queryset = self.get_family_queryset()
+        return list(queryset)
+
+    def get_family_count(self):
+        """Return number of nodes in family."""
+        return self.get_family_queryset().count()
+
+# The End

treenode/models/mixins/logical.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+"""
+TreeNode Logical methods Mixin
+
+Version: 2.1.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+from django.db import models
+
+
+class TreeNodeLogicalMixin(models.Model):
+    """TreeNode Logical Mixin."""
+
+    class Meta:
+        """Moxin Meta Class."""
+
+        abstract = True
+
+    def is_ancestor_of(self, target_obj):
+        """Return True if the current node is ancestor of target_obj."""
+        return self in target_obj.get_ancestors(include_self=False)
+
+    def is_child_of(self, target_obj):
+        """Return True if the current node is child of target_obj."""
+        return self in target_obj.get_children()
+
+    def is_descendant_of(self, target_obj):
+        """Return True if the current node is descendant of target_obj."""
+        return self in target_obj.get_descendants()
+
+    def is_first_child(self):
+        """Return True if the current node is the first child."""
+        return self.tn_priority == 0
+
+    def has_children(self):
+        """Return True if the node has children."""
+        return self.tn_children.exists()
+
+    def is_last_child(self):
+        """Return True if the current node is the last child."""
+        return self.tn_priority == self.get_siblings_count() - 1
+
+    def is_leaf(self):
+        """Return True if the current node is a leaf."""
+        return self.tn_children.count() == 0
+
+    def is_parent_of(self, target_obj):
+        """Return True if the current node is parent of target_obj."""
+        return self == target_obj.tn_parent
+
+    def is_root(self):
+        """Return True if the current node is root."""
+        return self.tn_parent is None
+
+    def is_root_of(self, target_obj):
+        """Return True if the current node is root of target_obj."""
+        return self == target_obj.get_root()
+
+    def is_sibling_of(self, target_obj):
+        """Return True if the current node is sibling of target_obj."""
+        if target_obj.tn_parent is None and self.tn_parent is None:
+            # Both objects are roots
+            return True
+        return (self.tn_parent == target_obj.tn_parent)
+
+# The End