
    Ih)                    R   d Z 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 ddlmZmZ ddlmZmZ ddlmZ d	d
lmZ dZ e       Z G d d      Z G d de      ZddefdZ G d d      Zd Zeefe
ffdZeeffdZ ddZ!d Z"ddZ#d dZ$	 	 	 d!dZ%d"dZ&d#dZ'd Z(eZ)eZ*y)$zFunctional Utilities.    )annotationsN)OrderedDictUserDict)IterableMapping)countrepeat)sleeptime)wraps   )	safe_repr)LRUCachememoizelazymaybe_evaluateis_list
maybe_list
dictfilterretry_over_timec                      e Zd Zd Zd Zd Zy)ChannelPromisec                    || _         y N)__contract__)selfcontracts     O/var/www/html/planif/env/lib/python3.12/site-packages/kombu/utils/functional.py__init__zChannelPromise.__init__   s
    $    c                l    	 | j                   S # t        $ r | j                         x}| _         |cY S w xY wr   )	__value__AttributeErrorr   )r   values     r   __call__zChannelPromise.__call__   s:    	>>! 	%)%6%6%88EDNL	s    "33c                    	 t        | j                        S # t        $ r dt        | j                        ddcY S w xY w)Nz<promise: 0xx>)reprr"   r#   idr   r   s    r   __repr__zChannelPromise.__repr__%   sB    	='' 	=!"T%6%6"7!:!<<	=s    #==N)__name__
__module____qualname__r   r%   r,    r    r   r   r      s    %=r    r   c                  v    e Zd ZdZddZd Zd ZddZd Zd Z	d	 Z
e
Zd
 ZeZd ZeZddZd Zd ZeZeZe
Zy)r   aM  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.
    Nc                b    || _         t        j                         | _        t	               | _        y r   )limit	threadingRLockmutexr   data)r   r3   s     r   r   zLRUCache.__init__7   s     
__&
M	r    c                    | j                   5  | j                  j                  |      x}| |<   |cd d d        S # 1 sw Y   y xY wr   )r6   r7   popr   keyr$   s      r   __getitem__zLRUCache.__getitem__<   s<    ZZ 	 $		c 22EDI	 	 	s	   "9Ac                   | j                   5  | j                  | j                  }} |j                  |i | |r<t	        |      |kD  r.t        t	        |      |z
        D ]  }|j                  d        d d d        y # 1 sw Y   y xY w)NF)last)r6   r7   r3   updatelenrangepopitem)r   argskwargsr7   r3   _s         r   r?   zLRUCache.updateA   s{    ZZ 	-))TZZ%DDKK((TU*s4y501 -ALLeL,-	- 	- 	-s   A)A??Bc                |    | j                   5  | j                  j                  |      cd d d        S # 1 sw Y   y xY wr   )r6   r7   rB   )r   r>   s     r   rB   zLRUCache.popitemJ   s0    ZZ 	+99$$T*	+ 	+ 	+s   2;c                .   | j                   5  | j                  rYt        | j                        | j                  k\  r7| j                  j	                  t        t        | j                                     || j                  |<   d d d        y # 1 sw Y   y xY wr   )r6   r3   r@   r7   r9   nextiterr:   s      r   __setitem__zLRUCache.__setitem__N   sb    ZZ 	#zzc$))n

