U /e0'@sddlmZddlmZmZmZmZmZmZm Z ddl m Z m Z m Z mZmZmZmZmZddlmZGdddee e fZdS)) annotations)Callable Collection ItemsViewIteratorKeysViewMutableMapping ValuesView)KTVT NoDefaultZictBasecloseflushlocked nodefault)InsertionSortedSetcseZdZUdZded<ded<ded<ded<ded <d ed <d ed <d ed<ded<ded<d ed<ded<dddddd dddd dfddZeddd d!d"Zed#d$d%d&d'Zddd(d)d*d+Z eddd(d)d,d-Z dRd.d(d/d0d1Z ee fd2d3d d4d5Z edd(d d6d7Zd8d9d:d;ZdZd?d9d@dAZdBd9dCdDZdEd9dFdGZdHdd dIdJZdKd9dLdMZeZd(d9dNdOZd(d9dPdQZZS)SLRUaEvict 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 zMutableMapping[KT, VT]dzInsertionSortedSet[KT]orderheavyzlist[Callable[[KT, VT], None]]on_evicton_cancel_evictzCallable[[KT, VT], float]weightfloatnoffsetzdict[KT, float]weightsboolclosed total_weightzdict[KT, bool] _cancel_evictNcCsdS)N)kvr#r#,/tmp/pip-unpacked-wheel-z3s6s24u/zict/lru.py]z LRU.)rrrz@Callable[[KT, VT], None] | list[Callable[[KT, VT], None]] | None)rrrrrcst||_|_d|_t|r*|g}|p0g|_t|rB|g}|pHg|_|_fdd| D|_ t |j |_ t||_tfdd|j D|_d|_i|_dS)Nrcsi|]\}}|||qSr#r#.0r$r%)rr#r& lsz LRU.__init__..c3s|]\}}|kr|VqdSNr#r))rr#r& oszLRU.__init__..F)super__init__rrrcallablerrritemsrsumvaluesr rrrrr!)selfrrrrr __class__)rrr&r/Rs"    z LRU.__init__r r )keyreturncCs&|j|}|j||j||Sr,)rrremoveadd)r4r7resultr#r#r& __getitem__ss   zLRU.__getitem__zCollection[KT]z dict[KT, VT])keysr8cs8fdd|D}|D]}j|j|q|S)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. csi|]}|j|qSr#r)r*r7r4r#r&r+sz*LRU.get_all_or_nothing..)rr9r:)r4r=r;r7r#r?r&get_all_or_nothingzs  zLRU.get_all_or_nothingNone)r7valuer8c Cs|||z |Wnftk r~|j|d|jkrx||jkrxzt|jdkr`| qHWntk rvYnXYnXdS)Nrr") set_noevictevict_until_below_target Exceptionrgetrrlenrevict)r4r7rBr#r#r& __setitem__s  zLRU.__setitem__cCsr|||||}||jkr*d|j|<||j|<|j|||jkrV|j|||j|<|j |7_ dS)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:rrrr )r4r7rBrr#r#r&rCs         zLRU.set_noevictz float | None)rr8cCsN|dkr|j}|j|j|krJ|jsJz |Wqtk rFYdSXqdS)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 rrrHKeyError)r4rr#r#r&rDs zLRU.evict_until_below_targetzKT | NoDefaultz/tuple[KT, VT, float] | tuple[None, None, float]c Cs|tkr>ztt|jp|j}Wntk r<tdYnX||jkrLdS|j|}|j |d|j|<z`| N|j D]}|||q~|j|r|j D]}|||qW5QRWdSW5QRXW5|j|=X|j|=|j ||j|}|j|8_|||fS)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)NNrF)rnextiterrr StopIterationrKr!rrJZunlockrrr9rpopr )r4r7rBcbrr#r#r&rHs0              z LRU.evictcCsN||jkrd|j|<|j|=|j||j||j|j|8_dSNT) r!rrr9rrJr rrOr4r7r#r#r& __delitem__s     zLRU.__delitem__z KeysView[KT])r8cCs |jSr,)rr=r?r#r#r&r=szLRU.keyszValuesView[VT]cCs |jSr,)rr3r?r#r#r&r3sz LRU.valueszItemsView[KT, VT]cCs |jSr,)rr1r?r#r#r&r1sz LRU.itemsintcCs t|jSr,)rGrr?r#r#r&__len__sz LRU.__len__z Iterator[KT]cCs t|jSr,)rMrr?r#r#r&__iter__sz LRU.__iter__objectcCs ||jkSr,r>rRr#r#r& __contains__ szLRU.__contains__strcCs<t|jtst|jnd}d|j|jd|jd|dS)Ndictz) isinstancerrZrYr rr)r4subr#r#r&__str__sz LRU.__str__cCst|jdSr,)rrr?r#r#r&rsz LRU.flushcCsd|_t|jdSrQ)rrrr?r#r#r&rsz LRU.close)N)__name__ __module__ __qualname____doc____annotations__r/rr<r@rIrCrDrrHrSr=r3r1rUrVrXr___repr__rr __classcell__r#r#r5r&rsP ) ! :rN) __future__rcollections.abcrrrrrrr Z zict.commonr r r r rrrrZ zict.utilsrrr#r#r#r&s $ (