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

treenode/models/mixins/family.py

@@ -2,13 +2,24 @@
 """
 TreeNode Descendants 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 django.db.models import Q
+from ...cache import cached_method
+
+
+'''
+try:
+    profile
+except NameError:
+    def profile(func):
+        """Profile."""
+        return func
+'''
 
 
 class TreeNodeFamilyMixin(models.Model):
@@ -19,7 +30,6 @@ class TreeNodeFamilyMixin(models.Model):
 
         abstract = True
 
-    @cached_method
     def get_family_queryset(self):
         """
         Return node family.
@@ -27,13 +37,10 @@ class TreeNodeFamilyMixin(models.Model):
         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
+        return self._meta.model.objects.filter(
+            Q(pk__in=self._get_path()) |
+            Q(_path__startswith=self._path+'.')
+        )
 
     @cached_method
     def get_family_pks(self):
@@ -43,9 +50,10 @@ class TreeNodeFamilyMixin(models.Model):
         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)
+        return self.query(objects="family")
 
+    # @profile
+    @cached_method
     def get_family(self):
         """
         Return node family.
@@ -53,11 +61,13 @@ class TreeNodeFamilyMixin(models.Model):
         Return a list containing the ancestors, the model itself and
         the descendants, in tree order.
         """
-        queryset = self.get_family_queryset()
-        return list(queryset)
+        ancestors = self.get_ancestors()
+        descendants = self.get_descendants()
+        return ancestors.extend(descendants)
 
+    @cached_method
     def get_family_count(self):
         """Return number of nodes in family."""
-        return self.get_family_queryset().count()
+        return self.query(objects="family", mode='count')
 
 # The End

treenode/models/mixins/logical.py

@@ -2,7 +2,7 @@
 """
 TreeNode Logical methods Mixin
 
-Version: 2.1.0
+Version: 3.0.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
@@ -18,51 +18,53 @@ class TreeNodeLogicalMixin(models.Model):
 
         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_ancestor_of(self, target):
+        """Check if self is an ancestor of other node."""
+        return target.id in target.query("ancestors", include_self=False)
 
-    def is_child_of(self, target_obj):
+    def is_child_of(self, target):
         """Return True if the current node is child of target_obj."""
-        return self in target_obj.get_children()
+        return self._parent_id == target.id
 
-    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_descendant_of(self, target):
+        """Check if self is a descendant of other node."""
+        return target.id in target.query("descendants", include_self=False)
 
     def is_first_child(self):
         """Return True if the current node is the first child."""
-        return self.tn_priority == 0
+        return self.priority == 0
 
     def has_children(self):
         """Return True if the node has children."""
-        return self.tn_children.exists()
+        return self.query(objects="children", mode='exist')
 
     def is_last_child(self):
         """Return True if the current node is the last child."""
-        return self.tn_priority == self.get_siblings_count() - 1
+        siblings_pks = self.query("siblings", include_self=True)
+        return siblings_pks[-1] == self.id
 
     def is_leaf(self):
         """Return True if the current node is a leaf."""
-        return self.tn_children.count() == 0
+        return not self.has_children()
 
-    def is_parent_of(self, target_obj):
+    def is_parent_of(self, target):
         """Return True if the current node is parent of target_obj."""
-        return self == target_obj.tn_parent
+        return self.id == target._parent_id
 
     def is_root(self):
         """Return True if the current node is root."""
-        return self.tn_parent is None
+        return self.parent is None
 
-    def is_root_of(self, target_obj):
+    def is_root_of(self, target):
         """Return True if the current node is root of target_obj."""
-        return self == target_obj.get_root()
+        return self.pk == target.query("ancestors")[0]
 
-    def is_sibling_of(self, target_obj):
+    def is_sibling_of(self, target):
         """Return True if the current node is sibling of target_obj."""
-        if target_obj.tn_parent is None and self.tn_parent is None:
+        if target.parent is None and self.parent is None:
             # Both objects are roots
             return True
-        return (self.tn_parent == target_obj.tn_parent)
+        return (self._parent_id == target._parent_id)
+
 
 # The End

treenode/models/mixins/node.py

@@ -2,16 +2,21 @@
 """
 TreeNode Node Mixin
 
