django-fast-treenode 2.1.3__tar.gz → 2.1.4__tar.gz

{django_fast_treenode-2.1.3/django_fast_treenode.egg-info → django_fast_treenode-2.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: django-fast-treenode
-Version: 2.1.3
+Version: 2.1.4
 Summary: Application for supporting tree (hierarchical) data structure in Django projects
 Home-page: https://django-fast-treenode.readthedocs.io/
 Author: Timur Kady
@@ -55,23 +55,25 @@ License-File: LICENSE
 Requires-Dist: Django>=4.0
 Requires-Dist: pympler>=1.0
 Requires-Dist: django-widget-tweaks>=1.5
+Requires-Dist: msgpack>=1.1
 Provides-Extra: import-export
 Requires-Dist: openpyxl; extra == "import-export"
 Requires-Dist: pyyaml; extra == "import-export"
 Requires-Dist: xlsxwriter; extra == "import-export"
 
 # Django-fast-treenode 
-**Combining Adjacency List and Closure Table for Optimal Performance**
+**Hybrid Tree Storage**
 
 [![Tests](https://github.com/TimurKady/django-fast-treenode/actions/workflows/test.yaml/badge.svg?branch=main)](https://github.com/TimurKady/django-fast-treenode/actions/workflows/test.yaml)
 [![Docs](https://readthedocs.org/projects/django-fast-treenode/badge/?version=latest)](https://django-fast-treenode.readthedocs.io/)
 [![PyPI](https://img.shields.io/pypi/v/django-fast-treenode.svg)](https://pypi.org/project/django-fast-treenode/)
 [![Published on Django Packages](https://img.shields.io/badge/Published%20on-Django%20Packages-0c3c26)](https://djangopackages.org/packages/p/django-fast-treenode/)
+[![Sponsor](https://img.shields.io/github/sponsors/TimurKady)](https://github.com/sponsors/TimurKady)
 
-**Django Fast TreeNode** is a high-performance Django application for working with tree structures, combining **Adjacency List** and **Closure Table** models. Each **TreeNodeModel** instance maintains two synchronized tables, enabling most operations to be performed with a single database query.
+**Django Fast TreeNode** is a high-performance Django application for working with tree structures. 
 
 ## Features
-- **Hybrid storage model**: Combines Adjacency List and Closure Table for optimal performance.
+- **Hybrid storage model**: Combines Adjacency List and Materialized Path (versions 2.2 and above) Closure Table (versions 2.1 and earlier) for optimal performance.
 - **Custom caching system**: A built-in caching mechanism, specifically designed for this package, significantly boosts execution speed.
 - **Efficient queries**: Retrieve ancestors, descendants, breadcrumbs, and tree depth with only one SQL queriy.
 - **Bulk operations**: Supports fast insertion, movement, and deletion of nodes.
@@ -79,6 +81,8 @@ Requires-Dist: xlsxwriter; extra == "import-export"
 - **Admin panel integration**: Full compatibility with Django's admin panel, allowing intuitive management of tree structures.
 - **Import & Export functionality**: Built-in support for importing and exporting tree structures in multiple formats (CSV, JSON, XLSX, YAML, TSV), including integration with the Django admin panel.
 
+It seems that django-fast-treenode is currently the most balanced and performant solution for most tasks, especially those related to dynamic hierarchical data structures. Check out the results of (comparison tests)[#] with other Django packages.
+
 ## Use Cases
 Django Fast TreeNode is suitable for a wide range of applications, from simple directories to complex systems with deep hierarchical structures:
 - **Categories and taxonomies**: Manage product categories, tags, and classification systems.
@@ -159,4 +163,4 @@ Released under [MIT License](https://github.com/TimurKady/django-fast-treenode/b
 ## Credits
 Thanks to everyone who contributed to the development and testing of this package, as well as the Django community for their inspiration and support. 
 
-Special thanks to [Fabio Caccamo](https://github.com/fabiocaccamo) for the idea behind creating a fast Django application for handling hierarchies and [Mathieu Leplatre](https://github.com/leplatrem) for the advice used in writing this application.
+Special thanks to [Fabio Caccamo](https://github.com/fabiocaccamo) for the idea behind creating a fast Django application for handling hierarchies.

{django_fast_treenode-2.1.3 → django_fast_treenode-2.1.4}/README.md

@@ -1,15 +1,16 @@
 # Django-fast-treenode 
-**Combining Adjacency List and Closure Table for Optimal Performance**
+**Hybrid Tree Storage**
 
 [![Tests](https://github.com/TimurKady/django-fast-treenode/actions/workflows/test.yaml/badge.svg?branch=main)](https://github.com/TimurKady/django-fast-treenode/actions/workflows/test.yaml)
 [![Docs](https://readthedocs.org/projects/django-fast-treenode/badge/?version=latest)](https://django-fast-treenode.readthedocs.io/)
 [![PyPI](https://img.shields.io/pypi/v/django-fast-treenode.svg)](https://pypi.org/project/django-fast-treenode/)
 [![Published on Django Packages](https://img.shields.io/badge/Published%20on-Django%20Packages-0c3c26)](https://djangopackages.org/packages/p/django-fast-treenode/)
+[![Sponsor](https://img.shields.io/github/sponsors/TimurKady)](https://github.com/sponsors/TimurKady)
 
-**Django Fast TreeNode** is a high-performance Django application for working with tree structures, combining **Adjacency List** and **Closure Table** models. Each **TreeNodeModel** instance maintains two synchronized tables, enabling most operations to be performed with a single database query.
+**Django Fast TreeNode** is a high-performance Django application for working with tree structures. 
 
 ## Features
-- **Hybrid storage model**: Combines Adjacency List and Closure Table for optimal performance.
+- **Hybrid storage model**: Combines Adjacency List and Materialized Path (versions 2.2 and above) Closure Table (versions 2.1 and earlier) for optimal performance.
 - **Custom caching system**: A built-in caching mechanism, specifically designed for this package, significantly boosts execution speed.
 - **Efficient queries**: Retrieve ancestors, descendants, breadcrumbs, and tree depth with only one SQL queriy.
 - **Bulk operations**: Supports fast insertion, movement, and deletion of nodes.
@@ -17,6 +18,8 @@
 - **Admin panel integration**: Full compatibility with Django's admin panel, allowing intuitive management of tree structures.
 - **Import & Export functionality**: Built-in support for importing and exporting tree structures in multiple formats (CSV, JSON, XLSX, YAML, TSV), including integration with the Django admin panel.
 
+It seems that django-fast-treenode is currently the most balanced and performant solution for most tasks, especially those related to dynamic hierarchical data structures. Check out the results of (comparison tests)[#] with other Django packages.
+
 ## Use Cases
 Django Fast TreeNode is suitable for a wide range of applications, from simple directories to complex systems with deep hierarchical structures:
 - **Categories and taxonomies**: Manage product categories, tags, and classification systems.
@@ -97,4 +100,4 @@ Released under [MIT License](https://github.com/TimurKady/django-fast-treenode/b
 ## Credits
 Thanks to everyone who contributed to the development and testing of this package, as well as the Django community for their inspiration and support. 
 
-Special thanks to [Fabio Caccamo](https://github.com/fabiocaccamo) for the idea behind creating a fast Django application for handling hierarchies and [Mathieu Leplatre](https://github.com/leplatrem) for the advice used in writing this application.
+Special thanks to [Fabio Caccamo](https://github.com/fabiocaccamo) for the idea behind creating a fast Django application for handling hierarchies.

{django_fast_treenode-2.1.3 → django_fast_treenode-2.1.4/django_fast_treenode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: django-fast-treenode
-Version: 2.1.3
+Version: 2.1.4
 Summary: Application for supporting tree (hierarchical) data structure in Django projects
 Home-page: https://django-fast-treenode.readthedocs.io/
 Author: Timur Kady
@@ -55,23 +55,25 @@ License-File: LICENSE
 Requires-Dist: Django>=4.0
 Requires-Dist: pympler>=1.0
 Requires-Dist: django-widget-tweaks>=1.5
+Requires-Dist: msgpack>=1.1
 Provides-Extra: import-export
 Requires-Dist: openpyxl; extra == "import-export"
 Requires-Dist: pyyaml; extra == "import-export"
 Requires-Dist: xlsxwriter; extra == "import-export"
 
 # Django-fast-treenode 
-**Combining Adjacency List and Closure Table for Optimal Performance**
+**Hybrid Tree Storage**
 
 [![Tests](https://github.com/TimurKady/django-fast-treenode/actions/workflows/test.yaml/badge.svg?branch=main)](https://github.com/TimurKady/django-fast-treenode/actions/workflows/test.yaml)
 [![Docs](https://readthedocs.org/projects/django-fast-treenode/badge/?version=latest)](https://django-fast-treenode.readthedocs.io/)
 [![PyPI](https://img.shields.io/pypi/v/django-fast-treenode.svg)](https://pypi.org/project/django-fast-treenode/)
 [![Published on Django Packages](https://img.shields.io/badge/Published%20on-Django%20Packages-0c3c26)](https://djangopackages.org/packages/p/django-fast-treenode/)
+[![Sponsor](https://img.shields.io/github/sponsors/TimurKady)](https://github.com/sponsors/TimurKady)
 
-**Django Fast TreeNode** is a high-performance Django application for working with tree structures, combining **Adjacency List** and **Closure Table** models. Each **TreeNodeModel** instance maintains two synchronized tables, enabling most operations to be performed with a single database query.
+**Django Fast TreeNode** is a high-performance Django application for working with tree structures. 
 
 ## Features
-- **Hybrid storage model**: Combines Adjacency List and Closure Table for optimal performance.
+- **Hybrid storage model**: Combines Adjacency List and Materialized Path (versions 2.2 and above) Closure Table (versions 2.1 and earlier) for optimal performance.
 - **Custom caching system**: A built-in caching mechanism, specifically designed for this package, significantly boosts execution speed.
 - **Efficient queries**: Retrieve ancestors, descendants, breadcrumbs, and tree depth with only one SQL queriy.
 - **Bulk operations**: Supports fast insertion, movement, and deletion of nodes.
@@ -79,6 +81,8 @@ Requires-Dist: xlsxwriter; extra == "import-export"
 - **Admin panel integration**: Full compatibility with Django's admin panel, allowing intuitive management of tree structures.
 - **Import & Export functionality**: Built-in support for importing and exporting tree structures in multiple formats (CSV, JSON, XLSX, YAML, TSV), including integration with the Django admin panel.
 
+It seems that django-fast-treenode is currently the most balanced and performant solution for most tasks, especially those related to dynamic hierarchical data structures. Check out the results of (comparison tests)[#] with other Django packages.
+
 ## Use Cases
 Django Fast TreeNode is suitable for a wide range of applications, from simple directories to complex systems with deep hierarchical structures:
 - **Categories and taxonomies**: Manage product categories, tags, and classification systems.
@@ -159,4 +163,4 @@ Released under [MIT License](https://github.com/TimurKady/django-fast-treenode/b
 ## Credits
 Thanks to everyone who contributed to the development and testing of this package, as well as the Django community for their inspiration and support. 
 
-Special thanks to [Fabio Caccamo](https://github.com/fabiocaccamo) for the idea behind creating a fast Django application for handling hierarchies and [Mathieu Leplatre](https://github.com/leplatrem) for the advice used in writing this application.
+Special thanks to [Fabio Caccamo](https://github.com/fabiocaccamo) for the idea behind creating a fast Django application for handling hierarchies.

{django_fast_treenode-2.1.3 → django_fast_treenode-2.1.4}/django_fast_treenode.egg-info/requires.txt

@@ -1,6 +1,7 @@
 Django>=4.0
 pympler>=1.0
 django-widget-tweaks>=1.5
+msgpack>=1.1
 
 [import_export]
 openpyxl

{django_fast_treenode-2.1.3 → django_fast_treenode-2.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "django-fast-treenode"
-version = "2.1.3"
+version = "2.1.4"
 description = "Application for supporting tree (hierarchical) data structure in Django projects"
 readme = "README.md"
 authors = [{ name = "Timur Kady", email = "timurkady@yandex.com" }]
@@ -13,7 +13,8 @@ requires-python = ">=3.9"
 dependencies = [
     "Django >=4.0",
     "pympler >=1.0",
-    "django-widget-tweaks >= 1.5"
+    "django-widget-tweaks >= 1.5",
+    "msgpack >= 1.1"
 ]
 classifiers = [
     "Development Status :: 5 - Production/Stable",

{django_fast_treenode-2.1.3 → django_fast_treenode-2.1.4}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = django-fast-treenode
-version = 2.1.3
+version = 2.1.4
 description = Application for supporting tree (hierarchical) data structure in Django projects
 long_description = file: README.md
 long_description_content_type = text/markdown
@@ -35,6 +35,7 @@ install_requires =
 	Django >=4.0
 	pympler >=1.0
 	django-widget-tweaks >= 1.5
+	msgpack >= 1.1
 
 [options.extras_require]
 import_export = 

django_fast_treenode-2.1.4/treenode/cache.py

@@ -0,0 +1,352 @@
+# -*- coding: utf-8 -*-
+"""
+TreeNode Cache Module
+
+This module provides a singleton-based caching system for TreeNode models.
+It includes optimized key generation, cache size tracking,
+and an eviction mechanism to ensure efficient memory usage.
+
+Features:
+- Singleton cache instance to prevent redundant allocations.
+- Custom cache key generation using function parameters.
+- Automatic cache eviction when memory limits are exceeded.
+- Decorator `@cached_method` for caching method results.
+
+Version: 2.2.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+import hashlib
+import msgpack
+import sys
+import threading
+from collections import deque, defaultdict, OrderedDict
+from django.conf import settings
+from django.core.cache import caches
+from functools import lru_cache
+from functools import wraps
+
+
+# ---------------------------------------------------
+# Utilities
+# ---------------------------------------------------
+
+_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+_CLEARINT_THESHOLD = 0.8
+_EVICT_INTERVAL = 50
+
+
+@lru_cache(maxsize=1000)
+def to_base36(num):
+    """
+    Convert an integer to a base36 string.
+
+    For example: 10 -> 'A', 35 -> 'Z', 36 -> '10', etc.
+    """
+    if num == 0:
+        return '0'
+    sign = '-' if num < 0 else ''
+    num = abs(num)
+    result = []
+    while num:
+        num, rem = divmod(num, 36)
+        result.append(_DIGITS[rem])
+    return sign + ''.join(reversed(result))
+
+
+# ---------------------------------------------------
+# Caching
+# ---------------------------------------------------
+
+class TreeCache:
+    """Singleton class for managing the TreeNode cache."""
+
+    _instance = None
+    _instance_lock = threading.Lock()
+
+    def __new__(cls, *args, **kwargs):
+        """Singleton new."""
+        with cls._instance_lock:
+            if cls._instance is None:
+                cls._instance = super(TreeCache, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self, cache_limit=100 * 1024 * 1024):
+        """
+        Initialize the cache.
+
+        If the 'treenode' key is present in settings.CACHES, the corresponding
+        backend is used.
+        Otherwise, the custom dictionary is used.
+        The cache size (in bytes) is taken from
+        settings.TREENODE_CACHE_LIMIT (MB), by default 100 MB.
+        """
+        if hasattr(self, '_initialized') and self._initialized:
+            return
+
+        # Get the cache limit (MB), then convert to bytes.
+        cache_limit_mb = getattr(settings, 'TREENODE_CACHE_LIMIT', 100)
+        self.cache_limit = cache_limit_mb * 1024 * 1024
+
+        # Select backend: if there is 'treenode' in settings.CACHES, use it.
+        # Otherwise, use our own dictionary.
+        if hasattr(settings, 'CACHES') and 'treenode' in settings.CACHES:
+            self.cache = caches['treenode']
+        else:
+            # We use our dictionary as a backend.
+            self.cache = OrderedDict()
+
+        self.order = deque()            # Queue for FIFO implementation.
+        self.total_size = 0             # Current cache size in bytes.
+        self.lock = threading.Lock()    # Lock for thread safety.
+
+        # Additional index for fast search of keys by prefix
+        # Format: {prefix: {key1, key2, ...}}
+        self.prefix_index = defaultdict(set)
+        # Dictionary to store the sizes of each key (key -> size in bytes)
+        self.sizes = {}
+        # Dictionary to store the prefix for each key to avoid repeated
+        # splitting
+        self.key_prefix = {}
+
+        # Counter for number of set operations for periodic eviction
+        self._set_counter = 0
+        # Evict cache every _evict_interval set operations when using external
+        # backend
+        self._evict_interval = _EVICT_INTERVAL
+
+        self._initialized = True
+
+    def generate_cache_key(self, label, func_name, unique_id, *args, **kwargs):
+        """
+        Generate a cache key.
+
+        <label>_<func_name>_<unique_id>_<hash>
+        """
+        # If using custom dict backend, use simple key generation without
+        # serialization.
+        if isinstance(self.cache, dict):
+            sorted_kwargs = sorted(kwargs.items())
+            return f"{label}_{func_name}_{unique_id}_{args}_{sorted_kwargs}"
+        else:
+            try:
+                # Using msgpack for fast binary representation of arguments
+                sorted_kwargs = sorted(kwargs.items())
+                params_bytes = msgpack.packb(
+                    (args, sorted_kwargs), use_bin_type=True)
+            except Exception:
+                params_bytes = repr((args, kwargs)).encode('utf-8')
+            # Using MD5 for speed (no cryptographic strength)
+            hash_value = hashlib.md5(params_bytes).hexdigest()
+            return f"{label}_{func_name}_{unique_id}_{hash_value}"
+
+    def get_obj_size(self, value):
+        """
+        Determine the size of the object in bytes.
+
+        If the value is already in bytes or bytearray, simply returns its
+        length. Otherwise, uses sys.getsizeof for an approximate estimate.
+        """
+        if isinstance(value, (bytes, bytearray)):
+            return len(value)
+        return sys.getsizeof(value)
+
+    def set(self, key, value):
+        """
+        Store the value in the cache.
+
+        Stores the value in the cache, updates the FIFO queue, prefix index,
+        size dictionary, and total cache size.
+        """
+        # Idea 1: Store raw object if using custom dict backend, otherwise
+        # serialize using msgpack.
+        if isinstance(self.cache, dict):
+            stored_value = value
+        else:
+            try:
+                stored_value = msgpack.packb(value, use_bin_type=True)
+            except Exception:
+                stored_value = value
+
+        # Calculate the size of the stored value
+        if isinstance(stored_value, (bytes, bytearray)):
+            size = len(stored_value)
+        else:
+            size = sys.getsizeof(stored_value)
+
+        # Store the value in the cache backend
+        if isinstance(self.cache, dict):
+            self.cache[key] = stored_value
+        else:
+            self.cache.set(key, stored_value)
+
+        # Update internal structures under lock
+        with self.lock:
+            if key in self.sizes:
+                # If the key already exists, adjust the total size
+                old_size = self.sizes[key]
+                self.total_size -= old_size
+            else:
+                # New key: add to FIFO queue
+                self.order.append(key)
+                # Compute prefix once and store it in key_prefix
+                if "_" in key:
+                    prefix = key.split('_', 1)[0] + "_"
+                else:
+                    prefix = key
+                self.key_prefix[key] = prefix
+                self.prefix_index[prefix].add(key)
+            # Save the size for this key and update total_size
+            self.sizes[key] = size
+            self.total_size += size
+
+            # Increment the set counter for periodic eviction
+            self._set_counter += 1
+
+        # Idea 3: If using external backend, evict cache every _evict_interval
+        # sets. Otherwise, always evict immediately.
+        if self._set_counter >= self._evict_interval:
+            with self.lock:
+                self._set_counter = 0
+            self._evict_cache()
+
+    def get(self, key):
+        """
+        Get a value from the cache by key.
+
+        Quickly retrieves a value from the cache by key.
+        Here we simply request a value from the backend (either a dictionary or
+        Django cache-backend) and return it without any additional operations.
+        """
+        if isinstance(self.cache, dict):
+            return self.cache.get(key)
+        else:
+            packed_value = self.cache.get(key)
+            if packed_value is None:
+                return None
+            try:
+                return msgpack.unpackb(packed_value, raw=False)
+            except Exception:
+                # If unpacking fails, return what we got
+                return packed_value
+
+    def invalidate(self, prefix):
+        """
+        Invalidate model cache.
+
+        Quickly removes all items from the cache whose keys start with prefix.
+        Uses prefix_index for instant access to keys.
+        When removing, each key's size is retrieved from self.sizes,
+        and total_size is reduced by the corresponding amount.
+        """
+        prefix += '_'
+        with self.lock:
+            keys_to_remove = self.prefix_index.get(prefix, set())
+            if not keys_to_remove:
+                return
+
+            # Remove keys from main cache and update total_size via sizes
+            # dictionary
+            if isinstance(self.cache, dict):
+                for key in keys_to_remove:
+                    self.cache.pop(key, None)
+                    size = self.sizes.pop(key, 0)
+                    self.total_size -= size
+                    # Remove key from key_prefix as well
+                    self.key_prefix.pop(key, None)
+            else:
+                # If using Django backend
+                self.cache.delete_many(list(keys_to_remove))
+                for key in keys_to_remove:
+                    size = self.sizes.pop(key, 0)
+                    self.total_size -= size
+                    self.key_prefix.pop(key, None)
+
+            # Remove prefix from index and update FIFO queue
+            del self.prefix_index[prefix]
+            self.order = deque(k for k in self.order if k not in keys_to_remove)
+
+    def clear(self):
+        """Clear cache completely."""
+        with self.lock:
+            if isinstance(self.cache, dict):
+                self.cache.clear()
+            else:
+                self.cache.clear()
+            self.order.clear()
+            self.prefix_index.clear()
+            self.sizes.clear()
+            self.key_prefix.clear()
+            self.total_size = 0
+
+    def _evict_cache(self):
+        """
+        Perform FIFO cache evacuation.
+
+        Removes old items until the total cache size is less than
+        _CLEARINT_THESHOLD of the limit.
+        """
+        with self.lock:
+            # Evict until total_size is below 80% of cache_limit
+            target_size = _CLEARINT_THESHOLD * self.cache_limit
+            while self.total_size > target_size and self.order:
+                # Extract the oldest key from the queue (FIFO)
+                key = self.order.popleft()
+
+                # Delete entry from backend cache
+                if isinstance(self.cache, dict):
+                    self.cache.pop(key, None)
+                else:
+                    self.cache.delete(key)
+
+                # Extract the size of the entry to be deleted and reduce
+                # the overall cache size
+                size = self.sizes.pop(key, 0)
+                self.total_size -= size
+
+                # Retrieve prefix from key_prefix without splitting
+                prefix = self.key_prefix.pop(key, None)
+                if prefix is not None:
+                    self.prefix_index[prefix].discard(key)
+                    if not self.prefix_index[prefix]:
+                        del self.prefix_index[prefix]
+
+
+# Global cache object (unique for the system)
+treenode_cache = TreeCache()
+
+
+# ---------------------------------------------------
+# Decorator
+# ---------------------------------------------------
+
+def cached_method(func):
+    """Decorate instance or class methods."""
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        cache = treenode_cache
+
+        if isinstance(self, type):
+            unique_id = to_base36(id(self))
+            label = getattr(self._meta, 'label', self.__name__)
+        else:
+            unique_id = getattr(self, "pk", None) or to_base36(id(self))
+            label = self._meta.label
+
+        cache_key = cache.generate_cache_key(
+            label,
+            func.__name__,
+            unique_id,
+            *args,
+            **kwargs
+        )
+        value = cache.get(cache_key)
+        if value is None:
+            value = func(self, *args, **kwargs)
+            cache.set(cache_key, value)
+        return value
+    return wrapper
+
+
+# The End

{django_fast_treenode-2.1.3 → django_fast_treenode-2.1.4}/treenode/managers/adjacency.py

@@ -14,6 +14,7 @@ Email: timurkady@yandex.com
 from collections import deque, defaultdict
 from django.db import models, transaction
 from django.db import connection
+from django.db.models import F
 
 
 class TreeNodeQuerySet(models.QuerySet):
@@ -137,10 +138,11 @@ class TreeNodeModelManager(models.Manager):
 
     def get_queryset(self):
         """Return a sorted QuerySet."""
-        queryset = TreeNodeQuerySet(self.model, using=self._db)\
-            .annotate(_depth_db=models.Max("parents_set__depth"))\
-            .order_by("_depth_db", "tn_parent", "tn_priority")
-        return queryset
+        return TreeNodeQuerySet(self.model, using=self._db)\
+            .order_by(
+                # F('tn_parent').asc(nulls_first=True),
+                'tn_parent', 'tn_priority'
+        )
 
     # Service methods -------------------
 

{django_fast_treenode-2.1.3 → django_fast_treenode-2.1.4}/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):