django-fast-treenode 3.0.0__tar.gz → 3.0.2__tar.gz

{django_fast_treenode-3.0.0 → django_fast_treenode-3.0.2}/LICENSE

@@ -19,3 +19,4 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+

{django_fast_treenode-3.0.0/django_fast_treenode.egg-info → django_fast_treenode-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-fast-treenode
-Version: 3.0.0
+Version: 3.0.2
 Summary: Treenode Framework for supporting tree (hierarchical) data structure in Django projects
 Home-page: https://django-fast-treenode.readthedocs.io/
 Author: Timur Kady
@@ -27,6 +27,7 @@ License: MIT License
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
         
+        
 Project-URL: Homepage, https://github.com/TimurKady/django-fast-treenode
 Project-URL: Documentation, https://django-fast-treenode.readthedocs.io/
 Project-URL: Source, https://github.com/TimurKady/django-fast-treenode

{django_fast_treenode-3.0.0 → django_fast_treenode-3.0.2/django_fast_treenode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-fast-treenode
-Version: 3.0.0
+Version: 3.0.2
 Summary: Treenode Framework for supporting tree (hierarchical) data structure in Django projects
 Home-page: https://django-fast-treenode.readthedocs.io/
 Author: Timur Kady
@@ -27,6 +27,7 @@ License: MIT License
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
         
+        
 Project-URL: Homepage, https://github.com/TimurKady/django-fast-treenode
 Project-URL: Documentation, https://django-fast-treenode.readthedocs.io/
 Project-URL: Source, https://github.com/TimurKady/django-fast-treenode

{django_fast_treenode-3.0.0 → django_fast_treenode-3.0.2}/docs/index.md

@@ -1,4 +1,4 @@
-# TreeNode Framework
+# Treenode Framework
 **A hybrid open-source framework for working with trees in Django**
 
 Welcome to the **django-fast-treenode** documentation!
@@ -147,14 +147,14 @@ The project is designed for long-term compatibility with future Django versions
 
 All SQL queries are adapted through a universal compatibility layer, ensuring support for major databases without the need to rewrite SQL code.
 
-| Database         | Minimum Version | Status              | Notes |
-|------------------|------------------|---------------------|-------|
-| **PostgreSQL**    | ≥ 9.4            | Full tested     | Recommended ≥ 12 |
-| **MySQL**         | ≥ 8.0            | Partially tested | |
-| **MariaDB**       | ≥ 10.2.2         | Not tested      | |
-| **SQLite**        | ≥ 3.25.0         | Partially tested | |
-| **Oracle**        | ≥ 12c            | Full tested     | Recommended ≥ 19c |
-| **MS SQL Server** | ≥ 2012           | Partially tested| |
+| Database          | Minimum Version   | Status          | Notes             |
+|:------------------|:------------------|:----------------|:-------------------|
+| **PostgreSQL**    | ≥ 10.0           | Full tested      | Recommended ≥ 12  |
+| **MySQL**         | ≥ 8.0            | Partially tested |                   |
+| **MariaDB**       | ≥ 10.5           | Not tested       |                   |
+| **SQLite**        | ≥ 3.35.0         | Partially tested |                   |
+| **Oracle**        | ≥ 12c R2         | Full tested      | Recommended ≥ 19c |
+| **MS SQL Server** | ≥ 2016           | Partially tested |                   |
 
 
 The project is **ready for production use** across all modern versions of Django and major relational databases without manual SQL corrections.

{django_fast_treenode-3.0.0 → django_fast_treenode-3.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "django-fast-treenode"
-version = "3.0.0"
+version = "3.0.2"
 description = "Treenode Framework for supporting tree (hierarchical) data structure in Django projects"
 readme = "README.md"
 authors = [{ name = "Timur Kady", email = "timurkady@yandex.com" }]
@@ -43,3 +43,4 @@ Documentation = "https://django-fast-treenode.readthedocs.io/"
 Source = "https://github.com/TimurKady/django-fast-treenode"
 Issues = "https://github.com/TimurKady/django-fast-treenode/issues"
 
+

{django_fast_treenode-3.0.0 → django_fast_treenode-3.0.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='django-fast-treenode',
-    version='3.0.0',
+    version='3.0.2',
     description='Treenode Framework for supporting tree (hierarchical) data structure in Django projects',
     long_description=open('README.md', encoding='utf-8').read(),
     long_description_content_type='text/markdown',
@@ -41,3 +41,4 @@ setup(
     ],
     python_requires='>=3.9',
 )
+

django_fast_treenode-3.0.2/tests/test_suite.py

@@ -0,0 +1,99 @@
+# tests/test_treenode.py
+from django.test import TestCase
+from django.db import transaction
+from .models import TestModel
+
+PATH_DIGITS = 3
+
+
+def hex_path(parts):
+    """Преобразуем массив индексов в нулепад-hex-строку."""
+    return ".".join(f"{n:0{PATH_DIGITS}X}" for n in parts)
+
+
+class TreeNodeModelTests(TestCase):
+    """Проверяем основные операции TreeNodeModel."""
+
+    @classmethod
+    def setUpTestData(cls):
+        """
+        Создаём тестовое дерево один раз на весь класс.
+        Django сделает его снимок, и в каждом тесте база
+        будет возвращаться в это состояние автоматически.
+        """
+        cls.root = TestModel.objects.create(name="root", priority=0)
+        cls.a = TestModel.objects.create(name="A", parent=cls.root, priority=1)
+        cls.b = TestModel.objects.create(name="B", parent=cls.root, priority=2)
+        cls.c = TestModel.objects.create(name="C", parent=cls.a, priority=1)
+        cls.d = TestModel.objects.create(name="D", parent=cls.a, priority=2)
+
+        _ = cls.a.get_order()
+        _ = cls.c.get_order()
+
+    # --- 1. Creating nodes -------------------------------------------------
+
+    def test_count_after_creation(self):
+        self.assertEqual(TestModel.objects.count(), 5)
+
+    # --- 2. _path and _depth --------------------------------------------------
+
+    def test_path_and_depth_saved(self):
+        with self.subTest("Depth values"):
+            self.assertEqual(self.a.get_depth(), 1)
+            self.assertEqual(self.c.get_depth(), 2)
+
+        with self.subTest("Path format"):
+            self.assertIn(".", self.a.get_order())
+            self.assertIn(".", self.c.get_order())
+
+    # --- 3. Ancestors and Descendants ------------------------------------------------
+
+    def test_ancestors_and_descendants(self):
+        TestModel.tasks.add("update", None)
+        TestModel.tasks.run()
+
+        ancestors = set(
+            self.c.get_ancestors_queryset().values_list("pk", flat=True)
+        )
+        expected_anc = {self.root.pk, self.a.pk, self.c.pk}
+        self.assertEqual(ancestors, expected_anc)
+
+        descendants = set(
+            self.root.get_descendants_queryset(include_self=True)
+            .values_list("pk", flat=True)
+        )
+        expected_desc = {
+            self.root.pk, self.a.pk, self.b.pk, self.c.pk, self.d.pk
+        }
+
+        test = descendants == expected_desc
+
+        self.assertEqual(test, True)
+
+    # --- 4. Moving a node ------------------------------------------------
+
+    def test_move_node(self):
+        # перемещаем c под b и проверяем
+        with transaction.atomic():
+            self.c.move_to(self.b)
+
+        self.c.refresh_from_db()
+        self.assertEqual(self.c.parent_id, self.b.pk)
+        self.assertEqual(self.c.get_depth(), self.b.get_depth() + 1)
+        self.assertTrue(
+            self.c.get_order().startswith(f"{self.b.get_order()}.")
+        )
+        self.assertEqual(self.c.get_order().count("."), self.c.get_depth())
+
+    # --- 5. Removing a node ---------------------------------------------------
+
+    def test_delete_subtree(self):
+        self.a.delete(cascade=False)
+
+        tree_data = TestModel.get_tree_json()
+
+        self.root.check_tree_integrity()
+        qs = TestModel.objects.filter(pk__in=[self.a.pk, self.c.pk]).all()
+
+        self.assertFalse(TestModel.objects.filter(pk=self.a.pk).exists())
+        self.assertTrue(TestModel.objects.filter(pk=self.c.pk).exists())

{django_fast_treenode-3.0.0 → django_fast_treenode-3.0.2}/treenode/apps.py

@@ -18,7 +18,7 @@ class TreeNodeConfig(AppConfig):
     """Config Class."""
 
     default_auto_field = "django.db.models.BigAutoField"
-    name = "supertree"
+    name = "treenode"
 
     def ready(self):
         """Ready method."""

{django_fast_treenode-3.0.0 → django_fast_treenode-3.0.2}/treenode/managers/queries.py

@@ -84,6 +84,48 @@ class TreeQuery:
             sql = self.order_by(sql1, "priority")
             return sql, params1
 
+    def get_descendants(self, include_self, depth):
+        """
+        Build SQL for the 'descendants'.
+
+        Relationship using startswith-like logic.
+        Avoids locale-dependent string comparison issues by relying on
+        _path LIKE 'xxx.%'.
+        """
+        like_pattern = self.node._path + '.%'  # emulate startswith
+
+        base_sql = f"""
+            SELECT id, _depth, priority
+            FROM {self.db_table}
+            WHERE _path LIKE %s
+        """
+        params = [like_pattern]
+
+        if depth is not None:
+            depth_val = getattr(self.node, "_depth", None)
+            if depth_val is None:
+                depth_val = type(self.node).objects.values_list(
+                    "_depth", flat=True).get(pk=self.node.pk)
+            base_sql += " AND _depth <= %s"
+            params.append(depth_val + depth)
+
+        if include_self:
+            sql_self = f"""
+                SELECT id, _depth, priority
+                FROM {self.db_table}
+                WHERE id = %s
+            """
+            union_sql, union_params = self.wrap_union_all([
+                (base_sql, params),
+                (sql_self, [self.node.pk])
+            ])
+        else:
+            union_sql, union_params = base_sql, params
+
+        union_sql = self.order_by(union_sql, "_depth, priority")
+        return union_sql, union_params
+
+    '''
     def get_descendants(self, include_self, depth):
         """
         Build SQL for the 'descendants' relationship.
@@ -113,6 +155,7 @@ class TreeQuery:
 
         union_sql = self.order_by(union_sql, "_depth, priority")
         return union_sql, union_params
+    '''
 
     def get_ancestors(self, include_self):
         """

{django_fast_treenode-3.0.0 → django_fast_treenode-3.0.2}/treenode/models/mixins/descendants.py

@@ -32,17 +32,23 @@ class TreeNodeDescendantsMixin(models.Model):
     def get_descendants_queryset(self, include_self=False, depth=None):
         """Get the descendants queryset."""
         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)
-
-        if include_self:
-            return self._meta.model.objects.filter(pk=self.pk) | queryset
-        else:
-            return queryset
+
+        # 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)
+        # if include_self:
+        #     return self._meta.model.objects.filter(pk=self.pk) | queryset
+        # else:
+        #    return queryset
+
+        suffix = "" if include_self else '.'
+        path += suffix
+        queryset = self._meta.model.objects.filter(_path__startswith=path)
+        return queryset
 
     @cached_method
     def get_descendants_pks(self, include_self=False, depth=None):

{django_fast_treenode-3.0.0 → django_fast_treenode-3.0.2}/treenode/utils/db/compiler.py

@@ -5,7 +5,7 @@ Tree update task compiler class.
 Compiles tasks to low-level SQL to update the materialized path (_path), depth
 (_depth), and node order (priority) when they are shifted or moved.
 
-Version: 3.0.0
+Version: 3.1.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
@@ -34,9 +34,11 @@ class TreePathCompiler:
         _depth) are recalculated.
         """
         db_table = model._meta.db_table
+        # Will eliminate the risk if the user names the model order or user.
+        qname = connection.ops.quote_name(db_table)
 
         sorting_field = model.sorting_field
-        sorting_fields = ["priority", "id"] if sorting_field == "priority" else [sorting_field]  # noqa: D501
+        sorting_fields = ["priority", "id"] if sorting_field == "priority" else [sorting_field]  # noqa: D5017
         sort_expr = ", ".join([
             f"c.{field}" if "." not in field else field
             for field in sorting_fields
@@ -44,7 +46,7 @@ class TreePathCompiler:
 
         cte_header = "(id, parent_id, new_priority, new_path, new_depth)"
 
-        row_number_expr = "ROW_NUMBER() OVER (ORDER BY {sort_expr}) - 1"
+        row_number_expr = f"ROW_NUMBER() OVER (ORDER BY {sort_expr}) - 1"
         hex_expr = SQLCompat.to_hex(row_number_expr)
         lpad_expr = SQLCompat.lpad(hex_expr, SEGMENT_LENGTH, "'0'")
 
@@ -57,7 +59,7 @@ class TreePathCompiler:
                     {row_number_expr} AS new_priority,
                     {new_path_expr} AS new_path,
                     0 AS new_depth
-                FROM {db_table} AS c
+                FROM {qname} AS c
                 WHERE c.parent_id IS NULL
             """
             params = []
@@ -70,16 +72,18 @@ class TreePathCompiler:
                     {row_number_expr} AS new_priority,
                     {path_expr} AS new_path,
                     p._depth + 1 AS new_depth
-                FROM {db_table} c
-                JOIN {db_table} p ON c.parent_id = p.id
+                FROM {qname} c
+                JOIN {qname} p ON c.parent_id = p.id
                 WHERE p.id = %s
             """
             params = [parent_id]
 
-        recursive_row_number_expr = "ROW_NUMBER() OVER (PARTITION BY c.parent_id ORDER BY {sort_expr}) - 1"   # noqa: D501
+        recursive_row_number_expr = f"ROW_NUMBER() OVER (PARTITION BY c.parent_id ORDER BY {sort_expr}) - 1"
         recursive_hex_expr = SQLCompat.to_hex(recursive_row_number_expr)
-        recursive_lpad_expr = SQLCompat.lpad(recursive_hex_expr, SEGMENT_LENGTH, "'0'")   # noqa: D501
-        recursive_path_expr = SQLCompat.concat("t.new_path", "'.'", recursive_lpad_expr)   # noqa: D501
+        recursive_lpad_expr = SQLCompat.lpad(
+            recursive_hex_expr, SEGMENT_LENGTH, "'0'")
+        recursive_path_expr = SQLCompat.concat(
+            "t.new_path", "'.'", recursive_lpad_expr)
 
         recursive_sql = f"""
             SELECT
@@ -88,27 +92,22 @@ class TreePathCompiler:
                 {recursive_row_number_expr} AS new_priority,
                 {recursive_path_expr} AS new_path,
                 t.new_depth + 1 AS new_depth
-            FROM {db_table} c
+            FROM {qname} c
             JOIN tree_cte t ON c.parent_id = t.id
         """
 
-        final_sql = f"""
-            WITH RECURSIVE tree_cte {cte_header} AS (
-                {base_sql}
-                UNION ALL
-                {recursive_sql}
-            )
-            UPDATE {db_table} AS orig
-            SET
-                priority = t.new_priority,
-                _path = t.new_path,
-                _depth = t.new_depth
-            FROM tree_cte t
-            WHERE orig.id = t.id;
-        """
+        final_sql = SQLCompat.update_from(
+            db_table=db_table,
+            cte_header=cte_header,
+            base_sql=base_sql,
+            recursive_sql=recursive_sql,
+            update_fields=["priority", "_path", "_depth"]
+        )
 
         with connection.cursor() as cursor:
-            cursor.execute(final_sql.format(sort_expr=sort_expr), params)
+            # Make params read-only
+            params = tuple(params)
+            cursor.execute(final_sql, params)
 
 
 # The End

django_fast_treenode-3.0.2/treenode/utils/db/sqlcompat.py

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+"""
+Database compatibility extension module.
+
+Adapts SQL code to the specific features of SQL syntax of various
+Database vendors.
+
+Instead of direct concatenation:
+old: p._path || '.' || LPAD(...)
+new: SQLCompat.concat("p._path", "'.'", SQLCompat.lpad(...))
+
+Instead of TO_HEX(...)
+old: TO_HEX(...)
+new: SQLCompat.to_hex(...)
+
+Instead of LPAD(...)
+old: LPAD(...)
+new: SQLCompat.lpad(...)
+
+Version: 3.1.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+from django.db import connection
+from .db_vendor import is_mysql, is_mariadb, is_sqlite, is_mssql
+from ...settings import TREENODE_PAD_CHAR
+
+
+class SQLCompat:
+    """Vendor-Specific SQL Compatibility Layer."""
+
+    @staticmethod
+    def concat(*args):
+        """Adapt string concatenation to the vendor-specific syntax."""
+        args_joined = ", ".join(args)
+        if is_mysql() or is_mariadb():
+            return f"CONCAT({args_joined})"
+        elif is_mssql():
+            return " + ".join(args)
+        else:
+            return " || ".join(args)
+
+    @staticmethod
+    def to_hex(value):
+        """Convert integer to uppercase hexadecimal string."""
+        if is_sqlite():
+            return f"UPPER(printf('%x', {value}))"
+        elif is_mysql() or is_mariadb():
+            return f"UPPER(CONV({value}, 10, 16))"
+        else:
+            return f"UPPER(TO_HEX({value}))"
+
+    @staticmethod
+    def lpad(value, length, char=TREENODE_PAD_CHAR):
+        """Pad string to the specified length."""
+        if is_sqlite():
+            return f"printf('%0{length}s', {value})"
+        else:
+            return f"LPAD({value}, {length}, {char})"
+
+    @staticmethod
+    def update_from(db_table, cte_header, base_sql, recursive_sql, update_fields):
+        """
+        Generate final SQL for updating via recursive CTE.
+
+        PostgreSQL uses UPDATE ... FROM.
+        Other engines use vendor-specific strategies.
+        """
+        qt = connection.ops.quote_name(db_table)
+        def qf(f): return connection.ops.quote_name(f)
+
+        cte_alias = {
+            "priority": "new_priority",
+            "_path": "new_path",
+            "_depth": "new_depth",
+        }
+
+        if connection.vendor == "postgresql":
+            set_clause = ", ".join(
+                f"{qf(f)} = t.{cte_alias.get(f, f)}" for f in update_fields
+            )
+            return f"""
+                WITH RECURSIVE tree_cte {cte_header} AS (
+                    {base_sql}
+                    UNION ALL
+                    {recursive_sql}
+                )
+                UPDATE {qt} AS orig
+                SET {set_clause}
+                FROM tree_cte t
+                WHERE orig.id = t.id;
+            """
+
+        elif connection.vendor in {"microsoft", "mssql"}:
+            set_clause = ", ".join(
+                f"{qt}.{f} = t.{f}" for f in update_fields
+            )
+            return f"""
+                WITH tree_cte {cte_header} AS (
+                    {base_sql}
+                    UNION ALL
+                    {recursive_sql}
+                )
+                UPDATE orig
+                SET {set_clause}
+                FROM {qt} AS orig
+                JOIN tree_cte t ON orig.id = t.id;
+            """
+
+        elif connection.vendor == "oracle":
+            set_clause = ", ".join(
+                f"orig.{f} = t.{f}" for f in update_fields
+            )
+            return f"""
+                WITH tree_cte {cte_header} AS (
+                    {base_sql}
+                    UNION ALL
+                    {recursive_sql}
+                )
+                MERGE INTO {qt} orig
+                USING tree_cte t
+                ON (orig.id = t.id)
+                WHEN MATCHED THEN UPDATE SET
+                    {set_clause};
+            """
+
+        else:
+            set_clause = ", ".join(
+                f"{qf(f)} = (SELECT t.{f} FROM tree_cte t WHERE t.id = {qt}.id)"
+                for f in update_fields
+            )
+            where_clause = f"id IN (SELECT id FROM tree_cte)"
+            return f"""
+                WITH RECURSIVE tree_cte {cte_header} AS (
+                    {base_sql}
+                    UNION ALL
+                    {recursive_sql}
+                )
+                UPDATE {qt}
+                SET {set_clause}
+                WHERE {where_clause};
+            """
+
+# The End

{django_fast_treenode-3.0.0 → django_fast_treenode-3.0.2}/treenode/version.py

@@ -4,10 +4,9 @@ TreeNode Version Module
 
 This module defines the current version of the TreeNode package.
 
-Version: 3.0.0
+Version: 3.0.2
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
-
-__version__ = '3.0.0'
+__version__ = '3.0.2'

{django_fast_treenode-3.0.0 → django_fast_treenode-3.0.2}/treenode/views/crud.py

@@ -10,14 +10,17 @@ Email: timurkady@yandex.com
 """
 
 import json
-
+import logging
+from django.core.exceptions import ValidationError
 from django.forms.models import model_to_dict
 from django.http import (
     JsonResponse, HttpResponseBadRequest, HttpResponseNotFound,
 )
-
+from django.utils.translation import gettext_lazy as _
 from django.views import View
 
+logger = logging.getLogger("treenode.views.crud")
+
 
 class TreeNodeBaseAPIView(View):
     """Simple API View for TreeNode-based models."""
@@ -128,8 +131,14 @@ class TreeNodeBaseAPIView(View):
             obj.full_clean()
             obj.save()
             return JsonResponse(model_to_dict(obj), status=201)
-        except Exception as e:
-            return HttpResponseBadRequest(str(e))
+        except ValidationError as ve:
+            # give the client clear field errors
+            return JsonResponse({"errors": ve.message_dict}, status=400)
+        except Exception:
+            # log full information for development
+            logger.exception("Failed to create node")
+            return JsonResponse(
+                {"error": _("Failed to create node")}, status=400)
 
     def put(self, request, pk):
         """
@@ -155,10 +164,16 @@ class TreeNodeBaseAPIView(View):
             obj.full_clean()
             obj.save()
             return JsonResponse(model_to_dict(obj))
+        except ValidationError as ve:
+            return JsonResponse({"errors": ve.message_dict}, status=400)
         except self.model.DoesNotExist:
-            return HttpResponseNotFound("Node not found.")
-        except Exception as e:
-            return HttpResponseBadRequest(str(e))
+            # give the client clear field errors
+            return HttpResponseNotFound(_("Node not found (pk={pk})."))
+        except Exception:
+            # log full information for development
+            logger.exception("Error replacing node %s", pk)
+            return JsonResponse(
+                {"error": _("Failed to update node")}, status=400)
 
     def patch(self, request, pk):
         """
@@ -200,10 +215,16 @@ class TreeNodeBaseAPIView(View):
                 "id": obj.pk,
                 "cascade": cascade
             })
+        except ValidationError as ve:
+            # give the client clear field errors|
+            return JsonResponse({"errors": ve.message_dict}, status=400)
         except self.model.DoesNotExist:
-            return HttpResponseNotFound("Node not found.")
-        except Exception as e:
-            return HttpResponseBadRequest(str(e))
+            return HttpResponseNotFound(_("Node not found (pk={pk})."))
+        except Exception:
+            # log full information for development
+            logger.exception("Error deleting node %s", pk)
+            return JsonResponse(
+                {"error": _("Error deleting node")}, status=400)
 
 
 # The End

{django_fast_treenode-3.0.0 → django_fast_treenode-3.0.2}/treenode/widgets.py

@@ -21,6 +21,8 @@ from django.utils.translation import gettext_lazy as _
 class TreeWidget(forms.Widget):
     """Custom widget for hierarchical tree selection."""
 
+    template_name = "django/forms/widgets/select.html"
+
     class Media:
         """Meta class to define required CSS and JS files."""
 

django_fast_treenode-3.0.0/tests/test_suite.py

@@ -1,91 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Automated tests for TreeNodeModel.
-"""
-
-import unittest
-from django.db import transaction
-from supertree.models import TestNode  # путь поправь, если нужно
-
-PATH_DIGITS = 3
-
-
-def _set_path(array):
-    """Store the path as a zero-padded hex string."""
-    return '.'.join(f"{n:0{PATH_DIGITS}X}" for n in array)
-
-
-class TreeNodeModelTests(unittest.TestCase):
-    """Test cases for the TreeNodeModel behavior."""
-
-    def setUp(self):
-        # Чистим таблицу перед каждым тестом
-        TestNode.objects.all().delete()
-
-    @transaction.atomic
-    def test_tree_operations(self):
-        """Main test covering tree creation, move, and serialization."""
-
-        # 1️⃣ Create a test tree
-        root = TestNode.objects.create(name="root", priority=0)
-        node_a = TestNode.objects.create(name="A", parent=root, priority=1)
-        node_b = TestNode.objects.create(name="B", parent=root, priority=2)
-        node_c = TestNode.objects.create(name="C", parent=node_a, priority=1)
-        node_d = TestNode.objects.create(name="D", parent=node_a, priority=2)
-
-        self.assertEqual(TestNode.objects.count(), 5)
-
-        # 2️⃣ Check the saving of `_path`
-        path_a = node_a.get_order()
-        path_c = node_c.get_order()
-
-        self.assertEqual(node_a.get_depth(), 1)
-        self.assertEqual(node_c._depth, 2)
-        self.assertTrue(isinstance(path_a, str) and '.' in path_a)
-        self.assertTrue(isinstance(path_c, str) and '.' in path_c)
-
-        # 3️⃣ Check ancestors and descendants
-        ancestor_ids = set(
-            node_c.get_ancestors_queryset().values_list("pk", flat=True))
-        self.assertEqual(ancestor_ids, {root.pk, node_a.pk, node_c.pk})
-
-        descendant_ids = set(root.get_descendants_queryset(
-            include_self=True).values_list("pk", flat=True))
-        self.assertEqual(descendant_ids, {
-                         root.pk, node_a.pk, node_b.pk, node_c.pk, node_d.pk})
-
-        # 4️⃣ Move node_c under node_b
-        node_c.move_to(node_b)
-        self.assertEqual(node_c.parent.pk, node_b.pk)
-        self.assertEqual(node_c.get_depth(), node_b.get_depth() + 1)
-        self.assertTrue(node_c.get_order().startswith(node_b.get_order() + '.'))
-        self.assertEqual(node_c.get_order().count('.'), node_c.get_depth())
-
-        # 5️⃣ Check deletion
-        node_a.delete()
-        self.assertFalse(TestNode.objects.filter(pk=node_a.pk).exists())
-        self.assertTrue(TestNode.objects.filter(pk=node_c.pk).exists())
-
-        # 6️⃣ Check save and load operations
-        TestNode.objects.all().delete()
-        self.assertFalse(TestNode.objects.exists())
-
-        # Recreate the tree
-        root = TestNode.objects.create(name="root", priority=0)
-        node_a = TestNode.objects.create(name="A", parent=root, priority=1)
-        node_b = TestNode.objects.create(name="B", parent=root, priority=2)
-        node_c = TestNode.objects.create(name="C", parent=node_a, priority=1)
-        node_d = TestNode.objects.create(name="D", parent=node_a, priority=2)
-
-        original_tree = TestNode.get_tree()
-        tree_json = TestNode.get_tree_json()
-        tree_data = TestNode.load_tree_json(tree_json)
-
-        TestNode.objects.all().delete()
-        self.assertFalse(TestNode.objects.exists())
-
-        TestNode.load_tree(tree_data)
-        new_tree = TestNode.get_tree_json()
-
-        # ✅ Checking the integrity of the tree after all operations
-        self.assertEqual(root.check_tree_integrity(verbose=False), [])

django_fast_treenode-3.0.0/treenode/utils/db/sqlcompat.py

@@ -1,60 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Database compatibility extension module.
-
-Adapts SQL code to the specific features of SQL syntax of various
-Database vendors.
-
-Instead of direct concatenation:
-old: p._path || '.' || LPAD(...)
-new: SQLCompat.concat("p._path", "'.'", SQLCompat.lpad(...))
-
-Instead of TO_HEX(...)
-old: TO_HEX(...)
-new: SQLCompat.to_hex(...)
-
-Instead of LPAD(...)
-old: LPAD(...)
-new: SQLCompat.lpad(...)
-
-Version: 3.0.0
-Author: Timur Kady
-Email: timurkady@yandex.com
-"""
-
-from .db_vendor import is_mysql, is_mariadb, is_sqlite, is_mssql
-from ...settings import TREENODE_PAD_CHAR
-
-
-class SQLCompat:
-    """Vendor-Specific SQL Compatibility Layer."""
-
-    @staticmethod
-    def concat(*args):
-        """Adapt string concatenation to the vendor-specific syntax."""
-        args_joined = ", ".join(args)
-        if is_mysql() or is_mariadb():
-            return f"CONCAT({args_joined})"
-        elif is_mssql():
-            return " + ".join(args)
-        else:
-            return " || ".join(args)
-
-    @staticmethod
-    def to_hex(value):
-        """Convert integer to hexadecimal string."""
-        if is_sqlite():
-            return f"printf('%x', {value})"
-        else:
-            return f"TO_HEX({value})"
-
-    @staticmethod
-    def lpad(value, length, char=TREENODE_PAD_CHAR):
-        """Pad string to the specified length."""
-        if is_sqlite():
-            return (f"substr(replace(hex(zeroblob({length})), '00', {char}), "
-                    f"1, {length} - length({value})) || {value}")
-        else:
-            return f"LPAD({value}, {length}, {char})"
-
-# The End