o ?Zcl)@sDdZddlZddlZddlZddlmZmZddlmZm Z ddl m Z m Z ddl mZm Z ddlmZdd lmZd ZeZGd d d ZGd ddeZddefddZGdddZddZe efeffddZe effddZd1ddZddZ d2dd Z!d3d"d#Z"  $ d4d&d'Z#d5d*d+Z$d6d-d.Z%d/d0Z&eZ'eZ(dS)7zFunctional Utilities.N) OrderedDictUserDict)IterableMapping)countrepeat)sleeptime)wraps) safe_repr)LRUCachememoizelazymaybe_evaluateis_list maybe_list dictfilterretry_over_timec@s$eZdZddZddZddZdS)ChannelPromisecCs ||_dSN) __contract__)selfcontractrL/var/www/chikooza/env/lib/python3.10/site-packages/kombu/utils/functional.py__init__ zChannelPromise.__init__cCs.z|jWSty|}|_|YSwr) __value__AttributeErrorr)rvaluerrr__call__s  zChannelPromise.__call__cCs4zt|jWStydt|jddYSw)Nz )reprrridrrrrr__repr__#s   zChannelPromise.__repr__N)__name__ __module__ __qualname__rr!r'rrrrrs rc@seZdZdZdddZddZddZdd d Zd d ZddZ ddZ e Z ddZ e Z ddZeZdddZddZddZeZe Ze ZdS) r a?LRU Cache implementation using a doubly linked list to track access. Arguments: limit (int): The maximum number of keys to keep in the cache. When a new key is inserted and the limit has been exceeded, the *Least Recently Used* key will be discarded from the cache. NcCs||_t|_t|_dSr)limit threadingRLockmutexrdata)rr+rrrr4s  zLRUCache.__init__cCsB|j|j|}||<|WdS1swYdSr)r.r/poprkeyr rrr __getitem__9s$zLRUCache.__getitem__cOs|jA|j|j}}|j|i||r,t||kr4tt||D]}|jddq#WddSWddSWddS1sGwYdS)NF)last)r.r/r+updatelenrangepopitem)rargskwargsr/r+_rrrr5>s"zLRUCache.updateTcCs6|j|j|WdS1swYdSr)r.r/r8)rr4rrrr8Gs $zLRUCache.popitemcCsb|j$|jrt|j|jkr|jtt|j||j|<WddS1s*wYdSr)r.r+r6r/r0nextiterr1rrr __setitem__Ks  "zLRUCache.__setitem__cCs t|jSr)r=r/r&rrr__iter__RrzLRUCache.__iter__c cs^|j!|D]}z ||j|fVWqtyYqwWddS1s(wYdSrr.r/KeyErrorrkrrr_iterate_itemsUs "zLRUCache._iterate_itemsc csZ|j|D]}z|j|VWqtyYqwWddS1s&wYdSrr@rBrrr_iterate_values^s "zLRUCache._iterate_valuescCs4|j |jWdS1swYdSr)r.r/keysr&rrr _iterate_keyshs$zLRUCache._iterate_keysr cCsN|jt|j||}t|||<|WdS1s wYdSr)r.intr/r0str)rr2deltanewvalrrrincrns  $z LRUCache.incrcCstt|}|d|S)Nr.)dictvarsr0)rdrrr __getstate__vs  zLRUCache.__getstate__cCs||_t|_dSr)__dict__r,r-r.)rstaterrr __setstate__{szLRUCache.__setstate__r)T)r )r(r)r*__doc__rr3r5r8r>r?rD iteritemsrE itervaluesrGiterkeysrLrPrSrFvaluesitemsrrrrr *s(   r csfdd}|S)z)Decorator to cache function return value.csXtdtfddfdd}d__|__S)N)r+c sr||}n |tftt|}z |}Wdn1s'wYWn0ty]|i|}jd7_||<WdY|S1sUwYY|Swjd7_|S)Nr ) KEYWORD_MARKtuplesortedrYrAmisseshits)r9r:r2r )_Mcachefunkeyfunr.rrr_s(     z%memoize.._memoize.._Mcsd__dS)z+Clear the cache and reset cache statistics.rN)clearr^r]r)r_r`rrrcsz(memoize.._memoize..clearr)r,Lockr r^r]rc original_func)rarcCacherbmaxsize)r_r`rar.r_memoizes  zmemoize.._memoizer)rhrbrgrirrfrrs rc@sXeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ dS)ra Holds lazy evaluation. Evaluated when called or if the :meth:`evaluate` method is called. The function is re-evaluated on every call. Overloaded operations that will evaluate the promise: :meth:`__str__`, :meth:`__repr__`, :meth:`__cmp__`. cOs||_||_||_dSr_fun_args_kwargs)rrar9r:rrrrs z lazy.__init__cCs|Sr)evaluater&rrrr!sz lazy.__call__cCs|j|ji|jSrrjr&rrrrnsz lazy.evaluatecC t|Sr)rIr&rrr__str__rz lazy.__str__cCror)r$r&rrrr'rz lazy.__repr__cCs ||kSrrrrhsrrr__eq__rz lazy.__eq__cCs ||kSrrrqrrr__ne__rz lazy.__ne__cCs||t|<|Sr)r%)rmemorrr __deepcopy__s zlazy.__deepcopy__cCs|j|jf|j|jdfS)N)rlrm) __class__rkrlrmr&rrr __reduce__szlazy.__reduce__N) r(r)r*rTrr!rnrpr'rsrtrvrxrrrrrs  rcCst|tr |S|S)z9Evaluate value only if value is a :class:`lazy` instance.) isinstancerrn)r rrrrs rcCst||o t||p d S)znReturn true if the object is iterable. Note: Returns false if object is a mapping or string. r)ry)objscalarsitersrrrrsrcCs|dus t||r |S|gS)z0Return list of one element if ``l`` is a scalar.N)r)rzr{rrrrsrcKs6|dur|n |rt|fi|n|}dd|DS)z=Remove all keys from dict ``d`` whose value is :const:`None`.NcSsi|] \}}|dur||qSrr.0rCvrrr szdictfilter..)rMrY)rOkwrrrrs$rccs4t|}tj}tdD] }|||dVq dS)Nr)listrandomshuffler)itrr;rrr shufflecycles  r?Fccs<|d} |r ||kr|V||7}n |sdS||Vq)Nrr)startstopstep repeatlastcurrrrfxranges   rY@ccsJd|d}} ||krdS|V|rt|||}n||7}||7}q )Nrr)min)rrrmaxsum_rrrr fxrangemaxsrc  Cs |sin|}|s gn|}t||||dd} | rt| nd} tD]`} z ||i|WS|y}zH|dur?| |kr?| rGt| krG| rL| t|rU||| | nt| }|rxtt|D] }| ri| tdqbttt||WYd}~q"d}~wwdS)aRetry the function over and over until max retries is exceeded. For each retry we sleep a for a while before we try again, this interval is increased for every retry until the max seconds is reached. Arguments: fun (Callable): The function to try catch (Tuple[BaseException]): Exceptions to catch, can be either tuple or a single exception class. Keyword Arguments: args (Tuple): Positional arguments passed on to the function. kwargs (Dict): Keyword arguments passed on to the function. errback (Callable): Callback for when an exception in ``catch`` is raised. The callback must take three arguments: ``exc``, ``interval_range`` and ``retries``, where ``exc`` is the exception instance, ``interval_range`` is an iterator which return the time in seconds to sleep next, and ``retries`` is the number of previous retries. max_retries (int): Maximum number of retries before we give up. If neither of this and timeout is set, we will retry forever. If one of this and timeout is reached, stop. interval_start (float): How long (in seconds) we start sleeping between retries. interval_step (float): By how much the interval is increased for each retry. interval_max (float): Maximum number of seconds to sleep between retries. timeout (int): Maximum seconds waiting before we give up. T)rNr) rr rfloatr<r7rHrabs)racatchr9r:errback max_retriesinterval_start interval_step interval_maxcallbacktimeoutinterval_rangeendretriesexcttsr;rrrrs: !   r, {0}={1}cs|fdd|DS)Nc3s$|] \}}|t|VqdSr)format _safe_reprr}fmtrr Ls"zreprkwargs..)joinrY)r:seprrrr reprkwargsKsrrcCs>|sin|}d||tt|pd|r|r|pdt||S)Nz {}({}{}{})r)rrmaprr)namer9r:rrrrreprcallOs rcCst|}||jvp||jvSr)inspectgetfullargspecr9 kwonlyargs)func argument_name argument_specrrraccepts_argumentXs  rr)rNrF)rNrr) NNNNrrrNN)rr)rNr))rTrrr, collectionsrrcollections.abcrr itertoolsrrr r vine.utilsr encodingr r__all__objectrZrr rrrrIrrrrrrrrrrpromise maybe_promiserrrrs@  Z%*     <