
    ԋg                        d dl mZ d dlZd dlZd dlZd dlmZmZ d dlm	Z	m
Z
mZmZmZmZ d dlmZmZmZ  ede
      Z ede
      Z ed	      Z G d
 deeef         Z G d dee         ZddZy)    )annotationsN)OrderedDictUserDict)CallableHashableIterableIteratorMapping
MutableSet)AnyTypeVarcastT)boundKVc                  <     e Zd ZdZd fdZd fdZd fdZ xZS )LRUzILimited size mapping, evicting the least recently looked-up key when fullc                N    t         |           t               | _        || _        y N)super__init__r   datamaxsize)selfr   	__class__s     7lib/python3.12/site-packages/distributed/collections.pyr   zLRU.__init__   s    M	    c                x    t         |   |      }t        t        | j                        j                  |       |S r   )r   __getitem__r   r   r   move_to_endr   keyvaluer   s      r   r    zLRU.__getitem__   s0    #C([$))$005r   c                    t        |       | j                  k\  r*t        t        | j                        j                  d       t        |   ||       y )NF)last)lenr   r   r   r   popitemr   __setitem__r"   s      r   r)   zLRU.__setitem__   s>    t9$dii(00e0<C'r   )r   floatreturnNone)r#   r   r+   r   )r#   r   r$   r   r+   r,   )__name__
__module____qualname____doc__r   r    r)   __classcell__)r   s   @r   r   r      s    S

( (r   r   c                      e Zd ZU dZdZded<   ded<   ded<   d	ed
<   ded<   ddZddZd dZe		 	 	 	 	 	 	 	 d!d       Z
d"dZd#dZd$dZd$dZd%dZd&dZd%dZd%dZd%dZd'dZd'dZd(dZy))HeapSeta  A set-like where the `pop` method returns the smallest item, as sorted by an
    arbitrary key function. Ties are broken by oldest first.

    Values must be compatible with :mod:`weakref`.

    Parameters
    ----------
    key: Callable
        A function that takes a single element of the collection as a parameter and
        returns a sorting key. The key does not need to be hashable and does not need to
        support :mod:`weakref`.

    Note
    ----
    The key returned for each element should not to change over time. If it does, the
    position in the heap won't change, even if the element is re-added, and it *may* not
    change even if it's discarded and then re-added later.
    )r#   _data_heap_inc_sortedCallable[[T], Any]r#   zset[T]r4   z%list[tuple[Any, int, weakref.ref[T]]]r5   intr6   boolr7   c               Z    || _         t               | _        d| _        g | _        d| _        y )Nr   T)r#   setr4   r6   r5   r7   )r   r#   s     r   r   zHeapSet.__init__=   s'    U
	
r   c                L    dt        |       j                   dt        |        dS )N<z: z items>)typer-   r'   r   s    r   __repr__zHeapSet.__repr__D   s&    4:&&'r#d)G<<r   c                    | j                   D cg c]!  \  }}} |       x}| j                  v s|||f# }}}}t        j                  | j                  | j
                  |ffS c c}}}w r   )r5   r4   r3   	_unpickler#   r6   )r   kivrefvheaps         r   
__reduce__zHeapSet.__reduce__G   s]    ,0JJVJjaD;14:::UAq	JV  488TYY"=== Ws
   A$A$c           
     X   t         j                  t              }| |_        |D ch c]  \  }}}|
 c}}|_        ||_        |D cg c]  \  }}}||t        j                  |      f  c}}}|_        t        j                  |j                         | |_        |S c c}}w c c}}}w r   )object__new__r3   r#   r4   r6   weakrefrefr5   heapqheapifyr7   )r#   incrH   r   _rG   rD   rE   s           r   rC   zHeapSet._unpickleK   s     ~~g&'+,tGAq!at,
	<@ADAqq!W[[^,DA
djj!x -As   B	#B%c                    || j                   v S r   )r4   r   r$   s     r   __contains__zHeapSet.__contains__X   s    

""r   c                ,    t        | j                        S r   )r'   r4   r@   s    r   __len__zHeapSet.__len__[   s    4::r   c                6   || j                   v ry | j                  |      }t        j                  |      }t	        j
                  | j                  || j                  |f       d| _        | j                   j                  |       | xj                  dz  c_        y )NF   )
r4   r#   rM   rN   rO   heappushr5   r6   r7   add)r   r$   rD   rF   s       r   r[   zHeapSet.add^   sm    DJJHHUO{{5!tzzAtyy$#78

