Hi%x zdZddlmZmZddlmZmZmZmZm Z m Z m Z dZ e dZ Gddee Ze de Zd ed efd Zd ed efd ZGddZGddee efZGddee efZGddeZGddee efZe dZGddeee efZGddee efee ee effee efZGddeee ZGdd 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)AnyCallableGenericOptionalTupleTypeVarcastKTceZdZdZdefdZdS)Elementz+All items stored in the BTree are Elements.returnct)zFThe key for this element; the returned type must implement comparison.)NotImplementedErrorselfs N/home/mmwave/public_html/mmwave/venv/lib/python3.11/site-packages/dns/btree.pykeyz Element.keys!!N)__name__ __module__ __qualname____doc__r rrrrrs555"R""""""rrET)boundtrc |dz S)z[The minimum number of keys in a non-root node for a BTree with the specified ``t`` rrs r_MINr#s  q5Lrcd|zdz S)zGThe maximum number of keys in node for a BTree with the specified ``t``r!rr"s r_MAXr&#s q519rceZdZdZdZdS)_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. c$t|dS)Nxidrs r__str__z_Creator.__str__0sT((rN)rrrrr-rrrr(r((s-rr(c &eZdZdZgdZdededefdZdefdZ defd Z d e de eeffd Z d edd fdZd e deed effdZd e dedzfdZd eddfdZdedededzfdZde d ed ffdZdd d edefdZdd d edefdZdd dedd ddfdZdd d eddfdZdefdZdefd Zdd d eddfd!Zd e ded d"edzdedzfd#Zd$eegdfddfd%Z d$ed gdfddfd&Z!deded fd'Z"dedd fd(Z#d)Z$dS)*_NodezFA Node in the BTree. A Node (leaf or internal) of the BTree. rcreatoris_leafeltschildrenrr1r2c\|dksJ||_||_||_g|_g|_dS)Nr0)rrr1r2s r__init__z_Node.__init__<s6Avvvv    -/ rrct|jt|jksJt|jt|jkS)z/Does this node have the maximal number of keys?)lenr3r&rrs r is_maximalz_Node.is_maximalD>49~~df----49~~df--rct|jt|jksJt|jt|jkS)z/Does this node have the minimal number of keys?)r9r3r#rrs r is_minimalz_Node.is_minimalIr;rrcnt|j}|dkr*||j|dz kr|dfSd}t|j}|dz }d}||krK||zdz}|j|}||kr|}d}n||kr|}|dz }n|dz}||kK||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. rr!Fr%T)r9r3r)rrlirequalmks rsearch_in_nodez_Node.search_in_nodeNs  NN q55S49QU+//1111e8O   NN E1ffQ1 A !   ""AaxxqEE1ff%xrindexz _Node[KT, ET]c|jrJ|j|}||j}|r ||j|<|S|SN)r2r4 maybe_cowr1)rrFchildcloneds rmaybe_cow_childz_Node.maybe_cow_childksM< e$..  #)DM% MLrc||\}}|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)rEr2rL _get_node)rrr@rBrJs rrOz_Node._get_nodeusa&&s++5  (!9  \ (9((++E??3'' 'rNc||\}}|r |j|S|jrdS|j||S)z8Get the element associated with *key* or return ``None``N)rEr3r2r4get)rrr@rBs rrQz _Node.getsW&&s++5  -9Q<  \ -4=#'',, ,rc|dkrdS|j|dz }t|jt|jkrdS||dz }t|jt|jkrG|||dz sdSt|jt|jkEdSdS)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!)r4r9r3r&rrLtry_right_steal)rrFlefts roptimize_in_order_insertionz!_Node.optimize_in_order_insertions A:: F}UQY' ty>>T$&\\ ) ) F##EAI..$)nntDF||++''eai88 $)nntDF||++++++relementin_orderc|rJ |}||\}}|r|j|}||j|<|S|jr|j||dS||}|r|j|| ||}|r| ||SrH) r:rrEr3r2insertrLadoptsplitinsert_nonfullrU) rrVrWrr@rBoldrJoelts rr\z_Node.insert_nonfulls??$$$$$ ++--C**3//HAu il& !      G,,,t,,Q//##%%DJ ..++GX>>844Q777 rcz|sJ||j|j|j}t |jt|jdzd|_|jt|j}t |jdt|j|_|jslt |jt|jdzd|_t |jdt|jdz|_|||fS)zASplit a maximal node into two minimal ones and a central element.r!N) r: __class__rr1r2listr3r#r4)rrightmiddles rr[z _Node.splits     tvt|T\BB$)DLL1$4$6$6788 4<<(>T$&\\>233 | D!$-TV q0@0B0B"CDDEN /Adf1A/A!BCCDMVU""rparentc|dkr|j|dz }|s||dz }|j|dz }|j|j|dz <|jd||js=|jrJ|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. rr!TF)r4r=rLr3poprYr2)rrdrFrTeltrJs rtry_left_stealz_Node.try_left_steals A::?519-D??$$ --eai88k%!),)- EAI&   C(((|3#|+++ M--//EM((E222turc|dzt|jkr|j|dz}|s||dz}|j|}|jd|j|<|j||js=|jrJ|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. r!rTF)r9r4r=rLr3rfappendr2)rrdrFrbrgrJs rrSz_Node.try_right_steals 19s6?++ + +OEAI.E##%% ..uqy99k%(%*Z^^A%6%6 E"   %%%}0#|+++!N..q11EM((///turrTrcrbc|rJ|jrJ|}||\}}|rJ|j||t |jdkr ||g|_dS|j||ksJ|j|dz|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.rr!N)r:r2rrEr3rYr9r4)rrTrcrbrr@rBs rrZz _Node.adopts??$$$$$<jjll&&s++5 F### t}   " "!5MDMMM=#t++++ M Q . . . . .rc2|j|dz}|j|j||j|j|js!|j|jdSdS)z>Merge this node's parent and its right sibling into this node.r!N)r4rfr3rjextendr2)rrdrFrbs rmergez _Node.merges##EAI.. //000 $$$| 1 M  0 0 0 0 0 1 1rch|jr |jdS|jdS)z"The least element in this subtree.r)r2r3r4minimumrs rrpz _Node.minimums1 < .9Q< =#++-- -rch|jr |jdS|jdS)z%The greatest element in this subtree.)r2r3r4maximumrs rrsz _Node.maximum s1 < /9R= =$,,.. .rc|jrJ|||rdS|||rdS|dkr|||dS||dz }|||dz dS)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!)r2rhrSrnrL)rrdrFrTs rbalancez _Node.balances>!!!   vu - -  F    . .  F A:: JJvu % % % % %))%!)44D JJvuqy ) ) ) ) )rexactcB||rJ||\}}d}|r||j||urtd|jr|j|Sd}|}|j|dz}|}|dz}|jr|tddS| |}|rU| ||||\}}|rJ|j|}|rJ| |||} |9| |\} }| J| J| 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 eltr!zexact delete had no match) r=rEr3 ValueErrorr2rfr4rprrLrudeleterO) rrrdrvr@rB original_keyleast_successorrJrgnoder^s rryz _Node.delete&s ~T__%6%6~~~&&s++5   TYq\%>%> !JKKK| (y}}Q'''EL"mAE2::<> 49%%%| 2 O " "4= 1 1 1 rc|js(ddd|jDz}nd}t|dd|jd|j|S)N c0g|]}t|dS)r*r+).0cs r z!_Node.__str__..ws"&K&K&K"Q%%||&K&K&Krr*)r2joinr4r,r1r3)rr4s rr-z _Node.__str__ush| SXX&K&KT]&K&K&KLLLHHHT((CCCt|CCdiCCCCr)%rrrr __slots__intr(boolr7r:r=r tuplerErLr rrOrrQrUr\r[rhrSrZrnrprsruryrrrrIrr-rrrr/r/4s @??I0#0040000.D.... .D.... "sDy)9:S_(R(E(?*CS*H$I(((( -r-b4i----$bDR$Y2 #u_b/AB # # # #_ST&ocd&///2/o/RV////"1O1C1D1111...../////*o*c*d****&--'8-ACd- d----^4HbT4Z$84T44445X6G6M-N5SW5555h.GX/DDDDDrr/ceZdZdZddZddZddZd Zd Zde dzfd Z de dzfd Z d e de ddfdZdded e ddfdZddZddZdZdZdS)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]c||_d|_d|_d|_d|_g|_d|_d|_d|_dS)NrFT) r current_node current_indexrecurse increasingparentsparked parking_keyparking_key_read)rrs rr7zCursor.__init__sM *.#$ 02  &* %rrNc|jJ|jjs`|j|j|jf|jj|j|_|jJd|_|jj^dSdSrN)rr2rrjrr4rs r _seek_leastzCursor._seek_leasts ,,,#+ # L  !2D4F G H H H $ 1 :4;M ND $000!"D  #+ # # # # #rc|jJ|jjsw|j|j|jf|jj|j|_|jJt |jj|_|jjudSdSrH)rr2rrjrr4r9r3rs r_seek_greatestzCursor._seek_greatests ,,,#+ = L  !2D4F G H H H $ 1 :4;M ND $000!$T%6%;!%>"##%%% | %*'')))$ #DO   ! #  !Q&&',T-?@(0(#'DL#&7799 (,% t|$$q((<@LGet the next element, or return None if on the right boundary.Nr!rTF)rrrrrrrrrr9r3r2rrrrfrs rnextz Cursor.nextst    $!Q&&t)Q....%)JO!%&"  """ | %?'$$&&&$ "DO!C(9(>$?$???',T-?@""a'""(0(#'DL#&7799 (,% t|$$q((<@L!   rchd|_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. Nr!Frrs r seek_lastzCursor.seek_lastKs> !   rc:|j||SrH)rregister_cursorrs r __enter__zCursor.__enter__Xs ""4((( rc:|j|dSr)rderegister_cursor)rexc_type exc_value tracebacks r__exit__zCursor.__exit__\s $$T***ur)rrrN)T)rrrrr7rrrrrrrrrrr rrrrrrrrrr}sV & & & &####====   $$$&& b4i& & & & P& b4i& & & & P''#'$'''' !#!#!#D!#D!#!#!#!#F          rrceZdZdZdS) ImmutablezThe BTree is immutable.N)rrrrrrrrras!!!!rrcTeZdZdZedddededfdZdZdd Z d d e d e de dzfd Z de de dzfdZde de dzde dzfdZde de dzfdZde de dzfdZdZdee gdfddfdZdeegdfddfdZdee e ffdZdeddfdZdeddfdZdZdZdS)!BTreez2An in-memory BTree with copy-on-write and cursors.Nroriginalrrcnt|_d|_|||t|_|<|jst d|j|_|j|_|j|_dS|dkrt d||_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 immutabler6zt must be >= 3Tr) r(r1 _immutablesetcursorsrxrrsizer/)rrrs rr7zBTree.__init__hs zz    $'EE  & D !BCCCZDF DI DIII1uu !1222DFdfdlD99DIDIIIrc&|js d|_dSdS)zMake the BTree immutable. Attempts to alter the BTree after making it immutable will raise an Immutable exception. This operation cannot be undone. TN)rrs rmake_immutablezBTree.make_immutables#  #"DOOO # #rrc^|jrt|jD]}|dSrH)rrrrrcursors r_check_mutable_and_parkzBTree._check_mutable_and_parks; ? Ol  F KKMMMM  rFrgrWc||j|j}|r||_|jrH|j}t |j|jd|_|jj||j ||}||xj dz c_ |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!) rrrIr1r:r/rrZr[r\r)rrgrWrKold_rootr^s rinsert_elementzBTree.insert_elements $$&&&$$T\22  DI 9   ! ! /yHdfdlE::DI DIOX^^-- . .y''X66 < IINII rrc6|j|S)zhGet the element matching *key* from the BTree, or return ``None`` if it does not exist. )rrQrrs r get_elementzBTree.get_elementsy}}S!!!rrvc||j|j}|r||_|j|d|}|o|xjdzc_t |jjdkrB|jjs6t |jj dksJ|jj d|_|S)Nr!r) rrrIr1ryrr9r3r2r4)rrrvrKrgs r_deletez BTree._deletes $$&&&$$T\22  DIisD%00 ? IINII49>""a''y(6ty122a7777 $ 21 5DI rc.||dS)zDelete the element matching *key* from the BTree. Returns the matching element or ``None`` if it does not exist. N)rrs r delete_keyzBTree.delete_keys ||C&&&rrVcb|||}||usJ|S)zwDelete *element* from the BTree. Returns the matching element or ``None`` if it was not in the BTree. )rr)rrVdelts r delete_exactzBTree.delete_exacts1 ||GKKMM733w rc|jSrH)rrs r__len__z BTree.__len__ yrr}c:|j|dS)zBCall *visit*(element) on all elements in the tree in sorted order.N)rrrr}s rrzBTree.visit_in_orders   '''''rc:|j|dSrH)rrrs rrzBTree._visit_preorder_by_nodes ))%00000rc t|S)zCreate a cursor.)rrs rrz BTree.cursorsd||rrc:|j|dS)z4Register a cursor for the automatic parking service.N)raddrs rrzBTree.register_cursors      rc:|j|dS)z7Deregister a cursor from the automatic parking service.N)rdiscardrs rrzBTree.deregister_cursors V$$$$$rc.||S)N)rr`rs r__copy__zBTree.__copy__s~~t~,,,rc#K|5} |}|n|V. ddddS#1swxYwYdSrH)rrr)rrrgs r__iter__zBTree.__iter__s [[]] f kkmm;ggii                     s0AAAr)F)rrrr DEFAULT_Trrr7rrrrrr rrrrrrrr/rrrrrrrrrrrres6<<#,DS8I<###"d."r"b4i"""" 2b4iBI"'b'R$Y''''B29(HbT4Z$8(T((((1Xugtm-D11111r2v!f!!!!!%%4%%%%---     rrVTcFeZdZdZdedefdZdefdZdefdZdZ d Z d S) KVz/The BTree element type used in a ``BTreeDict``.rvaluec"||_||_dSrH_key_value)rrrs rr7z KV.__init__s  rrc|jSrHrrs rrzKV.keyrrc|jSrH)rrs rrzKV.values {rc(d|jd|jdSNzKV(z, )rrs rr-z KV.__str__ 0TY00$+0000rc(d|jd|jdSrrrs r__repr__z KV.__repr__ rrN) rrrrr rr7rrr-rrrrrrs99BrRr11111111rrcteZdZdZeddddededzdeffdZd e d e fd Z d e d e d dfd Z d e d dfdZ xZS) BTreeDictzA MutableMapping implemented with a BTree. Unlike a normal Python dict, the BTreeDict may be mutated while iterating. NFrrrWrrrWc\t||||_dSNrsuperr7rWrrrrWr`s rr7zBTreeDict.__init__- 1x000  rrrc||}|ttt|SrH)rKeyErrorr rr)rrrgs r __getitem__zBTreeDict.__getitem__ s9s## ;NC==&&(( (rrc\t||}|||jdSrH)rrrW)rrrrgs r __setitem__zBTreeDict.__setitem__'s-enn C/////rc>||tdSrH)rr rs r __delitem__zBTreeDict.__delitem__+s! ??3   'N ( 'r)rrrrrrrrr7r rr rr __classcell__rs@rrrs!% !!! !$, !  !!!!!!)r)b))))0r0"00000rdrrc*eZdZdZdefdZdefdZdS)Memberz.The BTree element type used in a ``BTreeSet``.rc||_dSrHrrs rr7zMember.__init__3s  rrc|jSrHrrs rrz Member.key6rrN)rrrrr r7rrrrrr0sP88BRrrcpeZdZdZeddddededzdeffdZd e d efd Z d e d dfd Z d e d dfdZ xZS)BTreeSetzyA MutableSet implemented with a BTree. Unlike a normal Python set, the BTreeSet may be mutated while iterating. NFrrrrWc\t||||_dSrrr s rr7zBTreeSet.__init__@r rrrc0||duSrH)rrs r __contains__zBTreeSet.__contains__Js$$D00rrcZt|}|||jdSrH)rrrW)rrrgs rrz BTreeSet.addMs+Umm C/////rc0||dSrH)r)rrs rrzBTreeSet.discardQs r)rrrrrrrrr7rrr rrrrs@rrr:s!% !!! !$, !  !!!!!!111111000000RDrrN)rcollections.abcrrtypingrrrrr r r rr rrrr#r&r(r/r Exceptionrrrrrrrrrrr!s 76666666IIIIIIIIIIIIIIIIII   WT]]"""""gbk""" WT!!!CCCC        FDFDFDFDFDGBFOFDFDFDR aaaaaWRV_aaaH""""" """Q Q Q Q Q GBFOQ Q Q h WT]]11111'"b&/111(Br2b"f:~!6r2v8N@Wgbkugbk:b>r