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

treenode/managers/tasks.py

@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+"""
+TreeNode TaskQuery manager
+
+Version: 3.0.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+from django.db import connection
+
+from ..utils.db import TreePathCompiler
+
+'''
+try:
+    profile
+except NameError:
+    def profile(func):
+        """Profile."""
+        return func
+'''
+
+
+class TreeTaskQueue:
+    """TreeTaskQueue Class."""
+
+    def __init__(self, model):
+        """Init the task query."""
+        self.model = model
+        self.queue = []
+
+    def add(self, mode, parent_id):
+        """Add task to the query."""
+        self.queue.append({"mode": mode, "parent_id": parent_id})
+
+    def run(self):
+        """Run task queue."""
+        if len(self.queue) == 0:
+            return
+        try:
+            optimized = self._optimize()
+            for task in optimized:
+                if task["mode"] == "update":
+                    parent_id = task["parent_id"]
+                    TreePathCompiler.update_path(
+                        model=self.model,
+                        parent_id=parent_id
+                    )
+        finally:
+            self.queue.clear()
+            self._running = False
+
+    # @profile
+    def _optimize(self):
+        """Return optimized task queue (ID-only logic)."""
+        result_set = set()
+        id_set = set()
+
+        for task in self.queue:
+            if task["mode"] == "update":
+                parent_id = task["parent_id"]
+                if parent_id is None:
+                    # If we are already updating the entire tree, then
+                    # the remaining tasks are meaningless # noqa: D501
+                    return [{"mode": "update", "parent_id": None}]
+                else:
+                    id_set.add(parent_id)
+
+        id_list = list(id_set)
+
+        while id_list:
+            current = id_list.pop(0)
+            merged = False
+            for other in id_list[:]:
+                ancestor = self._get_common_ancestor(current, other)
+                if ancestor is not None:
+                    # If the common ancestor is the root, then we update
+                    # the entire tree
+                    if ancestor in self._get_root_ids():
+                        return [{"mode": "update", "parent_id": None}]
+                    if ancestor not in id_set:
+                        id_list.append(ancestor)
+                        id_set.add(ancestor)
+                    id_list.remove(other)
+                    merged = True
+                    break
+            if not merged:
+                result_set.add(current)
+
+        return [{"mode": "update", "parent_id": pk} for pk in sorted(result_set)]  # noqa: D501
+
+    def _get_root_ids(self):
+        """Return root node IDs."""
+        with connection.cursor() as cursor:
+            cursor.execute(
+                f"SELECT id FROM {self.model._meta.db_table} WHERE parent_id IS NULL")  # noqa: D501
+            return [row[0] for row in cursor.fetchall()]
+
+    def _get_parent_id(self, node_id):
+        """Return parent ID for a given node."""
+        with connection.cursor() as cursor:
+            cursor.execute(
+                f"SELECT parent_id FROM {self.model._meta.db_table} WHERE id = %s", [node_id])  # noqa: D501
+            row = cursor.fetchone()
+            return row[0] if row else None
+
+    '''
+    def _get_ancestor_path(self, node_id):
+        """Return list of ancestor IDs including the node itself."""
+        path = []
+        while node_id is not None:
+            path.append(node_id)
+            node_id = self._get_parent_id(node_id)
+        return path[::-1]  # root to leaf
+    '''
+
+    # @profile
+    def _get_ancestor_path(self, node_id):
+        """Return list of ancestor IDs including the node itself, using recursive SQL."""  # noqa: D501
+        table = self.model._meta.db_table
+
+        sql = f"""
+            WITH RECURSIVE ancestor_cte AS (
+                SELECT id, parent_id, 0 AS depth
+                FROM {table}
+                WHERE id = %s
+
+                UNION ALL
+
+                SELECT t.id, t.parent_id, a.depth + 1
+                FROM {table} t
+                JOIN ancestor_cte a ON t.id = a.parent_id
+            )
+            SELECT id FROM ancestor_cte ORDER BY depth DESC
+        """
+
+        with connection.cursor() as cursor:
+            cursor.execute(sql, [node_id])
+            rows = cursor.fetchall()
+
+        return [row[0] for row in rows]
+
+    # @profile
+    def _get_common_ancestor(self, id1, id2):
+        """Return common ancestor ID between two nodes."""
+        path1 = self._get_ancestor_path(id1)
+        path2 = self._get_ancestor_path(id2)
+        common = None
+        for a, b in zip(path1, path2):
+            if a == b:
+                common = a
+            else:
+                break
+        return common
+
+
+class TreeTaskManager:
+    """Handle to TreeTaskQueue."""
+
+    def __get__(self, instance, owner):
+        """Get query for instance."""
+        if not hasattr(owner, "_task_queue"):
+            owner._task_queue = TreeTaskQueue(owner)
+        return owner._task_queue
+
+
+# The End

treenode/models/__init__.py

@@ -1,8 +1,11 @@
 # -*- coding: utf-8 -*-
-from .adjacency import TreeNodeModel
+"""
+The TreeNode Model
 
