U dl) @s>dZddlZddlZddlZddlmZmZddlmZm 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__)selfZcontractr:/tmp/pip-unpacked-wheel-hqfrjlvz/kombu/utils/functional.py__init__szChannelPromise.__init__cCs4z|jWStk r.|}|_|YSXdSr) __value__AttributeErrorr)rvaluerrr__call__s zChannelPromise.__call__cCs:z t|jWStk r4dt|jddYSXdS)Nz )reprrridrrrrr__repr__#s zChannelPromise.__repr__N)__name__ __module__ __qualname__rrr%rrrrrsrc@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__c Cs6|j&|j|}||<|W5QRSQRXdSr)r,r-poprkeyrrrr __getitem__9szLRUCache.__getitem__c Osb|jR|j|j}}|j|||rTt||krTtt||D]}|jddqBW5QRXdS)NF)last)r,r-r)updatelenrangepopitem)rargskwargsr-r)_rrrr3>s  zLRUCache.updateTc Cs*|j|j|W5QRSQRXdSr)r,r-r6)rr2rrrr6GszLRUCache.popitemc CsL|j<|jr4t|j|jkr4|jtt|j||j|<W5QRXdSr)r,r)r4r-r.nextiterr/rrr __setitem__KszLRUCache.__setitem__cCs t|jSr)r;r-r$rrr__iter__RszLRUCache.__iter__c csJ|j:|D].}z||j|fVWq tk r8Yq Xq W5QRXdSrr,r-KeyErrorrkrrr_iterate_itemsUs zLRUCache._iterate_itemsc csF|j6|D]*}z|j|VWq tk r4Yq Xq W5QRXdSrr>r@rrr_iterate_values^s zLRUCache._iterate_valuesc Cs(|j|jW5QRSQRXdSr)r,r-keysr$rrr _iterate_keyshszLRUCache._iterate_keysr c CsB|j2t|j||}t|||<|W5QRSQRXdSr)r,intr-r.str)rr0deltaZnewvalrrrincrns z LRUCache.incrcCstt|}|d|S)Nr,)dictvarsr.)rdrrr __getstate__vs  zLRUCache.__getstate__cCs||_t|_dSr)__dict__r*r+r,)rstaterrr __setstate__{szLRUCache.__setstate__)N)T)r )r&r'r(__doc__rr1r3r6r<r=rB iteritemsrC itervaluesrEiterkeysrIrMrPrDvaluesitemsrrrrr *s&   r csfdd}|S)z)Decorator to cache function return value.csXtdtfddfdd}d__|__S)N)r)c sr||}n|tftt|}z|}W5QRXWnDtk r||}jd7_||<W5QRXYnXjd7_|S)Nr ) KEYWORD_MARKtuplesortedrVr?misseshits)r7r8r0r)_Mcachefunkeyfunr,rrr\s  z%memoize.._memoize.._Mcsd__dS)z+Clear the cache and reset cache statistics.rN)clearr[rZr)r\r]rrr`sz(memoize.._memoize..clearr)r*Lockr r[rZr`Z original_func)r^r`Cacher_maxsize)r\r]r^r,r_memoizes  zmemoize.._memoizer)rdr_rcrerrbrrs 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)rr^r7r8rrrrsz lazy.__init__cCs|Sr)evaluater$rrrrsz lazy.__call__cCs|j|j|jSrrfr$rrrrjsz lazy.evaluatecCs t|Sr)rGr$rrr__str__sz lazy.__str__cCs t|Sr)r"r$rrrr%sz lazy.__repr__cCs ||kSrrrrhsrrr__eq__sz lazy.__eq__cCs ||kSrrrlrrr__ne__sz lazy.__ne__cCs||t|<|Sr)r#)rmemorrr __deepcopy__s zlazy.__deepcopy__cCs|j|jf|j|jdfS)N)rhri) __class__rgrhrir$rrr __reduce__szlazy.__reduce__N) r&r'r(rQrrrjrkr%rnrorqrsrrrrrs rcCst|tr|S|S)z9Evaluate value only if value is a :class:`lazy` instance.) isinstancerrj)rrrrrs rcCst||ot||pd S)znReturn true if the object is iterable. Note: Returns false if object is a mapping or string. r)rt)objscalarsZitersrrrrsrcCs|dkst||r|S|gS)z0Return list of one element if ``l`` is a scalar.N)r)rurvrrrrsrcKs2|dkr |n|rt|f|n|}dd|DS)z=Remove all keys from dict ``d`` whose value is :const:`None`.NcSsi|]\}}|dk r||qSrr.0rAvrrr szdictfilter..)rJrV)rLkwrrrrs rccs2t|}tj}tdD]}|||dVqdS)Nr)listrandomshuffler)itr~r9rrr shufflecycles  r?Fccs:|d}|r||kr$|V||7}q|s*q6||VqdS)Nrr)startstopstep repeatlastcurrrrfxranges  rY@ccsHd|d}}||krqD|V|r2t|||}n||7}||7}qdS)Nrr)min)rrrmaxZsum_rrrr fxrangemaxsrc  Cs|sin|}|sgn|}t||||dd} | r:t| nd} tD]} z|||WS|k r}z|dk r~| |kr~| rt| kr| r| t|r||| | nt| }|rtt|D]}| r| tdqttt||W5d}~XYqDXqDdS)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:r5rFrabs)r^Zcatchr7r8Zerrback max_retriesZinterval_startZ interval_stepZ interval_maxcallbacktimeoutZinterval_rangeendretriesexcZttsr9rrrrs6!    r, {0}={1}cs|fdd|DS)Nc3s"|]\}}|t|VqdSr)format _safe_reprrwfmtrr Lszreprkwargs..)joinrV)r8seprrrr reprkwargsKsrrcCs>|sin|}d||tt|p d|r0|r0|p2dt||S)Nz {}({}{}{})r)rrmaprr)namer7r8rrrrreprcallOs rcCst|}||jkp||jkSr)inspectgetfullargspecr7 kwonlyargs)func argument_nameZ argument_specrrraccepts_argumentXs  r)N)rNrF)rNrr) NNNNrrrNN)rr)rNr))rQrr}r* collectionsrrcollections.abcrr itertoolsrrr rZ vine.utilsr encodingr r__all__objectrWrr rrrrGrrrrrrrrrrZpromiseZ maybe_promiserrrrsF  Z%*    <