ó
    0/¡j%x  ã            
       óà  • S r SSKJrJr  SSKJrJrJrJrJ	r	J
r
Jr  Sr\
" S5      r " S S\\   5      r\
" S\S	9rS
\S\4S jrS
\S\4S jr " S S5      r " S S\\\4   5      r " S S\\\4   5      r " S S\5      r " S S\\\4   5      r\
" S5      r " S S\\\\4   5      r " S S\\\4   \\\\\4   4   \\\4   5      r " S S\\\   5      r " S S \\\   \\   5      rg!)"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)ÚAnyÚCallableÚGenericÚOptionalÚTupleÚTypeVarÚcasté   ÚKTc                   ó&   • \ rS rSrSrS\4S jrSrg)ÚElementé   z+All items stored in the BTree are Elements.Úreturnc                 ó   • [         e)zFThe key for this element; the returned type must implement comparison.)ÚNotImplementedError©Úselfs    Úb/var/www/html/health-monitoring.indevconsultancy.in/venv/lib/python3.13/site-packages/dns/btree.pyÚkeyÚElement.key   s   € ä!Ð!ó    © N)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r   r   Ú__static_attributes__r   r   r   r   r      s   † Ù5ð"�R÷ "r   r   ÚET)ÚboundÚtr   c                 ó   • U S-
  $ )zSThe minimum number of keys in a non-root node for a BTree with the specified
``t``
é   r   ©r#   s    r   Ú_MINr'      s   € ð ˆq‰5€Lr   c                 ó   • SU -  S-
  $ )zGThe maximum number of keys in node for a BTree with the specified ``t``é   r%   r   r&   s    r   Ú_MAXr*   #   s   € àˆq‰5�1‰9Ðr   c                   ó   • \ rS rSrSrS rSrg)Ú_Creatoré(   zÃA _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                 ó   • [        U 5      S $ )NÚx)Úidr   s    r   Ú__str__Ú_Creator.__str__0   s   € Ü�T“(˜1�Ðr   r   N)r   r   r   r   r   r1   r    r   r   r   r,   r,   (   s   † ñõr   r,   c            	       ó(  • \ rS rSrSr/ SQrS\S\S\4S jr	S\4S	 jr
