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

{django_fast_treenode-2.1.0.dist-info → django_fast_treenode-2.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: django-fast-treenode
-Version: 2.1.0
+Version: 2.1.1
 Summary: Application for supporting tree (hierarchical) data structure in Django projects
 Home-page: https://github.com/TimurKady/django-fast-treenode
 Author: Timur Kady
@@ -28,7 +28,7 @@ License: MIT License
         SOFTWARE.
         
 Project-URL: Homepage, https://github.com/TimurKady/django-fast-treenode
-Project-URL: Documentation, https://github.com/TimurKady/django-fast-treenode#readme
+Project-URL: Documentation, https://django-fast-treenode.readthedocs.io/latest/
 Project-URL: Source, https://github.com/TimurKady/django-fast-treenode
 Project-URL: Issues, https://github.com/TimurKady/django-fast-treenode/issues
 Classifier: Development Status :: 5 - Production/Stable
@@ -60,9 +60,6 @@ Requires-Dist: openpyxl; extra == "import-export"
 Requires-Dist: pyyaml; extra == "import-export"
 Requires-Dist: xlsxwriter; extra == "import-export"
 
-
-# ⚠️ Version 2.1.0 - betta.
-
 # Django-fast-treenode 
 **Combining Adjacency List and Closure Table for Optimal Performance**
 
@@ -139,16 +136,16 @@ python manage.py migrate
 ```
 
 ## Documentation
-Full documentation is available at [this link](#).
+Full documentation is available at [this link](https://django-fast-treenode.readthedocs.io/latest/).
 
 Quick access links:
-* [Installation, configuration and fine tuning](#)
-* [Model Inheritance and Extensions](#)
-* [Working with Admin Classes](#)
-* [API Reference](#)
-* [Import & Export](#)
-* [Caching and working with cache](#)
-* [Migration and upgrade guide](#)
+* [Installation, configuration and fine tuning](https://django-fast-treenode.readthedocs.io/latest/installation/)
+* [Model Inheritance and Extensions](https://django-fast-treenode.readthedocs.io/latest/models/)
+* [Working with Admin Classes](https://django-fast-treenode.readthedocs.io/latest/admin/)
+* [API Reference](https://django-fast-treenode.readthedocs.io/latest/api/)
+* [Import & Export](https://django-fast-treenode.readthedocs.io/latest/import_export/)
+* [Caching and working with cache](https://django-fast-treenode.readthedocs.io/latest/cache/)
+* [Migration and upgrade guide](https://django-fast-treenode.readthedocs.io/latest/migration/)
 
 Your wishes, objections, comments are welcome.
 

{django_fast_treenode-2.1.0.dist-info → django_fast_treenode-2.1.1.dist-info}/RECORD

@@ -11,17 +11,6 @@ treenode/admin/__init__.py,sha256=TdlPIyRW8i9qTVqGLmLWiBw4DyoGHUYZErE6rCyGOPE,11
 treenode/admin/admin.py,sha256=6H3N2Dg6l-MrFwIcyKR5YENg0cEo-I4uKCP9MuhHkqo,10580
 treenode/admin/changelist.py,sha256=YZm3zNniX75CgLjnbHpVr0OIP91halDEBHmrcS8m5Og,2128
 treenode/admin/mixins.py,sha256=-dVZwEjKsfRzMkBe87dkI0SZ9MH45YE_o39SIhSJWy4,11194
-treenode/docs/.gitignore,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-treenode/docs/about.md,sha256=x0RnV3UiTn-Ii0nBpTPgQmm6Al_DDwtl72TUC2oH_-0,3532
-treenode/docs/admin.md,sha256=uA3esa2AF3epcXtfEN-JUoUXojw34PAGg-g3w9aqY8I,4653
-treenode/docs/api.md,sha256=xDq9BDIhg7qOOZa88fF2WhHL8Wr77dYLmLnZ2fctF8I,23524
-treenode/docs/cache.md,sha256=mX4P0a4ndyLZCEDKEXPBEcd8LSWqvEy_HdYIHgmnf8g,8323
-treenode/docs/import_export.md,sha256=sbI1iR-eI54obTaIeR5xDhjn8FAy3dJ0aR4rfbCRcyU,2134
-treenode/docs/index.md,sha256=wXq_8AA9RooIG_6V_Yq5KPgrxyOKkc84sq-lwa-FQDk,1140
-treenode/docs/installation.md,sha256=w_ImbNgdt0Ot-z2ERApkRcBz1TdXloOFkNzU3EJBxeA,2512
-treenode/docs/migration.md,sha256=eFZO_DWJA8-015hD0he7_HzxgMnbOv192M-9Zf1uLcQ,6581
-treenode/docs/models.md,sha256=PxLHVvQDsH-IsD3pwilTtjUeB8hROYWNf3jdbHjhESY,5781
-treenode/docs/roadmap.md,sha256=T3aB3LfqhfXdpc9phTA4oPlQriKTjfuoaMBvvMcHa90,3336
 treenode/managers/__init__.py,sha256=EG_tj9P1Hama3kaqMfHck4lfzUWoPaJJVOXe3qaKMUo,585
 treenode/managers/adjacency.py,sha256=NVN8dq5z7gIh90yqW2uxV7MokmUfXTOT7crqMDyMaH0,7889
 treenode/managers/closure.py,sha256=PcScdJJUnLcKe8Y1wqROYPsRtAnBMUO4xn5sILk9AIM,10638
@@ -68,8 +57,8 @@ treenode/utils/db.py,sha256=36q4OckKmEd6uHTbMTxdKpV9nOIZ55DAantRWR9bxWg,4297
 treenode/utils/exporter.py,sha256=mV6Gch7XfW8f_1x3WqWgtV0qekMLdo-_n9gz6GJjXjw,7259
 treenode/utils/importer.py,sha256=Hvirbd6NyZ2MHa56_jOrUF3kYFeby1DbSLR3mhHy-9s,12891
 treenode/utils/radix.py,sha256=zHpOuDxsebiv9Gza6snNhAtBKiex6CDrAVRtB6esaWo,1642
-django_fast_treenode-2.1.0.dist-info/LICENSE,sha256=T0evsb7y-63fg18ovdNSx3wwWWRwyluQvN9J4zFSvfE,1093
-django_fast_treenode-2.1.0.dist-info/METADATA,sha256=gZTAxkM31OqmnQvHNN5fdj9yFHgB8E-vOlV4gV_Makw,7202
-django_fast_treenode-2.1.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-django_fast_treenode-2.1.0.dist-info/top_level.txt,sha256=fmgxHbXyx1O2MPi_9kjx8aL9L-8TmV0gre4Go8XgqFk,9
-django_fast_treenode-2.1.0.dist-info/RECORD,,
+django_fast_treenode-2.1.1.dist-info/LICENSE,sha256=T0evsb7y-63fg18ovdNSx3wwWWRwyluQvN9J4zFSvfE,1093
+django_fast_treenode-2.1.1.dist-info/METADATA,sha256=E1ThWhY4yy_h8_28imc4CYkd4kR7e9aCvtvpa6Pyncs,7620
+django_fast_treenode-2.1.1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+django_fast_treenode-2.1.1.dist-info/top_level.txt,sha256=fmgxHbXyx1O2MPi_9kjx8aL9L-8TmV0gre4Go8XgqFk,9
+django_fast_treenode-2.1.1.dist-info/RECORD,,

treenode/docs/about.md

@@ -1,36 +0,0 @@
-## About the project
-### The Debut Idea
-The idea of ​​this package belongs to **[Fabio Caccamo](https://github.com/fabiocaccamo)**. His idea was to use the **Adjacency List** method to store the data tree. The most probable and time-consuming requests are calculated in advance and stored in the database. Also, most requests are cached. As a result, query processing is carried out in one call to the database or without it at all.
-
-The original application **[django-treenode](https://github.com/fabiocaccamo/django-treenode)** has significant advantages over other analogues, and indeed, is one of the best implementations of support for hierarchical structures for Django.
-
-However, this application has a number of undeniable shortcomings:
-* the selected pre-calculations scheme entails high costs for adding a new element;
-* inserting new elements uses signals, which leads to failures when using bulk-operations;
-* the problem of ordering elements by priority inside the parent node has not been resolved.
-
-That is, an excellent debut idea, in my humble opinion, should have been improved.
-
-### The Development of the Idea
-My idea was to solve these problems by combining the **Adjacency List** with the **Closure Table**. Main advantages:
-* the Closure Model is generated automatically;
-* maintained compatibility with the original package at the level of documented functions;
-* most requests are satisfied in one call to the database;
-* inserting a new element takes two calls to the database without signals usage;
-* bulk-operations are supported;
-* the cost of creating a new dependency is reduced many times;
-* useful functionality added for some methods (e.g.  the `include_self=False` and `depth` parameters has been added to functions that return lists/querysets);
-* additionally, the package includes a tree view widget for the `tn_parent` field in the change form.
-
-Of course, at large levels of nesting, the use of the Closure Table leads to an increase in resource costs. However, the combined approach still outperforms both the original application and other available Django solutions in terms of performance, especially in large trees with over 100k nodes.
-
-### The Theory
-You can get a basic understanding of what is a **Closure Table** from:
-* [presentation](https://www.slideshare.net/billkarwin/models-for-hierarchical-data) by **Bill Karwin**;
-* [article](https://dirtsimple.org/2010/11/simplest-way-to-do-tree-based-queries.html) by blogger **Dirt Simple**;
-* [article](https://towardsdatascience.com/closure-table-pattern-to-model-hierarchies-in-nosql-c1be6a87e05b) by **Andriy Zabavskyy**.
-
-You can easily find additional information on your own on the Internet.
-
-### Our days
-Over the course of development, the package has undergone significant improvements, with a strong emphasis on performance optimization, database efficiency, and seamless integration with Django’s admin interface. The introduction of a hybrid model combining **Adjacency List** and **Closure Table** has substantially reduced query overhead, improved scalability, and enhanced flexibility when managing hierarchical data. These advancements have made the package not only a powerful but also a practical solution for working with large tree structures. Moving forward, the project will continue to evolve, focusing on refining caching mechanisms, expanding compatibility with Django’s ecosystem, and introducing further optimizations to ensure maximum efficiency and ease of use.

treenode/docs/admin.md

@@ -1,104 +0,0 @@
-## Working with Admin Classes
-
-### Using `TreeNodeModelAdmin`
-The easiest way to integrate tree structures into Django’s admin panel is by inheriting from `TreeNodeModelAdmin`. This base class provides all the necessary functionality for managing hierarchical data.
-
-##### admin.py:
-```python
-from django.contrib import admin
-from treenode.admin import TreeNodeModelAdmin
-
-from .models import Category
-
-@admin.register(Category)
-class CategoryAdmin(TreeNodeModelAdmin):
-
-    # Set the display mode: 'accordion', 'breadcrumbs', or 'indentation'
-    treenode_display_mode = TreeNodeModelAdmin.TREENODE_DISPLAY_MODE_ACCORDION
-    # treenode_display_mode = TreeNodeModelAdmin.TREENODE_DISPLAY_MODE_BREADCRUMBS
-    # treenode_display_mode = TreeNodeModelAdmin.TREENODE_DISPLAY_MODE_INDENTATION
-
-    list_display = ("name",)
-    search_fields = ("name",)
-```
-
-The tree structure in the admin panel **loads dynamically as nodes are expanded**. This allows handling **large datasets** efficiently, preventing performance issues.
-
-You can choose from three display modes:
-- **`TREENODE_DISPLAY_MODE_ACCORDION` (default)**  
-  Expands/collapses nodes dynamically.
-- **`TREENODE_DISPLAY_MODE_BREADCRUMBS`**  
-  Displays the tree as a sequence of **breadcrumbs**, making it easy to navigate.
-- **`TREENODE_DISPLAY_MODE_INDENTATION`**  
-  Uses a **long dash** (`———`) to indicate nesting levels, providing a simple visual structure.
-
-The accordion mode is **always active**, and the setting only affects how nodes are displayed.
-
-**Why Dynamic Loading**:  Traditional pagination does not work well for **deep hierarchical trees**, as collapsed trees may contain a **huge number of nodes**, which is in the hundreds of thousands. The dynamic approach allows efficient loading, reducing database load while keeping large trees manageable.
-
-#### Search Functionality
-The search bar helps quickly locate nodes within large trees. As you type, **an AJAX request retrieves up to 20 results** based on relevance. If you don’t find the desired node, keep typing to refine the search until fewer than 20 results remain.
-
-### Working with Forms
-
-#### Using TreeNodeForm
-If you need to customize forms for tree-based models, inherit from `TreeNodeForm`. It provides:
-- A **custom tree widget** for selecting parent nodes.
-- Automatic **exclusion of self and descendants** from the parent selection to prevent circular references.
-
-##### `forms.py`:
-```python
-from treenode.forms import TreeNodeForm
-from .models import Category
-
-class CategoryForm(TreeNodeForm):
-    """Form for Category model with hierarchical selection."""
-
-    class Meta(TreeNodeForm.Meta):
-        model = Category
-```
-
-Key Considerations:
-- This form automatically ensures that **a node cannot be its own parent**.
-- It uses **`TreeWidget`**, a custom hierarchical dropdown for selecting parent nodes.
-- If you need a form for another tree-based model, use the **dynamic factory method**:
-  
-  ```python
-  CategoryForm = TreeNodeForm.factory(Category)
-  ```
-
-This method ensures that the form correctly associates with different tree models dynamically.
-
-
-### Using TreeWidget Widget
-
-#### The TreeWidget Class
-The `TreeWidget` class is a **custom Select2-like widget** that enables hierarchical selection in forms. While it is used inside the Django admin panel by default, it can **also be used in regular forms** outside the admin panel.
-
-##### `widgets.py`
-
-```python
-from django import forms
-from treenode.widgets import TreeWidget
-from .models import Category
-
-class CategorySelectionForm(forms.Form):
-    parent = forms.ModelChoiceField(
-        queryset=Category.objects.all(),
-        widget=TreeWidget(),
-        required=False
-    )
-```
-
-Important Notes:
-- **Requires jQuery**: The widget relies on AJAX requests, so ensure jQuery is available when using it outside Django’s admin.
-- **Dynamically Fetches Data**: It loads the tree structure asynchronously, preventing performance issues with large datasets.
-- **Customizable Data Source**: The `data-url` attribute can be adjusted to fetch tree data from a custom endpoint.
-
-If you plan to use this widget in non-admin templates, make sure the necessary **JavaScript and CSS files** are included:
-```html
-<link rel="stylesheet" href="/static/treenode/tree_widget.css">
-<script src="/static/treenode/js/tree_widget.js"></script>
-```
-
-By following these guidelines, you can seamlessly integrate `TreeNodeModelAdmin`, `TreeNodeForm`, and `TreeWidget` into your Django project, ensuring efficient management of hierarchical data.