Be0'ddlmZddlmZmZmZmZmZmZm Z ddl m Z m Z m Z mZmZmZmZmZddlmZGddee e fZy)) annotations)Callable Collection ItemsViewIteratorKeysViewMutableMapping ValuesView)KTVT NoDefaultZictBasecloseflushlocked nodefault)InsertionSortedSetc~eZdZUdZded<ded<ded<ded<ded <d ed <d ed <d ed<ded<ded<d ed<ded<dddd d*fdZed+dZed,dZd-dZ ed-dZ d.d/dZ ee f d0dZ ed1d Zd2d!Zd3d"Zd4d#Zd5d$Zd6d%Zd7d&Zd8d'ZeZd9d(Zd9d)ZxZS):LRUaEvict Least Recently Used Elements. Parameters ---------- n: int or float Number of elements to keep, or total weight if ``weight`` is used. Any individual key that is heavier than n will be automatically evicted as soon as it is inserted. It can be updated after initialization. See also: ``offset`` attribute. d: MutableMapping Dict-like in which to hold elements. There are no expectations on its internal ordering. Iteration on the LRU follows the order of the underlying mapping. on_evict: callable or list of callables Function:: k, v -> action to call on key/value pairs prior to eviction If an exception occurs during an on_evict callback (e.g a callback tried storing to disk and raised a disk full error) the key will remain in the LRU. on_cancel_evict: callable or list of callables Function:: k, v -> action to call on key/value pairs if they're deleted or updated from a thread while the on_evict callables are being executed in another. If you're not accessing the LRU from multiple threads, ignore this parameter. weight: callable Function:: k, v -> number to determine the size of keeping the item in the mapping. Defaults to ``(k, v) -> 1`` Notes ----- If you call methods of this class from multiple threads, access will be fast as long as all methods of ``d`` are fast. Callbacks are not protected by locks and can be arbitrarily slow. Examples -------- >>> lru = LRU(2, {}, on_evict=lambda k, v: print("Lost", k, v)) >>> lru['x'] = 1 >>> lru['y'] = 2 >>> lru['z'] = 3 Lost x 1 MutableMapping[KT, VT]dzInsertionSortedSet[KT]orderheavyzlist[Callable[[KT, VT], None]]on_evicton_cancel_evictCallable[[KT, VT], float]weightfloatnoffsetzdict[KT, float]weightsboolclosed total_weightzdict[KT, bool] _cancel_evictNcy)N)kvs (lib/python3.12/site-packages/zict/lru.pyz LRU.]s)rrrc t|||_|_d|_t |r|g}|xsg|_t |r|g}|xsg|_||_|jDcic]\}}||||c}}|_ t|jj|_ t||_tfd|jjD|_d|_i|_ycc}}w)Nrc34K|]\}}|k\s |ywNr().0r)r*rs r+ zLRU.__init__..os'UdaaSTf'Us F)super__init__rrr callablerrritemsr!sumvaluesr$rrrr#r%) selfrrrrrr)r* __class__s ` r+r4z LRU.__init__Rs  H  zH B O $./O.4" 45GGI>DAq6!Q<>  3 3 56'* ''Udll6H6H6J'UU   ?s2Dc|j|}|jj||jj||Sr0rrremoveadd)r9keyresults r+ __getitem__zLRU.__getitem__ss6 # s r-c|Dcic]}||j|}}|D]8}|jj||jj|:|Scc}w)a8If all keys exist in the LRU, update their FIFO priority and return their values; this would be the same as ``{k: lru[k] for k in keys}``. If any keys are missing, however, raise KeyError for the first one missing and do not bring any of the available keys to the top of the LRU. r<)r9keysr?r@s r+get_all_or_nothingzLRU.get_all_or_nothingzsa/33s#tvvc{"33 C JJ  c " JJNN3   4sAcx|j|| |jy#t$r|jj |d|j kDr`||j vrR t|jdkDr)|jt|jdkDr)#t$rYwxYwwxYw)Nrr') set_noevictevict_until_below_target Exceptionr!getrrlenrevict)r9r?values r+ __setitem__zLRU.__setitem__s e$   ) ) + ||Q'$&&0S 5Jdff+/ dff+/ !   s/%AB9&AB('B9( B41B93B44B9ct|j||j||}||jvrd|j|<||j|<|jj |||j kDr|jj |||j|<|xj|z c_ y)a<Variant of ``__setitem__`` that does not evict if the total weight exceeds n. Unlike ``__setitem__``, this method does not depend on the ``on_evict`` functions to be thread-safe for its own thread-safety. It also is not prone to re-raising exceptions from the ``on_evict`` callbacks. TN) discardrr%rrr>rrr!r$)r9r?rLrs r+rFzLRU.set_noevicts SS%( $$$ $&*D  s #s  s DFF? JJNN3 " S V#r-c| |j}|j|jz|kDrI|js< |j |j|jz|kDr|js:yyyy#t $rYywxYw)zEvict key/value pairs until the total weight falls below n Parameters ---------- n: float, optional Total weight threshold to achieve. Defaults to self.n. N)rr$r r#rKKeyError)r9rs r+rGzLRU.evict_until_below_targetsx 9A$++-1$++  $++-1$++1+1  sA55 BBc&|tur- tt|jxs |j}||jvry|j|}|jj|d|j|< |j5|jD] }||| |j|r1|jD] }|||  ddd|j|=y ddd|j|=|j|=|jj||jj|}|xj |zc_|||fS#t $r t dwxYw#1swYxYw#|j|=wxYw)a$Evict least recently used key, or least recently inserted key with individual weight > n, if any. You may also evict a specific key. This is typically called from internal use, but can be externally triggered as well. Returns ------- Tuple of (key, value, weight) Or (None, None, 0) if the key that was being evicted was updated or deleted from another thread while the on_evict callbacks were being executed. This outcome is only possible in multithreaded access. zevict(): dictionary is empty)NNrFN)rnextiterrr StopIterationrQr%rrOunlockrrr=r!popr$)r9r?rLcbrs r+rKz LRU.evicts$ )  ?4 8djj9: $$$ $ s  3"'3 ( )--#BsEN#%%c*"22'3'( )""3' +  )""3' FF3K #!!#& V#E6!!I! ?=>> ?& ) )""3's6,E?FAE5F+FE25E>:FFc ||jvrd|j|<|j|=|jj||jj ||xj |jj|zc_yNT) r%rrr=rrOr$r!rWr9r?s r+ __delitem__zLRU.__delitem__so $$$ $&*D  s # FF3K # 3 T\\--c22r-c6|jjSr0)rrCr9s r+rCzLRU.keyssvv{{}r-c6|jjSr0)rr8r^s r+r8z LRU.valuessvv}}r-c6|jjSr0)rr6r^s r+r6z LRU.itemssvv||~r-c,t|jSr0)rJrr^s r+__len__z LRU.__len__s466{r-c,t|jSr0)rTrr^s r+__iter__z LRU.__iter__sDFF|r-c||jvSr0)rr[s r+ __contains__zLRU.__contains__ sdff}r-ct|jtst|jnd}d|j|j zd|j d|dS)Ndictz) isinstancerrhstrr$r r)r9subs r+__str__z LRU.__str__sM!+DFFD!9c$&&kv))DKK78$&&cU!LLr-c.t|jyr0)rrr^s r+rz LRU.flushs  dff r-c<d|_t|jyrZ)r#rrr^s r+rz LRU.closes  dff r-) rrrrr@Callable[[KT, VT], None] | list[Callable[[KT, VT], None]] | Nonerrqrr)r?r returnr )rCzCollection[KT]rrz dict[KT, VT])r?r rLr rrNoner0)rz float | Nonerrrs)r?zKT | NoDefaultrrz/tuple[KT, VT, float] | tuple[None, None, float])r?r rrrs)rrz KeysView[KT])rrzValuesView[VT])rrzItemsView[KT, VT])rrint)rrz Iterator[KT])r?objectrrr")rrrl)rrrs)__name__ __module__ __qualname____doc____annotations__r4rrArDrMrFrGrrKr\rCr8r6rbrdrfrn__repr__rr __classcell__)r:s@r+rrsN'R !! !!,,33 %% H M  L!!,:   "    * B         $ $"  $-8"!8" 88" 8"t 3 3MHr-rN) __future__rcollections.abcrrrrrr r zict.commonr r r rrrrr zict.utilsrrr(r-r+rs="UTT)H(2r6 Hr-