S\4S
 jrS\S\\\4   4S jrS\SS4S jrS\S\\S   \4   4S jrS\S\S-  4S jrS\SS4S jrS\S\S\S-  4S jrS\S\S4   4S jrSSS\S\4S jrSSS\S\4S jrSSS\SSSS4S jrSSS\SS4S jrS\4S  jrS\4S! jrSSS\SS4S" jrS\S\S   S#\S-  S\S-  4S$ jrS%\ \/S4   SS4S& jr!S%\ S/S4   SS4S' jr"S\S\S   4S( jr#S\SS4S) jr$S* r%S+r&g),Ú_Nodeé4   z>A Node in the BTree.

A Node (leaf or internal) of the BTree.
©r#   ÚcreatorÚis_leafÚeltsÚchildrenr#   r7   r8   c                 óT   • US:¼  d   eXl         X l        X0l        / U l        / U l        g )Né   r6   )r   r#   r7   r8   s       r   Ú__init__Ú_Node.__init__<   s*   € Ø�A‹vˆˆvØŒØŒØŒØ ˆŒ	Ø-/ˆ�r   r   c                 ó´   • [        U R                  5      [        U R                  5      ::  d   e[        U R                  5      [        U R                  5      :H  $ )z/Does this node have the maximal number of keys?)Úlenr9   r*   r#   r   s    r   Ú
is_maximalÚ_Node.is_maximalD   ó;   € ä�4—9‘9‹~¤ d§f¡f£Ó-Ð-Ð-Ü�4—9‘9‹~¤ d§f¡f£Ñ-Ð-r   c                 ó´   • [        U R                  5      [        U R                  5      :¼  d   e[        U R                  5      [        U R                  5      :H  $ )z/Does this node have the minimal number of keys?)r@   r9   r'   r#   r   s    r   Ú
is_minimalÚ_Node.is_minimalI   rC   r   r   c                 óf  • [        U R                  5      nUS:”  a'  XR                  US-
     R                  5       :”  a  US4$ Sn[        U R                  5      nUS-
  nSnX$::  aJ  X$-   S-  nU R                  U   R                  5       nX:X  a  UnSn X54$ X:  a  UnUS-
  nOUS-   nX$::  a  MJ  X54$ )z·Get 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.
r   r%   Fr)   T)r@   r9   r   )r   r   ÚlÚiÚrÚequalÚmÚks           r   Úsearch_in_nodeÚ_Node.search_in_nodeN   sË   € ô �—	‘	‹NˆØˆq‹5�SŸ9™9 Q¨¡UÑ+×/Ñ/Ó1Ó1à�e�8ˆOØˆÜ�—	‘	‹NˆØ�‰EˆØˆØ‹fØ‘˜1‘ˆAØ—	‘	˜!‘× Ñ Ó"ˆAØ‹xØ�Ø�Øð ˆxˆð “Ø�Ø˜‘E‘à˜‘E�ð �fð ˆxˆr   Úindexz_Node[KT, ET]c                 ó®   • U R                   (       a   eU R                  U   nUR                  U R                  5      nU(       a  X0R                  U'   U$ U$ ©N)r8   r:   Ú	maybe_cowr7   )r   rP   ÚchildÚcloneds       r   Úmaybe_cow_childÚ_Node.maybe_cow_childk   sH   € Ø—<—<ÐÐØ—‘˜eÑ$ˆØ—‘ §¡Ó.ˆÞØ#)�M‰M˜%Ñ ØˆMàˆLr   c                 ó¤   • U R                  U5      u  p#U(       a  X4$ U R                  (       a  gU R                  U5      nUR                  U5      $ )z¼Get 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   )rN   r8   rV   Ú	_get_node)r   r   rI   rK   rT   s        r   rZ   Ú_Node._get_nodeu   sJ   € ð ×&Ñ& sÓ+‰ˆÞØ�9ÐØ�\�\Øà×(Ñ(¨Ó+ˆEØ—?‘? 3Ó'Ð'r   Nc                 ó´   • U R                  U5      u  p#U(       a  U R                  U   $ U R                  (       a  gU R                  U   R	                  U5      $ )z8Get the element associated with *key* or return ``None``N)rN   r9   r8   r:   Úget)r   r   rI   rK   s       r   r]   Ú	_Node.get…   sI   € à×&Ñ& sÓ+‰ˆÞØ—9‘9˜Q‘<ÐØ�\�\Øà—=‘= Ñ#×'Ñ'¨Ó,Ð,r   c                 ó¢  • US:X  a  gU R                   US-
     n[        UR                  5      [        U R                  5      :X  a  gU R                  US-
  5      n[        UR                  5      [        U R                  5      :  aI  UR                  XS-
  5      (       d  g[        UR                  5      [        U R                  5      :  a  MH  gg)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.
r   Nr%   )r:   r@   r9   r*   r#   rV   Útry_right_steal)r   rP   Úlefts      r   Úoptimize_in_order_insertionÚ!_Node.optimize_in_order_insertion�   s™   € ð �A‹:ØØ�}‰}˜U Q™YÑ'ˆÜˆt�y‰y‹>œT $§&¡&›\Ó)ØØ×#Ñ# E¨A¡IÓ.ˆÜ�$—)‘)‹nœt D§F¡F›|Ó+Ø×'Ñ'¨°a©i×8Ñ8Øô �$—)‘)‹nœt D§F¡F›|×+r   ÚelementÚin_orderc                 óþ  • U R                  5       (       a   e UR                  5       nU R                  U5      u  pEU(       a  U R                  U   nXR                  U'   U$ U R                  (       a  U R                  R                  XA5        g U R                  U5      nUR                  5       (       a  U R                  " UR                  5       6   M¼  UR                  X5      nU(       a  U R                  U5        U$ rR   )rA   r   rN   r9   r8   ÚinsertrV   ÚadoptÚsplitÚinsert_nonfullrb   )	r   rd   re   r   rI   rK   ÚoldrT   Úoelts	            r   rj   Ú_Node.insert_nonfull¡   sÍ   € Ø—?‘?×$Ñ$Ð$Ð$ØØ—+‘+“-ˆCØ×*Ñ*¨3Ó/‰HˆAÞà—i‘i ‘l�Ø&—	‘	˜!‘Ø�
Ø——Ø—	‘	× Ñ  Ô,Øà×,Ñ,¨QÓ/�Ø×#Ñ#×%Ñ%Ø—J’J §¡£Ñ.ñ Ø×+Ñ+¨GÓ>�ÞØ×4Ñ4°QÔ7Ø�r   c                 ó’  • U R                  5       (       d   eU R                  U R                  U R                  U R                  5      n[        U R                  [        U R                  5      S-   S 5      Ul        U R                  [        U R                  5         n[        U R                  S[        U R                  5       5      U l        U R                  (       df  [        U R                  [        U R                  5      S-   S 5      Ul        [        U R                  S[        U R                  5      S-    5      U l        XU4$ )zASplit a maximal node into two minimal ones and a central element.r%   N)	rA   Ú	__class__r#   r7   r8   Úlistr9   r'   r:   )r   ÚrightÚmiddles      r   ri   Ú_Node.splitº   sé   € à�‰× Ñ Ð Ð Ø—‘˜tŸv™v t§|¡|°T·\±\ÓBˆÜ˜$Ÿ)™)¤D¨¯©£L°1Ñ$4Ð$6Ð7Ó8ˆŒ
Ø—‘œ4 §¡›<Ñ(ˆÜ˜Ÿ™ >¤T¨$¯&©&£\Ð2Ó3ˆŒ	Ø�|�|Ü! $§-¡-´°T·V±V³¸qÑ0@Ð0BÐ"CÓDˆEŒNÜ  §¡Ð/A´°d·f±f³ÀÑ1AÐ!BÓCˆDŒMØ˜UÐ"Ð"r   Úparentc                 óì  • US:w  aî  UR                   US-
     nUR                  5       (       dÇ  UR                  US-
  5      nUR                  US-
     nUR                  R	                  5       UR                  US-
  '   U R                  R                  SU5        UR                  (       dI  U R                  (       a   eUR                   R	                  5       nU R                   R                  SU5        gg)z‡Try to steal from this Node's left sibling for balancing purposes.

Returns ``True`` if the theft was successful, or ``False`` if not.
r   r%   TF)r:   rE   rV   r9   Úpoprg   r8   )r   rt   rP   ra   ÚeltrT   s         r   Útry_left_stealÚ_Node.try_left_stealÆ   sÀ   € ð
 �A‹:Ø—?‘? 5¨1¡9Ñ-ˆDØ—?‘?×$Ñ$Ø×-Ñ-¨e°a©iÓ8�Ø—k‘k %¨!¡)Ñ,�Ø)-¯©¯©«�—‘˜E A™IÑ&Ø—	‘	× Ñ   CÔ(Ø—|—|Ø#Ÿ|Ÿ|Ð+Ð+Ø ŸM™M×-Ñ-Ó/�EØ—M‘M×(Ñ(¨¨EÔ2ØØr   c                 ó  • US-   [        UR                  5      :  aè  UR                  US-      nUR                  5       (       dÁ  UR                  US-   5      nUR                  U   nUR                  R                  S5      UR                  U'   U R                  R                  U5        UR                  (       dI  U R                  (       a   eUR                  R                  S5      nU R                  R                  U5        gg)zˆTry to steal from this Node's right sibling for balancing purposes.

Returns ``True`` if the theft was successful, or ``False`` if not.
r%   r   TF)r@   r:   rE   rV   r9   rv   Úappendr8   )r   rt   rP   rq   rw   rT   s         r   r`   Ú_Node.try_right_stealÙ   sÉ   € ð
 �1‰9”s˜6Ÿ?™?Ó+Ó+Ø—O‘O E¨A¡IÑ.ˆEØ×#Ñ#×%Ñ%Ø×.Ñ.¨u°q©yÓ9�Ø—k‘k %Ñ(�Ø%*§Z¡Z§^¡^°AÓ%6�—‘˜EÑ"Ø—	‘	× Ñ  Ô%Ø—}—}Ø#Ÿ|Ÿ|Ð+Ð+Ø!ŸN™N×.Ñ.¨qÓ1�EØ—M‘M×(Ñ(¨Ô/ØØr   ra   rr   rq   c                 ó’  • U R                  5       (       a   eU R                  (       a   eUR                  5       nU R                  U5      u  pVU(       a   eU R                  R                  XR5        [        U R                  5      S:X  a	  X/U l        gU R                  U   U:X  d   eU R                  R                  US-   U5        g)zÂAdopt 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.r   r%   N)rA   r8   r   rN   r9   rg   r@   r:   )r   ra   rr   rq   r   rI   rK   s          r   rh   Ú_Node.adoptì   s¤   € ð —?‘?×$Ñ$Ð$Ð$Ø—<—<ÐÐØ�j‰j‹lˆØ×&Ñ& sÓ+‰ˆÞÐˆyØ�	‰	×Ñ˜Ô#Üˆt�}‰}Ó Ó"à!˜MˆD�Mà—=‘= Ñ# tÓ+Ð+Ð+Ø�M‰M× Ñ   Q¡¨Õ.r   c                 ó`  • UR                   R                  US-   5      nU R                  R                  UR                  R                  U5      5        U R                  R	                  UR                  5        U R
                  (       d&  U R                   R	                  UR                   5        gg)z>Merge this node's parent and its right sibling into this node.r%   N)r:   rv   r9   r{   Úextendr8   )r   rt   rP   rq   s       r   ÚmergeÚ_Node.mergeý   sq   € à—‘×#Ñ# E¨A¡IÓ.ˆØ�	‰	×Ñ˜Ÿ™Ÿ™¨Ó/Ô0Ø�	‰	×Ñ˜Ÿ™Ô$Ø�|�|Ø�M‰M× Ñ  §¡Õ0ð r   c                 ó|   • U R                   (       a  U R                  S   $ U R                  S   R                  5       $ )z"The least element in this subtree.r   )r8   r9   r:   Úminimumr   s    r   r„   Ú_Node.minimum  s/   € à�<�<Ø—9‘9˜Q‘<Ðà—=‘= Ñ#×+Ñ+Ó-Ð-r   c                 ó|   • U R                   (       a  U R                  S   $ U R                  S   R                  5       $ )z%The greatest element in this subtree.éÿÿÿÿ)r8   r9   r:   Úmaximumr   s    r   rˆ   Ú_Node.maximum  s/   € à�<�<Ø—9‘9˜R‘=Ð à—=‘= Ñ$×,Ñ,Ó.Ð.r   c                 ó  • UR                   (       a   eU R                  X5      (       a  gU R                  X5      (       a  gUS:X  a  U R                  X5        gUR	                  US-
  5      nUR                  XS-
  5        g)z¦This 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.Nr   r%   )r8   rx   r`   r�   rV   )r   rt   rP   ra   s       r   ÚbalanceÚ_Node.balance  sr   € ð —>—>Ð!Ð!Ø×Ñ˜v×-Ñ-ØØ×Ñ ×.Ñ.Øà�A‹:à�J‰J�vÕ%ð ×)Ñ)¨%°!©)Ó4ˆDØ�J‰J�v q™yÕ)r   Úexactc                 óP  • Ub  U R                  5       (       a   eU R                  U5      u  pESnU(       a…  Ub  U R                  U   ULa  [        S5      eU R                  (       a  U R                  R                  U5      $ SnUnU R                  US-      R                  5       nUR                  5       nUS-   nU R                  (       a  Ub  [        S5      egU R                  U5      nUR                  5       (       aS  UR                  X5        U R                  U5      u  pEU(       a   eU R                  U   nUR                  5       (       a   eUR                  XU5      n	Ub<  U R                  U5      u  p¤U
c   eU	c   eU
R                  U   nXšR                  U'   Un	U	$ )z±Delete 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%   zexact delete had no match)rE   rN   r9   Ú
ValueErrorr8   rv   r:   r„   r   rV   r‹   ÚdeleterZ   )r   r   rt   r�   rI   rK   Úoriginal_keyÚleast_successorrT   rw   Únoderl   s               r   r�   Ú_Node.delete&  s�  € ð ‰~ T§_¡_×%6Ñ%6Ð6Ð6Ø×&Ñ& sÓ+‰ˆØˆÞàÑ  T§Y¡Y¨q¡\¸Ò%>Ü Ð!JÓKÐKØ�|�|Ø—y‘y—}‘} QÓ'Ð'ð ˆEØˆLØ"Ÿm™m¨A°©EÑ2×:Ñ:Ó<ˆOØ!×%Ñ%Ó'ˆCØ�A‘ˆAØ�<�<àÑ Ü Ð!<Ó=Ð=Øà×$Ñ$ QÓ'ˆØ×Ñ×ÑØ�M‰M˜$Ô"à×*Ñ*¨3Ó/‰HˆAÞÐ�9Ø—M‘M !Ñ$ˆEØ×'Ñ'×)Ñ)Ð)Ð)Ø�l‰l˜3 eÓ,ˆØÑ#Ø—n‘n \Ó2‰GˆDØÑ#Ð#Ð#Ø‘?Ð"�?Ø—9‘9˜Q‘<ˆDØ�I‰I�a‰LØˆCØˆ
r   Úvisitc                 ó  • [        U R                  5       H<  u  p#U R                  (       d  U R                  U   R	                  U5        U" U5        M>     U R                  (       d  U R                  S   R	                  U5        gg)z-Call *visit* on all of the elements in order.r‡   N)Ú	enumerater9   r8   r:   Úvisit_in_order)r   r•   rI   rw   s       r   r˜   Ú_Node.visit_in_orderU  sa   € ä §	¡	Ö*‰FˆAØ—<—<Ø—‘˜aÑ ×/Ñ/°Ô6Ù�#ŽJñ +ð �|�|Ø�M‰M˜"Ñ×,Ñ,¨UÕ3ð r   c                 ó€   • U" U 5        U R                   (       d%  U R                   H  nUR                  U5        M     gg)z?Visit nodes in preorder.  This method is only used for testing.N)r8   r:   Ú_visit_preorder_by_node)r   r•   rT   s      r   r›   Ú_Node._visit_preorder_by_node^  s1   € áˆdŒØ�|�|ØŸœ�Ø×-Ñ-¨eÖ4ò 'ð r   c                 óD   • U R                   ULa  U R                  U5      $ g)z”Return 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)r7   Úclone)r   r7   s     r   rS   Ú_Node.maybe_cowe  s"   € ð �<‰<˜wÒ&Ø—:‘:˜gÓ&Ð&àr   c                 ó  • U R                  U R                  XR                  5      nUR                  R	                  U R                  5        U R                  (       d%  UR
                  R	                  U R
                  5        U$ )z+Make a shallow-copy duplicate of this node.)ro   r#   r8   r9   r€   r:   )r   r7   rU   s      r   rž   Ú_Node.clonem  sR   € à—‘ §¡¨·±Ó>ˆØ�‰×Ñ˜4Ÿ9™9Ô%Ø�|�|Ø�O‰O×"Ñ" 4§=¡=Ô1Øˆr   c           	      óü   • U R                   (       d;  SSR                  U R                   Vs/ s H  n[        U5      S PM     sn5      -   nOSn[        U 5      S SU R                   SU R
                   U 3$ s  snf )NÚ r/   Ú )r8   Újoinr:   r0   r7   r9   )r   Úcr:   s      r   r1   Ú_Node.__str__u  sm   € Ø�|�|Ø˜SŸX™X¸T¿]º]Ó&Kº]¸¬"¨Q«%°¨¢|¹]Ñ&KÓLÑL‰HàˆHÜ�T“(˜1�˜Q˜tŸ|™|˜n¨A¨d¯i©i¨[¸¸
ÐCÐCùò 'Ls   ¬A9
)r:   r7   r9   r8   r#   )'r   r   r   r   r   Ú	__slots__Úintr,   Úboolr=   rA   rE   r   ÚtuplerN   rV   r	   r   rZ   r!   r]   rb   rj   ri   rx   r`   rh   r�   r„   rˆ   r‹   r�   r   r˜   r›   rS   rž   r1   r    r   r   r   r4   r4   4   s7  † ñò
 @€Ið0˜#ð 0¨ð 0¸4ô 0ð.˜Dô .ð
.˜Dô .ð
 "ð ¨¨s°D¨yÑ)9ô ð: Sð ¨_ô ð(˜Rð ( E¨(°?Ñ*CÀSÐ*HÑ$Iô (ð -�rð -˜b 4™iô -ð°ð ¸ô ð$ bð °Dð ¸RÀ$¹Yô ð2
#�u˜_¨b°/ÐAÑBô 
#ð _ð ¸Sð ÀTô ð& oð ¸cð Àdô ð&/˜/ð /°2ð /¸oð /ÐRVô /ð"1˜Oð 1°Cð 1¸Dô 1ð.˜ô .ð/˜ô /ð*˜oð *°cð *¸dô *ð&-Øð-Ø'¨Ñ8ð-ØACÀdÁð-à	ˆd‰ô-ð^4 H¨b¨T°4¨ZÑ$8ð 4¸Tô 4ð5¨X°Ð6GÈÐ6MÑ-Nð 5ÐSWô 5ð ð ¨h°Ñ.Gô ð˜Xð ¨/ô õDr   r4   c                   óº   • \ rS rSrSrSS jrSS jrSS jrS rS	 r	S\
S-  4S
 jrS\
S-  4S jrS\S\SS4S jrSS\S\SS4S jjrSS jrSS jrS rS rSrg)ÚCursori}  z½A 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.
c                 ó€   • Xl         S U l        SU l        SU l        SU l        / U l        SU l        S U l        SU l        g )Nr   FT)	ÚbtreeÚcurrent_nodeÚcurrent_indexÚrecurseÚ
increasingÚparentsÚparkedÚparking_keyÚparking_key_read)r   r¯   s     r   r=   ÚCursor.__init__…  sE   € ØŒ
Ø*.ˆÔð #$ˆÔØˆŒØˆŒØ02ˆŒØˆŒØ&*ˆÔØ %ˆÕr   r   Nc                 ór  • U R                   c   eU R                   R                  (       d�  U R                  R                  U R                   U R                  45        U R                   R
                  U R                     U l         U R                   c   eSU l        U R                   R                  (       d  MŒ  g g rY   )r°   r8   r´   r{   r±   r:   r   s    r   Ú_seek_leastÚCursor._seek_least“  s•   € ð × Ñ Ñ,Ð,Ð,Ø×#Ñ#×+×+Ø�L‰L×Ñ ×!2Ñ!2°D×4FÑ4FÐ GÔHØ $× 1Ñ 1× :Ñ :¸4×;MÑ;MÑ NˆDÔØ×$Ñ$Ñ0Ð0Ð0Ø!"ˆDÔð	 ×#Ñ#×+×+Ó+r   c                 ó¬  • U R                   c   eU R                   R                  (       dª  U R                  R                  U R                   U R                  45        U R                   R
                  U R                     U l         U R                   c   e[        U R                   R                  5      U l        U R                   R                  (       d  M©  g g rR   )r°   r8   r´   r{   r±   r:   r@   r9   r   s    r   Ú_seek_greatestÚCursor._seek_greatest�  s¦   € ð × Ñ Ñ,Ð,Ð,Ø×#Ñ#×+×+Ø�L‰L×Ñ ×!2Ñ!2°D×4FÑ4FÐ GÔHØ $× 1Ñ 1× :Ñ :¸4×;MÑ;MÑ NˆDÔØ×$Ñ$Ñ0Ð0Ð0Ü!$ T×%6Ñ%6×%;Ñ%;Ó!<ˆDÔð	 ×#Ñ#×+×+Ó+r   c                 ó6   • U R                   (       d  SU l         gg)aw  Park 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µ   r   s    r   ÚparkÚCursor.park§  s   € ð �{�{ØˆD�Kð r   c                 ó  • U R                   (       ay  U R                  b]  U R                  nU R                  (       a  U R                  (       + nOU R                  nU R	                  U R                  U5        Xl        SU l         S U l        g g ©NF)rµ   r¶   r³   r·   Úseek)r   r³   Úbefores      r   Ú_maybe_unparkÚCursor._maybe_unpark³  sm   € Ø�;�;Ø×ÑÑ+à!Ÿ_™_�
Ø×(×(ð "&§¡Ô0‘Fð
 "Ÿ_™_�FØ—	‘	˜$×*Ñ*¨FÔ3Ø",”ØˆDŒKØ#ˆDÕð! r   c                 óz  • U R                  5         SU l        U R                  c|  U R                  S:X  a  gU R                  S:X  d   eU R                  R
                  U l        [        U R                  R
                  R                  5      U l        U R                  5          U R                  (       a(  U R                  (       d  U R                  5         SU l	        SU l
        U =R                  S-  sl        U R                  S:¼  ac  U R                  R                  U R                     nU R                  R                  (       d  SU l	        UR                  5       U l        SU l        U$ [        U R                  5      S:”  a(  U R                  R                  5       u  U l        U l        OSU l        SU l        gGM  )zAGet the previous element, or return None if on the left boundary.Nr   r%   TF)rÆ   r¶   r°   r±   r¯   Úrootr@   r9   r½   r²   r³   r8   r   r·   r´   rv   ©r   rw   s     r   ÚprevÚCursor.prevÆ  s_  € à×ÑÔØˆÔØ×ÑÑ$à×!Ñ! QÓ&àà×)Ñ)¨QÓ.Ð.Ð.ð %)§J¡J§O¡O�Ô!Ü%(¨¯©¯©×)=Ñ)=Ó%>�Ô"Ø×#Ñ#Ô%ØØ�|�|Ø——ð ×'Ñ'Ô)Ø$�”Ø#ˆDŒOØ×Ò !Ñ#ÕØ×!Ñ! QÓ&Ø×'Ñ'×,Ñ,¨T×-?Ñ-?Ñ@�Ø×(Ñ(×0×0Ø#'�D”LØ#&§7¡7£9�Ô Ø(,�Ô%Ø�
ä�t—|‘|Ó$ qÓ(Ø<@¿L¹L×<LÑ<LÓ<NÑ9�DÔ% tÕ'9à(,�DÔ%Ø)*�DÔ&Øò- r   c                 óf  • U R                  5         SU l        U R                  cU  U R                  S:X  a  gU R                  S:X  d   eU R                  R
                  U l        SU l        U R                  5          U R                  (       a(  U R                  (       a  U R                  5         SU l        SU l        U R                  [        U R                  R                  5      :  ax  U R                  R                  U R                     nU =R                  S-  sl        U R                  R                  (       d  SU l        UR                  5       U l        SU l        U$ [        U R                  5      S:”  a(  U R                  R                  5       u  U l        U l        OSU l        SU l        gGM8  )z>Get the next element, or return None if on the right boundary.Nr%   r   TF)rÆ   r¶   r°   r±   r¯   rÉ   rº   r²   r³   r@   r9   r8   r   r·   r´   rv   rÊ   s     r   ÚnextÚCursor.nextî  s]  € à×ÑÔØˆÔØ×ÑÑ$à×!Ñ! QÓ&àà×)Ñ)¨QÓ.Ð.Ð.ð %)§J¡J§O¡O�Ô!Ø%&�Ô"Ø× Ñ Ô"ØØ�|�|Ø—?—?ð ×$Ñ$Ô&Ø$�”Ø"ˆDŒOØ×!Ñ!¤C¨×(9Ñ(9×(>Ñ(>Ó$?Ó?Ø×'Ñ'×,Ñ,¨T×-?Ñ-?Ñ@�Ø×"Ò" aÑ'Õ"Ø×(Ñ(×0×0Ø#'�D”LØ#&§7¡7£9�Ô Ø(,�Ô%Ø�
ä�t—|‘|Ó$ qÓ(Ø<@¿L¹L×<LÑ<LÓ<NÑ9�DÔ% tÕ'9à(,�DÔ%Ø)*�DÔ&Øò- r   rÅ   rI   c                 ó4   • U(       a  X l         g US-   U l         g )Nr%   )r±   )r   rÅ   rI   s      r   Ú_adjust_for_beforeÚCursor._adjust_for_before  s   € ÞØ!"Õà!" Q¡ˆDÕr   r   c                 óô  • U R                   R                  U l        U R                  c   eSU l        / U l        X l        SU l        Xl        SU l        U R                  R                  (       dÏ  U R                  R                  U5      u  p4U(       a:  U R                  X#5        U(       a  U R                  5         gU R                  5         gU R                  R                  U R                  U45        U R                  R                  U   U l        U R                  c   eU R                  R                  (       d  MÏ  U R                  R                  U5      u  p4U(       a  U R                  X#5        gX0l        g)a�  Seek 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)r¯   rÉ   r°   r²   r´   r³   rµ   r¶   r·   r8   rN   rÑ   r½   rº   r{   r:   r±   )r   r   rÅ   rI   rK   s        r   rÄ   ÚCursor.seek  s8  € ð !ŸJ™JŸO™OˆÔØ× Ñ Ñ,Ð,Ð,ØˆŒØˆŒØ ŒØˆŒØÔØ %ˆÔØ×#Ñ#×+×+Ø×(Ñ(×7Ñ7¸Ó<‰HˆAÞØ×'Ñ'¨Ô2ÞØ×'Ñ'Ô)ð ð ×$Ñ$Ô&ØØ�L‰L×Ñ ×!2Ñ!2°AÐ 6Ô7Ø $× 1Ñ 1× :Ñ :¸1Ñ =ˆDÔØ×$Ñ$Ñ0Ð0Ð0ð ×#Ñ#×+×+Ñ+ð ×$Ñ$×3Ñ3°CÓ8‰ˆÞØ×#Ñ# FÕ.à!"Õr   c                 óf   • SU l         SU l        SU l        SU l        / U l        SU l        SU l        g)zŒSeek 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.Nr   FT©r°   r±   r²   r³   r´   rµ   r¶   r   s    r   Ú
seek_firstÚCursor.seek_first?  s8   € ð !ˆÔØˆÔØˆŒØˆŒØˆŒØˆŒØˆÕr   c                 óf   • SU l         SU l        SU l        SU l        / U l        SU l        SU l        g)z“Seek 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%   FrÖ   r   s    r   Ú	seek_lastÚCursor.seek_lastK  s8   € ð
 !ˆÔØˆÔØˆŒØˆŒØˆŒØˆŒØˆÕr   c                 ó<   • U R                   R                  U 5        U $ rR   )r¯   Úregister_cursorr   s    r   Ú	__enter__ÚCursor.__enter__X  s   € Ø�
‰
×"Ñ" 4Ô(Øˆr   c                 ó:   • U R                   R                  U 5        grÃ   )r¯   Úderegister_cursor)r   Úexc_typeÚ	exc_valueÚ	tracebacks       r   Ú__exit__ÚCursor.__exit__\  s   € Ø�
‰
×$Ñ$ TÔ*Ør   )	r¯   r±   r°   r³   r´   rµ   r¶   r·   r²   )r¯   zBTree[KT, ET]©r   N)T)r   r   r   r   r   r=   rº   r½   rÀ   rÆ   r!   rË   rÎ   rª   r©   rÑ   r   rÄ   r×   rÚ   rÞ   rå   r    r   r   r   r­   r­   }  s‹   † ñô&ô#ô=ò
ò$ð&& �b˜4‘iô & ðP& �b˜4‘iô & ðP'¨ð '°#ð '¸$ô 'ñ!#˜ð !# Dð !#°Dõ !#ôF
 ô òõr   r­   c                   ó   • \ rS rSrSrSrg)Ú	Immutableia  zThe BTree is immutable.r   N)r   r   r   r   r   r    r   r   r   ré   ré   a  s   † Ü!r   ré   c                   ó^  • \ rS rSrSr\SS.S\S\S    4S jjrS r	S S
 jr
S!S\S\S	\S-  4S jjrS\S	\S-  4S jrS\S\S-  S	\S-  4S jrS\S	\S-  4S jrS\S	\S-  4S jrS rS\\/S4   S	S4S jrS\\/S4   S	S4S jrS	\\\4   4S jrS\S	S4S jrS\S	S4S jrS rS rSrg)"ÚBTreeie  z2An in-memory BTree with copy-on-write and cursors.N©r#   Úoriginalr#   rí   c                óˆ  • [        5       U l        SU l        U   U   U   [        5       U l        UbP  UR                  (       d  [        S5      eUR                  U l        UR                  U l        UR                  U l        gUS:  a  [        S5      eXl        [        U R                  U R                  S5      U l        SU l        g)zÕCreate 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.
FNzoriginal BTree is not immutabler<   zt must be >= 3Tr   )
r,   r7   Ú
_immutableÚsetÚcursorsr�   r#   rÉ   Úsizer4   )r   r#   rí   s      r   r=   ÚBTree.__init__h  s™   € ô  “zˆŒØˆŒÙÙÙÜ$'£EˆŒØÑØ×&×&Ü Ð!BÓCÐCØ—Z‘ZˆDŒFØ Ÿ™ˆDŒIØ Ÿ™ˆD�Ià�1‹uÜ Ð!1Ó2Ð2ØŒFÜ˜dŸf™f d§l¡l°DÓ9ˆDŒIØˆD�Ir   c                 ó6   • U R                   (       d  SU l         gg)z–Make the BTree immutable.

