o j%x @szdZddlmZmZddlmZmZmZmZm Z m Z m Z dZ e dZ Gdddee Ze ded Zd ed efd d Zd ed efddZGdddZGdddee efZGdddee efZGdddeZGdddee efZe dZGdddeee efZGdddee efee ee effee efZGdd d eee ZGd!d"d"eee ee Zd#S)$z A BTree in the style of Cormen, Leiserson, and Rivest's "Algorithms" book, with copy-on-write node updates, cursors, and optional space optimization for mostly-in-order insertion. )MutableMapping MutableSet)AnyCallableGenericOptionalTupleTypeVarcastKTc@seZdZdZdefddZdS)Elementz+All items stored in the BTree are Elements.returncCst)zFThe key for this element; the returned type must implement comparison.)NotImplementedErrorselfr|/root/aizidognhua/tmp/workspace/projects/ec89d86c-575f-41c9-af57-ac45cbdbf775/venv/lib/python3.10/site-packages/dns/btree.pykeysz Element.keyN)__name__ __module__ __qualname____doc__r rrrrrr sr ET)boundtrcCs|dS)z[The minimum number of keys in a non-root node for a BTree with the specified ``t`` rrrrr_MINsrcCs d|dS)zGThe maximum number of keys in node for a BTree with the specified ``t``rrrrrr_MAX#s r c@seZdZdZddZdS)_CreatorzA _Creator class instance is used as a unique id for the BTree which created a node. We use a dedicated creator rather than just a BTree reference to avoid circularity that would complicate GC. cCs t|dS)Nxidrrrr__str__0 z_Creator.__str__N)rrrrr%rrrrr!(s r!c @s eZdZdZgdZdededefddZdefd d Z defd d Z d e de eeffddZ deddfddZd e deedeffddZd e dedBfddZdeddfddZdedededBfddZde dedffdd Zd!ddedefd"d#Zd!ddedefd$d%Zd&dd'ed(dddfd)d*Zd!ddeddfd+d,Zdefd-d.Zdefd/d0Zd!ddeddfd1d2Zd e d!edd3edBdedBfd4d5Zd6eegdfddfd7d8Z d6edgdfddfd9d:Z!dededfd;d<Z"deddfd=d>Z#d?d@Z$dS)A_NodezFA Node in the BTree. A Node (leaf or internal) of the BTree. rcreatoris_leafeltschildrenrr)r*cCs.|dksJ||_||_||_g|_g|_dS)Nr()rrr)r*rrr__init__<s  z_Node.__init__rcCs,t|jt|jks Jt|jt|jkS)z/Does this node have the maximal number of keys?)lenr+r rrrrr is_maximalDz_Node.is_maximalcCs,t|jt|jks Jt|jt|jkS)z/Does this node have the minimal number of keys?)r/r+rrrrrr is_minimalIr1z_Node.is_minimalrcCst|j}|dkr||j|dkr|dfSd}t|j}|d}d}||krV||d}|j|}||krC|}d} ||fS||krN|}|d}n|d}||ks)||fS)zGet the index of the ``Element`` matching ``key`` or the index of its least successor. Returns a tuple of the index and an ``equal`` boolean that is ``True`` iff. the key was found. rrFrT)r/r+r)rrlirequalmkrrrsearch_in_nodeNs*     z_Node.search_in_nodeindexz _Node[KT, ET]cCs6|jrJ|j|}||j}|r||j|<|S|SN)r*r, maybe_cowr))rr:childclonedrrrmaybe_cow_childks    z_Node.maybe_cow_childcCs8||\}}|r ||fS|jrdS||}||S)zGet the node associated with key and its index, doing copy-on-write if we have to descend. Returns a tuple of the node and the index, or the tuple ``(None, 0)`` if the key was not found. Nr)r9r*r? _get_node)rrr4r6r=rrrrAus  z_Node._get_nodeNcCs6||\}}|r|j|S|jrdS|j||S)z8Get the element associated with *key* or return ``None``N)r9r+r*r,get)rrr4r6rrrrBs  z _Node.getcCs|dkrdS|j|d}t|jt|jkrdS||d}t|jt|jkr@|||ds4dSt|jt|jks*dSdS)a-Try to minimize the number of Nodes in a BTree where the insertion is done in-order or close to it, by stealing as much as we can from our right sibling. If we don't do this, then an in-order insertion will produce a BTree where most of the nodes are minimal. rNr)r,r/r+r rr?try_right_steal)rr:leftrrroptimize_in_order_insertionsz!_Node.optimize_in_order_insertionelementin_orderc Cs|rJ |}||\}}|r |j|}||j|<|S|jr,|j||dS||}|r=|j|q| ||}|rJ| ||Sr;) r0rr9r+r*insertr?adoptsplitinsert_nonfullrE) rrFrGrr4r6oldr=oeltrrrrKs&      z_Node.insert_nonfullcCs|sJ||j|j|j}t|jt|jdd|_|jt|j}t|jdt|j|_|jsUt|jt|jdd|_t|jdt|jd|_|||fS)zASplit a maximal node into two minimal ones and a central element.rN) r0 __class__rr)r*listr+rr,)rrightmiddlerrrrJs  z _Node.splitparentcCs|dkrD|j|d}|sD||d}|j|d}|j|j|d<|jd||jsB|jr6J|j}|jd|dSdS)zTry to steal from this Node's left sibling for balancing purposes. Returns ``True`` if the theft was successful, or ``False`` if not. rrTF)r,r2r?r+poprHr*)rrRr:rDeltr=rrrtry_left_steals  z_Node.try_left_stealcCs|dt|jkrE|j|d}|sE||d}|j|}|jd|j|<|j||jsC|jr7J|jd}|j|dSdS)zTry to steal from this Node's right sibling for balancing purposes. Returns ``True`` if the theft was successful, or ``False`` if not. rrTF)r/r,r2r?r+rSappendr*)rrRr:rPrTr=rrrrCs     z_Node.try_right_stealrDrQrPcCs|rJ|jr J|}||\}}|rJ|j||t|jdkr/||g|_dS|j||ks8J|j|d|dS)zAdopt left, middle, and right into our Node (which must not be maximal, and which must not be a leaf). In the case were we are not the new root, then the left child must already be in the Node.rrN)r0r*rr9r+rHr/r,)rrDrQrPrr4r6rrrrIs  z _Node.adoptcCsN|j|d}|j|j||j|j|js%|j|jdSdS)z>Merge this node's parent and its right sibling into this node.rN)r,rSr+rVextendr*)rrRr:rPrrrmerges z _Node.mergecC|jr|jdS|jdS)z"The least element in this subtree.r)r*r+r,minimumrrrrrZ z _Node.minimumcCrY)z%The greatest element in this subtree.)r*r+r,maximumrrrrr] r[z _Node.maximumcCsd|jrJ|||r dS|||rdS|dkr!|||dS||d}|||ddS)zThis Node is minimal, and we want to make it non-minimal so we can delete. We try to steal from our siblings, and if that doesn't work we will merge with one of them.Nrr)r*rUrCrXr?)rrRr:rDrrrbalances   z _Node.balanceexactc Cs@|dus |r J||\}}d}|rB|dur$|j||ur$td|jr-|j|Sd}|}|j|d}|}|d}|jrO|durMtddS| |}|rt| ||||\}}|riJ|j|}|rtJ| |||} |dur| |\} }| dusJ| dusJ| j|} | | j|<| } | S)zDelete an element matching *key* if it exists. If *exact* is not ``None`` then it must be an exact match with that element. The Node must not be minimal unless it is the root.Nz'exact delete did not match existing eltrzexact delete had no match) r2r9r+ ValueErrorr*rSr,rZrr?r^deleterA) rrrRr_r4r6 original_keyleast_successorr=rTnoderMrrrra&sB         z _Node.deletevisitcCsPt|jD]\}}|js|j||||q|js&|jd|dSdS)z-Call *visit* on all of the elements in order.r\N) enumerater+r*r,visit_in_order)rrer4rTrrrrgUs z_Node.visit_in_ordercCs,|||js|jD] }||q dSdS)z?Visit nodes in preorder. This method is only used for testing.N)r*r,_visit_preorder_by_node)rrer=rrrrh^s   z_Node._visit_preorder_by_nodecCs|j|ur ||SdS)zReturn a clone of this Node if it was not created by *creator*, or ``None`` otherwise (i.e. copy for copy-on-write if we haven't already copied it).N)r)clone)rr)rrrr<es  z_Node.maybe_cowcCs8||j||j}|j|j|js|j|j|S)z+Make a shallow-copy duplicate of this node.)rNrr*r+rWr,)rr)r>rrrrims z _Node.clonecCsH|jsdddd|jD}nd}t|dd|jd|j|S)N cSsg|]}t|dqS)r"r#).0crrr wsz!_Node.__str__..r")r*joinr,r$r)r+)rr,rrrr%us"z _Node.__str__)%rrrr __slots__intr!boolr.r0r2r tupler9r?rrrArrBrErKrJrUrCrIrXrZr]r^rarrgrhr<rir%rrrrr'4sD    /  r'c@seZdZdZd$ddZd%dd Zd%d d Zd d ZddZde dBfddZ de dBfddZ de de ddfddZd&dede ddfddZd%ddZd%ddZd d!Zd"d#ZdS)'CursorzA seekable cursor for a BTree. If you are going to use a cursor on a mutable BTree, you should use it in a ``with`` block so that any mutations of the BTree automatically park the cursor. btree BTree[KT, ET]cCs:||_d|_d|_d|_d|_g|_d|_d|_d|_dS)NrFT) ru current_node current_indexrecurse increasingparentsparked parking_keyparking_key_read)rrurrrr.s zCursor.__init__rNcCs^|jdusJ|jjs-|j|j|jf|jj|j|_|jdus$Jd|_|jjr dSdSr@)rwr*r{rVrxr,rrrr _seek_leastszCursor._seek_leastcCsf|jdusJ|jjs1|j|j|jf|jj|j|_|jdus$Jt|jj|_|jjr dSdSr;)rwr*r{rVrxr,r/r+rrrr_seek_greatestszCursor._seek_greatestcC|jsd|_dSdS)aPark the cursor. A cursor must be "parked" before mutating the BTree to avoid undefined behavior. Cursors created in a ``with`` block register with their BTree and will park automatically. Note that a parked cursor may not observe some changes made when it is parked; for example a cursor being iterated with next() will not see items inserted before its current position. TN)r|rrrrparks z Cursor.parkcCsT|jr(|jdur |j}|jr|j }n|j}||j|||_d|_d|_dSdSNF)r|r}rzr~seek)rrzbeforerrr _maybe_unparks   zCursor._maybe_unparkcCs|d|_|jdur+|jdkrdS|jdksJ|jj|_t|jjj|_| |j r9|j s6|d|_ d|_ |jd8_|jdkr`|jj|j}|jj sVd|_ | |_d|_ |St|jdkrq|j\|_|_nd|_d|_dSq,)zAGet the previous element, or return None if on the left boundary.NrrTF)rr}rwrxrurootr/r+rryrzr*rr~r{rSrrTrrrprevs:     z Cursor.prevcCs|d|_|jdur&|jdkrdS|jdksJ|jj|_d|_| |jr4|jr1|d|_d|_|jt |jj kr_|jj |j}|jd7_|jj sUd|_| |_d|_ |St |jdkrp|j\|_|_nd|_d|_dSq')z>Get the next element, or return None if on the right boundary.NrrTF)rr}rwrxrurrryrzr/r+r*rr~r{rSrrrrnexts:    z Cursor.nextrr4cCs|r||_dS|d|_dS)Nr)rx)rrr4rrr_adjust_for_befores zCursor._adjust_for_beforeTrcCs|jj|_|jdus Jd|_g|_||_d|_||_d|_|jj s[|j |\}}|r@| |||r:| dS| dS|j|j|f|jj||_|jdusWJ|jj r"|j |\}}|rm| ||dS||_dS)aSeek to the specified key. If *before* is ``True`` (the default) then the cursor is positioned just before *key* if it exists, or before its least successor if it doesn't. A subsequent next() will retrieve this value. If *before* is ``False``, then the cursor is positioned just after *key* if it exists, or its greatest precessessor if it doesn't. A subsequent prev() will return this value. NF)rurrwryr{rzr|r}r~r*r9rrrrVr,rx)rrrr4r6rrrrs2    z Cursor.seekcCs.d|_d|_d|_d|_g|_d|_d|_dS)zSeek to the left boundary (i.e. just before the least element). A subsequent next() will return the least element if the BTree isn't empty.NrFTrwrxryrzr{r|r}rrrr seek_first?s zCursor.seek_firstcCs.d|_d|_d|_d|_g|_d|_d|_dS)zSeek to the right boundary (i.e. just after the greatest element). A subsequent prev() will return the greatest element if the BTree isn't empty. NrFrrrrr seek_lastKs zCursor.seek_lastcCs|j||Sr;)ruregister_cursorrrrr __enter__X zCursor.__enter__cCs|j|dSr)ruderegister_cursor)rexc_type exc_value tracebackrrr__exit__\rzCursor.__exit__)rurvrN)T)rrrrr.rrrrrrrrrrqrr rrrrrrrrrrt}s     (( #  rtc@seZdZdZdS) ImmutablezThe BTree is immutable.N)rrrrrrrrrasrc@sFeZdZdZedddededfddZdd Zd/d d Z d0de de d e dBfddZ de d e dBfddZde de dBd e dBfddZde d e dBfddZde d e dBfddZddZdee gdfd dfd d!Zdeegdfd dfd"d#Zd ee e ffd$d%Zd&ed dfd'd(Zd&ed dfd)d*Zd+d,Zd-d.ZdS)1BTreez2An in-memory BTree with copy-on-write and cursors.NroriginalrrcCst|_d|_|||t|_|dur*|jstd|j|_|j|_|j|_dS|dkr2td||_t |j|jd|_d|_dS)zCreate a BTree. If *original* is not ``None``, then the BTree is shallow-cloned from *original* using copy-on-write. Otherwise a new BTree with the specified *t* value is created. The BTree is not thread-safe. FNzoriginal BTree is not immutabler-zt must be >= 3Tr) r!r) _immutablesetcursorsr`rrsizer')rrrrrrr.hs"   zBTree.__init__cCr)zMake the BTree immutable. Attempts to alter the BTree after making it immutable will raise an Immutable exception. This operation cannot be undone. TN)rrrrrmake_immutables zBTree.make_immutablercCs"|jrt|jD]}|qdSr;)rrrrrcursorrrr_check_mutable_and_parks   zBTree._check_mutable_and_parkFrTrGcCsz||j|j}|r||_|jr)|j}t|j|jd|_|jj||j ||}|dur;|j d7_ |S)aEInsert the element into the BTree. If *in_order* is ``True``, then extra work will be done to make left siblings full, which optimizes storage space when the the elements are inserted in-order or close to it. Returns the previously existing element at the element's key or ``None``. FNr) rrr<r)r0r'rrIrJrKr)rrTrGr>old_rootrMrrrinsert_elements  zBTree.insert_elementrcCs |j|S)zhGet the element matching *key* from the BTree, or return ``None`` if it does not exist. )rrBrrrrr get_elements zBTree.get_elementr_cCs||j|j}|r||_|j|d|}|dur@|jd8_t|jjdkr@|jjs@t|jj dks9J|jj d|_|S)Nrr) rrr<r)rarr/r+r*r,)rrr_r>rTrrr_deletesz BTree._deletecCs ||dS)zDelete the element matching *key* from the BTree. Returns the matching element or ``None`` if it does not exist. N)rrrrr delete_keys zBTree.delete_keyrFcCs |||}||usJ|S)zwDelete *element* from the BTree. Returns the matching element or ``None`` if it was not in the BTree. )rr)rrFdeltrrr delete_exacts zBTree.delete_exactcC|jSr;)rrrrr__len__z BTree.__len__recC|j|dS)zBCall *visit*(element) on all elements in the tree in sorted order.N)rrgrrerrrrgzBTree.visit_in_ordercCs|j|dSr;)rrhrrrrrhszBTree._visit_preorder_by_nodecCst|S)zCreate a cursor.)rtrrrrrsz BTree.cursorrcCr)z4Register a cursor for the automatic parking service.N)raddrrrrrrzBTree.register_cursorcCr)z7Deregister a cursor from the automatic parking service.N)rdiscardrrrrrrzBTree.deregister_cursorcCs |j|dS)N)rrNrrrr__copy__r&zBTree.__copy__ccsP|} |}|durn|VqWddS1s!wYdSr;)rrr)rrrTrrr__iter__s  "zBTree.__iter__r)F)rrrr DEFAULT_Trqrr.rrrrrrr rrrrrrrgr'rhrtrrrrrrrrrres$    rVTc@sNeZdZdZdedefddZdefddZdefd d Zd d Z d dZ dS)KVz/The BTree element type used in a ``BTreeDict``.rvaluecCs||_||_dSr;_key_value)rrrrrrr.s z KV.__init__rcCrr;rrrrrrrzKV.keycCrr;)rrrrrrrzKV.valuecCd|jd|jdSNzKV(z, )rrrrrr% z KV.__str__cCrrrrrrr__repr__ rz KV.__repr__N) rrrrr rr.rrr%rrrrrrs rcsveZdZdZeddddededBdeffdd Zd e d e fd d Z d e de d dfddZ d e d dfddZ ZS) BTreeDictzA MutableMapping implemented with a BTree. Unlike a normal Python dict, the BTreeDict may be mutated while iterating. NFrrrGrrrGctj||d||_dSNrsuperr.rGrrrrGrrrr. zBTreeDict.__init__rrcCs$||}|dur ttt|Sr;)rKeyErrorr rr)rrrTrrr __getitem__ s zBTreeDict.__getitem__rcCst||}|||jdSr;)rrrG)rrrrTrrr __setitem__'s zBTreeDict.__setitem__cCs||dur tdSr;)rrrrrr __delitem__+szBTreeDict.__delitem__)rrrrrrqrrrr.r rrrr __classcell__rrrrrs rc@s,eZdZdZdefddZdefddZdS) Memberz.The BTree element type used in a ``BTreeSet``.rcCs ||_dSr;rrrrrr.3s zMember.__init__rcCrr;rrrrrr6rz Member.keyN)rrrrr r.rrrrrr0srcsreZdZdZeddddededBdeffdd Zd e d efd d Z de d dfddZ de d dfddZ ZS)BTreeSetzyA MutableSet implemented with a BTree. Unlike a normal Python set, the BTreeSet may be mutated while iterating. NFrrrrGcrrrrrrrr.@rzBTreeSet.__init__rrcCs||duSr;)rrrrr __contains__JzBTreeSet.__contains__rcCst|}|||jdSr;)rrrG)rrrTrrrrMsz BTreeSet.addcCs||dSr;)r)rrrrrrQrzBTreeSet.discard)rrrrrrqrrrr.rrr rrrrrrrr:s rN)rcollections.abcrrtypingrrrrrr r rr r rrqrr r!r'rt Exceptionrrrrrrrrrrrs.$  Ke4