+Version: 3.0.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+from .models import TreeNodeModel
 
-__all__ = ["TreeNodeModel",]
-
-
-# The End
+__all__ = ["TreeNodeModel"]

treenode/models/decorators.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+"""
+TreeeNodeModel Class Decorators
+
+- Decorator `@cached_method` for caching method results.
+
+Version: 3.0.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+
+_TIMEOUT = 10
+_INTERVAL = 0.2
+
+_UNSET = object()
+
+
+class classproperty(object):
+    """Classproperty class."""
+
+    def __init__(self, getter):
+        """Init."""
+        self.getter = getter
+
+    def __get__(self, instance, owner):
+        """Get."""
+        return self.getter(owner)
+
+
+def lazy_property(source, default=_UNSET):
+    """
+    Декоратор ленивого свойства, которое берёт значение из другого поля.
+
+    source — имя поля (например, 'parent_id')
+    default — значение по умолчанию. Если не задан, берётся self.source
+    """
+    def decorator(func):
+        def getter(self):
+            attr_name = '_' + func.__name__
+            if not hasattr(self, attr_name):
+                if default is _UNSET:
+                    value = getattr(self, source)
+                else:
+                    value = default
+                setattr(self, attr_name, value)
+            return getattr(self, attr_name)
+
+        def setter(self, value):
+            attr_name = '_' + func.__name__
+            setattr(self, attr_name, value)
+
+        return property(getter, setter)
+    return decorator

treenode/models/factory.py

@@ -1,81 +1,57 @@
 # -*- coding: utf-8 -*-
 """
-TreeNode Factory for Closure Table
+TreeNode Factory
 
-This module provides a metaclass `TreeFactory` that automatically binds
-a model to a Closure Table for hierarchical data storage.
+This module provides a metaclass that automatically associates a model with
+a service table and creates a set of indexes for the database
 
 Features:
-- Ensures non-abstract, non-proxy models get a corresponding Closure Table.
-- Dynamically creates and assigns a Closure Model for each TreeNodeModel.
-- Facilitates the management of hierarchical relationships.
+- Dynamically creates and assigns a service model.
+- Facilitates the formation of indexes taking into account the DB vendor.
 
-Version: 2.1.0
+Version: 3.0.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
 