Attempts to alter the BTree after making it immutable will raise an
Immutable exception.  This operation cannot be undone.
TN)rï   r   s    r   Úmake_immutableÚBTree.make_immutable†  s   € ð ��Ø"ˆD�Oð r   r   c                 óx   • U R                   (       a  [        eU R                   H  nUR                  5         M     g rR   )rï   ré   rñ   rÀ   ©r   Úcursors     r   Ú_check_mutable_and_parkÚBTree._check_mutable_and_park�  s%   € Ø�?�?ÜˆOØ—l”lˆFØ�K‰KŽMò #r   rw   re   c                 óà  • U R                  5         U R                  R                  U R                  5      nU(       a  X0l        U R                  R	                  5       (       aY  U R                  n[        U R                  U R                  S5      U l        U R                  R                  " UR                  5       6   U R                  R                  X5      nUc  U =R                  S-  sl
        U$ )a  Insert 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``.
Fr%   )rú   rÉ   rS   r7   rA   r4   r#   rh   ri   rj   rò   )r   rw   re   rU   Úold_rootrl   s         r   Úinsert_elementÚBTree.insert_element™  s¦   € ð 	×$Ñ$Ô&Ø—‘×$Ñ$ T§\¡\Ó2ˆÞØŒIØ�9‰9×Ñ×!Ñ!Ø—y‘yˆHÜ˜dŸf™f d§l¡l°EÓ:ˆDŒIØ�I‰I�OŠO˜XŸ^™^Ó-Ñ.Ø�y‰y×'Ñ'¨Ó6ˆØ‰<à�IŠI˜‰N�IØˆr   r   c                 ó8   • U R                   R                  U5      $ )zXGet the element matching *key* from the BTree, or return ``None`` if it
does not exist.
)rÉ   r]   ©r   r   s     r   Úget_elementÚBTree.get_element°  s   € ð �y‰y�}‰}˜SÓ!Ð!r   r�   c                 óö  • U R                  5         U R                  R                  U R                  5      nU(       a  X0l        U R                  R	                  US U5      nUb–  U =R
                  S-  sl        [        U R                  R                  5      S:X  a^  U R                  R                  (       dC  [        U R                  R                  5      S:X  d   eU R                  R                  S   U l        U$ )Nr%   r   )
rú   rÉ   rS   r7   r�   rò   r@   r9   r8   r:   )r   r   r�   rU   rw   s        r   Ú_deleteÚBTree._delete¶  s´   € Ø×$Ñ$Ô&Ø—‘×$Ñ$ T§\¡\Ó2ˆÞØŒIØ�i‰i×Ñ˜s D¨%Ó0ˆØ‰?à�IŠI˜‰N�IÜ�4—9‘9—>‘>Ó" aÓ'ð —y‘y×(×(Ü˜tŸy™y×1Ñ1Ó2°aÓ7Ð7Ð7Ø $§	¡	× 2Ñ 2°1Ñ 5�D”IØˆ
r   c                 ó&   • U R                  US5      $ )zrDelete the element matching *key* from the BTree.

