o

�N�gB+�@sf
dd
lm
Z
mZmZmZ
ddlZddlZddlZddlZddl	Z	ddl
mZ
eZ
zddlmZ
Wn2eyb


zddlmZ
Wn ey_


zddlmZ
Wney\


e�d�

Yn
wYn
wYn
wddlZdd�Zdd	�Zd
d�Zd)dd
�
Zdd�Zdd�Zdd�Zdd�ZGdd�d�Zdd�Zdd�ddfdd�
Zdd �Z d!d"�Z!d#d$�Z"d%d&�Z#d'd(�Z$dS)*�)�absolute_import�unicode_literals�print_function�divisionN)
�count)
�	lru_cachezNo lru_cache availablecGsd
d�}
t�
|
|�S)a
	Compose any number of unary functions into a single unary function.

	>>> import textwrap
	>>> from six import text_type
	>>> stripped = text_type.strip(textwrap.dedent(compose.__doc__))
	>>> compose(text_type.strip, textwrap.dedent)(compose.__doc__) == stripped
	True

	Compose also allows the innermost function to take arbitrary arguments.

	>>> round_three = lambda x: round(x, ndigits=3)
	>>> f = compose(round_three, int.__truediv__)
	>>> [f(3*x, x+1) for x in range(1,10)]
	[1.5, 2.0, 2.25, 2.4, 2.5, 2.571, 2.625, 2.667, 2.7]
	cs��
fd
d�S)Ncs��
|i|
�
�
�
S�
N���args�kwargs��f1�f2r	�D/opt/saltstack/salt/lib/python3.10/site-packages/jaraco/functools.py�<lambda>1sz.compose.<locals>.compose_two.<locals>.<lambda>r	r
r	r
r�compose_two0s
zcompose.<locals>.compose_two)�	functools�reduce)�funcsrr	r	r�composesrc
s��
�fd
d�}|S)z�
	Return a function that will call a named method on the
	target object with optional positional and keyword
	arguments.

	>>> lower = method_caller('lower')
	>>> lower('MyString')
	'mystring'
	c
st|��}
|
�i�
�
�
Sr)
�getattr)�target�func�rr�method_namer	r�call_method?s


z"method_caller.<locals>.call_methodr	)rrrrr	rr�
method_caller5s
rc

s*t�
��
��
fd
d��
�
�
f
dd��
_�
S)a
	Decorate func so it's only ever called the first time.

	This decorator can ensure that an expensive or non-idempotent function
	will not be expensive on subsequent calls and is idempotent.

	>>> add_three = once(lambda a: a+3)
	>>> add_three(3)
	6
	>>> add_three(9)
	6
	>>> add_three('12')
	6

	To reset the stored value, simply clear the property ``saved_result``.

	>>> del add_three.saved_result
	>>> add_three(9)
	12
	>>> add_three(8)
	12

	Or invoke 'reset()' on it.

	>>> add_three.reset()
	>>> add_three(-3)
	0
	>>> add_three(0)
	0
	cs t�
d
�s
�|i|
�
�
�
_
�
j
S�N�saved_result)�hasattrrr
�r�wrapperr	rr"ds


zonce.<locals>.wrappercst��
�
d
�
Sr)�vars�__delitem__r	)
r"r	rriszonce.<locals>.<lambda>)r�wraps�reset�
rr	r!r�onceEs

r(cs&�pt����
fd
d�}t
�
��p|S)aR
	Wrap lru_cache to support storing the cache data in the object instances.

	Abstracts the common paradigm where the method explicitly saves an
	underscore-prefixed protected property on first call and returns that
	subsequently.

	>>> class MyClass:
	...     calls = 0
	...
	...     @method_cache
	...     def method(self, value):
	...         self.calls += 1
	...         return value

	>>> a = MyClass()
	>>> a.method(3)
	3
	>>> for x in range(75):
	...     res = a.method(x)
	>>> a.calls
	75

	Note that the apparent behavior will be exactly like that of lru_cache
	except that the cache is stored on each instance, so values in one
	instance will not flush values from another, and when an instance is
	deleted, so are the cached values for that instance.

	>>> b = MyClass()
	>>> for x in range(35):
	...     res = b.method(x)
	>>> b.calls
	35
	>>> a.method(0)
	0
	>>> a.calls
	75

	Note that if method had been decorated with ``functools.lru_cache()``,
	a.calls would have been 76 (due to the cached value of 0 having been
	flushed by the 'b' instance).

	Clear the cache with ``.cache_clear()``

	>>> a.method.cache_clear()

	Another cache wrapper may be supplied:

	>>> cache = lru_cache(maxsize=2)
	>>> MyClass.method2 = method_cache(lambda self: 3, cache_wrapper=cache)
	>>> a = MyClass()
	>>> a.method2()
	3

	Caution - do not subsequently wrap the method with another decorator, such
	as ``@property``, which changes the semantics of the function.

	See also
	http://code.activestate.com/recipes/577452-a-memoize-decorator-for-instance-methods/
	for another implementation and additional justification.
	c