:		d4		?34"DIIcN	# 	# 	#s   A5BBc                ,    t        | j                        S r   )rI   r7   r+   s    r   __iter__zLRUCache.__iter__U   s    DIIr    c              #     K   | j                   5  | D ]  }	 || j                  |   f  	 d d d        y # t        $ r Y .w xY w# 1 sw Y   y xY wwr   r6   r7   KeyErrorr   ks     r   _iterate_itemszLRUCache._iterate_itemsX   sa     ZZ 	 diil++	 	   		 	s:   AA5A	A	AA AAA	Ac              #     K   | j                   5  | D ]  }	 | j                  |     	 d d d        y # t        $ r Y ,w xY w# 1 sw Y   y xY wwr   rN   rP   s     r   _iterate_valueszLRUCache._iterate_valuesa   s\     ZZ 	 ))A,&	 	   		 	s6   AA3A	A	?A?AAAc                z    | j                   5  | j                  j                         cd d d        S # 1 sw Y   y xY wr   )r6   r7   keysr+   s    r   _iterate_keyszLRUCache._iterate_keysk   s,    ZZ 	$99>>#	$ 	$ 	$s   1:c                    | j                   5  t        | j                  j                  |            |z   }t	        |      | |<   |cd d d        S # 1 sw Y   y xY wr   )r6   intr7   r9   str)r   r;   deltanewvals       r   incrzLRUCache.incrq   sL    ZZ 	 s+,u4FFDI	 	 	s   7AAc                P    t        t        |             }|j                  d       |S )Nr6   )dictvarsr9   )r   ds     r   __getstate__zLRUCache.__getstate__y   s     d	gr    c                D    || _         t        j                         | _        y r   )__dict__r4   r5   r6   )r   states     r   __setstate__zLRUCache.__setstate__~   s    __&
r    r   )T)r   )r-   r.   r/   __doc__r   r<   r?   rB   rJ   rL   rR   	iteritemsrT   
itervaluesrW   iterkeysr]   rb   rf   rV   valuesitemsr0   r    r   r   r   ,   si    "

