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

treenode/templates/admin/treenode_rows.html

@@ -0,0 +1,57 @@
+{% load i18n %}
+
+<div class="results">
+  <table id="result_list">
+
+
+<thead>
+  <tr>
+    {% for h in headers %}
+      <th scope="col"{{ h.class_attrib|safe }}>
+        {% if "action-checkbox-column" in h.class_attrib %}
+          <div class="text">
+            <span>
+              <input type="checkbox" id="action-toggle" aria-label="{% translate 'Select all objects on this page for an action' %}">
+            </span>
+          </div>
+          <div class="clear"></div>
+        {% else %}
+          {% if h.sortable %}
+            <div class="sortoptions">
+              {% if h.url_remove %}
+                <a class="sortremove" href="{{ h.url_remove }}" title="{% translate 'Remove from sorting' %}"></a>
+              {% endif %}
+              {% if h.url_toggle %}
+                <a href="{{ h.url_toggle }}" class="toggle {% if h.ascending %}ascending{% else %}descending{% endif %}" title="{% translate 'Toggle sorting' %}"></a>
+              {% endif %}
+            </div>
+          {% else %}
+            <div class="sortoptions"></div>
+          {% endif %}
+
+          <div class="text">
+            {% if h.sortable %}
+              <a href="{{ h.url_primary }}">{{ h.text|safe }}</a>
+            {% else %}
+              <a href="#">{{ h.text|safe }}</a>
+            {% endif %}
+          </div>
+          <div class="clear"></div>
+        {% endif %}
+      </th>
+    {% endfor %}
+  </tr>
+</thead>
+
+
+    <tbody>
+      {% for row in rows %}
+        <tr {{ row.attrs|safe }}>
+          {% for cell in row.cells %}
+            {{ cell }}
+          {% endfor %}
+        </tr>
+      {% endfor %}
+    </tbody>
+  </table>
+</div>

treenode/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

treenode/urls.py