-Version: 2.1.3
+Version: 3.0.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
 from django.db import models
-from django.core.exceptions import FieldDoesNotExist
 
-from ...cache import cached_method, treenode_cache
-from ...utils.base36 import to_base36
+from ...settings import BASE
+
+try:
+    profile
+except NameError:
+    def profile(func):
+        """Profile."""
+        return func
 
 
 class TreeNodeNodeMixin(models.Model):
@@ -22,72 +27,106 @@ class TreeNodeNodeMixin(models.Model):
 
         abstract = True
 
-    @cached_method
     def get_breadcrumbs(self, attr='id'):
         """Optimized breadcrumbs retrieval with direct cache check."""
+        ancestors = self.get_ancestors()
+        return [getattr(n, attr, None) for n in ancestors]
 
-        try:
-            self._meta.get_field(attr)
-        except FieldDoesNotExist:
-            raise ValueError(f"Invalid attribute name: {attr}")
-
-        ancestors = self.get_ancestors(include_self=True)
-        return [getattr(node, attr) for node in ancestors]
-
-    @cached_method
     def get_depth(self):
         """Get the node depth (self, how many levels of descendants)."""
-        return self.closure_model.get_depth(self)
+        is_dry = getattr(self, "is_dry", True) or len(self.tasks.queue) > 0
+        if is_dry:
+            self.tasks.run()
+            self.refresh()
+        return self._depth
+
+    def distance_to(self, targer):
+        """Return number of edges on shortest path between two nodes."""
+        self_path = self.query(objects='ancestors')
+        targer_path = targer.query(objects='ancestors')
+
+        i = 0
+        for a, b in zip(self_path, targer_path):
+            if a != b:
+                break
+            i += 1
+
+        return (len(self_path) - i) + (len(targer_path) - i)
 
-    @cached_method
     def get_index(self):
         """Get the node index (self, index in node.parent.children list)."""
-        if self.tn_parent is None:
-            return self.tn_priority
-        source = list(self.tn_parent.tn_children.all())
-        return source.index(self) if self in source else self.tn_priority
+        return self.priority
 
-    @cached_method
     def get_level(self):
         """Get the node level (self, starting from 1)."""
-        return self.closure_model.get_level(self)
+        is_dry = getattr(self, "is_dry", True)
+        if is_dry:
+            self.refresh()
+        return self._depth + 1
+
+    def get_left(self):
+        """Get the node to left."""
+        return self.get_previous_sibling()
+
+    def get_right(self):
+        """Get the node to right."""
+        return self.get_next_sibling()
 
     def get_order(self):
         """Return the materialized path."""
-        path = self.get_breadcrumbs(attr='tn_priority')
-        segments = [to_base36(i).rjust(6, '0') for i in path]
-        return ''.join(segments)
+        is_dry = getattr(self, "is_dry", True) or len(self.tasks.queue) > 0
+        if is_dry:
+            self.tasks.run()
+            self.refresh()
+        return self._path
+
+    def get_path(self, prefix='', suffix='', delimiter='.', format_str=''):
+        """Return Materialized Path of node."""
+        priorities = self.get_breadcrumbs(attr='priority')
+        if not priorities or all(p is None for p in priorities):
+            return prefix + suffix
+
+        str_ = "{%s}" % format_str
+        path = delimiter.join([
+            str_.format(p)
+            for p in priorities
+            if p is not None
+        ])
+        return prefix + path + suffix
 
-    def insert_at(self, target, position='first-child', save=False):
+    @classmethod
+    def shortest_path(cls, source, destination):
         """
-        Insert a node into the tree relative to the target node.
+        Return the shortest path (as list of PKs).
 
-        Parameters:
-        target: еhe target node relative to which this node will be placed.
+        Returned value is pks from `source` to `destination`, going up to their
+        lowest common ancestor (LCA), then down to `destination`.
+        """
+        source_path = source.query(objects='ancestors')
+        destination_path = destination.query(objects='ancestors')
 
-        position – the position, relative to the target node, where the
-        current node object will be moved to, can be one of:
+        # Find the divergence index
+        i = 0
+        for a, b in zip(source_path, destination_path):
+            if a != b:
+                break
+            i += 1
 