-+# I !J$ H
' DFEr    r   c                      fd}|S )z)Decorator to cache function return value.c                     t        j                                t                fd       fd}dx_        _        |_         _        S )N)r3   c                 t   r
 | |      }n-| t         fz   t        t        |j                                     z   }	 5  |   }d d d        xj                  dz  c_        S # 1 sw Y    xY w# t
        $ r?  | i |}xj                  dz  c_        5  ||<   d d d        Y |S # 1 sw Y   Y |S xY ww xY w)Nr   )KEYWORD_MARKtuplesortedrl   hitsrO   misses)	rC   rD   r;   r$   _Mcachefunkeyfunr6   s	       r   ru   z%memoize.<locals>._memoize.<locals>._M   s    T6*l_,uVFLLN5K/LL	 '!#JE' 1L' ' 'T,V,		Q	 '!&E#J' ' L	' ' L's@   A/ A#A/ #A,(A/ /(B7B(B7(B3	-B73B7c                 B    j                          dx _         _        y)z+Clear the cache and reset cache statistics.r   N)clearrs   rt   )ru   rv   s   r   rz   z(memoize.<locals>._memoize.<locals>.clear   s    KKM"##BGbir    r   )r4   Lockr   rs   rt   rz   original_func)rw   rz   ru   rv   r6   Cacherx   maxsizes   ` @@@r   _memoizezmemoize.<locals>._memoize   sX     G$	s	 
	"	$
  ")	r    r0   )r~   rx   r}   r   s   ``` r   r   r      s    @ Or    c                  F    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zy)r   a
  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__`.
    c                .    || _         || _        || _        y r   _fun_args_kwargs)r   rw   rC   rD   s       r   r   zlazy.__init__   s    	
r    c                "    | j                         S r   )evaluater+   s    r   r%   zlazy.__call__   s    }}r    c                N     | j                   | j                  i | j                  S r   r   r+   s    r   r   zlazy.evaluate   s     tyy$**555r    c                "    t         |              S r   )rZ   r+   s    r   __str__zlazy.__str__   s    46{r    c                "    t         |              S r   )r)   r+   s    r   r,   zlazy.__repr__   s    DF|r    c                     |        |k(  S r   r0   r   rhss     r   __eq__zlazy.__eq__       v}r    c                     |        |k7  S r   r0   r   s     r   __ne__zlazy.__ne__   r   r    c                "    | |t        |       <   | S r   )r*   )r   memos     r   __deepcopy__zlazy.__deepcopy__   s    RXr    c                d    | j                   | j                  f| j                  | j                  dfS )N)r   r   )	__class__r   r   r   r+   s    r   
__reduce__zlazy.__reduce__   s0    

:>,,/H I 	Ir    N)r-   r.   r/   rg   r   r%   r   r   r,   r   r   r   r   r0   r    r   r   r      s5    
6Ir    r   c                F    t        | t              r| j                         S | S )z9Evaluate value only if value is a :class:`lazy` instance.)
isinstancer   r   )r$   s    r   r   r      s    %~~Lr    c                @    t        | |      xr t        | |xs d       S )zwReturn true if the object is iterable.

    Note:
    ----
        Returns false if object is a mapping or string.
    r0   )r   )objscalarsiterss      r   r   r      s$     c5!H*S'-R*H&HHr    c                (    | t        | |      r| S | gS )z0Return list of one element if ``l`` is a scalar.)r   )r   r   s     r   r   r      s    +g!63ASEAr    c                    | |n|rt        | fi |n| } | j                         D ci c]  \  }}|	|| c}}S c c}}w )z=Remove all keys from dict ``d`` whose value is :const:`None`.)r_   rl   )ra   kwrQ   vs       r   r   r      s?    ird1mmqAWWY8TQ!-AqD888s   
<<c              #     K   t        |       } t        j                  }t        d       D ]  } ||        | d     y w)Nr   )listrandomshuffler	   )itr   rE   s      r   shufflecycler      s;     	bBnnGD\ es   <>c              #  N   K   | dz  }	 |r||k  r
| ||z  }n
|sy ||z
   w)N      ?r0   )startstopstep
repeatlastcurs        r   fxranger      s>     
#+C
sd{I4KC* s   #%c              #  h   K   d| dz  }}	 ||k\  ry | |rt        ||z   |      }n||z  }||z  }'w)Nr   r   )min)r   r   r   maxsum_r   s         r   
fxrangemaxr     sO     53;#D
3;	cDj$'C4KC s   02c           	        |si n|}|sg n|}t        |||z   |d      }|
rt               |
z   nd}t               D ]  }	  | |i |c S  y# |$ r}|||k\  r |rt               |kD  r |	r |	        t        |r
 ||||      n
t	        |            }|rMt        t        |            D ]  }|	r |	        t        d        t        t        t        |      |z
               Y d}~d}~ww xY w)a  Retry 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)r   Nr   )	r   r   r   floatrH   rA   rY   r
   abs)rw   catchrC   rD   errbackmax_retriesinterval_startinterval_stepinterval_maxcallbacktimeoutinterval_rangeendretriesexcttsrE   s                    r   r   r     s    F R6F2tD^)N:*t=N &$&7
4C7 +	+'''+  	+&7k+Atv|
^W=!.13Cs3x A 
#J
 c#c(S.)*	+s   A

C)BC$$C)c                T    |j                  fd| j                         D              S )Nc              3  Z   K   | ]"  \  }}j                  |t        |             $ y wr   )format
_safe_repr).0rQ   r   fmts      r   	<genexpr>zreprkwargs.<locals>.<genexpr>R  s$     LTQCJJq*Q-0Ls   (+)joinrl   )rD   sepr   s     `r   
reprkwargsr   Q  s    88LV\\^LLLr    c           
         |si n|}dj                  | |j                  t        t        |xs d            |xr |xr |xs dt	        ||            S )Nz
{}({}{}{})r0    )r   r   mapr   r   )namerC   rD   r   s       r   reprcallr   U  sR    R6Fchhs:tzr23	&!c'R63 r    c                h    t        j                  |       }||j                  v xs ||j                  v S r   )inspectgetfullargspecrC   
kwonlyargs)funcargument_nameargument_specs      r   accepts_argumentr   ^  s8    **40M+++ 	2111r    r   )r   Nr   F)r   Nr   g      Y@)	NNNN   r      NN), z{0}={1})r0   Nr   )+rg   
__future__r   r   r   r4   collectionsr   r   collections.abcr   r   	itertoolsr   r	   r   r
   
vine.utilsr   encodingr   r   __all__objectrp   r   r   r   r   r   rZ   r   r   r   r   r   r   r   r   r   r   promisemaybe_promiser0   r    r   <module>r      s     "    - - #   -
 x= =&Xx Xv X "J'I 'IT "3{ I %cN B
9	
 AEFG<@;+|M r    