@@ -1,38 +1,17 @@
 # -*- coding: utf-8 -*-
 """
-TreeNode URL Configuration
+TreeNode URLs Module.
 
-This module defines URL patterns for handling AJAX requests related
-to tree-structured data in Django. It includes endpoints for Select2
-autocomplete and retrieving child node counts.
-
-Routes:
-- `tree-autocomplete/`: Returns JSON data for Select2 hierarchical selection.
-- `get-children-count/`: Retrieves the number of children for a given
-  parent node.
-
-Version: 2.1.0
+Version: 3.0.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
+from .views import AutoTreeAPI
 
-from django.urls import path
-from .views import TreeNodeAutocompleteView, ChildrenView
+app_name = "treenode"
 
-urlpatterns = [
-    path(
-        "tree-autocomplete/",
-        TreeNodeAutocompleteView.as_view(),
-        name="tree_autocomplete"
-    ),
 
-    path(
-        "tree-children/",
-        ChildrenView.as_view(),
-        name="tree_children"
-    ),
+urlpatterns = [
+    *AutoTreeAPI().discover(),
 ]
-
-
-# The End

treenode/utils/__init__.py

@@ -1,15 +0,0 @@
-import importlib
-
-extra = all([
-            importlib.util.find_spec(pkg) is not None
-            for pkg in ["openpyxl", "yaml", "xlsxwriter"]
-        ])
-
-if extra:
-    from .exporter import TreeNodeExporter
-    from .importer import TreeNodeImporter
-    __all__ = ["TreeNodeExporter", "TreeNodeImporter"]
-else:
-    __all__ = []
-
-# The End

treenode/utils/db/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+from .service import ModelSQLService
+from .sqlquery import SQLQueue
+from .sqlcompat import SQLCompat
+from .compiler import TreePathCompiler
+
+__all__ = ['ModelSQLService', 'SQLQueue', 'SQLCompat', 'TreePathCompiler']

treenode/utils/db/compiler.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+"""
+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
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+from django.db import connection
+
+from ...settings import SEGMENT_LENGTH
+from .sqlcompat import SQLCompat
+
+
+class TreePathCompiler:
+    """
+    Tree Task compiler class.
+
+    Efficient, ORM-free computation of _path, _depth and priority
+    for tree structures based on Materialized Path.
+    """
+
+    @classmethod
+    def update_path(cls, model, parent_id=None):
+        """
+        Rebuild subtree starting from parent_id.
+
+        If parent_id=None, then the whole tree is rebuilt.
+        Uses only fields: parent_id and id. All others (priority, _path,
+        _depth) are recalculated.
+        """
+        db_table = model._meta.db_table
+
+        sorting_field = model.sorting_field
+        sorting_fields = ["priority", "id"] if sorting_field == "priority" else [sorting_field]  # noqa: D501
+        sort_expr = ", ".join([
+            f"c.{field}" if "." not in field else field
+            for field in sorting_fields
+        ])
+
+        cte_header = "(id, parent_id, new_priority, new_path, new_depth)"
+
+        row_number_expr = "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'")
+
+        if parent_id is None:
+            new_path_expr = lpad_expr
+            base_sql = f"""
+                SELECT
+                    c.id,
+                    c.parent_id,
+                    {row_number_expr} AS new_priority,
+                    {new_path_expr} AS new_path,
+                    0 AS new_depth
+                FROM {db_table} AS c
+                WHERE c.parent_id IS NULL
+            """
+            params = []
+        else:
+            path_expr = SQLCompat.concat("p._path", "'.'", lpad_expr)
+            base_sql = f"""
+                SELECT
+                    c.id,
+                    c.parent_id,
+                    {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
+                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_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_sql = f"""
+            SELECT
+                c.id,
+                c.parent_id,
+                {recursive_row_number_expr} AS new_priority,
+                {recursive_path_expr} AS new_path,
+                t.new_depth + 1 AS new_depth
+            FROM {db_table} 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;
+        """
+
+        with connection.cursor() as cursor:
+            cursor.execute(final_sql.format(sort_expr=sort_expr), params)
+
+
+# The End

treenode/utils/db/db_vendor.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+"""
+API-First Support Module.
+
+CRUD and Tree Operations for TreeNode models.
+
+Version: 3.0.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+
+from django.db import connection
+
+_vendor = connection.vendor.lower()
+
+
+def is_postgresql():
+    """Return True if DB is PostgreSQL."""
+    return _vendor == "postgresql"
+
+
+def is_mysql():
+    """Return True if DB is MySQL."""
+    return _vendor == "mysql"
+
+
+def is_mariadb():
+    """Return True if DB is MariaDB."""
+    return _vendor == "mariadb"
+
+
+def is_sqlite():
+    """Return True if DB is SQLite."""
+    return _vendor == "sqlite"
+
+
+def is_oracle():
+    """Return True if DB is Oracle."""
+    return _vendor == "oracle"
+
+
+def is_mssql():
+    """Return True if DB is Microsoft SQL Server."""
+    return _vendor in ("microsoft", "mssql")
+
+
+def get_vendor():
+    """Return DB vendor."""
+    return _vendor

