o j`d@sdZddlZddlZddlmZddlmZmZmZddl m Z m Z m Z m Z mZmZmZddlmZddlmZddlmZmZdd lmZdd lmZdd lmZd ZGd ddeZ ddZ!Gdddej"#eZ$dS)z5 A custom manager for working with trees of objects. N)groupby) connectionsmodelsrouter)F IntegerFieldManyToManyFieldMaxOuterRefQSubquery)gettext)cached_field_value)CantDisableUpdates InvalidMove) TreeQuerySet) node_moved)_get_tree_model) TreeManagerc@seZdZdZeZdS)SQCountz,(SELECT count(*) FROM (%(subquery)s) _count)N)__name__ __module__ __qualname__templater output_fieldrrL/var/www/mitschrieb_seite/venv/lib/python3.10/site-packages/mptt/managers.pyrs rcstfdd}|S)z; Delegate method calls to base manager, if exists. cs4|jrt|jj|i|S|g|Ri|SN) _base_managergetattrrselfargskwargsmethodrrwrapped(sz!delegate_manager..wrapped) functoolswraps)r%r&rr$rdelegate_manager#sr)cseZdZdZfddZfddZddZdXd d ZdXd d Ze j d dZ e j ddZ e ddZe ddZe ddZe ddZe ddZddZedYddZedYd d!Zd"d#Zdifd$d%Ze &   'dZd(d)Ze 'd[d*d+Zd\d,d-Zed.d/Zed0d1Zed2d3Zd'e_ed4d5Z ed]d6d7Z!d^d9d:Z"dYd;d<Z#d=d>Z$d?d@Z%dAdBZ&d_dDdEZ'dFdGZ(dHdIZ)dYdJdKZ*dLdMZ+dNdOZ,dPdQZ-dRdSZ.dTdUZ/dVdWZ0Z1S)`rz6 A manager for working with trees of objects. csPt|||jjs"t||_d|_|jr$|j|ur&|jj|_dSdSdSdSr)supercontribute_to_class_metaabstractr tree_modelr _tree_manager)r!modelname __class__rrr+7s zTreeManager.contribute_to_classcstj|i||j|jS)zO Ensures that this manager always returns nodes in tree order. )r* get_querysetorder_by tree_id_attr left_attrr r2rrr4Bs zTreeManager.get_querysetc s|j|jusJ|jjt}|rdnd}d|}d|}|dkr(j}j} n |dkr2j}j} j} | d|} |d|} |jjjjjjj| |jgdd j DR} | si| St | fd d d D]}d }t |dD]k}t |jt |jt |jt || t ||f\}}}}}|d ur|d}||d}q}||kr||dkr||d<||dkr||d<|d}q}||kr|tdi| || |d| |diO}||d}|d}q}|tdi| || |d| |diO}qs||S)a Returns a queryset containing either the descendants ``direction == desc`` or the ancestors ``direction == asc`` of a given queryset. This function is not meant to be called directly, although there is no harm in doing so. Instead, it should be used via ``get_queryset_descendants()`` and/or ``get_queryset_ancestors()``. This function works by grouping contiguous siblings and using them to create a range that selects all nodes between the range, instead of querying for each node individually. Three variables are required when querying for ancestors or descendants: tree_id_attr, left_attr, right_attr. If we weren't using ranges and our queryset contained 100 results, the resulting SQL query would contain 300 variables. However, when using ranges, if the same queryset contained 10 sets of contiguous siblings, then the resulting SQL query should only contain 30 variables. The attributes used to create the range are completely dependent upon whether you are ascending or descending the tree. * Ascending (ancestor nodes): select all nodes whose right_attr is greater than (or equal to, if include_self = True) the smallest right_attr within the set of contiguous siblings, and whose left_attr is less than (or equal to) the largest left_attr within the set of contiguous siblings. * Descending (descendant nodes): select all nodes whose left_attr is greater than (or equal to, if include_self = True) the smallest left_attr within the set of contiguous siblings, and whose right_attr is less than (or equal to) the largest right_attr within the set of contiguous siblings. The result is the more contiguous siblings in the original queryset, the fewer SQL variables will be required to execute the query. eltgtascdesc__cSsg|]}|dqS)-)lstrip).0frrr sz7TreeManager._get_queryset_relatives..cst|jt|jdfS)N_id)rr6 parent_attr)noptsrrs z5TreeManager._get_queryset_relatives..)keyN)minmaxrLrMr)r0 _mptt_metar r7 right_attrr6r5rEonlyorder_insertion_bynonerlistrfilter)r!queryset direction include_selffiltersr8max_opmin_opmax_attrmin_attrtree_keymin_keymax_keyqgroupnext_lftnodetreelftrghtmin_valmax_valmin_maxrrGr_get_queryset_relativesLs%             z#TreeManager._get_queryset_relativesFcC||d|S)z Returns a queryset containing the descendants of all nodes in the given queryset. If ``include_self=True``, nodes in ``queryset`` will also be included in the result. r=rjr!rUrWrrrget_queryset_descendantsz$TreeManager.get_queryset_descendantscCrk)z Returns a queryset containing the ancestors of all nodes in the given queryset. If ``include_self=True``, nodes in ``queryset`` will also be included in the result. r<rlrmrrrget_queryset_ancestorsroz"TreeManager.get_queryset_ancestorsc cs|jjjrtd|jj|jjjrtd|jj|j|jur)td|jj|jjs2dVdS|jdz dVW|jddS|jdw)a0 Context manager. Disables mptt updates. NOTE that this context manager causes inconsistencies! MPTT model methods are not guaranteed to return the correct results. When to use this method: If used correctly, this method can be used to speed up bulk updates. This doesn't do anything clever. It *will* mess up your tree. You should follow this method with a call to ``TreeManager.rebuild()`` to ensure your tree stays sane, and you should wrap both calls in a transaction. This is best for updates that span a large part of the table. If you are doing localised changes (one tree, or a few trees) consider using ``delay_mptt_updates``. If you are making only minor changes to your tree, just let the updates happen. Transactions: This doesn't enforce any transactional behavior. You should wrap this in a transaction to ensure database consistency. If updates are already disabled on the model, this is a noop. Usage:: with transaction.atomic(): with MyNode.objects.disable_mptt_updates(): ## bulk updates. MyNode.objects.rebuild() zBYou can't disable/delay mptt updates on %s, it's an abstract modelz`You can't disable/delay mptt updates on %s, it's a proxy model. Call the concrete model instead.zOYou can't disable/delay mptt updates on %s, it doesn't contain the mptt fields.NFT) r0r,r-rrproxyr._mptt_updates_enabled_set_mptt_updates_enabledr!rrrdisable_mptt_updatess2 &    z TreeManager.disable_mptt_updatesc cs|B|jjrdVn)|jzdVWn ty%|jw|j}|j}|D]}||q0WddSWddS1sJwYdS)a Context manager. Delays mptt updates until the end of a block of bulk processing. NOTE that this context manager causes inconsistencies! MPTT model methods are not guaranteed to return the correct results until the end of the context block. When to use this method: If used correctly, this method can be used to speed up bulk updates. This is best for updates in a localised area of the db table, especially if all the updates happen in a single tree and the rest of the forest is left untouched. No subsequent rebuild is necessary. ``delay_mptt_updates`` does a partial rebuild of the modified trees (not the whole table). If used indiscriminately, this can actually be much slower than just letting the updates occur when they're required. The worst case occurs when every tree in the table is modified just once. That results in a full rebuild of the table, which can be *very* slow. If your updates will modify most of the trees in the table (not a small number of trees), you should consider using ``TreeManager.disable_mptt_updates``, as it does much fewer queries. Transactions: This doesn't enforce any transactional behavior. You should wrap this in a transaction to ensure database consistency. Exceptions: If an exception occurs before the processing of the block, delayed updates will not be applied. Usage:: with transaction.atomic(): with MyNode.objects.delay_mptt_updates(): ## bulk updates. N)rur0_mptt_is_tracking_mptt_start_tracking Exception_mptt_stop_trackingpartial_rebuild)r!resultsrztree_idrrrdelay_mptt_updatess& -      "zTreeManager.delay_mptt_updatescC |jjjSr)r0rNrErtrrrrE\ zTreeManager.parent_attrcCr~r)r0rNr7rtrrrr7`rzTreeManager.left_attrcCr~r)r0rNrOrtrrrrOdrzTreeManager.right_attrcCr~r)r0rNr6rtrrrr6hrzTreeManager.tree_id_attrcCr~r)r0rN level_attrrtrrrrlrzTreeManager.level_attrc Ks^i}dj}|D]#\}}|d}g}|j}|D] } |t|| d| q||||<q |S)Nr>_attr)joinitemssplitappendr) r!lookups new_lookups join_partskvparts new_partsnew_parts__appendpartrrr_translate_lookupsps zTreeManager._translate_lookupsNcK(|dur|}|jdi|jdi|S)zg Like ``self.filter()``, but translates name-agnostic filters for MPTT fields. Nr)rTr)r!qsrXrrr _mptt_filter|szTreeManager._mptt_filtercKr)zS Like ``self.update()``, but translates name-agnostic MPTT fields. Nr)updater)r!rrrrr _mptt_updateszTreeManager._mptt_updatecKsttj|jfi|Sr)rr db_for_writer0)r!hintsrrr_get_connectionszTreeManager._get_connectioncCs|r|dt|j|dt|j|dt|ji}n'|}|dD] } |j| } | j}q!| } t| t r7d} n| j j } |t| i}|j j di||d} |jdi|t| iS)a Adds a related item count to a given ``QuerySet`` using its ``extra`` method, for a ``Model`` class which has a relation to this ``Manager``'s ``Model`` class. Arguments: ``rel_model`` A ``Model`` class which has a relation to this `Manager``'s ``Model`` class. ``rel_field`` The name of the field in ``rel_model`` which holds the relation. ``count_attr`` The name of an attribute which should be added to each item in this ``QuerySet``, containing a count of how many instances of ``rel_model`` are related to it through ``rel_field``. ``cumulative`` If ``True``, the count will be for each item and all of its descendants, otherwise it will be for each item itself. ``extra_filters`` Dict with aditional parameters filtering the related queryset. __tree_id __lft__gte __lft__lter>pkNr)r r6r7rOrr, get_field related_model isinstancer remote_field field_nameobjectsrTvaluesannotater)r!rU rel_model rel_field count_attr cumulative extra_filterssubquery_filterscurrent_rel_modelrel_field_partcurrent_mptt_field mptt_fieldrsubqueryrrradd_related_counts&$  zTreeManager.add_related_count last-childTcCs|jr|s|j|jdrttd|dur@|}t||jdt||jdt||j dt||j |t||j dn| r|dvr|rN| t||j }|dkr_|}|d} n|d}|} || t||jdt||jdt||j dt||j |t||j dn]t||jdt||j d|r| ||||\} } } } } t||j }|d| |t||j| t||j| dt||j | t||j |t||j | | r|| | |r||S) a Sets up the tree state for ``node`` (which has not yet been inserted into in the database) so it will be positioned relative to a given ``target`` node as specified by ``position`` (when appropriate) it is inserted, with any necessary space already having been made for it. A ``target`` of ``None`` indicates that ``node`` should be the last root node. If ``save`` is ``True``, ``node``'s ``save()`` method will be called before it is returned. NOTE: This is a low-level method; it does NOT respect ``MPTTMeta.order_insertion_by``. In most cases you should just set the node's parent and let mptt call this during save. rz2Cannot insert a node which has already been saved.NrKrleftrightr)rrTexists ValueError__get_next_tree_idsetattrr7rOrr6rE is_root_node _mptt_refreshr_create_tree_space!_calculate_inter_tree_move_values _create_space'_post_insert_update_cached_parent_rightsave)r!rctargetpositionrallow_existing_pkrefresh_targetr|target_tree_id space_targetlevelrparent right_shiftrrr insert_nodes^       zTreeManager.insert_nodecCs|jjr|j||||d|dS|dur |r||dSdS|r1|dvr1||||dS|r>||||dS||||dS)NT)rrrrr) r.rvr is_child_node_make_child_root_noder_make_sibling_of_root_node_move_root_node_move_child_node)r!rcrrrrrrr _move_node)s$ zTreeManager._move_nodecCs0|j|||d|tj|j|||ddS)ax Moves ``node`` relative to a given ``target`` node as specified by ``position`` (when appropriate), by examining both nodes and calling the appropriate method to perform the move. A ``target`` of ``None`` indicates that ``node`` should be turned into a root node. Valid values for ``position`` are ``'first-child'``, ``'last-child'``, ``'left'`` or ``'right'``. ``node`` will be modified to reflect its new tree state in the database. This method explicitly checks for ``node`` being made a sibling of a root node, as this is a special case due to our use of tree ids to order root nodes. NOTE: This is a low-level method; it does NOT respect ``MPTTMeta.order_insertion_by``. In most cases you should just move the node yourself by setting node.parent. )r)senderinstancerrN)rrrsendr3)r!rcrrrrr move_nodeCs   zTreeManager.move_nodecCs|j|ddS)zF Returns the root node of the tree with the given id. N)r|r)rget)r!r|rrr root_node`zTreeManager.root_nodecCs |jddS)z? Creates a ``QuerySet`` containing root nodes. Nr)rrtrrr root_nodesgs zTreeManager.root_nodescCs`|jj}|jdd}|jr|j|j}|jddd}|j}d}|D] }|d7}||d|q!dS)zO Rebuilds all trees in the database table using `parent` link. NrrTflatrrK)r0rNrrQr5 values_list_rebuild_helper)r!rHrpksrebuild_helperidxrrrrrebuildns  zTreeManager.rebuildcCsl|jj}|jd|d}|jr|j|j}|jddd}|sdSt|dkr+td|||dd|dS) z Partially rebuilds a tree i.e. It rebuilds only the tree with given ``tree_id`` in database table using ``parent`` link. N)rr|rTrrKzKMore than one root node with tree_id %d. That's invalid, do a full rebuild.r) r0rNrrQr5rlen RuntimeErrorr)r!r|rHrrrrrrzs  zTreeManager.partial_rebuildcsjj|rC|j|dvr't|j}|dkrt|j}n-t|jd}n$t|jd}|dkr.treeifyrrN)rKr) r0rNr|rrr7rOrrr)r!rrrrrrrrbuild_tree_nodess* zTreeManager.build_tree_nodesrc Cs|jj}|d}|j|d}|jr|j|j}|jddd}|j} |D] } | | |||d}q#|jj|j j |d}|j |||||d|dS)NrK) parent__pkrTrr)rrrr|) r0rNrrQr5rr_default_manager db_managerdbrTr) r!rrr|rrHrr child_idsrchild_idrrrrs  zTreeManager._rebuild_helpercCsbt||jt||j|t||j}|r/|st}||||vr%t|j|||ddSdS)N)seen) rrOrrrEsetaddrr)r!rrrrrrrrs  z3TreeManager._post_insert_update_cached_parent_rightcCst||j}t||j}t||j}t||j}t||j}|dks&|dkr:|dkr/|d} n|} ||d} |} n&|dksB|dkrX|dkrK|d} n|} ||} t||j} nttd||| d} d} | rrd|d} | | | | | fS) z~ Calculates values required when moving ``node`` relative to ``target`` as specified by ``position``. rrrKrr"An invalid position was given: %s.rr)rr7rrOrErrget_descendant_count)r!rcrrrr target_left target_right target_levelr level_changerleft_right_changerrrrrs.         z-TreeManager._calculate_inter_tree_move_valuescCs|| ||dS)z Closes a gap of a certain ``size`` after the given ``target`` point in the tree identified by ``tree_id``. N _manage_spacer!sizerr|rrr _close_gap%szTreeManager._close_gapcCs||||dS)z Creates a space of a certain ``size`` after the given ``target`` point in the tree identified by ``tree_id``. Nrrrrrr,rzTreeManager._create_spacerKcCs:|j|d}|j|t|j|d|j|d|dS)zt Creates space for a new tree by incrementing all tree ids greater than ``target_tree_id``. ) tree_id__gt)r|rKN)rrrr6r._mptt_track_tree_insertions)r!r num_treesrrrrr3s zTreeManager._create_tree_spacecCs,t|t|jd}|pd}|dS)zj Determines the next largest unused tree id for the tree managed by this manager. rrK)rS aggregater r6r)r! max_tree_idrrrr<szTreeManager._get_next_tree_idcCs|j|d}|jj}|jj}d||jjj|||jj |||j j |||j j |||j j d}t ||j } t ||j } | | d} | d} | | || | || | || | | | || | t ||j g} |}||| dS)z Removes ``node`` from its current tree, with the given set of changes being applied to ``node`` and its descendants, closing the gap left by moving ``node`` as it does so. raU UPDATE %(table)s SET %(level)s = CASE WHEN %(left)s >= %%s AND %(left)s <= %%s THEN %(level)s - %%s ELSE %(level)s END, %(tree_id)s = CASE WHEN %(left)s >= %%s AND %(left)s <= %%s THEN %%s ELSE %(tree_id)s END, %(left)s = CASE WHEN %(left)s >= %%s AND %(left)s <= %%s THEN %(left)s - %%s WHEN %(left)s > %%s THEN %(left)s - %%s ELSE %(left)s END, %(right)s = CASE WHEN %(right)s >= %%s AND %(right)s <= %%s THEN %(right)s - %%s WHEN %(right)s > %%s THEN %(right)s - %%s ELSE %(right)s END WHERE %(tree_id)s = %%s)tablerrr|rrKN)rops quote_namer0r,r.db_tablerrcolumnr7r6rOrrexecute)r!rcrr new_tree_id connectionqnrHinter_tree_move_queryrrgap_sizegap_target_leftparamsrrrr_inter_tree_move_and_close_gapEsF      z*TreeManager._inter_tree_move_and_close_gapcCst||j}t||j}t||j}|s|}|d}|||||t||j||t||j||t||jdt||j|t||jdd|j |j<dS)a Removes ``node`` from its tree, making it the root node of a new tree. If ``new_tree_id`` is not specified a new tree id will be generated. ``node`` will be modified to reflect its new tree state in the database. rKrN) rr7rOrrrrr6rE_mptt_cached_fields)r!rcrrrrrrrrrs  z!TreeManager._make_child_root_nodecCs||kr ttd|jj}t||j}t||j}|rV|dkr)|d}|}n|dkr4|}|d}nttd|||||krNt ||j|d| ||dS|dkr||krv| } || krhdSt| |j}||} } d} n<|}||} } d} n2|dkr||kr|}||} } d} n | } || krdSt| |j}||} } d} nttd||j |d}|jj}d ||jjj|||jjd }|}||||| | | gt ||j|dS) a Moves ``node``, making it a sibling of the given ``target`` root node as specified by ``position``. ``node`` will be modified to reflect its new tree state in the database. Since we use tree ids to reduce the number of rows affected by tree mangement during insertion and deletion, root nodes are not true siblings; thus, making an item a sibling of a root node is a special case which involves shuffling tree ids around. +A node may not be made a sibling of itself.rrKrrNr z UPDATE %(table)s SET %(tree_id)s = CASE WHEN %(tree_id)s = %%s THEN %%s ELSE %(tree_id)s + %%s END WHERE %(tree_id)s >= %%s AND %(tree_id)s <= %%s)r r|)rrr0r,rr6rrrrrget_previous_siblingget_next_siblingrr rr.rrrrr)r!rcrrrHr|rrr left_sibling lower_bound upper_boundshift right_siblingrrroot_sibling_queryrrrrrsj               z&TreeManager._make_sibling_of_root_nodec Cs|jjr |j|dS|}|jj}|jj}d||jjj|| |j j || |j j || |j j d}|}|||||||||gdS)z Manages spaces in the tree identified by ``tree_id`` by changing the values of the left and right columns by ``size`` after the given ``target`` point. a UPDATE %(table)s SET %(left)s = CASE WHEN %(left)s > %%s THEN %(left)s + %%s ELSE %(left)s END, %(right)s = CASE WHEN %(right)s > %%s THEN %(right)s + %%s ELSE %(right)s END WHERE %(tree_id)s = %%s AND (%(left)s > %%s OR %(right)s > %%s))r rrr|N)r.rv_mptt_track_tree_modifiedrr rr0r,rrr7rrOr6rr) r!rrr|rrrH space_queryrrrrrs  zTreeManager._manage_spacecCsDt||j}t||j}||kr||||dS||||dS)z Calls the appropriate method to move child node ``node`` relative to the given ``target`` node as specified by ``position``. N)rr6_move_child_within_tree_move_child_to_new_tree)r!rcrrr|rrrrr!s  zTreeManager._move_child_nodecCst||j}t||j}t||j}t||j}||||\}} } } } ||d} || ||||| | |t||j|| t||j|| t||j|| t||j|t||j | | j |j |j <dS)a  Moves child node ``node`` to a different tree, inserting it relative to the given ``target`` node in the new tree as specified by ``position``. ``node`` will be modified to reflect its new tree state in the database. rKN) rr7rOrr6rrrrrErr)r!rcrrrrrrrrrrnew_parent_right tree_widthrrrr(/s,     z#TreeManager._move_child_to_new_treecCst||j}t||j}t||j}||d}t||j}t||j} t||j} t||j} |dks8|dkr||krBttd|| krL|krTnnttd|dkrn| |kre| |} | d} n| } | |d} n| |kr{| |d} | } n| d} | |} || d}|}nf|dks|dkr||krttd|| kr|krnnttd |dkr| |kr| |} | d} n| } | |d} n| |kr| |d} | } n| d} | |} || }t||j}nttd |t || }t || }| |}|}|d kr | }|j |d }|j j }|jj}d ||jjj|||jj|||jj|||jj|||jjd}|}||||||||||||||||||gt||j| t||j| t||j||t||j||j|j|j<dS)z Moves child node ``node`` within its current tree relative to the given ``target`` node as specified by ``position``. ``node`` will be modified to reflect its new tree state in the database. rKrr)A node may not be made a child of itself.9A node may not be made a child of any of its descendants.rrrz;A node may not be made a sibling of any of its descendants.rrr a UPDATE %(table)s SET %(level)s = CASE WHEN %(left)s >= %%s AND %(left)s <= %%s THEN %(level)s - %%s ELSE %(level)s END, %(left)s = CASE WHEN %(left)s >= %%s AND %(left)s <= %%s THEN %(left)s + %%s WHEN %(left)s >= %%s AND %(left)s <= %%s THEN %(left)s + %%s ELSE %(left)s END, %(right)s = CASE WHEN %(right)s >= %%s AND %(right)s <= %%s THEN %(right)s + %%s WHEN %(right)s >= %%s AND %(right)s <= %%s THEN %(right)s + %%s ELSE %(right)s END WHERE %(tree_id)s = %%sr rrrr|N)rr7rOrr6rrrErrLrMrr rr0r,r.rrrrrrrr)r!rcrrrrrwidthr|rrrnew_left new_rightrr left_boundaryright_boundaryrrrrrHmove_subtree_queryrrrrr'Xs                    z#TreeManager._move_child_within_treec Cst||j}t||j}t||j}t||j}t||j}||d} ||kr.ttd||kr8ttd||||\} } } } }|| | ||j |d}|j j }|j j }d||jj j|||jj|||jj|||jj|||jjd}|}||| | | ||||gt||j|| t||j|| t||j|| t||j|t||j| | j|j|j<dS)z Moves root node``node`` to a different tree, inserting it relative to the given ``target`` node as specified by ``position``. ``node`` will be modified to reflect its new tree state in the database. rKr+r,r a UPDATE %(table)s SET %(level)s = %(level)s - %%s, %(left)s = %(left)s - %%s, %(right)s = %(right)s - %%s, %(tree_id)s = %%s WHERE %(left)s >= %%s AND %(left)s <= %%s AND %(tree_id)s = %%sr-N)rr7rOrr6rrrrrr rr0r,r.rrrrrrrErr)r!rcrrrrrr|rr.rrrrrrrrHmove_tree_queryrrrrrsb         zTreeManager._move_root_node)Fr)rFFT)rTT)r)Nr)r)rK)2rrr__doc__r+r4rjrnrp contextlibcontextmanagerrur}propertyrEr7rOr6rrr)rrrrrrrrrr alters_datarzrrrrrrrrrrrrrr(r'r __classcell__rrr2rr1s   t  I =         > X       H $   EW#) r)%r5r6r' itertoolsr django.dbrrrdjango.db.modelsrrrr r r r django.utils.translationr r mptt.compatrmptt.exceptionsrrmptt.querysetsr mptt.signalsr mptt.utilsr__all__rr)Manager from_querysetrrrrrs  $