u		Q	r   c                t    | j                   j                  |       | j                   s| j                          y y r   )r4   discardclearrT   s     r   r]   zHeapSet.discardh   s)    

5!zzJJL r   c                    | j                   st        d      	  | j                  d   d          }|| j                   v r|S t        j                  | j                         d| _        N)z/Return the smallest element without removing itpeek into empty setr      F)r4   KeyErrorr5   rO   heappopr7   rT   s     r   peekzHeapSet.peekm   s\    zz011$DJJqM!$&E

"MM$**% DL r   c              #     K   |dk  s| sy|dk(  r| j                          yt        j                  | j                         |      E d{    y7 w)zzIterate over the n smallest elements without removing them.
        This is O(1) for n == 1; O(n*logn) otherwise.
        r   NrY   )rd   	itertoolsislicesorted)r   ns     r   peeknzHeapSet.peeknx   sE      66))+ !''q999s   AA
AAc                $   | j                   st        d      	 t        j                  | j                        \  }}}d| _         |       }|| j                   v r9| j                   j                  |       | j                   s| j                          |S y)Npop from an empty setF)r4   rb   rO   rc   r5   r7   r]   r^   r   rR   rF   r$   s       r   popzHeapSet.pop   sv    zz233tzz2JAq$ DLFE

"

""5)zzJJL r   c                    | j                   st        d      	  | j                  d   d          }|| j                   v r|S | j                  d= 5)zReturn one of the largest elements (not necessarily the largest!) without
        removing it. It's guaranteed that ``self.peekright() >= self.peek()``.
        r`   ra   )r4   rb   r5   rT   s     r   	peekrightzHeapSet.peekright   sR     zz011%DJJrN1%'E

"

2	 r   c                   | j                   st        d      	 | j                  j                         \  }}} |       }|| j                   v r9| j                   j	                  |       | j                   s| j                          |S m)zRemove and return one of the largest elements (not necessarily the largest!)
        It's guaranteed that ``self.popright() >= self.peek()``.
        rl   )r4   rb   r5   rn   r]   r^   rm   s       r   poprightzHeapSet.popright   so     zz233)JAq$FE

"

""5)zzJJL r   c                ,    t        | j                        S )zwIterate over all elements. This is a O(n) operation which returns the
        elements in pseudo-random order.
        )iterr4   r@   s    r   __iter__zHeapSet.__iter__   s     DJJr   c              #    K   | j                   s!| j                  j                          d| _         t               }| j                  D ]6  \  }}} |       }|| j                  v s||vs"| |j                  |       8 yw)zIterate over all elements. This is a O(n*logn) operation which returns the
        elements in order, from smallest to largest according to the key and insertion
        order.
        TN)r7   r5   sortr<   r4   r[   )r   seenrR   rF   r$   s        r   rh   zHeapSet.sorted   si     
 ||JJOODLu**JAq$FE

"uD'8	 %s   A B #B (B c                z    | j                   j                          | j                  j                          d| _        y )NT)r4   r^   r5   r7   r@   s    r   r^   zHeapSet.clear   s)    



r   N)r#   r8   )r+   str)r+   ztuple[Callable, tuple])r#   r8   rQ   r9   rH   zlist[tuple[Any, int, T]]r+   z
HeapSet[T])r$   rK   r+   r:   )r+   r9   )r$   r   r+   r,   )r+   r   )ri   r9   r+   Iterator[T])r+   r|   )r+   r,   )r-   r.   r/   r0   	__slots____annotations__r   rA   rI   staticmethodrC   rU   rW   r[   r]   rd   rj   rn   rq   rs   rv   rh   r^    r   r   r3   r3   "   s    & =I	M00
IM=> 

&)
1I
	
 
#
	!: 
  r   r3   c                   i }| D ]:  }t        |t              r|j                         }|D ]  \  }}	 ||xx   |z  cc<    < |S # t        $ r |||<   Y *w xY w)z0Sum the values of the given mappings, key by key)
isinstancer
   itemsrb   )dsoutdrD   rG   s        r   sum_mappingsr      sg    Ca!	ADAqA!   J  As   AAA)r   z/Iterable[Mapping[K, V] | Iterable[tuple[K, V]]]r+   z
dict[K, V])
__future__r   rO   rf   rM   collectionsr   r   collections.abcr   r   r   r	   r
   r   typingr   r   r   r   r   r   r   r3   r   r   r   r   <module>r      sm    "    - W W % %Cx Cx CL((1a4. (&fjm fRr   