django-fast-treenode 2.0.11__py3-none-any.whl → 2.1.1__py3-none-any.whl

treenode/admin/mixins.py

@@ -0,0 +1,302 @@
+# -*- coding: utf-8 -*-
+"""
+Views Mixin for TreeNodeAdminModel
+
+Version: 2.1.0
+Author: Timur Kady
+Email: kaduevtr@gmail.com
+"""
+
+import os
+from datetime import datetime
+from django.contrib import admin
+from django.contrib import messages
+from django.contrib.admin.helpers import ACTION_CHECKBOX_NAME
+from django.db import models
+from django.http import JsonResponse
+from django.shortcuts import render, redirect
+from django.shortcuts import resolve_url
+from django.template.loader import render_to_string
+from django.urls import path
+from django.utils.encoding import force_str
+from django.utils.safestring import mark_safe
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class AdminMixin(admin.ModelAdmin):
+    """Admin Mixin with views."""
+
+    def change_list_view(self, request):
+        """
+        View for lazy loading of child nodes.
+
+        Clicking the expand button sends an AJAX request to this view, which
+        returns JSON with the data of the selected node's immediate children.
+        All returned nodes are collapsed by default.
+        """
+        parent_id = request.GET.get("tn_parent_id")
+        if not parent_id:
+            # If there is no AJAX parameter, then it's normal work: show roots
+            return super().change_list_view(request)
+
+        parent = self.model.objects.filter(pk=parent_id).first()
+        if not parent:
+            # If there is no parent, return an empty response
+            return JsonResponse({'html': ''})
+
+        children = parent.get_children_queryset()
+
+        # We take list_display to understand which "columns" are needed
+        list_display = self.get_list_display(request)
+
+        # We collect future "rows"; each as a list of cells
+        rows = []
+        td_classes = []
+        for obj in children:
+            row_data = []
+            checkbox = mark_safe(
+                f'<input type="checkbox" name="{ACTION_CHECKBOX_NAME}"'
+                f' value="{obj.pk}" class="action-select" />'
+            )
+            row_data.append(checkbox)
+            td_classes.append("action-checkbox")
+            for field in list_display:
+                if callable(field):
+                    # If it is a method (drag, toggle, etc.), call
+                    row_data.append(field(obj))
+                    field_name = field.__name__
+                else:
+                    # If it is a string, we try to get the attribute from
+                    # the object
+                    value = getattr(obj, field, '')
+                    if callable(value):
+                        # If suddenly this is also a method
+                        # (for example, property), then call it
+                        value = value()
+                    row_data.append(value)
+                    field_name = field
+                td_classes.append(f"field-{field_name}")
+
+            row_info = {
+                "node_id": obj.pk,
+                "parent_id": parent_id,
+                "cells": zip(row_data, td_classes),
+            }
+            rows.append(row_info)
+
+        # Pass rows to the template
+        html = render_to_string(
+            'admin/treenode_ajax_rows.html',
+            {"rows": rows},
+            request=request
+        )
+
+        return JsonResponse({'html': html})
+
+    def search_view(self, request):
+        """View for finding nodes using get_list_display."""
+        # Get a search query
+        q = request.GET.get("q", "")
+
+        # Perform filtering with annotation to calculate the level
+        queryset = self.model.objects\
+            .annotate(cl_depth=models.Max("parents_set__depth"))\
+            .filter(name__icontains=q)
+        queryset_list = list(queryset)[:20]
+        sorted_list = self.model._sort_node_list(queryset_list)
+
+        # Get the set of columns as it is formed in change_list.
+        # The first two columns (drag and toggle) are not needed for searching,
+        # and the main display column is at index 2.
+        list_display = self.get_list_display(request)
+        display_func = list_display[2]
+
+        results = []
+        for node in sorted_list:
+            # Get the HTML display of the node via the function generated by
+            # get_list_display
+            display_html = display_func(node)
+            results.append({
+                "id": node.pk,
+                "text": display_html,
+                "level": node.cl_depth,
+                "is_leaf": node.is_leaf(),
+            })
+
+        return JsonResponse({"results": results})
+
+    def import_view(self, request):
+        """
+        Import View.
+
+        File upload processing, auto-detection of format, validation and data
+        import.
+        """
+        if not self.import_export:
+            self.message_user(
+                request,
+                "Import functionality is disabled because required \
+packages are not installed."
+            )
+            return redirect("..")
+
+        if request.method == 'POST':
+            if 'file' not in request.FILES:
+                return render(
+                    request,
+                    "admin/tree_node_import.html",
+                    {"errors": ["No file uploaded."]}
+                )
+
+            file = request.FILES['file']
+            ext = os.path.splitext(file.name)[-1].lower().strip(".")
+
+            allowed_formats = {"csv", "json", "xlsx", "yaml", "tsv"}
+            if ext not in allowed_formats:
+                return render(
+                    request,
+                    "admin/tree_node_import.html",
+                    {"errors": [f"Unsupported file format: {ext}"]}
+                )
+
+            # Import data from file
+            importer = self.TreeNodeImporter(self.model, file, ext)
+            raw_data = importer.import_data()
+            clean_result = importer.finalize(raw_data)
+
+            errors = clean_result.get("errors", [])
+            created_count = len(clean_result.get("create", []))
+            updated_count = len(clean_result.get("update", []))
+
+            if errors:
+                return render(
+                    request,
+                    "admin/tree_node_import_report.html",
+                    {
+                        "errors": errors,
+                        "created_count": created_count,
+                        "updated_count": updated_count,
+                    }
+                )
+
+            # If there are no errors, redirect to the list of objects with
+            # a message
+            messages.success(
+                request,
+                f"Successfully imported {created_count} records. "
+                f"Successfully updated {updated_count} records."
+            )
+
+            app_label = self.model._meta.app_label
+            model_name = self.model._meta.model_name
+            admin_changelist_url = f"admin:{app_label}_{model_name}_changelist"
+            path = resolve_url(admin_changelist_url) + "?import_done=1"
+            return redirect(path)
+
+        # If the request is not POST, simply display the import form
+        return render(request, "admin/tree_node_import.html")
+
+    def export_view(self, request):
+        """
+        Export view.
+
+        - If the GET parameters include download, we send the file directly.
+        - If the format parameter is missing, we render the format selection
+          page.
+        - If the format is specified, we perform a test export to catch errors.
+
+        If there are no errors, we render the success page with a message, a
+        link for manual download,
+        and a button to go to the model page.
+        """
+        if not self.import_export:
+            self.message_user(
+                request,
+                "Export functionality is disabled because required \
+packages are not installed."
+            )
+            return redirect("..")
+
+        # If the download parameter is present, we give the file directly
+        if 'download' in request.GET:
+            # Get file format
+            export_format = request.GET.get('format', 'csv')
+            # Filename
+            now = force_str(datetime.now().strftime("%Y-%m-%d %H-%M"))
+            filename = self.model._meta.label + " " + now
+            # Init
+            exporter = self.TreeNodeExporter(
+                self.get_queryset(request),
+                filename=filename
+            )
+            # Export working
+            response = exporter.export(export_format)
+            logger.debug("DEBUG: File response generated.")
+            return response
+
+        # If the format parameter is not passed, we show the format
+        # selection page
+        if 'format' not in request.GET:
+            return render(request, "admin/tree_node_export.html")
+
+        # If the format is specified, we try to perform a test export
+        # (without returning the file)
+        export_format = request.GET['format']
+        exporter = self.TreeNodeExporter(
+            self.model.objects.all(),
+            filename=self.model._meta.model_name
+        )
+        try:
+            # Test call to check for export errors (result not used)
+            exporter.export(export_format)
+        except Exception as e:
+            logger.error("Error during test export: %s", e)
+            errors = [str(e)]
+            return render(
+                request,
+                "admin/tree_node_export.html",
+                {"errors": errors}
+            )
+
+        # Form the correct download URL. If the URL already contains
+        # parameters, add them via &download=1, otherwise via ?download=1
+        current_url = request.build_absolute_uri()
+        if "?" in current_url:
+            download_url = current_url + "&download=1"
+        else:
+            download_url = current_url + "?download=1"
+
+        context = {
+            "download_url": download_url,
+            "message": "Your file is ready for export. \
+The download should start automatically.",
+            "manual_download_label": "If the download does not start, \
+click this link.",
+            # Can be replaced with the desired URL to return to the model
+            "redirect_url": "../",
+            "button_text": "Return to model"
+        }
+        return render(request, "admin/export_success.html", context)
+
+    def get_urls(self):
+        """
+        Extend admin URLs with custom import/export routes.
+
+        Register these URLs only if all the required packages are installed.
+        """
+        urls = super().get_urls()
+        if self.import_export:
+            custom_urls = [
+                path('change_list/', self.change_list_view, name='change_list'),
+                path('search/', self.search_view, name='search'),
+                path('import/', self.import_view, name='tree_node_import'),
+                path('export/', self.export_view, name='tree_node_export'),
+            ]
+        else:
+            custom_urls = []
+        return custom_urls + urls
+
+# The End