Returns the matching element or ``None`` if it does not exist.
N)r  r  s     r   Ú
delete_keyÚBTree.delete_keyÇ  s   € ð
 �|‰|˜C Ó&Ð&r   rd   c                 óR   • U R                  UR                  5       U5      nX!L d   eU$ )zgDelete *element* from the BTree.

Returns the matching element or ``None`` if it was not in the BTree.
)r  r   )r   rd   Údelts      r   Údelete_exactÚBTree.delete_exactÎ  s)   € ð
 �|‰|˜GŸK™K›M¨7Ó3ˆØŠÐˆØˆr   c                 ó   • U R                   $ rR   )rò   r   s    r   Ú__len__ÚBTree.__len__×  ó   € Ø�y‰yÐr   r•   c                 ó:   • U R                   R                  U5        g)zBCall *visit*(element) on all elements in the tree in sorted order.N)rÉ   r˜   ©r   r•   s     r   r˜   ÚBTree.visit_in_orderÚ  s   € à�	‰	× Ñ  Õ'r   c                 ó:   • U R                   R                  U5        g rR   )rÉ   r›   r  s     r   r›   ÚBTree._visit_preorder_by_nodeÞ  s   € Ø�	‰	×)Ñ)¨%Õ0r   c                 ó   • [        U 5      $ )zCreate a cursor.)r­   r   s    r   rù   ÚBTree.cursorá  s   € ä�d‹|Ðr   rù   c                 ó:   • U R                   R                  U5        g)z4Register a cursor for the automatic parking service.N)rñ   Úaddrø   s     r   rÝ   ÚBTree.register_cursorå  s   € à�‰×Ñ˜Õ r   c                 ó:   • U R                   R                  U5        g)z7Deregister a cursor from the automatic parking service.N)rñ   Údiscardrø   s     r   rá   ÚBTree.deregister_cursoré  s   € à�‰×Ñ˜VÕ$r   c                 ó    • U R                  U S9$ )N)rí   ©ro   r   s    r   Ú__copy__ÚBTree.__copy__í  s   € Ø�~‰~ tˆ~Ð,Ð,r   c              #   ó²   #   • U R                  5        n UR                  5       nUc  OUR                  5       v •  M(  S S S 5        g ! , (       d  f       g = f7frR   )rù   rÎ   r   )r   rù   rw   s      r   Ú__iter__ÚBTree.__iter__ð  s?   é € Ø�[‰[Œ]˜fØØ—k‘k“m�Ø‘;ØØ—g‘g“i’ñ	 ÷ �]Ž]üs   ‚A“*A½	AÁ