treenode/utils/db/service.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+"""
+DB Vendor Utility Module
+
+The module contains utilities related to optimizing the application's operation
+with various types of Databases.
+
+Version: 3.0.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+from __future__ import annotations
+from django.db import models, connection
+
+
+class SQLService:
+    """SQL utility class bound to a specific model."""
+
+    def __init__(self, model):
+        """Init."""
+        self.db_vendor = connection.vendor
+        self.model = model
+        self.table = model._meta.db_table
+
+    def get_next_id(self):
+        """Reliably get the next ID for this model on different DBMS."""
+        if self.db_vendor == 'postgresql':
+            seq_name = f"{self.table}_id_seq"
+            with connection.cursor() as cursor:
+                cursor.execute(f"SELECT nextval('{seq_name}')")
+                return cursor.fetchone()[0]
+
+        elif self.db_vendor == 'oracle':
+            seq_name = f"{self.table}_SEQ"
+            with connection.cursor() as cursor:
+                try:
+                    cursor.execute(f"SELECT {seq_name}.NEXTVAL FROM DUAL")
+                    return cursor.fetchone()[0]
+                except Exception:
+                    cursor.execute(
+                        f"CREATE SEQUENCE {seq_name} START WITH 1 INCREMENT BY 1"
+                    )
+                    cursor.execute(f"SELECT {seq_name}.NEXTVAL FROM DUAL")
+                    return cursor.fetchone()[0]
+
+        elif self.db_vendor in ('sqlite', 'mysql'):
+            with connection.cursor() as cursor:
+                cursor.execute(f"SELECT MAX(id) FROM {self.table}")
+                row = cursor.fetchone()
+                return (row[0] or 0) + 1
+
+        else:
+            raise NotImplementedError(
+                f"get_next_id() not supported for DB vendor '{self.db_vendor}'")
+
+    def reassign_children(self, old_parent_id, new_parent_id):
+        """Set new parent to children."""
+        sql = f"""
+            UPDATE {self.table}
+            SET parent_id = %s
+            WHERE parent_id = %s
+        """
+        with connection.cursor() as cursor:
+            cursor.execute(sql, [new_parent_id, old_parent_id])
+
+
+class ModelSQLService:
+    """
+    Decorate SQLService.
+
+    Descriptor to bind SQLService to Django models via
+    `db = ModelSQLService()`.
+    """
+
+    def __set_name__(self, owner, name):
+        """Set name."""
+        self.model = owner
+
+    def __get__(self, instance, owner):
+        """Get SQLService."""
+        return SQLService(owner)
+
+# The End

treenode/utils/db/sqlcompat.py

@@ -0,0 +1,60 @@
+# -*- 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

treenode/utils/db/sqlquery.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+"""
+SQL Queue Class.
+
+SQL query queue supporting Query and (sql, params).
+
+Version: 3.0.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+
+from __future__ import annotations
+from django.db import connections, connection, DEFAULT_DB_ALIAS
+from typing import Union, Tuple, List
+from django.db.models.sql import Query
+
+
+class SQLQueue:
+    """SQL Queue Class."""
+
+    def __init__(self, using: str = DEFAULT_DB_ALIAS):
+        """Init Queue."""
+        self.using = using
+        self._items: List[Tuple[str, list]] = []
+
+    def append(self, item: Union[Query, Tuple[str, list]]):
+        """
+        Add a query to the queue.
+
+        Supports:
+        - Django Query: model.objects.filter(...).query
+        - tuple (sql, params)
+        """
+        if isinstance(item, tuple):
+            sql, params = item
+            if not isinstance(sql, str) or not isinstance(params, (list, tuple)):  # noqa: D501
+                raise TypeError("Ожидается (sql: str, params: list | tuple)")
+            self._items.append((sql, list(params)))
+
+        elif isinstance(item, Query):
+            sql, params = item.as_sql(connection)
+            self._items.append((sql, params))
+
+        else:
+            raise TypeError("Expected either Query or (sql, params)")
+
+    def flush(self):
+        """
+        Execute all requests from the queue and clear it.
+
+        flush() is called manually.
+        """
+        if not self._items:
+            return
+
+        # print("sqlq: ", self._items)
+
+        conn = connections[self.using]
+        with conn.cursor() as cursor:
+            for sql, params in self._items:
+                try:
+                    cursor.execute(sql, params)
+                except Exception as e:
+                    print(">>> SQLQueue error:", e)
+                    raise
+        self._items.clear()
+
+
+# The End

treenode/version.py

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

treenode/views/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# from .crud import *
+from .autoapi import AutoTreeAPI
+
+__all__ = ['AutoTreeAPI']