-        - first-root: the node will be the first root node;
-        - last-root: the node will be the last root node;
-        - sorted-root: the new node will be moved after sorting by
-          the treenode_sort_field field;
+        # Path up from source to LCA (excluding LCA)
+        up = source_path[:i-1:-1]
+        # path down from LCA to destination (including LCA)
+        down = destination_path[i-1:]
 
-        - first-sibling: the node will be the new leftmost sibling of the
-          target node;
-        - left-sibling: the node will take the target node’s place, which will
-          be moved to the target position with shifting follows nodes;
-        - right-sibling: the node will be moved to the position after the
-          target node;
-        - last-sibling: the node will be the new rightmost sibling of the
-          target node;
-        - sorted-sibling: the new node will be moved after sorting by
-          the treenode_sort_field field;
+        return up + down
 
-        - first-child: the node will be the first child of the target node;
-        - last-child: the node will be the new rightmost child of the target
-        - sorted-child: the new node will be moved after sorting by
-          the treenode_sort_field field.
+    def insert_at(self, target, position=None, save=False):
+        """
+        Insert a node into the tree relative to the target node.
+
+        Parameters:
+        target: еhe target node relative to which this node will be placed.
+        position – the position, relative to the target node, where the
+        current node object will be moved to, can be one of. Look _get_place().
 
         save : if `save=true`, the node will be saved in the tree. Otherwise,
         the method will return a model instance with updated fields: parent
@@ -100,18 +139,66 @@ class TreeNodeNodeMixin(models.Model):
         """
         # This method seems to have very dubious practical value.
         parent, priority = self._meta.model._get_place(target, position)
-        self.tn_parent = parent
-        self.tn_priority = priority
+        self.parent = parent
+        self.priority = priority
 
         if save:
             self.save()
 
-    def move_to(self, target, position=0):
+    def move_to(self, target, position='last-child'):
         """
-        Move node relative to target node and position.
+        Move node with subtree relative to target node and position.
 
-        Moves the model instance relative to the target node and sets its
-        position (if necessary).
+        Parameters:
+        target: еhe target node relative to which this node will be placed.
+        position – the position, relative to the target node, where the
+        current node object will be moved to, can be one of. Look _get_place().
+        """
+        parent, priority = self._meta.model._get_place(target, position)
+        self.parent = parent
+        self.priority = priority
+        self.save()
+
+    def get_parent(self):
+        """Get the parent node."""
+        return self.parent
+
+    def set_parent(self, parent_obj):
+        """Set the parent node."""
+        self.parent = parent_obj
+        self.save()
+
+    def get_parent_pk(self):
+        """Get the parent node pk."""
+        return self._parent_id
+
+    def get_priority(self):
+        """Get the node priority."""
+        return self.priority
+
+    def set_priority(self, priority=0):
+        """Set the node priority."""
+        self.priority = priority
+        self.save()
+
+    def get_root(self):
+        """Get the root node for the current node."""
+        if self.parent_id is None:
+            return self
+        root_pk = self.query(objects='root')[0]
+        return self._meta.model.objects.filter(pk=root_pk).first()
+
+    def get_root_pk(self):
+        """Get the root node pk for the current node."""
+        return self.query(objects='root')
+
+# -----------------------------------------------------------------
+
+    @classmethod
+    # @profile
+    def _get_place(cls, target, position='last-child'):
+        """
+        Get position relative to the target node.
 
         position – the position, relative to the target node, where the
         current node object will be moved to, can be one of:
@@ -120,7 +207,6 @@ class TreeNodeNodeMixin(models.Model):
         - last-root: the node will be the last root node;
         - sorted-root: the new node will be moved after sorting by
           the treenode_sort_field field;
-          Note: if `position` contains `root`, then `target` parametr is ignored
 
         - first-sibling: the node will be the new leftmost sibling of the
           target node;
@@ -136,59 +222,31 @@ class TreeNodeNodeMixin(models.Model):
         - first-child: the node will be the first child of the target node;
         - last-child: the node will be the new rightmost child of the target
         - sorted-child: the new node will be moved after sorting by
-          the treenode_sort_field field;
-        """
-        parent, priority = self._meta.model._get_place(target, position)
-        self.tn_parent = parent
-        self.tn_priority = priority
-        self.save()
-
-    def get_path(self, prefix='', suffix='', delimiter='.', format_str=''):
-        """Return Materialized Path of node."""
-        priorities = self.get_breadcrumbs(attr='tn_priority')
-        if not priorities or all(p is None for p in priorities):
-            return prefix + suffix
-
-        str_ = "{%s}" % format_str
-        path = delimiter.join([
-            str_.format(p)
-            for p in priorities
-            if p is not None
-        ])
-        return prefix + path + suffix
-
-    @cached_method
-    def get_parent(self):
-        """Get the parent node."""
-        return self.tn_parent
+          the treenode_sort_field field.
 