AÁA)rï   r7   rñ   rÉ   rò   r#   rç   )F)r   r   r   r   r   Ú	DEFAULT_Tr©   r   r=   rõ   rú   r!   rª   rþ   r   r  r  r  r  r  r   r˜   r4   r›   r­   rù   rÝ   rá   r!  r$  r    r   r   r   rë   rë   e  s6  † Ù<à#,ÈDò ˜Sð ¸ÀÑ8Iõ ò<#ôñ "ð °ð ÀÀdÁõ ð."˜rð " b¨4¡iô "ð˜2ð  b¨4¡ið °B¸±Iô ð"'˜bð ' R¨$¡Yô 'ð Bð ¨2°©9ô òð( H¨b¨T°4¨ZÑ$8ð (¸Tô (ð1¨X°u°g¸t°mÑ-Dð 1Èô 1ð˜˜r 2˜v™ô ð! fð !°ô !ð%¨ð %°4ô %ò-õ r   rë   ÚVTc                   óR   • \ rS rSrSrS\S\4S jrS\4S jrS\4S jr	S	 r
S
 rSrg)ÚKViü  z/The BTree element type used in a ``BTreeDict``.r   Úvaluec                 ó   • Xl         X l        g rR   ©Ú_keyÚ_value)r   r   r*  s      r   r=   ÚKV.__init__ÿ  s   € ØŒ	Ø�r   r   c                 ó   • U R                   $ rR   ©r-  r   s    r   r   ÚKV.key  r  r   c                 ó   • U R                   $ rR   )r.  r   s    r   r*  ÚKV.value  s   € Ø�{‰{Ðr   c                 ó<   • SU R                    SU R                   S3$ ©NzKV(z, Ú)r,  r   s    r   r1   Ú
KV.__str__	  ó   € Ø�T—Y‘Y�K˜r $§+¡+ ¨aÐ0Ð0r   c                 ó<   • SU R                    SU R                   S3$ r6  r,  r   s    r   Ú__repr__ÚKV.__repr__  r9  r   r,  N)r   r   r   r   r   r   r'  r=   r   r*  r1   r;  r    r   r   r   r)  r)  ü  s:   † Ù9ð˜Bð  rô ð�Rô ð�rô ò1õ1r   r)  c                   óˆ   ^ • \ rS rSrSr\SSS.S\S\S-  S\4U 4S	 jjjr	S
\
S\4S jrS
\
S\SS4S jrS
\
SS4S jrSrU =r$ )Ú	BTreeDicti  zwA MutableMapping implemented with a BTree.