treenode/apps.py

@@ -5,13 +5,17 @@ TreeNode Application Configuration
 This module defines the application configuration for the TreeNode app.
 It sets the default auto field and specifies the app's name.
 
-Version: 2.0.0
+Version: 2.1.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
 
+import logging
 from django.apps import AppConfig
+from django.db.models.signals import post_migrate
+
+logger = logging.getLogger(__name__)
 
 
 class TreeNodeConfig(AppConfig):
@@ -20,4 +24,11 @@ class TreeNodeConfig(AppConfig):
     default_auto_field = "django.db.models.BigAutoField"
     name = "treenode"
 
+    def ready(self):
+        """
+        Attach a post_migrate handler.
 
+        This allows you to perform operations after the migration is complete.
+        """
+        from .utils.db import post_migrate_update
+        post_migrate.connect(post_migrate_update, sender=self)

treenode/cache.py

@@ -212,8 +212,8 @@ def cached_method(func):
             label,
             func.__name__,
             unique_id,
-            args,
-            kwargs
+            *args,
+            **kwargs
         )
 
         # Retrieving from cache

treenode/forms.py

@@ -10,13 +10,12 @@ Functions:
 - __init__: Initializes the form and filters out invalid parent choices.
 - factory: Dynamically creates a form class for a given TreeNode model.
 