-    def set_parent(self, parent_obj):
-        """Set the parent node."""
-        self.tn_parent = parent_obj
-        self.save()
+        """
+        choices = {
+            "first-root": lambda: (None, 0),
+            "last-root": lambda: (None, BASE - 1),
+            "sorted-root": lambda: (None, 0),
 
-    def get_parent_pk(self):
-        """Get the parent node pk."""
-        return self.get_parent().pk if self.tn_parent else None
+            "first-sibling": lambda: (target.parent, 0),
+            "left-sibling": lambda: (target.parent, target.priority),
+            "right-sibling": lambda: (target.parent, target.priority + 1),
+            "last-sibling": lambda: (target.parent, BASE - 1),
+            "sorted-sibling": lambda: (target.parent, 0),
 
-    @cached_method
-    def get_priority(self):
-        """Get the node priority."""
-        return self.tn_priority
+            "first-child": lambda: (target, 0),
+            "last-child": lambda: (target, BASE - 1),
+            "sorted-child": lambda: (target, 0),
+        }
 
-    def set_priority(self, priority=0):
-        """Set the node priority."""
-        self.tn_priority = priority
-        self.save()
+        if isinstance(position, int):
+            return target, position
+        elif not isinstance(position, str) or position not in choices:
+            raise ValueError(f"Invalid position format: {position}")
 
-    @cached_method
-    def get_root(self):
-        """Get the root node for the current node."""
-        return self.closure_model.get_root(self)
+        return choices[position]()
 
-    def get_root_pk(self):
-        """Get the root node pk for the current node."""
-        root = self.get_root()
-        return root.pk if root else None
 
 # The End

treenode/models/mixins/properties.py

@@ -2,12 +2,12 @@
 """
 TreeNode Properties Mixin
 
-Version: 2.1.0
+Version: 3.0.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
-from ..classproperty import classproperty
+from ..decorators import classproperty
 
 
 class TreeNodePropertiesMixin:
@@ -88,25 +88,35 @@ class TreeNodePropertiesMixin:
         """Get the last child node."""
         return self.get_last_child()
 
+    @property
+    def left(self):
+        """Get the node to left."""
+        return self.get_left()
+
+    @property
+    def right(self):
+        """Get the node to right."""
+        return self.get_right()
+
     @property
     def level(self):
         """Get the node level."""
         return self.get_level()
 
-    @property
-    def parent(self):
-        """Get node parent."""
-        return self.tn_parent
+    # @property
+    # def parent(self):
+    #    """Get node parent."""
+    #    return self.tn_parent
 
     @property
     def parent_pk(self):
         """Get node parent pk."""
         return self.get_parent_pk()
 
-    @property
-    def priority(self):
-        """Get node priority."""
-        return self.get_priority()
+    # @property
+    # def priority(self):
+    #    """Get node priority."""
+    #    return self.get_priority()
 
     @classproperty
     def roots(cls):
@@ -143,14 +153,10 @@ class TreeNodePropertiesMixin:
         """Get an n-dimensional dict representing the model tree."""
         return cls.get_tree()
 
-    @classproperty
-    def tree_display(cls):
-        """Get a multiline string representing the model tree."""
-        return cls.get_tree_display()
-
     @property
-    def tn_order(self):
+    def order(self):
         """Return the materialized path."""
         return self.get_order()
 
+
 # The End