Unlike a normal Python dict, the BTreeDict may be mutated while iterating.
NF©r#   rí   re   r#   rí   re   c                ó,   >• [         TU ]  XS9  X0l        g ©Nrì   ©Úsuperr=   re   ©r   r#   rí   re   ro   s       €r   r=   ÚBTreeDict.__init__  ó   ø€ ô 	‰Ñ˜1ÐÑ0Ø �r   r   r   c                 ór   • U R                  U5      nUc  [        e[        [        U5      R	                  5       $ rR   )r  ÚKeyErrorr   r)  r*  )r   r   rw   s      r   Ú__getitem__ÚBTreeDict.__getitem__   s1   € Ø×Ñ˜sÓ#ˆØ‰;ÜˆNäœ˜C“=×&Ñ&Ó(Ð(r   r*  c                 óP   • [        X5      nU R                  X0R                  5        g rR   )r)  rþ   re   )r   r   r*  rw   s       r   Ú__setitem__ÚBTreeDict.__setitem__'  s   € Ü�‹nˆØ×Ñ˜C§¡Õ/r   c                 ó4   • U R                  U5      c  [        eg rR   )r  rH  r  s     r   Ú__delitem__ÚBTreeDict.__delitem__+  s   € Ø�?‰?˜3ÓÑ'ÜˆNð (r   ©re   )r   r   r   r   r   r&  r©   rë   rª   r=   r   r'  rI  rL  rO  r    Ú__classcell__r   s   @r   r>  r>    s„   ø† ñð Ø!%Øò!ð ð!ð ˜$‘,ð	!ð
 ÷!ð !ð)˜rð ) bô )ð0˜rð 0¨"ð 0°ô 0ð˜rð  d÷ ò r   r>  c                   ó4   • \ rS rSrSrS\4S jrS\4S jrSrg)	ÚMemberi0  z.The BTree element type used in a ``BTreeSet``.r   c                 ó   • Xl         g rR   r1  r  s     r   r=   ÚMember.__init__3  s   € Ø�	r   r   c                 ó   • U R                   $ rR   r1  r   s    r   r   Ú
