o ӷ6i,@s|dZddlZddlZddlZddlZddlmZdZddZ de fdd Z     dd d Z dd d Z ddZddZdS)zL Utilities for working with lists of model instances which represent trees. N)gettext)drilldown_tree_for_nodeget_cached_treesprevious_current_nexttree_item_iteratorcCsHtdg|dg}t|d\}}}t|t|t|t|||S)z From http://www.wordaligned.org/articles/zippy-triples-served-with-python Creates an iterator which returns (previous, current, next) triples, with ``None`` filling in when there is no previous or next available. N) itertoolschainteenextzip)itemsextendprevcurnexrO/var/www/hoanhtaovolam_webdjango/env/lib/python3.10/site-packages/mptt/utils.pyrs  rFc csi}d}d}t|D]r\}}}|dur|j}t||j} |rLt||j| k|d<|rK|dr>|ddt|d |d<|drK|d||n d|d<|rVg|d<| }|ritt| t||jd|d<n tt| |dd|d<|t |fVq dS) a> Given a list of tree items, iterates over the list, generating two-tuples of the current tree item and a ``dict`` containing information about the tree structure around the item, with the following keys: ``'new_level'`` ``True`` if the current item is the start of a new level in the tree, ``False`` otherwise. ``'closed_levels'`` A list of levels which end after the current item. This will be an empty list if the next item is at the same level as the current item. If ``ancestors`` is ``True``, the following key will also be available: ``'ancestors'`` A list of representations of the ancestors of the current node, in descending order (root node first, immediate parent last). For example: given the sample tree below, the contents of the list which would be available under the ``'ancestors'`` key are given on the right:: Books -> [] Sci-fi -> ['Books'] Dystopian Futures -> ['Books', 'Sci-fi'] You can overload the default representation by providing an optional ``callback`` function which takes a single argument and performs coercion as required. Nr new_level closed_levels ancestorsT) r _mptt_metagetattr level_attrlenappendlistrangecopydeepcopy) r rcallback structureoptsfirst_item_levelpreviouscurrentnext_ current_levelrrrr*s>%  rcCsH|r|n|}|r|r|r|j|||||}t||g|S)a Creates a drilldown tree for the given node. A drilldown tree consists of a node's ancestors, itself and its immediate children or all descendants, all in tree order. Optional arguments may be given to specify a ``Model`` class which is related to the node's class, for the purpose of adding related item counts to the node's children: ``rel_cls`` A ``Model`` class which has a relation to the node's class. ``rel_field`` The name of the field in ``rel_cls`` which holds the relation to the node's class. ``count_attr`` The name of an attribute which should be added to each child in the drilldown tree, containing a count of how many instances of ``rel_cls`` are related through ``rel_field``. ``cumulative`` If ``True``, the count will be for each child and all of its descendants, otherwise it will be for each child itself. ``all_descendants`` If ``True``, return all descendants, not just immediate children. )get_descendants get_children _tree_manageradd_related_countrr get_ancestors)noderel_cls rel_field count_attr cumulativeall_descendantschildrenrrrr|s $  rc Cs|jj}t|dur tjn|}d|jd|j|j|j |j df}| || ddD]/}t ||j}g}|ddD] }|t ||q;dd |t|} || | |q+dS) z Given an mptt queryset, prints some debug information to stdout. Use this when things go wrong. Please include the output from this method when filing bug issues. Npkz%s_idprettytree_idlftrz{}{}z- )modelrcsvwritersysstdoutr parent_attr tree_id_attr left_attr right_attrwriteroworder_byrrformatstr) qsfiler$r<headernlevelrowfieldrow_textrrrprint_debug_infos(    rOcCs>t|}|r|}t|dr|jjs|jjs|S|sdS)Nr)rmropophasattr_metaabstractproxy) model_classbasesbrrr_get_tree_models rYc sPg}fdd}|rt|do|j}g}d}d}ddd|D]}g|_|dk|_|}|dus<|rQ||krQ|}|jj}|jj|jj |jj n||kr`t t dt |f|t|krq|g|t|ksf|||||kr||||d} | durt||| | j|nd} ||ks| dur||q$|S) a Cache the parents and children on a queryset of MPTT instances. Args: queryset: List or queryset of _all_ the nodes that will have a cache. Instances not in the queryset will not be retrieved using the cache. Notes: Takes a list/queryset of model objects in MPTT (ordered by depth ASC) and caches the children and parent of every node. This allows up and down traversal through the tree without the need for further queries. Use cases include using a recursively included template or arbitrarily traversing trees. Any instance which has no parent in the provided queryset will be added to the top nodes list. For it to return proper results, queryset _must_ be ordered by ascending level. Returns: A list of top-level nodes, one node per tree root. See Also: Aliases to this function are also available: ``mptt.templatetags.mptt_tag.cache_tree_children`` Use for recursive rendering in templates. ``mptt.querysets.TreeQuerySet.get_cached_trees`` Useful for chaining with queries; e.g., `Node.objects.filter(**kwargs).get_cached_trees()` csb|D],}t|t|kr.t|t|kr,t|kr,t|kr.|SqqdS)a Find the parent of ``obj`` in a list of items of the upper level. Args: obj: Instance to find a parent for. tree_level: List of instances at the upper level. Returns: The instance that is the correct parent for ``obj``. ``None`` if ``obj`` has no parent in the list. Notes: ``lft`` and ``right`` define the bounds of a tree node. Any child node has bounds inside the bounds of its parent. N)r)obj tree_levelitemrArBr@rr find_parents z%get_cached_trees..find_parentqueryNrz Node %s not in depth-first orderr)rRr_ has_filters_cached_children_mptt_use_cached_ancestors get_levelrr?r@rArB ValueError_typerrsetattr) queryset top_nodesr^ is_filteredtree root_levelr?rZ node_levelparentrr]rrsN        r)NNNFF)N)__doc__r r;rr=django.utils.translationrrf__all__rrFrrrOrYrrrrrs$ T ,