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

treenode/models/mixins/roots.py

@@ -2,13 +2,23 @@
 """
 TreeNode Roots Mixin
 
-Version: 2.1.0
+Version: 3.0.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
 from django.db import models
-from treenode.cache import cached_method
+from ...cache import cached_method
+
+
+'''
+try:
+    profile
+except NameError:
+    def profile(func):
+        """Profile."""
+        return func
+'''
 
 
 class TreeNodeRootsMixin(models.Model):
@@ -51,46 +61,80 @@ class TreeNodeRootsMixin(models.Model):
             instance = cls(**kwargs)
 
         parent, priority = cls._get_place(None, position)
-        instance.tn_parent = None
-        instance.tn_priority = priority
+        instance.parent = None
+        instance.priority = priority
         instance.save()
         return instance
 
     @classmethod
-    @cached_method
     def get_roots_queryset(cls):
         """Get root nodes queryset with preloaded children."""
-        qs = cls.objects.filter(tn_parent=None).prefetch_related('tn_children')
-        return qs
+        return cls.objects.filter(parent_id__isnull=True)
 
     @classmethod
-    @cached_method
     def get_roots_pks(cls):
         """Get a list with all root nodes."""
-        pks = cls.objects.filter(tn_parent=None).values_list("id", flat=True)
-        return list(pks)
+        queryset = cls.objects.filter(parent_id__isnull=True)
+        return queryset.values_list("id", flat=True)
 
     @classmethod
+    @cached_method
     def get_roots(cls):
         """Get a list with all root nodes."""
-        qs = cls.get_roots_queryset()
-        return list(qs)
+        return list(cls.objects.filter(parent__isnull=True))
 
     @classmethod
     def get_roots_count(cls):
         """Get a list with all root nodes."""
-        return len(cls.get_roots_pks())
+        return cls.objects.filter(parent__isnull=True).count()
 
     @classmethod
     def get_first_root(cls):
         """Return the first root node in the tree or None if it is empty."""
         roots = cls.get_roots_queryset()
-        return roots.fiest() if roots.count() > 0 else None
+        return roots.first()
 
     @classmethod
     def get_last_root(cls):
         """Return the last root node in the tree or None if it is empty."""
         roots = cls.get_roots_queryset()
-        return roots.last() if roots.count() > 0 else None
+        return roots.last()
+
+    @classmethod
+    def sort_roots(cls):
+        """
+        Re-sort root nodes.
+
+        Sorts all nodes with parent_id IS NULL using a raw SQL query with
+        a window function.
+        The new ordering is computed based on the model's sorting_field
+        (defaulting to 'priority').
+        It updates the 'priority' field for all root nodes.
+        """
+        from django.db import connection
+
+        db_table = cls._meta.db_table
+        ordering_field = cls.sorting_field
+
+        # Only root nodes have parent_id IS NULL
+        where_clause = "parent_id IS NULL"
+        params = []
+
+        query = f"""
+            WITH ranked AS (
+                SELECT id,
+                    ROW_NUMBER() OVER (ORDER BY {ordering_field}) - 1 AS new_priority
+                FROM {db_table}
+                WHERE {where_clause}
+            )
+            UPDATE {db_table} AS t
+            SET priority = ranked.new_priority
+            FROM ranked
+            WHERE t.id = ranked.id;
+        """
+
+        with connection.cursor() as cursor:
+            cursor.execute(query, params)
+
 
 # The End

treenode/models/mixins/siblings.py

@@ -2,13 +2,23 @@
 """
 TreeNode Siblings Mixin
 
-Version: 2.1.0
+Version: 3.0.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
 from django.db import models
-from treenode.cache import cached_method
+from ...cache import cached_method
+
+
+'''
+try:
+    profile
+except NameError:
+    def profile(func):
+        """Profile."""
+        return func
+'''
 
 
 class TreeNodeSiblingsMixin(models.Model):
@@ -26,67 +36,59 @@ class TreeNodeSiblingsMixin(models.Model):
         Returns the created node object or None if failed. It will be saved
         by this method.
         """
-        if isinstance(position, int):
-            priority = position
-            parent = self.tn_parent
-        else:
-            if position not in [
-                    'first-sibling', 'left-sibling', 'right-sibling',
-                    'last-sibling', 'sorted-sibling']:
-                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_priority = priority
-        instance.tn_priority = parent
+
+        parent, priority = self._meta.model._get_place(self.patent, position)
+
+        instance.parent = parent
+        instance.priority = priority
         instance.save()
+        if isinstance(position, str) and 'sorted' in position:
+            self._sort_siblings()
         return instance
 
-    @cached_method
     def get_siblings_queryset(self, include_self=True):
-        """Get the siblings queryset with prefetch."""
-        if self.tn_parent:
-            qs = self._meta.model.objects.filter(tn_parent=self.tn_parent)
-        else:
-            qs = self._meta.model.objects.filter(tn_parent__isnull=True)
-        return qs if include_self else qs.exclude(pk=self.pk)
+        """Get Siblings QuerySet."""
+        qs = self._meta.model.objects.filter(parent_id=self._parent_id)
+        return qs if include_self else qs.exclude(pk=self.id)
 
+    # @profile
+    @cached_method
     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, include_self=True):
-        """Get the siblings count."""
-        return self.get_siblings_queryset(include_self).count()
+        queryset = self._meta.model.objects.filter(parent=self.parent)
+        queryset = queryset if include_self else queryset.exclude(pk=self.pk)
+        return [n for n in queryset]
 
+    @cached_method
     def get_siblings_pks(self, include_self=True):
         """Get the siblings pks list."""
-        return [item.pk for item in self.get_siblings_queryset(include_self)]
+        return self.query("siblings", include_self)
 
-    def get_first_sibling(self):
-        """
-        Return the fist node’s sibling.
+    @cached_method
+    def get_siblings_count(self):
+        """Get the siblings count."""
+        qs = self.query("siblings")
+        return qs.count()
 
-        Method can return the node itself if it was the leftmost sibling.
-        """
-        return self.get_siblings_queryset().fist()
+    @cached_method
+    def get_first_sibling(self):
+        """Return the first sibling in the tree, or None."""
+        qs = self._meta.model.objects.filter(parent_id=self._parent_id)
+        return qs.first()
 
+    @cached_method
     def get_previous_sibling(self):
         """Return the previous sibling in the tree, or None."""
-        priority = self.tn_priority - 1
-        if priority < 0:
-            return None
-        return self.get_siblings_queryset.filter(tn_priority=priority)
+        options = {'parent_id': self._parent_id, 'priority__lt': self.priority}
+        return self._meta.model.objects.filter(**options).last()
 
     def get_next_sibling(self):
         """Return the next sibling in the tree, or None."""
-        priority = self.tn_priority = 1
-        queryset = self.get_siblings_queryset()
-        if priority == queryset.count():
-            return None
-        return queryset.filter(tn_priority=priority)
+        options = {'parent_id': self._parent_id, 'priority__gt': self.priority}
+        return self._meta.model.objects.filter(**options).first()
 
     def get_last_sibling(self):
         """
@@ -94,6 +96,7 @@ class TreeNodeSiblingsMixin(models.Model):
 
         Method can return the node itself if it was the leftmost sibling.
         """
-        return self.get_siblings_queryset().last()
+        qs = self._meta.model.objects.filter(parent_id=self._parent_id)
+        return qs.last()
 
 # The End