-import sys
-from django.db import models
-from .closure import ClosureModel
-
-
-class TreeFactory(models.base.ModelBase):
-    """
-    Metaclass for binding a model to a Closure Table.
-
-    For each non-abstract, non-proxy, and "top" (without parents) model,
-    assigns the `ClosureModel` as the closure table.
-    """
-
-    def __init__(cls, name, bases, dct):
-        """Class initialization.
-
-        We check that the model:
-            - is not abstract
-            - is not a proxy
-            - is not a child
-        and only then assign the ClosureModel.
-        """
-        super().__init__(name, bases, dct)
-
-        if (cls._meta.abstract or cls._meta.proxy or
-                cls._meta.get_parent_list()):
-            return
-
-        closure_name = f"{cls._meta.object_name}ClosureModel"
-        if getattr(cls, "closure_model", None) is not None:
-            return
-
-        fields = {
-            "parent": models.ForeignKey(
-                cls._meta.model,
-                related_name="children_set",
-                on_delete=models.CASCADE
-            ),
-
-            "child": models.ForeignKey(
-                cls._meta.model,
-                related_name="parents_set",
-                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
-
+from django.db import models, connection
+from django.db.models import Func, F
+
+
+class TreeNodeModelBase(models.base.ModelBase):
+    """Base Class for TreeNodeModel."""
+
+    def __new__(mcls, name, bases, attrs, **kwargs):
+        """Create a New Class."""
+        new_class = super().__new__(mcls, name, bases, attrs, **kwargs)
+        if not new_class._meta.abstract:
+            class_name = name.lower()
+            # Create an index with the desired name
+            """Set DB Indexes with unique names per model."""
+            vendor = connection.vendor
+            indexes = []
+
+            if vendor == 'postgresql':
+                indexes.append(models.Index(
+                    fields=['_path'],
+                    name=f'idx_{class_name}_path_ops',
+                    opclasses=['text_pattern_ops']
+                ))
+            elif vendor in {'mysql'}:
+                indexes.append(models.Index(
+                    Func(F('_path'), function='md5'),
+                    name=f'idx_{class_name}_path_hash'
+                ))
+            else:
+                indexes.append(models.Index(
+                    fields=['_path'],
+                    name=f'idx_{class_name}_path'
+                ))
+
+            # Update the list of indexes
+            new_class._meta.indexes += indexes
+
+        return new_class
 
 # The End

treenode/models/mixins/__init__.py

@@ -10,13 +10,14 @@ from .properties import TreeNodePropertiesMixin
 from .roots import TreeNodeRootsMixin
 from .siblings import TreeNodeSiblingsMixin
 from .tree import TreeNodeTreeMixin
+from .update import RawSQLMixin
 
 
 __all__ = [
     "TreeNodeAncestorsMixin", "TreeNodeChildrenMixin", "TreeNodeFamilyMixin",
     "TreeNodeDescendantsMixin", "TreeNodeLogicalMixin", "TreeNodeNodeMixin",
     "TreeNodePropertiesMixin", "TreeNodeRootsMixin", "TreeNodeSiblingsMixin",
-    "TreeNodeTreeMixin"
+    "TreeNodeTreeMixin", "RawSQLMixin"
 ]
 
 

treenode/models/mixins/ancestors.py

@@ -2,14 +2,13 @@
 """
 TreeNode Ancestors Mixin
 
-Version: 2.1.4
+Version: 3.0.0
 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
+from ...cache import cached_method
 
 
 class TreeNodeAncestorsMixin(models.Model):
@@ -20,29 +19,54 @@ class TreeNodeAncestorsMixin(models.Model):
 
         abstract = True
 
-    @cached_method
-    def get_ancestors_queryset(self, include_self=True, depth=None):
-        """Get the ancestors queryset (ordered from root to parent)."""
-        options = dict(child_id=self.pk, depth__gte=0 if include_self else 1)
-        if depth:
-            options.update({'depth__lte': depth})
-
-        return self.closure_model.objects\
-            .filter(**options)\
-            .order_by('-depth')
+    def get_ancestors_queryset(self, include_self=True):
+        """Get all ancestors of a node."""
+        pks = self.query("ancestors", include_self)
+        return self._meta.model.objects.filter(pk__in=pks)
 
     @cached_method
     def get_ancestors_pks(self, include_self=True, depth=None):
         """Get the ancestors pks list."""
-        return self.get_ancestors_queryset(include_self, depth)\
-            .values_list('id', flat=True)
+        return self.query("ancestors", include_self)
 
-    def get_ancestors(self, include_self=True, depth=None):
-        """Get a list with all ancestors (ordered from root to self/parent)."""
-        return list(self.get_ancestors_queryset(include_self, depth))
+    @cached_method
+    def get_ancestors(self, include_self=True):
+        """Get a list of all ancestors of a node."""
+        node = self if include_self else self.parent
+        ancestors = []
+        while node:
+            ancestors.append(node)
+            node = node.parent
+        return ancestors[::-1]
 
-    def get_ancestors_count(self, include_self=True, depth=None):
+    @cached_method
+    def get_ancestors_count(self, include_self=True):
         """Get the ancestors count."""
-        return len(self.get_ancestors_pks(include_self, depth))
+        return self.query(
+            objects="ancestors",
+            include_self=include_self,
+            mode='count'
+        )
+
+    def get_common_ancestor(self, target):
+        """Find lowest common ancestor between self and other node."""
+        if self._path == target._path:
+            return self
+
+        self_path_pks = self.query("ancestors")
+        target_path_pks = target.query("ancestors")
+        common = []
+
+        for a, b in zip(self_path_pks, target_path_pks):
+            if a == b:
+                common.append(a)
+            else:
+                break
+
+        if not common:
+            return None
+
+        ancestor_id = common[-1]
+        return self._meta.model.objects.get(pk=ancestor_id)
 
 # The End

treenode/models/mixins/children.py

@@ -2,13 +2,23 @@
 """
 TreeNode Children 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 TreeNodeChildrenMixin(models.Model):
@@ -36,47 +46,44 @@ class TreeNodeChildrenMixin(models.Model):
         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))