s0t�
�
|�}�|�
}t|�
j|�
||
i|�
�
Sr)r�partial�setattr�__name__)�selfrrZbound_methodZ
cached_method��
cache_wrapper�methodr	rr"�s


zmethod_cache.<locals>.wrapper)r�_special_method_cache)r/r.r"r	r-r�method_cachems
>r1cs2�
j}d
}||v
rdSd|���
�fdd�}|S)a%

	Because Python treats special methods differently, it's not
	possible to use instance attributes to implement the cached
	methods.

	Instead, install the wrapper method under a different name
	and return a simple proxy to that wrapper.

	https://github.com/jaraco/jaraco.functools/issues/5
	)�__getattr__�__getitem__NZ__cachedc
sF�t|�
v
rt
��
|�}�|�
}t|�|�
nt|��}||
i|�
�
Sr)r#rr)r*r)r,rr�bound�cache�r.r/Zwrapper_namer	r�proxy�s





z$_special_method_cache.<locals>.proxy)
r+)r/r.�nameZ
special_namesr7r	r6rr0�s


	r0c
��f
d
d�}
|
S)z�
	Decorate a function with a transform function that is
	invoked on results returned from the decorated function.

	>>> @apply(reversed)
	... def get_numbers(start):
	...     return range(start, start+3)
	>>> list(get_numbers(4))
	[6, 5, 4]
	c

s
t�|�Sr)
rr'�
�	transformr	r�wrap��

zapply.<locals>.wrapr	)r;r<r	r:r�apply�sr>c
r9)a

	Decorate a function with an action function that is
	invoked on the results returned from the decorated
	function (for its side-effect), then return the original
	result.

	>>> @result_invoke(print)
	... def add_two(a, b):
	...     return a + b
	>>> x = add_two(2, 3)
	5
	c
st�
��
�
�fd
d��
}
|
S)Ncs�
|i|
�
�
}�|�

|Srr	)rr�result)�actionrr	rr"�s

z,result_invoke.<locals>.wrap.<locals>.wrapper�rr%r!�
r@r'rr<�s

zresult_invoke.<locals>.wrapr	)r@r<r	rBr�
result_invoke�s
rCc
Os||
i|�
�

|S)
aA

	Call a function for its side effect after initialization.

	>>> @call_aside
	... def func(): print("called")
	called
	>>> func()
	called

	Use functools.partial to pass parameters to the initial call

	>>> @functools.partial(call_aside, name='bingo')
	... def func(name): print("called with", name)
	called with bingo
	r	)�
frrr	r	r�
call_aside�s
rEc@sBeZ
dZd
Zed�
f
dd�
Zdd�Zdd�Zd	d
�Zddd
�
Z	dS)�	Throttlerz-
	Rate-limit a function (or other callable)
	ZInfcCs(t|
t
�r|
j}
|
|_||_|��
dSr)�
isinstancerFr�max_rater&)r,rrHr	r	r�__init__
s






zThrottler.__init__c

Cs
d
|_dS)Nr
)
�last_called)
r,r	r	rr&
r=zThrottler.resetc
Os|��
|j
|
i|�
�
Sr)�_waitr)r,rrr	r	r�__call__
s

zThrottler.__call__c
Cs:t��|j
}
d
|j|
}t�td|��

t��|_
dS)z1ensure at least 1/max_rate seconds from last call�
r
N)�timerJrH�sleep�max)r,�elapsedZ	must_waitr	r	rrK"
s


zThrottler._waitNcCst|j
t�|j|
��Sr)�first_invokerKrr)r)r,�obj�typer	r	r�__get__)
s
zThrottler.__get__r)
r+�
__module__�__qualname__�__doc__�floatrIr&rLrKrUr	r	r	rrF
s
rFc���
fd
d�}|S)z�
	Return a function that when invoked will invoke func1 without
	any parameters (for its side-effect) and then invoke func2
	with whatever parameters were passed, returning its result.
	cs��
�
|i|
�
�
Srr	r
��func1�func2r	rr"3
s

zfirst_invoke.<locals>.wrapperr	)r\r]r"r	r[rrR-
srRc
CsdSrr	r	r	r	rr9
srr	c	CsN|td
�
kr	t
�nt|�
}|D]}z|�W
S|y#


