django-fast-treenode 2.0.10__py3-none-any.whl → 2.1.0__py3-none-any.whl

treenode/utils/db.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+"""
+DB Vendor Utility Module
+
+This module provides a utility function for converting integers
+to Base36 string representation.
+
+Features:
+- Converts integers into a more compact Base36 format.
+- Maintains lexicographic order when padded with leading zeros.
+- Supports negative numbers.
+
+Version: 2.1.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+import logging
+from django.apps import apps
+from django.db import connection
+
+from ..models import TreeNodeModel
+
+logger = logging.getLogger(__name__)
+
+
+def create_indexes(model):
+    """Create indexes for the descendants of TreeNodeModel."""
+    vendor = connection.vendor
+    sender = "Django Fast TeeNode"
+    table = model._meta.db_table
+
+    with connection.cursor() as cursor:
+        if vendor == "postgresql":
+            cursor.execute(
+                "SELECT indexname FROM pg_indexes WHERE tablename = %s AND indexname = %s;",
+                [table, f"idx_{table}_btree"]
+            )
+            if not cursor.fetchone():
+                cursor.execute(
+                    f"CREATE INDEX idx_{table}_btree ON {table} USING BTREE (id);"
+                )
+                logger.info(f"{sender}: GIN index for table {table} created.")
+
+            # Если существует первичный ключ, выполняем кластеризацию
+            cursor.execute(
+                "SELECT relname FROM pg_class WHERE relname = %s;",
+                [f"{table}_pkey"]
+            )
+            if cursor.fetchone():
+                cursor.execute(f"CLUSTER {table} USING {table}_pkey;")
+                logger.info(f"{sender}: Table {table} is clustered.")
+
+        elif vendor == "mysql":
+            cursor.execute("SHOW TABLE STATUS WHERE Name = %s;", [table])
+            columns = [col[0] for col in cursor.description]
+            row = cursor.fetchone()
+            if row:
+                table_status = dict(zip(columns, row))
+                engine = table_status.get("Engine", "").lower()
+                if engine != "innodb":
+                    cursor.execute(f"ALTER TABLE {table} ENGINE = InnoDB;")
+                    logger.info(
+                        f"{sender}: Table {table} has been converted to InnoDB."
+                    )
+
+        elif vendor in ["microsoft", "oracle"]:
+            if vendor == "microsoft":
+                cursor.execute(
+                    "SELECT name FROM sys.indexes WHERE name = %s AND object_id = OBJECT_ID(%s);",
+                    [f"idx_{table}_cluster", table]
+                )
+            else:
+                cursor.execute(
+                    "SELECT index_name FROM user_indexes WHERE index_name = %s;",
+                    [f"IDX_{table.upper()}_CLUSTER"]
+                )
+            if not cursor.fetchone():
+                cursor.execute(
+                    f"CREATE CLUSTERED INDEX idx_{table}_cluster ON {table} (id);")
+                logger.info(
+                    f"{sender}: CLUSTERED index for table {table} created."
+                )
+
+        elif vendor == "sqlite":
+            # Kick those on SQLite
+            logger.warning(
+                f"{sender} Unable to create GIN and CLUSTER indexes for SQLite."
+            )
+        else:
+            logger.warning(
+                f"{sender}: Unknown vendor. Index creation cancelled."
+            )
+
+
+def post_migrate_update(sender, **kwargs):
+    """Update indexes and tn_closure field only when necessary."""
+    # Перебираем все зарегистрированные модели
+    for model in apps.get_models():
+        # Check that the model inherits from TreeNodeModel and
+        # is not abstract
+        if issubclass(model, TreeNodeModel) and not model._meta.abstract:
+            # Create GIN and CLUSTER indexrs
+            create_indexes(model)
+            # Get ClosureModel
+            closure_model = model.closure_model
+            # Check node counts
+            al_count = model.objects.exists()
+            cl_counts = closure_model.objects.exclude(node=None).exists()
+
+            if al_count and not cl_counts:
+                # Call update_tree()
+                model.update_tree()
+
+
+# The End

treenode/utils/exporter.py

@@ -12,7 +12,7 @@ Features:
 - Provides optimized data extraction for QuerySets.
 - Generates downloadable files with appropriate HTTP responses.
 
-Version: 2.0.10
+Version: 2.0.11
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
@@ -23,6 +23,7 @@ import json
 import yaml
 import xlsxwriter
 import numpy as np
+import uuid
 from io import BytesIO
 from django.http import HttpResponse
 import logging
@@ -43,6 +44,7 @@ class TreeNodeExporter:
         self.queryset = queryset
         self.filename = filename
         self.fields = [field.name for field in queryset.model._meta.fields]
+        self.fields = self.get_ordered_fields()
 
     def export(self, format):
         """Determine the export format and calls the corresponding method."""
@@ -60,7 +62,9 @@ class TreeNodeExporter:
     def process_complex_fields(self, record):
         """Convert complex fields (lists, dictionaries) into JSON strings."""
         for key, value in record.items():
-            if isinstance(value, (list, dict)):
+            if isinstance(value, uuid.UUID):
+                record[key] = str(value)
+            elif isinstance(value, (list, dict)):
                 try:
                     record[key] = json.dumps(value, ensure_ascii=False)
                 except Exception as e:
@@ -68,11 +72,24 @@ class TreeNodeExporter:
                     record[key] = None
         return record
 
+    def get_ordered_fields(self):
+        """Return fields in the desired order.
+
+        Order: id, tn_parent, tn_priority, then the rest.
+        """
+        required_fields = ["id", "tn_parent", "tn_priority"]
+        other_fields = [
+            field for field in self.fields if field not in required_fields]
+        return required_fields + other_fields
+
     def get_sorted_queryset(self):
-        """Sort queryset by tn_order."""
-        queryset_list = list(self.queryset)
-        tn_orders = np.array([obj.tn_order for obj in queryset_list])
-        return [queryset_list[int(i)] for i in np.argsort(tn_orders)]
+        """Quick sort queryset by tn_order."""
+        queryset = self.queryset
+        tn_orders = np.array([obj.tn_order for obj in queryset])
+        sorted_indices = np.argsort(tn_orders)
+        queryset_list = list(queryset.iterator())
+        result = [queryset_list[int(idx)] for idx in sorted_indices]
+        return result
 
     def get_data(self):
         """Return a list of data from QuerySet as dictionaries."""
@@ -100,70 +117,80 @@ class TreeNodeExporter:
         return data
 
     def to_csv(self):
-        """Export to CSV with proper attachment handling."""
-        response = HttpResponse(content_type="text/csv")
+        """Export to CSV with proper UTF-8 encoding."""
+        response = HttpResponse(content_type="text/csv; charset=utf-8")
         response["Content-Disposition"] = f'attachment; filename="{self.filename}.csv"'
+        response.write("\ufeff")  # Добавляем BOM для Excel
+
         writer = csv.DictWriter(response, fieldnames=self.fields)
         writer.writeheader()
-        writer.writerows(self.get_data())
+        for row in self.get_data():
+            writer.writerow({key: str(value)
+                            for key, value in row.items()})  # Приводим к строкам
+
         return response
 
     def to_json(self):
-        """Export to JSON with UUID serialization handling."""
-        response = HttpResponse(content_type="application/octet-stream")
+        """Export to JSON with proper UTF-8 encoding."""
+        response = HttpResponse(content_type="application/json; charset=utf-8")
         response["Content-Disposition"] = f'attachment; filename="{self.filename}.json"'
-        json.dump(
-            self.get_data(),
-            response,
-            ensure_ascii=False,
-            indent=4,
-            default=str
-        )
+        json_str = json.dumps(self.get_data(), ensure_ascii=False, indent=4)
+        response.write(json_str)
         return response
 
     def to_xlsx(self):
-        """Export to XLSX."""
+        """Export to XLSX with UTF-8 encoding."""
         response = HttpResponse(
             content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
         )
         response["Content-Disposition"] = f'attachment; filename="{self.filename}.xlsx"'
 
-        data = self.get_data()
         output = BytesIO()
         workbook = xlsxwriter.Workbook(output)
         worksheet = workbook.add_worksheet()
 
-        # Записываем заголовки
-        headers = list(data[0].keys()) if data else []
+        # Заголовки
+        headers = list(self.fields)
         for col_num, header in enumerate(headers):
             worksheet.write(0, col_num, header)
 
-        # Записываем строки данных
-        for row_num, row in enumerate(data, start=1):
+        # Данные
+        for row_num, row in enumerate(self.get_data(), start=1):
             for col_num, key in enumerate(headers):
-                worksheet.write(row_num, col_num, row[key])
+                worksheet.write(
+                    row_num,
+                    col_num,
+                    str(row[key]) if row[key] is not None else ""
+                )
 
         workbook.close()
         output.seek(0)
-        return response.write(output.read())
+        response.write(output.read())
+        return response
 
     def to_yaml(self):
-        """Export to YAML with proper attachment handling."""
-        response = HttpResponse(content_type="application/octet-stream")
+        """Export to YAML with proper UTF-8 encoding."""
+        response = HttpResponse(
+            content_type="application/x-yaml; charset=utf-8")
         response["Content-Disposition"] = f'attachment; filename="{self.filename}.yaml"'
-        yaml_str = yaml.dump(self.get_data(), allow_unicode=True)
+        yaml_str = yaml.dump(
+            self.get_data(), allow_unicode=True, default_flow_style=False)
         response.write(yaml_str)
         return response
 
     def to_tsv(self):
-        """Export to TSV with proper attachment handling."""
-        response = HttpResponse(content_type="application/octet-stream")
+        """Export to TSV with UTF-8 encoding."""
+        response = HttpResponse(
+            content_type="text/tab-separated-values; charset=utf-8")
         response["Content-Disposition"] = f'attachment; filename="{self.filename}.tsv"'
+        response.write("\ufeff")  # Добавляем BOM
+
         writer = csv.DictWriter(
-            response,
-            fieldnames=self.fields,
-            delimiter="	"
-        )
+            response, fieldnames=self.fields, delimiter="\t")
         writer.writeheader()
-        writer.writerows(self.get_data())
+        for row in self.get_data():
+            writer.writerow({key: str(value) for key, value in row.items()})
+
         return response
+
+# The End