Ë
|
@ñúhA ã óª d dl Zd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z d Z
|
d Z ej « fdZ d Zd Zd Zd Z G d d
|
« Zd Z ed ej( « Zd d dfdZd Zd Zd Zd Zd ZddddZ d Z e ddZ d Z ej@ d « Z!e!jD d ejF jH fd « Z%d Z&y) é Nc ó4 d }t j || « S )a;
|
Compose any number of unary functions into a single unary function.
|
|
>>> import textwrap
|
>>> expected = str.strip(textwrap.dedent(compose.__doc__))
|
>>> strip_and_dedent = compose(str.strip, textwrap.dedent)
|
>>> strip_and_dedent(compose.__doc__) == expected
|
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]
|
c ó fdS )Nc ó | i |¤« S ©N© )ÚargsÚkwargsÚf1Úf2s ú_H:\Change_password\venv_build\Lib\site-packages\setuptools/_vendor/jaraco/functools/__init__.pyú<lambda>z.compose.<locals>.compose_two.<locals>.<lambda> s ø ¡r©"¨dÐ*=°fÑ*=Ó'> ó r )r
|
r s ``r Ú compose_twoz compose.<locals>.compose_two s ù Ü>Ð>r )Ú functoolsÚreduce)Úfuncsr s r Úcomposer s ò$?ô × Ñ K¨Ó /Ð/r c óZ t j « fd« fd_ S )ad
|
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
|
c óN t d« s | i |¤_ j S ©NÚ saved_result)Úhasattrr )r r ÚfuncÚwrappers r r zonce.<locals>.wrapperE s+ ø äw Ô/Ù#'¨Ð#8°Ñ#8GÔ Ø×#Ñ#Ð#r c ó8 t « j d« S r )ÚvarsÚ __delitem__)r s r r zonce.<locals>.<lambda>K s ø D M× 5Ñ 5°nÓ E r )r ÚwrapsÚreset©r r s `@r Úoncer! % s0 ù ô@ __TÓô$ó ð$ó
|
FGMØ Nr c óB fd}d |_ t « xs |S )aV
|
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()
|
|
Same for a method that hasn't yet been called.
|
|
>>> c = MyClass()
|
>>> c.method.cache_clear()
|
|
Another cache wrapper may be supplied:
|
|
>>> cache = functools.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 ó~ t j | « } |« }t | j |« ||i |¤S r )ÚtypesÚ
|
MethodTypeÚsetattrÚ__name__)Úselfr r Ú bound_methodÚ cached_methodÚ cache_wrapperÚmethods r r z method_cache.<locals>.wrapper s? ø ä ×'Ñ'¨°Ó5 Ù% lÓ3 Üfoo }Ô5Ù dÐ- fÑ-Ð-r c ó y r r r r r r z method_cache.<locals>.<lambda> ó r )Ú cache_clearÚ_special_method_cache)r, r+ r s `` r Ú method_cacher1 O s% ù õH.ñ 'GÔä ¨ Ó 7Ò B¸7ÐBr c óJ j }d}||vryd|z fd}|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__NÚ__cachedc ó t | « vr,t j | « } |« }t | |« n t | « } ||i |¤S r )r r$ r% r& Úgetattr)r( r r ÚboundÚcacher+ r, Ú wrapper_names r Úproxyz$_special_method_cache.<locals>.proxy³ sS ø Ø t DzÑ )Ü×$Ñ$ V¨TÓ2EÙ! %Ó(EÜ D,¨Õ .äD ,Ó/EÙdÐ%fÑ%Ð%r )r' )r, r+ ÚnameÚ special_namesr; r: s `` @r r0 r0 s4 ú ð ??DØ0Mà =Ñ Øà Ñ$Lö&ð Lr c ó fd}|S )ab
|
Decorate a function with a transform function that is
|
invoked on results returned from the decorated function.
|
|
>>> @apply(reversed)
|
... def get_numbers(start):
|
... "doc for get_numbers"
|
... return range(start, start+3)
|
>>> list(get_numbers(4))
|
[6, 5, 4]
|
>>> get_numbers.__doc__
|
'doc for get_numbers'
|
c óN t j | « t | « « S r )r r r )r Ú transforms r Úwrapzapply.<locals>.wrapÎ s ø Ø$ytÓ$¤W¨Y¸Ó%=Ó>Ð>r r )r@ rA s ` r ÚapplyrB ¿ s ø ô ?ð Kr c ó fd}|S )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
|
>>> x
|
5
|
c óF t j « fd« }|S )Nc ó( | i |¤} |« |S r r )r r ÚresultÚactionr s r r z,result_invoke.<locals>.wrap.<locals>.wrapperå s ø á4Ð* 6Ñ*FÙ 6NØMr ©r r )r r rG s ` r rA zresult_invoke.<locals>.wrapä s% ù Ü Ó ô ó
|
ð ð
|
r r )rG rA s ` r Ú result_invokerI Ô s ø ô ð Kr c ó | |i |¤ | S )a
|
Call a function for its side effect after initialization.
|
|
The benefit of using the decorator instead of simply invoking a function
|
after defining it is that it makes explicit the author's intent for the
|
function to be called immediately. Whereas if one simply calls the
|
function immediately, it's less obvious if that was intentional or
|
incidental. It also avoids repeating the name - the two actions, defining
|
the function and calling it immediately are modeled separately, but linked
|
by the decorator construct.
|
|
The benefit of having a function construct (opposed to just invoking some
|
behavior inline) is to serve as a scope in which the behavior occurs. It
|
avoids polluting the global namespace with local variables, provides an
|
anchor on which to attach documentation (docstring), keeps the behavior
|
logically separated (instead of conceptually separated or not separated at
|
all), and provides potential to re-use the behavior for testing or other
|
purposes.
|
|
This function is named as a pithy way to communicate, "call this function
|
primarily for its side effect", or "while defining this function, also
|
take it aside and call it". It exists because there's no Python construct
|
for "define and call" (nor should there be, as decorators serve this need
|
just fine). The behavior happens immediately and synchronously.
|
|
>>> @invoke
|
... def func(): print("called")
|
called
|
>>> func()
|
called
|
|
Use functools.partial to pass parameters to the initial call
|
|
>>> @functools.partial(invoke, name='bingo')
|
... def func(name): print('called with', name)
|
called with bingo
|
r )Úfr r s r ÚinvokerL ð s ñL tÐvÒØ Hr c ó@ e Zd ZdZ ed« fdZd Zd Zd Zd dZ y)
|
Ú Throttlerz*Rate-limit a function (or other callable).ÚInfc óx t |t « r |j }|| _ || _ | j « y r )Ú
|
isinstancerN r Úmax_rater )r( r rR s r Ú__init__zThrottler.__init__ s, Ü dIÔ &Ø99DØ Ø Ø
|
|
r c ó d| _ y )Nr )Ú last_called)r( s r r zThrottler.reset$ s
|
Ø Õr c óF | j « | j |i |¤S r )Ú_waitr )r( r r s r Ú__call__zThrottler.__call__' s! Ø
|
|
Øtyy$Ð) &Ñ)Ð)r c óÚ t j « | j z
|
}d| j z |z
|
}t j t d|« « t j « | _ y)z2Ensure at least 1/max_rate seconds from last call.é r N)ÚtimerU rR ÚsleepÚmax)r( ÚelapsedÚ must_waits r rW zThrottler._wait+ sL ä))+ × 0Ñ 0Ñ0Ø Ñ%¨Ñ/ Ü
|
|
3q)Ó$Ô%Ü 99;Õr Nc ój t | j t j | j |« « S r )Ú first_invokerW r Úpartialr )r( ÚobjÚowners r Ú__get__zThrottler.__get__2 s$ ÜDJJ¬ ×(9Ñ(9¸$¿)¹)ÀSÓ(IÓJÐJr r )
|
r' Ú
|
__module__Ú __qualname__Ú__doc__ÚfloatrS r rX rW re r r r rN rN s& Ù4á&+¨E£ló ò ò*ò'ôKr rN c ó fd}|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.
|
c ó" « | i |¤S r r )r r Úfunc1Úfunc2s r r z first_invoke.<locals>.wrapper= s ø Ù ÙdÐ%fÑ%Ð%r r )rl rm r s `` r ra ra 6 s ù õ&ð Nr c ó: t j dt d¬« S )NzS`jaraco.functools.method_caller` is deprecated, use `operator.methodcaller` insteadé )Ú
|
stacklevel)ÚwarningsÚwarnÚDeprecationWarningr r r r r E s HMMð .äØô r c ó y r r r r r r r O r. r r c ó® |t d« k( rt j « n
|
t |« }|D ] } | « c S | « S # |$ r
|
|« Y #w xY w)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)ri Ú itertoolsÚcountÚrange)r ÚcleanupÚretriesÚtrapÚattemptsÚ_s r Ú
|
retry_callr O s[ ð %,¬u°U«|Ò$;yÔ ÄÀwà HØ ò ð Ù6Mðñ 6Møð ò Ù Ið ús ´AÁ AÁAc ó fd}|S )a7
|
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 óH t j « fd« }|S )Nc óT t j g| ¢i |¤}t |g¢i ¤S r )r rb r )Úf_argsÚf_kwargsr8 r Úr_argsÚr_kwargss r r z(retry.<locals>.decorate.<locals>.wrapperp s2 ø ä ×%Ñ% dÐ@¨VÒ@°xÑ@EÜ eÐ9 fÒ9°Ñ9Ð 9r rH )r r r
r s ` r Údecoratezretry.<locals>.decorateo s% ù Ü Ó õ :ó
|
ð :ð r r )r
r r s `` r Úretryr ` s ù õ ð Or c óª t j t t « }t t
|
j || « } t j | « |« S )z³
|
Convert a generator into a function that prints all yielded elements.
|
|
>>> @print_yielded
|
... def x():
|
... yield 3; yield None
|
>>> x()
|
3
|
None
|
)r rb ÚmapÚprintr Úmore_itertoolsÚconsumer )r Ú print_allÚ print_resultss r Ú print_yieldedr z s@ ô ×!Ñ!¤#¤uÓ-IÜN× 2Ñ 2°I¸tÓDMØ 9??4Ó Ó /Ð/r c óB t j « fd« }|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 ó" | | g|¢i |¤S y r r )Úparamr r r s r r zpass_none.<locals>.wrapper s! ø à Ð ÙÐ/ Ò/¨Ñ/Ð /Ør rH r s ` r Ú pass_noner s' ø ô __TÓóó ðð
|
Nr c óÆ t j | « }|j j « }|D ci c] }||v s||| }}t j
|
| fi |¤S c c}w )a
|
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
|
)ÚinspectÚ signatureÚ
|
parametersÚkeysr rb )r Ú namespaceÚsigÚparamsÚkÚcall_nss r Ú assign_paramsr sc ô4 ×
|
Ñ
|
DÓ
|
!CØ ^^× Ñ Ó "FØ(.ÖA 1°!°y².q)A,ÐAGÐAÜ × Ñ TÑ - WÑ -Ð-ùò Bs
|
´ A ¾A c ór t j dd« t j « fd« }|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_kwargsz args kwargsc óf dj z } ||« }t | ||« | g|¢i |¤S )NÚ_saved_)r' r& )r( r r Ú attr_nameÚattrr¡ r, s r r z!save_method_args.<locals>.wrapperá s> ø à §¡Ñ/ Ù t VÓ,Üi Ô&ÙdÐ,TÒ, VÑ,Ð,r )Ú collectionsÚ
|
namedtupler r )r, r r¡ s ` @r Úsave_method_argsr¨ ½ s; ù ôD "×,Ñ,Ð->À ÓNOä__VÓ ô-ó ð-ð Nr )ÚreplaceÚusec ó fd}|S )a-
|
Replace the indicated exceptions, if raised, with the indicated
|
literal replacement or evaluated expression (if present).
|
|
>>> safe_int = except_(ValueError)(int)
|
>>> safe_int('five')
|
>>> safe_int('5')
|
5
|
|
Specify a literal replacement with ``replace``.
|
|
>>> safe_int_r = except_(ValueError, replace=0)(int)
|
>>> safe_int_r('five')
|
0
|
|
Provide an expression to ``use`` to pass through particular parameters.
|
|
>>> safe_int_pt = except_(ValueError, use='args[0]')(int)
|
>>> safe_int_pt('five')
|
'five'
|
|
c óJ t j « fd« }|S )Nc ój | i |¤S # $ r" t « cY S # t $ r cY cY S w xY ww xY wr )ÚevalÚ TypeError)r r Ú
|
exceptionsr r© rª s r r z*except_.<locals>.decorate.<locals>.wrapper sJ ø ð #ÙTÐ, VÑ,Ð,øØ ò #ð#Ü 9Ò$øÜ ò #Ø"Nð#úð #ús 2
|
2 .©2.®2rH )r r r° r© rª s ` r r zexcept_.<locals>.decorate s% ù Ü Ó ö #ó
|
ð #ð r r )r© rª r° r s ``` r Úexcept_r± ë s ú ö0 ð Or c ó | S )zV
|
Return the argument.
|
|
>>> o = object()
|
>>> identity(o) is o
|
True
|
r )Úxs r Úidentityr´ s ð Hr ©Ú_opc ó fd}|S )a
|
Decorate a function to return its parameter when ``check``.
|
|
>>> bypassed = [] # False
|
|
>>> @bypass_when(bypassed)
|
... def double(x):
|
... return x * 2
|
>>> double(2)
|
4
|
>>> bypassed[:] = [object()] # True
|
>>> double(2)
|
2
|
c óH t j « fd« }|S )Nc ó( « r| S | « S r r )r r¶ Úcheckr s r r z.bypass_when.<locals>.decorate.<locals>.wrapper/ s ø á J5Ð 7©D°«KÐ 7r rH )r r r¶ rº s ` r r z bypass_when.<locals>.decorate. s% ù Ü Ó õ 8ó
|
ð 8ð r r )rº r¶ r s `` r Ú bypass_whenr» s ù õ ð Or c ó8 t | t j ¬« S )a
|
Decorate a function to return its parameter unless ``check``.
|
|
>>> enabled = [object()] # True
|
|
>>> @bypass_unless(enabled)
|
... def double(x):
|
... return x * 2
|
>>> double(2)
|
4
|
>>> del enabled[:] # False
|
>>> double(2)
|
2
|
rµ )r» ÚoperatorÚnot_)rº s r Ú bypass_unlessr¿ 8 s ô u¤(§-¡-Ô 0Ð0r c ó || S )zSplat args to func.r ©r r s r Ú _splat_innerr J s ñ ;Ðr r c ó |di | ¤S )z Splat kargs to func as kwargs.r r rÁ s r r~ r~ P s ñ <$<Ðr c ój t j | « t j t | ¬« « S )a´
|
Wrap func to expect its parameters to be passed positionally in a tuple.
|
|
Has a similar effect to that of ``itertools.starmap`` over
|
simple ``map``.
|
|
>>> pairs = [(-1, 1), (0, 2)]
|
>>> more_itertools.consume(itertools.starmap(print, pairs))
|
-1 1
|
0 2
|
>>> more_itertools.consume(map(splat(print), pairs))
|
-1 1
|
0 2
|
|
The approach generalizes to other iterators that don't have a "star"
|
equivalent, such as a "starfilter".
|
|
>>> list(filter(splat(operator.add), pairs))
|
[(0, 2)]
|
|
Splat also accepts a mapping argument.
|
|
>>> def is_nice(msg, code):
|
... return "smile" in msg or code == 0
|
>>> msgs = [
|
... dict(msg='smile!', code=20),
|
... dict(msg='error :(', code=1),
|
... dict(msg='unknown', code=0),
|
... ]
|
>>> for msg in filter(splat(is_nice), msgs):
|
... print(msg)
|
{'msg': 'smile!', 'code': 20}
|
{'msg': 'unknown', 'code': 0}
|
©r )r r rb r rÅ s r ÚsplatrÆ V s( ðF !9??4Ó ¤×!2Ñ!2´<ÀdÔ!KÓ LÐLr )'Úcollections.abcr¦ r r rw r½ r[ r$ rq r r r! Ú lru_cacher1 r0 rB rI rL rN ra Ú methodcallerÚ method_callerr r r r r r¨ r± r´ r» r¿ Úsingledispatchr ÚregisterÚabcÚMappingr~ rÆ r r r ú<module>rÏ s ðÛ Û Û Û Û Û Û Û ã ò0ò0'ðT (; y×':Ñ':Ó'<ó NCòb ò>ò*ò8' ÷TKñ Kò8 ñ ñð ×Ñó ñ *°1¸2ó ò"ò4 0ò ò& .ò@+ð\ "&¨4ô %òP ð 'ô ò41ð$ ×Ññó ðð
|
×ÑðKOO× #Ñ #ò ó ðó
|
#Mr
|
