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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: django-fast-treenode
-Version: 2.1.3
+Version: 2.1.5
 Summary: Application for supporting tree (hierarchical) data structure in Django projects
 Home-page: https://django-fast-treenode.readthedocs.io/
 Author: Timur Kady
@@ -53,22 +53,24 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 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"
+Dynamic: license-file
 
 # 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.
@@ -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.
@@ -87,7 +91,6 @@ Django Fast TreeNode is suitable for a wide range of applications, from simple d
 - **Geographical data**: Represent administrative divisions, regions, and areas of influence.
 - **Organizational and Business Structures**: Model company hierarchies, business processes, employees and departments.
 
-In all applications, `django-fast-treenode` models show excellent performance and stability.
 
 ## Quick start
 1. Run `pip install django-fast-treenode`.
@@ -159,4 +162,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.5}/README.md

@@ -1,12 +1,13 @@
 # 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.
@@ -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.
@@ -25,7 +28,6 @@ Django Fast TreeNode is suitable for a wide range of applications, from simple d
 - **Geographical data**: Represent administrative divisions, regions, and areas of influence.
 - **Organizational and Business Structures**: Model company hierarchies, business processes, employees and departments.
 
-In all applications, `django-fast-treenode` models show excellent performance and stability.
 
 ## Quick start
 1. Run `pip install django-fast-treenode`.
@@ -97,4 +99,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.5/django_fast_treenode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: django-fast-treenode
-Version: 2.1.3
+Version: 2.1.5
 Summary: Application for supporting tree (hierarchical) data structure in Django projects
 Home-page: https://django-fast-treenode.readthedocs.io/
 Author: Timur Kady
@@ -53,22 +53,24 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 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"
+Dynamic: license-file
 
 # 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.
@@ -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.
@@ -87,7 +91,6 @@ Django Fast TreeNode is suitable for a wide range of applications, from simple d
 - **Geographical data**: Represent administrative divisions, regions, and areas of influence.
 - **Organizational and Business Structures**: Model company hierarchies, business processes, employees and departments.
 
-In all applications, `django-fast-treenode` models show excellent performance and stability.
 
 ## Quick start
 1. Run `pip install django-fast-treenode`.
@@ -159,4 +162,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.5}/django_fast_treenode.egg-info/requires.txt

@@ -1,6 +1,6 @@
 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.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "django-fast-treenode"
-version = "2.1.3"
+version = "2.1.5"
 description = "Application for supporting tree (hierarchical) data structure in Django projects"
 readme = "README.md"
 authors = [{ name = "Timur Kady", email = "timurkady@yandex.com" }]
@@ -12,8 +12,8 @@ license = { file = "LICENSE" }
 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.5}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = django-fast-treenode
-version = 2.1.3
+version = 2.1.5
 description = Application for supporting tree (hierarchical) data structure in Django projects
 long_description = file: README.md
 long_description_content_type = text/markdown
@@ -33,8 +33,8 @@ classifiers =
 python_requires = >=3.9
 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.5/treenode/admin/__init__.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+from .admin import TreeNodeModelAdmin
+
+
+__all__ = ["TreeNodeModelAdmin"]
+
+
+# The end

{django_fast_treenode-2.1.3 → django_fast_treenode-2.1.5}/treenode/admin/admin.py

@@ -29,7 +29,7 @@ import logging
 logger = logging.getLogger(__name__)
 
 
-class TreeNodeAdminModel(AdminMixin, admin.ModelAdmin):
+class TreeNodeModelAdmin(AdminMixin, admin.ModelAdmin):
     """
     TreeNodeAdmin class.
 

django_fast_treenode-2.1.5/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.5}/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 -------------------