treenode/views/autoapi.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+"""
+Route generator for all models inherited from TreeNodeModel
+
+Version: 3.0.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+
+from django.apps import apps
+from django.urls import path
+from django.conf import settings
+from django.contrib.auth.decorators import login_required
+
+from ..models import TreeNodeModel
+from .autocomplete import TreeNodeAutocompleteView
+from .children import TreeChildrenView
+from .search import TreeSearchView
+from .crud import TreeNodeBaseAPIView
+
+
+class AutoTreeAPI:
+    """Auto-discover and expose TreeNode-based APIs."""
+
+    def __init__(self, base_view=TreeNodeBaseAPIView, base_url="api"):
+        """Init auto-discover."""
+        self.base_view = base_view
+        self.base_url = base_url
+
+    def protect_view(self, view, model):
+        """
+        Protect view.
+
+        Protects view with login_required if needed, based on model attribute
+        or global settings.
+        """
+        if getattr(model, 'api_login_required', None) is True:
+            return login_required(view)
+        if getattr(settings, 'TREENODE_API_LOGIN_REQUIRED', False):
+            return login_required(view)
+        return view
+
+    def discover(self):
+        """Scan models and generate API urls."""
+        urls = [
+            # Admin and Widget end-points
+            path("widget/autocomplete/", TreeNodeAutocompleteView.as_view(), name="tree_autocomplete"),  # noqa: D501
+            path("widget/children/", TreeChildrenView.as_view(), name="tree_children"),  # noqa: D501
+            path("widget/search/", TreeSearchView.as_view(), name="tree_search"),  # noqa: D501
+        ]
+        for model in apps.get_models():
+            if issubclass(model, TreeNodeModel) and model is not TreeNodeModel:
+                model_name = model._meta.model_name
+
+                # Dynamically create an API view class for the model
+                api_view_class = type(
+                    f"{model_name.capitalize()}APIView",
+                    (self.base_view,),
+                    {"model": model}
+                )
+
+                # List of API actions and their corresponding URL patterns
+                action_patterns = [
+                    # List / Create
+                    ("", None, f"{model_name}-list"),
+                    # Retrieve / Update / Delete
+                    ("<int:pk>/", None, f"{model_name}-detail"),
+                    ("tree/", {'action': 'tree'}, f"{model_name}-tree"),
+                    # Direct children
+                    ("<int:pk>/children/", {'action': 'children'}, f"{model_name}-children"),  # noqa: D501
+                    # All descendants
+                    ("<int:pk>/descendants/", {'action': 'descendants'}, f"{model_name}-descendants"),   # noqa: D501
+                    # Ancestors + Self + Descendants
+                    ("<int:pk>/family/", {'action': 'family'}, f"{model_name}-family"),   # noqa: D501
+                ]
+
+                # Create secured view instance once
+                view = self.protect_view(api_view_class.as_view(), model)
+
+                # Automatically build all paths for this model
+                for url_suffix, extra_kwargs, route_name in action_patterns:
+                    urls.append(
+                        path(
+                            f"{self.base_url}/{model_name}/{url_suffix}",
+                            view,
+                            extra_kwargs or {},
+                            name=route_name
+                        )
+                    )
+        return urls

treenode/views/autocomplete.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+"""
+
+
+Handles autocomplete suggestions for TreeNode models.
+
+Version: 3.0.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+# autocomplete.py
+from django.http import JsonResponse
+from django.views import View
+from django.contrib.admin.views.decorators import staff_member_required
+from django.utils.decorators import method_decorator
+
+from .common import get_model_from_request
+
+
+@method_decorator(staff_member_required, name='dispatch')
+class TreeNodeAutocompleteView(View):
+    """Widget Autocomplete View."""
+
+    def get(self, request, *args, **kwargs):
+        """Get request."""
+        select_id = request.GET.get("select_id", "").strip()
+        q = request.GET.get("q", "").strip()
+
+        model = get_model_from_request(request)
+        results = []
+
+        if q:
+            field = getattr(model, "display_field", "id")
+            queryset = model.objects.filter(**{f"{field}__icontains": q})
+        elif select_id:
+            pk = int(select_id)
+            queryset = model.objects.filter(pk=pk)
+        else:
+            queryset = model.objects.filter(parent__isnull=True)
+
+        results = [
+            {
+                "id": obj.pk,
+                "text": str(obj),
+                "level": obj.get_depth(),
+                "is_leaf": obj.is_leaf(),
+            }
+            for obj in queryset[:20]
+        ]
+
+        return JsonResponse({"results": results})