Member.key6  r  r   r1  N)	r   r   r   r   r   r   r=   r   r    r   r   r   rT  rT  0  s   † Ù8ð˜Bô ð�R÷ r   rT  c                   ó„   ^ • \ rS rSrSr\SSS.S\S\S-  S\4U 4S	 jjjr	S
\
S\4S jrS\SS4S jrS\SS4S jrSrU =r$ )ÚBTreeSeti:  zqA MutableSet implemented with a BTree.

Unlike a normal Python set, the BTreeSet may be mutated while iterating.
NFr?  r#   rí   re   c                ó,   >• [         TU ]  XS9  X0l        g rA  rB  rD  s       €r   r=   ÚBTreeSet.__init__@  rF  r   r   r   c                 ó(   • U R                  U5      S L$ rR   )r  r  s     r   Ú__contains__ÚBTreeSet.__contains__J  s   € Ø×Ñ Ó$¨DÐ0Ð0r   r*  c                 óP   • [        U5      nU R                  X R                  5        g rR   )rT  rþ   re   )r   r*  rw   s      r   r  ÚBTreeSet.addM  s   € Ü�U‹mˆØ×Ñ˜C§¡Õ/r   c                 ó&   • U R                  U5        g rR   )r  )r   r*  s     r   r  ÚBTreeSet.discardQ  s   € Ø�‰˜Õr   rQ  )r   r   r   r   r   r&  r©   rë   rª   r=   r   r^  r   r  r  r    rR  r   s   @r   rZ  rZ  :  s}   ø† ñð Ø!%Øò!ð ð!ð ˜$‘,ð	!ð
 ÷!ð !ð1 ð 1¨ô 1ð0˜ð 0 ô 0ð˜Rð  D÷ ò r   rZ  N)r   Úcollections.abcr   r   Útypingr   r   r   r   r	   r
   r   r&  r   r   r!   r©   r'   r*   r,   r4   r­   Ú	Exceptionré   rë   r'  r)  r>  rT  rZ  r   r   r   Ú<module>rg     sE  ðñ÷ 7ß I× IÑ Ià€	áˆTƒ]€ô"ˆg�b‰kô "ñ ˆT˜Ñ!€ðˆCð �Cô ðˆCð �Cô ÷
	ñ 	ôFDˆG�B˜�F‰Oô FDôR
aˆW�R˜�V‰_ô aôH"�	ô "ôQ ˆG�B˜�F‰Oô Q ñh ˆTƒ]€ô1ˆ�'˜"˜b˜&‘/ô 1ô(�˜˜B˜‘  r¨2¨b°"¨f©: ~Ñ!6¸ÀrÈ2ÀvÑ8Nô ô@ˆW�g˜b‘kô ôˆu�g˜b‘k :¨b¡>õ r   