+        parent, priority = self._meta.model._get_place(self, position)
+
+        instance.parent = self
+        instance.priority = priority
+        instance.save()
 
-    @cached_method
     def get_children_queryset(self):
-        """Get the children queryset with prefetch."""
-        # return self.tn_children.prefetch_related('tn_children')
-        return self._meta.model.objects.filter(tn_parent__pk=self.id)
+        """Get the children queryset."""
+        return self._meta.model.objects.filter(parent_id=self.id)
 
+    @cached_method
     def get_children(self):
         """Get a list containing all children."""
-        return list(self.get_children_queryset())
+        queryset = self._meta.model.objects.filter(parent_id=self.id)
+        return list(queryset)
 
+    @cached_method
+    def get_children_pks(self):
+        """Get the children pks list."""
+        return self.query("children")
+
+    @cached_method
     def get_children_count(self):
         """Get the children count."""
-        return len(self.get_children_pks())
+        return self.query(objects="children", mode='count')
 
+    @cached_method
     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
+        return self.get_children_queryset().first()
 
+    @cached_method
     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
+        return self.get_children_queryset().last()
 
 # The End

treenode/models/mixins/descendants.py

@@ -2,15 +2,23 @@
 """
 TreeNode Descendants Mixin
 
-Version: 2.1.0
+Version: 3.0.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
 from django.db import models
-from django.db.models import OuterRef, Subquery, Min
+from ...cache import cached_method
 
-from treenode.cache import treenode_cache, cached_method
+
+'''
+try:
+    profile
+except NameError:
+    def profile(func):
+        """Profile."""
+        return func
+'''
 
 
 class TreeNodeDescendantsMixin(models.Model):
@@ -21,40 +29,43 @@ class TreeNodeDescendantsMixin(models.Model):
 
         abstract = True
 
-    @cached_method
     def get_descendants_queryset(self, include_self=False, depth=None):
         """Get the descendants queryset."""
-        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)
+        path = self.get_order()  # calls refresh and gets the current _path
+        from_path = path + '.'
+        to_path = path + '/'
+        options = {'_path__gte': from_path, '_path__lt': to_path}
+        if depth:
+            options["_depth__lt"] = depth
+        queryset = self._meta.model.objects.filter(**options)
 
-        # 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 self._meta.model.objects.filter(pk=self.pk) | queryset
+        else:
+            return queryset
 
     @cached_method
     def get_descendants_pks(self, include_self=False, depth=None):
         """Get the descendants pks list."""
-        return self.get_descendants_queryset(include_self, depth)\
-            .values_list("id", flat=True)
+        return self.query("descendants", include_self)
 
+    # @profile
+    @cached_method
     def get_descendants(self, include_self=False, depth=None):
         """Get a list containing all descendants."""
+        # descendants_pks = self.query("descendants", include_self)
+        # queryset = self._meta.model.objects.filter(pk__in=descendants_pks)
         queryset = self.get_descendants_queryset(include_self, depth)
         return list(queryset)
 
+    @cached_method
     def get_descendants_count(self, include_self=False, depth=None):
         """Get the descendants count."""
-        return len(self.get_descendants_pks(include_self, depth))
+        return self.query(
+            objects="descendants",
+            include_self=include_self,
+            mode='count'
+        )
+
 
 # The End