-Version: 2.0.11
+Version: 2.1.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
 from django import forms
-import numpy as np
 from django.forms.models import ModelChoiceField, ModelChoiceIterator
 from django.utils.translation import gettext_lazy as _
 
@@ -29,13 +28,12 @@ class SortedModelChoiceIterator(ModelChoiceIterator):
     def __iter__(self):
         """Return sorted choices based on tn_order."""
         qs_list = list(self.queryset.all())
-        # Sort objects by their tn_order using NumPy.
-        tn_orders = np.array([obj.tn_order for obj in qs_list])
-        sorted_indices = np.argsort(tn_orders)
-        # Iterate over sorted indices and yield (value, label) pairs.
-        for idx in sorted_indices:
-            # Cast the index to int if it is numpy.int64.
-            obj = qs_list[int(idx)]
+
+        # Sort objects
+        sorted_objects = self.queryset.model._sort_node_list(qs_list)
+
+        # Iterate yield (value, label) pairs.
+        for obj in sorted_objects:
             yield (
                 self.field.prepare_value(obj),
                 self.field.label_from_instance(obj)
@@ -100,7 +98,7 @@ class TreeNodeForm(forms.ModelForm):
             )
             self.fields["tn_parent"].widget.model = queryset.model
 
-            # Если есть текущее значение, устанавливаем его
+            # If there is a current value, set it
             if self.instance and self.instance.pk and self.instance.tn_parent:
                 self.fields["tn_parent"].initial = self.instance.tn_parent
 

