django-fast-treenode 2.1.2__py3-none-any.whl → 2.1.4__py3-none-any.whl

treenode/models/adjacency.py

@@ -74,8 +74,6 @@ class TreeNodeModel(
 
         abstract = True
         indexes = [
-            models.Index(fields=["tn_parent"]),
-            models.Index(fields=["tn_parent", "id"]),
             models.Index(fields=["tn_parent", "tn_priority"]),
         ]
 
@@ -151,43 +149,45 @@ class TreeNodeModel(
             using=self._state.db,
             update_fields=kwargs.get("update_fields", None)
         )
-
-        # If the object already exists, get the old parent and priority values
-        is_new = self.pk is None
-        if not is_new:
-            old_parent, old_priority = model.objects\
-                .filter(pk=self.pk)\
-                .values_list('tn_parent', 'tn_priority')\
-                .first()
-            is_move = (old_priority != self.tn_priority)
-        else:
-            force_insert = True
-            is_move = False
-            old_parent = None
-
-        # Check if we are trying to move a node to a child
-        if old_parent and old_parent != self.tn_parent and self.tn_parent:
-            # Get pk of children via values_list to avoid creating full
-            # set of objects
-            if self.tn_parent.pk in self.get_descendants_pks():
-                raise ValueError("You cannot move a node into its own child.")
-
-        # Save the object and synchronize with the closing table
-        # Disable signals
-        with (disable_signals(pre_save, model),
-              disable_signals(post_save, model)):
-
-            if is_new or is_move:
-                self._update_priority()
-            super().save(force_insert=force_insert, *args, **kwargs)
-            # Run synchronize
-            if is_new:
-                self.closure_model.insert_node(self)
-            elif is_move:
-                subtree_nodes = self.get_descendants(include_self=True)
-                self.closure_model.move_node(subtree_nodes)
-            # Update priorities among neighbors or clear cache if there was
-            # no movement
+        with transaction.atomic():
+            # If the object already exists, get the old parent and priority
+            # values
+            is_new = self.pk is None
+            if not is_new:
+                old_parent, old_priority = model.objects\
+                    .filter(pk=self.pk)\
+                    .values_list('tn_parent', 'tn_priority')\
+                    .first()
+                is_move = (old_priority != self.tn_priority)
+            else:
+                force_insert = True
+                is_move = False
+                old_parent = None
+
+            descendants = self.get_descendants(include_self=True)
+
+            # Check if we are trying to move a node to a child
+            if old_parent and old_parent != self.tn_parent and self.tn_parent:
+                # Get pk of children via values_list to avoid creating full
+                # set of objects
+                if self.tn_parent in descendants:
+                    raise ValueError(
+                        "You cannot move a node into its own child."
+                    )
+
+            # Save the object and synchronize with the closing table
+            # Disable signals
+            with (disable_signals(pre_save, model),
+                  disable_signals(post_save, model)):
+
+                if is_new or is_move:
+                    self._update_priority()
+                super().save(force_insert=force_insert, *args, **kwargs)
+                # Run synchronize
+                if is_new:
+                    self.closure_model.insert_node(self)
+                elif is_move:
+                    self.closure_model.move_node(descendants)
 
         # Clear model cache
         model.clear_cache()
@@ -203,7 +203,7 @@ class TreeNodeModel(
 
     def _update_priority(self):
         """Update tn_priority field for siblings."""
-        siblings = self.get_siblings()
+        siblings = self.get_siblings(include_self=False)
         siblings = sorted(siblings, key=lambda x: x.tn_priority)
         insert_pos = min(self.tn_priority, len(siblings))
         siblings.insert(insert_pos, self)
@@ -214,7 +214,6 @@ class TreeNodeModel(
         # Save changes
         model = self._meta.model
         model.objects.bulk_update(siblings, ['tn_priority'])
-        model.clear_cache()
 
     @classmethod
     def _get_place(cls, target, position=0):

treenode/models/closure.py

@@ -62,7 +62,8 @@ class ClosureModel(models.Model):
         unique_together = (("parent", "child"),)
         indexes = [
             models.Index(fields=["parent", "child"]),
-            models.Index(fields=["child", "parent"]),
+            models.Index(fields=["parent", "depth"]),
+            models.Index(fields=["child", "depth"]),
             models.Index(fields=["parent", "child", "depth"]),
         ]
 
@@ -72,28 +73,6 @@ class ClosureModel(models.Model):
 
     # ----------- Methods of working with tree structure ----------- #
 
-    @classmethod
-    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')\
-            .values_list('parent_id', flat=True)
-        return list(queryset.values_list("parent_id", flat=True))
-
-    @classmethod
-    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)\
-            .order_by('depth')\
-            .values_list('child_id', flat=True)
-        return queryset
-
     @classmethod
     def get_root(cls, node):
         """Get the root node pk for the current node."""

treenode/models/mixins/ancestors.py

@@ -2,12 +2,13 @@
 """
 TreeNode Ancestors Mixin
 
-Version: 2.1.0
+Version: 2.1.4
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
 from django.db import models
+from django.db.models import OuterRef, Subquery, IntegerField, Case, When, Value
 from ...cache import treenode_cache, cached_method
 
 
@@ -22,41 +23,23 @@ class TreeNodeAncestorsMixin(models.Model):
     @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)
+        options = dict(child_id=self.pk, depth__gte=0 if include_self else 1)
+        if depth:
+            options.update({'depth__lte': depth})
 
-        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")
+        return self.closure_model.objects\
+            .filter(**options)\
+            .order_by('-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 []
+        return self.get_ancestors_queryset(include_self, depth)\
+            .values_list('id', flat=True)
 
     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)
+        return list(self.get_ancestors_queryset(include_self, depth))
 
     def get_ancestors_count(self, include_self=True, depth=None):
         """Get the ancestors count."""

treenode/models/mixins/children.py

@@ -60,7 +60,8 @@ class TreeNodeChildrenMixin(models.Model):
     @cached_method
     def get_children_queryset(self):
         """Get the children queryset with prefetch."""
-        return self.tn_children.prefetch_related('tn_children')
+        # return self.tn_children.prefetch_related('tn_children')
+        return self._meta.model.objects.filter(tn_parent__pk=self.id)
 
     def get_children(self):
         """Get a list containing all children."""

treenode/models/mixins/descendants.py

@@ -8,6 +8,8 @@ Email: timurkady@yandex.com
 """
 
 from django.db import models
+from django.db.models import OuterRef, Subquery, Min
+
 from treenode.cache import treenode_cache, cached_method
 
 
@@ -22,37 +24,29 @@ class TreeNodeDescendantsMixin(models.Model):
     @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)
+        Closure = self.closure_model
+        desc_qs = Closure.objects.filter(child=OuterRef('pk'), parent=self.pk)
+        desc_qs = desc_qs.values('child').annotate(
+            mdepth=Min('depth')).values('mdepth')[:1]
+
+        queryset = self._meta.model.objects.annotate(
+            min_depth=Subquery(desc_qs)
+        ).filter(min_depth__isnull=False)
 
         if depth is not None:
             queryset = queryset.filter(min_depth__lte=depth)
-        if include_self and not queryset.filter(pk=self.pk).exists():
+
+        # add self if needed
+        if include_self:
             queryset = queryset | self._meta.model.objects.filter(pk=self.pk)
 
-        return queryset.order_by("min_depth", "tn_priority")
+        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 []
+        return self.get_descendants_queryset(include_self, depth)\
+            .values_list("id", flat=True)
 
     def get_descendants(self, include_self=False, depth=None):
         """Get a list containing all descendants."""

treenode/models/mixins/node.py

@@ -2,7 +2,7 @@
 """
 TreeNode Node Mixin
 
-Version: 2.1.0
+Version: 2.1.3
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
@@ -23,32 +23,16 @@ class TreeNodeNodeMixin(models.Model):
         abstract = True
 
     @cached_method
-    def get_breadcrumbs(self, attr='pk'):
+    def get_breadcrumbs(self, attr='id'):
         """Optimized breadcrumbs retrieval with direct cache check."""
+
         try:
             self._meta.get_field(attr)
         except FieldDoesNotExist:
             raise ValueError(f"Invalid attribute name: {attr}")
 
-        # Easy logics for roots
-        if self.tn_parent is None:
-            return [getattr(self, attr)]
-
-        # Generate parents cache key
-        cache_key = treenode_cache.generate_cache_key(
-            self._meta.label,
-            self.get_breadcrumbs.__name__,
-            self.tn_parent.pk,
-            attr
-        )
-
-        # Try get value from cache
-        breadcrumbs = treenode_cache.get(cache_key)
-        if breadcrumbs is not None:
-            return breadcrumbs + [getattr(self, attr)]
-
-        queryset = self.get_ancestors_queryset(include_self=True).only(attr)
-        return [getattr(item, attr) for item in queryset]
+        ancestors = self.get_ancestors(include_self=True)
+        return [getattr(node, attr) for node in ancestors]
 
     @cached_method
     def get_depth(self):

treenode/models/mixins/siblings.py

@@ -45,25 +45,25 @@ class TreeNodeSiblingsMixin(models.Model):
         return instance
 
     @cached_method
-    def get_siblings_queryset(self):
+    def get_siblings_queryset(self, include_self=True):
         """Get the siblings queryset with prefetch."""
         if self.tn_parent:
-            qs = self.tn_parent.tn_children.prefetch_related('tn_children')
+            qs = self._meta.model.objects.filter(tn_parent=self.tn_parent)
         else:
             qs = self._meta.model.objects.filter(tn_parent__isnull=True)
-        return qs.exclude(pk=self.pk)
+        return qs if include_self else qs.exclude(pk=self.pk)
 
-    def get_siblings(self):
+    def get_siblings(self, include_self=True):
         """Get a list with all the siblings."""
         return list(self.get_siblings_queryset())
 
-    def get_siblings_count(self):
+    def get_siblings_count(self, include_self=True):
         """Get the siblings count."""
-        return self.get_siblings_queryset().count()
+        return self.get_siblings_queryset(include_self).count()
 
-    def get_siblings_pks(self):
+    def get_siblings_pks(self, include_self=True):
         """Get the siblings pks list."""
-        return [item.pk for item in self.get_siblings_queryset()]
+        return [item.pk for item in self.get_siblings_queryset(include_self)]
 
     def get_first_sibling(self):
         """

treenode/version.py

@@ -4,10 +4,10 @@ TreeNode Version Module
 
 This module defines the current version of the TreeNode package.
 
-Version: 2.1.2
+Version: 2.1.4
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
 
-__version__ = '2.1.2'
+__version__ = '2.1.4'