|
�
Yqw|�S)z�
	Given a callable func, trap the indicated exceptions
	for up to 'retries' times, invoking cleanup on the
	exception. On the final attempt, allow any exceptions
	to propagate.
	�inf)rYr�range)rZcleanupZretriesZtrapZattemptsZattemptr	r	r�
retry_call9
s





�r`crZ)a

	Decorator wrapper for retry_call. Accepts arguments to retry_call
	except func and then returns a decorator for the decorated function.

	Ex:

	>>> @retry(retries=3)
	... def my_func(a, b):
	...     "this is my funk"
	...     print(a, b)
	>>> my_func.__doc__
	'this is my funk'
	c
st�
��
��
�fd
d��
}
|
S)Ncs.tj
�g
|�
Ri|
�
�
}t|g
�
�
Ri��
�
Sr)rr)r`)Zf_argsZf_kwargsr4)r�r_args�r_kwargsr	rr"Y
s
z(retry.<locals>.decorate.<locals>.wrapperrAr!�rarbr'r�decorateX
s

zretry.<locals>.decorater	)rarbrdr	rcr�retryJ
srec
Cs*t�
tt�}
ttjj|
|�}t�|�
|�
S)
z�
	Convert a generator into a function that prints all yielded elements

	>>> @print_yielded
	... def x():
	...     yield 3; yield None
	>>> x()
	3
	None
	)	rr)�map�printr�more_itertoolsZrecipesZconsumer%)rZ	print_allZ
print_resultsr	r	r�
print_yieldeda
s

ric
st�
��
�f
d
d��
}
|
S)z�
	Wrap func so it's not called if its first param is None

	>>> print_text = pass_none(print)
	>>> print_text('text')
	text
	>>> print_text(None)
	c
s"|du
r�|g
|
�
Ri|�
�
SdSrr	)�paramrrr'r	rr"z
s
�zpass_none.<locals>.wrapperrAr!r	r'r�	pass_noneq
s	
rkcs`zt�
|�
}|j��}Wnty


t�|�
}|j}Yn
w�f
d
d�|D�
}tj|f
i|�
�
S)aG
	Assign parameters from namespace where func solicits.

	>>> def func(x, y=3):
	...     print(x, y)
	>>> assigned = assign_params(func, dict(x=2, z=4))
	>>> assigned()
	2 3

	The usual errors are raised if a function doesn't receive
	its required parameters:

	>>> assigned = assign_params(func, dict(y=3, z=4))
	>>> assigned()
	Traceback (most recent call last):
	TypeError: func() ...argument...

	It even works on methods:

	>>> class Handler:
	...     def meth(self, arg):
	...         print(arg)
	>>> assign_params(Handler().meth, dict(arg='crystal', foo='clear'))()
	crystal
	c
si|]}
|
�vr|
�|
�qSr	r	)�.0�
k�
�	namespacer	r�
<dictcomp>�
s

�z!assign_params.<locals>.<dictcomp>)	�inspectZ	signatureZ
parameters�keys�AttributeErrorZ
getargspecrrr))rro�sig�params�specZcall_nsr	rnr�
assign_params�
s







�
�rwc
s(t�
d
d��t��
�
��
fdd��
}
|
S)a�
	Wrap a method such that when it is called, the args and kwargs are
	saved on the method.

	>>> class MyClass:
	...     @save_method_args
	...     def method(self, a, b):
	...         print(a, b)
	>>> my_ob = MyClass()
	>>> my_ob.method(1, 2)
	1 2
	>>> my_ob._saved_method.args
	(1, 2)
	>>> my_ob._saved_method.kwargs
	{}
	>>> my_ob.method(a=3, b='foo')
	3 foo
	>>> my_ob._saved_method.args
	()
	>>> my_ob._saved_method.kwargs == dict(a=3, b='foo')
	True

	The arguments are stored on the instance, allowing for
	different instance to save different args.

	>>> your_ob = MyClass()
	>>> your_ob.method({str('x'): 3}, b=[4])
	{'x': 3} [4]
	>>> your_ob._saved_method.args
	({'x': 3},)
	>>> my_ob._saved_method.args
	()
	�args_and_kwargszargs kwargsc
s6d
�
j}�|
|�}t
|||�
�
|g
|
�
Ri|�
�
S)NZ_saved_)r+r*)r,rrZ	attr_name�attr�rxr/r	rr"�
s




z!save_method_args.<locals>.wrapper)�collections�
namedtuplerr%)r/r"r	rzr�save_method_args�
s"
r}r)%Z
__future__rrrrrrN�warningsrqr{�	itertoolsrrTZ
__metaclass__r�ImportErrorZbackports.functools_lru_cacheZfunctools32�warnZmore_itertools.recipesrhrrr(r1r0r>rCrErFrRr`rerirkrwr}r	r	r	r�<module>
sP













�����

(J(