treenode/managers/__init__.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""
+Managers and QuerySets
+
+This module defines custom managers and query sets for the TreeNode model.
+It includes optimized bulk operations for handling hierarchical data
+using the Closure Table approach.
+
+Features:
+- `ClosureModelManager` for managing closure records.
+- `TreeNodeModelManager` for adjacency model operations.
+
+Version: 2.1.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+from .closure import ClosureModelManager
+from .adjacency import TreeNodeModelManager
+
+__all__ = ["TreeNodeModelManager", "ClosureModelManager"]

treenode/managers/adjacency.py

@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+"""
+Adjacency List Manager and QuerySet
+
+This module defines custom managers and query sets for the Adjacency List.
+It includes operations for synchronizing with the model implementing
+the Closure Table.
+
+Version: 2.1.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+from collections import deque, defaultdict
+from django.db import models, transaction
+from django.db import connection
+
+
+class TreeNodeQuerySet(models.QuerySet):
+    """TreeNodeModel QuerySet."""
+
+    def __init__(self, model=None, query=None, using=None, hints=None):
+        # First we call the parent class constructor
+        super().__init__(model, query, using, hints)
+
+    def create(self, **kwargs):
+        """Ensure that the save logic is executed when using create."""
+        obj = self.model(**kwargs)
+        obj.save()
+        return obj
+
+    def update(self, **kwargs):
+        """Update node with synchronization of tn_parent change."""
+        tn_parent_changed = 'tn_parent' in kwargs
+        # Save pks of updated objects
+        pks = list(self.values_list('pk', flat=True))
+        # Clone the query and clear the ordering to avoid an aggregation error
+        qs = self._clone()
+        qs.query.clear_ordering()
+        result = super(TreeNodeQuerySet, qs).update(**kwargs)
+        if tn_parent_changed and pks:
+            objs = list(self.model.objects.filter(pk__in=pks))
+            self.model.closure_model.objects.bulk_update(objs, ['tn_parent'])
+        return result
+
+    def get_or_create(self, defaults=None, **kwargs):
+        """Ensure that the save logic is executed when using get_or_create."""
+        defaults = defaults or {}
+        created = False
+        obj = self.filter(**kwargs).first()
+        if obj is None:
+            params = {k: v for k, v in kwargs.items() if "__" not in k}
+            params.update(
+                {k: v() if callable(v) else v for k, v in defaults.items()}
+            )
+            obj = self.create(**params)
+            created = True
+        return obj, created
+
+    def update_or_create(self, defaults=None, create_defaults=None, **kwargs):
+        """Update or create."""
+        defaults = defaults or {}
+        create_defaults = create_defaults or {}
+
+        with transaction.atomic():
+            obj = self.filter(**kwargs).first()
+            params = {k: v for k, v in kwargs.items() if "__" not in k}
+            if obj is None:
+                params.update({k: v() if callable(v) else v for k,
+                              v in create_defaults.items()})
+                obj = self.create(**params)
+                created = True
+            else:
+                params.update(
+                    {k: v() if callable(v) else v for k, v in defaults.items()})
+                for field, value in params.items():
+                    setattr(obj, field, value)
+                obj.save(update_fields=params.keys())
+                created = False
+        return obj, created
+
+    def bulk_create(self, objs, batch_size=1000, *args, **kwargs):
+        """
+        Bulk create.
+
+        Method of bulk creation objects with updating and processing of
+        the Closuse Model.
+        """
+        # 1. Bulk Insertion of Nodes in Adjacency Models
+        objs = super().bulk_create(objs, batch_size, *args, **kwargs)
+        # 2. Synchronization of the Closing Model
+        self.model.closure_model.objects.bulk_create(objs)
+        # 3. Clear cache and return result
+        self.model.clear_cache()
+        return objs
+
+    def bulk_update(self, objs, fields, batch_size=1000):
+        """Bulk update with synchronization of tn_parent change."""
+        # Clone the query and clear the ordering to avoid an aggregation error
+        qs = self._clone()
+        qs.query.clear_ordering()
+        # Perform an Adjacency Model Update
+        result = super(TreeNodeQuerySet, qs).bulk_update(
+            objs, fields, batch_size
+        )
+        # Synchronize data in the Closing Model
+        if 'tn_parent' in fields:
+            self.model.closure_model.objects.bulk_update(
+                objs, ['tn_parent'], batch_size
+            )
+        return result
+
+
+class TreeNodeModelManager(models.Manager):
+    """TreeNodeModel Manager."""
+
+    def bulk_create(self, objs, batch_size=1000, ignore_conflicts=False):
+        """
+        Bulk Create.
+
+        Override bulk_create for the adjacency model.
+        Here we first clear the cache, then delegate the creation via our
+        custom QuerySet.
+        """
+        self.model.clear_cache()
+        result = self.get_queryset().bulk_create(
+            objs, batch_size=batch_size, ignore_conflicts=ignore_conflicts
+        )
+        transaction.on_commit(lambda: self._update_auto_increment())
+        return result
+
+    def bulk_update(self, objs, fields=None, batch_size=1000):
+        """Bulk Update."""
+        self.model.clear_cache()
+        result = self.get_queryset().bulk_update(objs, fields, batch_size)
+        return result
+
+    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
+
+    # Service methods -------------------
+
+    def _bulk_update_tn_closure(self, objs, fields=None, batch_size=1000):
+        """Update tn_closure in bulk."""
+        self.model.clear_cache()
+        super().bulk_update(objs, fields, batch_size)
+
+    def _get_auto_increment_sequence(self):
+        """Get auto increment sequence."""
+        table_name = self.model._meta.db_table
+        pk_column = self.model._meta.pk.column
+        with connection.cursor() as cursor:
+            query = "SELECT pg_get_serial_sequence(%s, %s)"
+            cursor.execute(query, [table_name, pk_column])
+            result = cursor.fetchone()
+        return result[0] if result else None
+
+    def _update_auto_increment(self):
+        """Update auto increment."""
+        table_name = self.model._meta.db_table
+        with connection.cursor() as cursor:
+            db_engine = connection.vendor
+
+            if db_engine == "postgresql":
+                sequence_name = self._get_auto_increment_sequence()
+                # Get the max id from the table
+                cursor.execute(
+                    f"SELECT COALESCE(MAX(id), 0) FROM {table_name};"
+                )
+                max_id = cursor.fetchone()[0]
+                next_id = max_id + 1
+                # Directly specify the next value of the sequence
+                cursor.execute(
+                    f"ALTER SEQUENCE {sequence_name} RESTART WITH {next_id};"
+                )
+            elif db_engine == "mysql":
+                cursor.execute(f"SELECT MAX(id) FROM {table_name};")
+                max_id = cursor.fetchone()[0] or 0
+                next_id = max_id + 1
+                cursor.execute(
+                    f"ALTER TABLE {table_name} AUTO_INCREMENT = {next_id};"
+                )
+            elif db_engine == "sqlite":
+                cursor.execute(
+                    f"UPDATE sqlite_sequence SET seq = (SELECT MAX(id) \
+FROM {table_name}) WHERE name='{table_name}';"
+                )
+            elif db_engine == "mssql":
+                cursor.execute(f"SELECT MAX(id) FROM {table_name};")
+                max_id = cursor.fetchone()[0] or 0
+                cursor.execute(
+                    f"DBCC CHECKIDENT ('{table_name}', RESEED, {max_id});"
+                )
+            else:
+                raise NotImplementedError(
+                    f"Autoincrement for {db_engine} is not supported."
+                )
+
+# The End