Vi SrSSKJr SSKrSSKrSSKrSSKrSSKrSSKJ r J r \ \ r Sr \R$rSS KJr \"S S 9rSS KJr \R6S :r\(dSSKJr OSSKJr SSSS00\SSSS\4 SjrS0Sjr Sr!S1Sjr"S2Sjr#Sr$"SS\RJ5r&"SS\RJ5r'\'r%S3Sjr(S4S jr)S4S!jr*S5S"jr+S4S#jr,S$r-"S%S&\5r."S'S(\/5r0"S)S*\/5r1S+\24S,jr3SS-KJ4r4 S/r5g!\a Sr \\4rSr Nf=f!\a SrNf=f!\a \"5rGNf=f!\a SrGN f=f!\a S.r4NVf=f)6zPython's built-in :mod:`functools` module builds several useful utilities on top of Python's first-class function support. ``funcutils`` generally stays in the same vein, adding to and correcting Python's standard metaprogramming facilities. )print_functionN) MethodType FunctionTypeTc[X5$N)r)descobjobj_types d/home/james-whalen/.local/share/pipx/venvs/semgrep/lib/python3.13/site-packages/boltons/funcutils.pyr 4s j.CFcgNF)funcs r r r ?sr ) make_sentinel NO_DEFAULT)var_name) partialmethod)) formatargspec)formatannotationrc SU-$)N*rnames r r r \ssTzr c SU-$)Nz**rrs r r r ]sTD[r cS[U5-$N=)reprvalues r r r ^s cDK&7r c SU-$)Nz -> r)texts r r r _sv}r c ^^^ UU U4Sjn /nU(a[U5[U5- n[U5H=unnU "U5nU(aUW:aUU "UUU- 5-nURU5 M? UbURU"U "U555 OU(aURS5 U(a=UH7nU "U5nU(aUU;aUU "UU5- nURU5 M9 UbURU "U "U555 SSRU5-S-nST;aUU "T "TS55- nU$)aCopy formatargspec from python 3.7 standard library. Python 3 has deprecated formatargspec and requested that Signature be used instead, however this requires a full reimplementation of formatargspec() in terms of creating Parameter objects and such. Instead of introducing all the object-creation overhead and having to reinvent from scratch, just copy their compatibility routine. cF>T"U5nUT;aUST"TU5-- nU$)Nz: r)argresult annotationsr formatargs r formatargandannotation5inspect_formatargspec..formatargandannotationis3s^Fk!$!1+c2B!CCCMr r(, )return)len enumerateappendjoin)argsvarargsvarkwdefaults kwonlyargskwonlydefaultsr+r, formatvarargs formatvarkw formatvalue formatreturnsrr-specs firstdefaultir)spec kwonlyargr*s `` ` r inspect_formatargspecrFXs<"   t9s8}4LoFAs)#.DA-k(1|3C*DEE LL  &   LL'=g'FG H S! ' -i8!i>&AKy(ABBD T" (   LL%;E%BC Dtyy''#- { " m$4[5J$KL LF r c[U[5(a[RUn00p2[ U5HtnU(aU"U5(aM[ X5nURnX`R:waMC[U[5(aXRU'M^[U5(dMpXSU'Mv X#4$![ a Mf=f![a Mf=f)zReturns two maps of (*types*, *funcs*) from *mod*, optionally ignoring based on the :class:`bool` return value of the *ignore* callable. *mod* can be a string name of a module in :data:`sys.modules` or the module instance itself. ) isinstance basestringsysmodulesdirgetattr Exception __module__AttributeError__name__typecallable)modignoretypesfuncs attr_nameattr attr_mod_names r get_module_callablesr[s #z""kk#r5X fY''  3*D  OOM LL (  dD ! !#)  d^^#) !" <      s$ B2 C2 C?C CCcb[RRSUR55$)aTakes a type and returns an iterator over all class variables throughout the type hierarchy (respecting the MRO). >>> sorted(set([k for k, v in mro_items(int) if not k.startswith('__') and 'bytes' not in k and not callable(v)])) ['denominator', 'imag', 'numerator', 'real'] c3V# UHnURR5v M! g7fr)__dict__items).0cts r mro_items..s()E3CR*,):):)<)<3Cs')) itertoolschain from_iterable__mro__)type_objs r mro_itemsris2 ?? ( ()E3;3C3C)E EEr c|0n[U5Hn[X5X#'M U$![a U(aeM,f=f)zReturn a dictionary of attribute names to values for a given object. Unlike ``obj.__dict__``, this function returns all attributes on the object, including ones on parent classes. )rLrMrN)r raise_excretks r dir_dictrnsJ C X S_CF J  s %;;c [URURUR[ USS5[ USS5S9nU(a%UR R UR 5 U$)aReturns a shallow copy of the function, including code object, globals, closure, etc. >>> func = lambda: func >>> func() is func True >>> func_copy = copy_function(func) >>> func_copy() is func True >>> func_copy is not func True Args: orig (function): The function to be copied. Must be a function, not just any method or callable. copy_dict (bool): Also copy any attributes set on the function instance. Defaults to ``True``. __defaults__N __closure__)rargdefsclosure)r__code__ __globals__rQrMr^update)orig copy_dictrls r copy_functionrys]& t}}'' MM&t^TB&t]DA  CC  DMM* Jr cSnSnSn[US5(dXl[US5(dX l[US5(dX0lU$)aClass decorator, similar to :func:`functools.total_ordering`, except it is used to define `partial orderings`_ (i.e., it is possible that *x* is neither greater than, equal to, or less than *y*). It assumes the presence of the ``__le__()`` and ``__ge__()`` method, but nothing else. It will not override any existing additional comparison methods. .. _partial orderings: https://en.wikipedia.org/wiki/Partially_ordered_set >>> @partial_ordering ... class MySet(set): ... def __le__(self, other): ... return self.issubset(other) ... def __ge__(self, other): ... return self.issuperset(other) ... >>> a = MySet([1,2,3]) >>> b = MySet([1,2]) >>> c = MySet([1,2,4]) >>> b < a True >>> b > a False >>> b < c True >>> a < c False >>> c > a False c"X:*=(a X:+$rrselfothers r __lt__ partial_ordering..__lt__DM$G$6GGr c"X:=(a X::+$rrr|s r __gt__ partial_ordering..__gt__rr c X:=(a X:*$rrr|s r __eq__ partial_ordering..__eq__sDM$CdmCr rrr)hasattrrrr)clsrrrs r partial_orderingrsF>HGC 3 ! !: 3 ! !: 3 ! !: Jr c4\rSrSrSr\b\S5rSrSr g)InstancePartiali a:class:`functools.partial` is a huge convenience for anyone working with Python's great first-class functions. It allows developers to curry arguments and incrementally create simpler callables for a variety of use cases. Unfortunately there's one big gap in its usefulness: methods. Partials just don't get bound as methods and automatically handed a reference to ``self``. The ``InstancePartial`` type remedies this by inheriting from :class:`functools.partial` and implementing the necessary descriptor protocol. There are no other differences in implementation or usage. :class:`CachedInstancePartial`, below, has the same ability, but is slightly more efficient. Nc\[UR/URQ70URD6$rrrr7keywordsr}s r _partialmethodInstancePartial._partialmethod# HTYYH$--H Hr c[XU5$r) make_method)r}r r s r __get__InstancePartial.__get__s4h//r r) rQrO __qualname____firstlineno____doc__rpropertyrr__static_attributes__rr r rr s(  I  I0r rcZ\rSrSrSr\b\S5r\RS:aSr Sr Sr g) CachedInstancePartiali#aThe ``CachedInstancePartial`` is virtually the same as :class:`InstancePartial`, adding support for method-usage to :class:`functools.partial`, except that upon first access, it caches the bound method on the associated object, speeding it up for future accesses, and bringing the method call overhead to about the same as non-``partial`` methods. See the :class:`InstancePartial` docstring for more details. Nc\[UR/URQ70URD6$rrrs r r$CachedInstancePartial._partialmethod.rr )rcX lgr)rQ)r}r rs r __set_name__"CachedInstancePartial.__set_name__3s Mr c[USS5UlURRUlURRUlURnUc#[ U5HupEXPLdM U=UlnM Uc [ XU5$URU$![a [ XU5=URU'nUs$f=f)NrQ) rMrQrrrOrirr^KeyError)r}r r rrmvrls r rCachedInstancePartial.__get__6s j$7 yy(( ))..}} <!(+9+,,DMD, ;t(3 3 <<% % '24h'G GCLL J s B'CC)rrOrQ) rQrOrrrrrrrJ version_inforrrrr r rr#s=  I  I 6! !r rc .URS[5nU(a+[SSRUR 55-5eU=(d 0nSRUVs/sH oT"U5PM sn5n[ U[ 5(a[U5Vs/sHowX'4PM nnOUnSRUVV s/sHupyU<SU"U 5<3PM sn n5n Un U (a U (aU S- n X- n U<SU <S3$s snfs snfs sn nf)aNGiven a name, positional arguments, and keyword arguments, format a basic Python-style function call. >>> print(format_invocation('func', args=(1, 2), kwargs={'c': 3})) func(1, 2, c=3) >>> print(format_invocation('a_func', args=(1,))) a_func(1) >>> print(format_invocation('kw_func', kwargs=[('a', 1), ('b', 2)])) kw_func(a=1, b=2) r"zunexpected keyword args: %rr0r!r/r1)popr" TypeErrorr6keysrHdictsorted) rr7kwargskw_repraa_textrm kwarg_itemsrkw_text all_args_texts r format_invocationrRs FF64 E 5 "'')8LLMM \rF YY$/$Qa$/ 0F&$/5f~>~!69~~ >  ii[I[TQAuQx0[IJGM M] ++0>Js#DD D c [U5RnU=(d /nU=(d /n[5/pvX#-H,nX;aM URU5 UR U5 M. UcSn[ U5(deUVs/sHn[ XS5PM n nUVs/sHo[ XS54PM n nU VV s/sHupX;aU"U 5(aMX4PM n nn [XYU 5$s snfs snfs sn nf)atRender an expression-style repr of an object, based on attribute names, which are assumed to line up with arguments to an initializer. >>> class Flag(object): ... def __init__(self, length, width, depth=None): ... self.length = length ... self.width = width ... self.depth = depth ... That's our Flag object, here are some example reprs for it: >>> flag = Flag(5, 10) >>> print(format_exp_repr(flag, ['length', 'width'], [], ['depth'])) Flag(5, 10) >>> flag2 = Flag(5, 15, 2) >>> print(format_exp_repr(flag2, ['length'], ['width', 'depth'])) Flag(5, width=15, depth=2) By picking the pos_names, req_names, opt_names, and opt_key, you can fine-tune how you want the repr to look. Args: obj (object): The object whose type name will be used and attributes will be checked pos_names (list): Required list of attribute names which will be rendered as positional arguments in the output repr. req_names (list): List of attribute names which will always appear in the keyword arguments in the output repr. Defaults to None. opt_names (list): List of attribute names which may appear in the keyword arguments in the output repr, provided they pass the *opt_key* check. Defaults to None. opt_key (callable): A function or callable which checks whether an opt_name should be in the repr. Defaults to a ``None``-check. Nc USL$rrrs r r !format_exp_repr..AIr )rRrQsetaddr5rSrMr) r pos_names req_names opt_namesopt_keycn uniq_names all_namesrr7kw_itemsvals r format_exp_reprrqsL c  BRIRIE2 %   t & % G   1: ;GCt $D ;=FGYTws$/0YHG-5=X )gcl XH= Rx 00 <G=sC3#C8C=C=c URRnU=(d /nU=(d /n[5/peX-H,nXu;aM URU5 UR U5 M. UcSn[ U5(deUVs/sHow[ XS54PM nnUVV s/sH"upyXr;aU"U 5(aMU<SU <3PM$ n nn U (dS[U5-/n SU<SSRU 5<S3n U $s snfs sn nf)a<Format a non-expression-style repr Some object reprs look like object instantiation, e.g., App(r=[], mw=[]). This makes sense for smaller, lower-level objects whose state roundtrips. But a lot of objects contain values that don't roundtrip, like types and functions. For those objects, there is the non-expression style repr, which mimic's Python's default style to make a repr like so: >>> class Flag(object): ... def __init__(self, length, width, depth=None): ... self.length = length ... self.width = width ... self.depth = depth ... >>> flag = Flag(5, 10) >>> print(format_nonexp_repr(flag, ['length', 'width'], ['depth'])) If no attributes are specified or set, utilizes the id, not unlike Python's built-in behavior. >>> print(format_nonexp_repr(flag)) Nc USL$rrrs r r $format_nonexp_repr..rr r!zid=%s< >) __class__rQrrr5rSrMidr6) r rrrrrrrr_rlabelsrls r format_nonexp_reprrs8   BRIRIE2 %   t & % G   :C D)$GCt, -)E D5:;U 'GCL$s#UF; BsG#$388F+ ,C J E;sD&D  D c *[[4USXS.UD6$)aDecorator factory to apply update_wrapper() to a wrapper function. Modeled after built-in :func:`functools.wraps`. Returns a decorator that invokes update_wrapper() with the decorated function as the wrapper argument and the arguments to wraps() as the remaining arguments. Default arguments are as for update_wrapper(). This is a convenience function to simplify applying partial() to update_wrapper(). Same example as in update_wrapper's doc but with wraps: >>> from boltons.funcutils import wraps >>> >>> def print_return(func): ... @wraps(func) ... def wrapper(*args, **kwargs): ... ret = func(*args, **kwargs) ... print(ret) ... return ret ... return wrapper ... >>> @print_return ... def example(): ... '''docstring''' ... return 'example return value' >>> >>> val = example() example return value >>> example.__name__ 'example' >>> example.__doc__ 'docstring' N)r build_frominjectedexpected)partialupdate_wrapper)rrrrs r wrapsrs(B > ?$ ?;= ??r c Uc/nO$[U[5(aU/nO [U5n[U5n[U[[ 45(a[ S[USS5<35eURSS5nURSS5nURSS5n U(a[ S UR5-5e[U[R5(aXRLa U=(d Un[RU=(d U5n UHn U RU 5 M UHupU R%X5 M U R&(aS U R)5-U lOS U R)5-U l[-XS 9n U R/XS 9nU (a [1US5(aUR2S U$U (dXlU$![ a U(aU R"bMef=f)a Modeled after the built-in :func:`functools.update_wrapper`, this function is used to make your wrapper function reflect the wrapped function's: * Name * Documentation * Module * Signature The built-in :func:`functools.update_wrapper` copies the first three, but does not copy the signature. This version of ``update_wrapper`` can copy the inner function's signature exactly, allowing seamless usage and :mod:`introspection `. Usage is identical to the built-in version:: >>> from boltons.funcutils import update_wrapper >>> >>> def print_return(func): ... def wrapper(*args, **kwargs): ... ret = func(*args, **kwargs) ... print(ret) ... return ret ... return update_wrapper(wrapper, func) ... >>> @print_return ... def example(): ... '''docstring''' ... return 'example return value' >>> >>> val = example() example return value >>> example.__name__ 'example' >>> example.__doc__ 'docstring' In addition, the boltons version of update_wrapper supports modifying the outer signature. By passing a list of *injected* argument names, those arguments will be removed from the outer wrapper's signature, allowing your decorator to provide arguments that aren't passed in. Args: wrapper (function) : The callable to which the attributes of *func* are to be copied. func (function): The callable whose attributes are to be copied. injected (list): An optional list of argument names which should not appear in the new wrapper's signature. expected (list): An optional list of argument names (or (name, default) pairs) representing new arguments introduced by the wrapper (the opposite of *injected*). See :meth:`FunctionBuilder.add_arg()` for more details. build_from (function): The callable from which the new wrapper is built. Defaults to *func*, unless *wrapper* is partial object built from *func*, in which case it defaults to *wrapper*. Useful in some specific cases where *wrapper* and *func* have the same arguments but differ on which are keyword-only and positional-only. update_dict (bool): Whether to copy other, non-standard attributes of *func* over to the wrapper. Defaults to True. inject_to_varkw (bool): Ignore missing arguments when a ``**kwargs``-type catch-all is present. Defaults to True. hide_wrapped (bool): Remove reference to the wrapped function(s) in the updated function. In opposition to the built-in :func:`functools.update_wrapper` bolton's version returns a copy of the function and does not modifiy anything in place. For more in-depth wrapping of functions, see the :class:`FunctionBuilder` type, on which update_wrapper was built. Nz~wraps does not support wrapping classmethods and staticmethods, change the order of wrapping to wrap the underlying function: __func__ update_dictTinject_to_varkw hide_wrappedFunexpected kwargs: %rzreturn await _call(%s)zreturn _call(%s))_call_func) with_dict __wrapped__)rHrIlist_parse_wraps_expected classmethod staticmethodrrMrr functoolsrrFunctionBuilder from_func remove_argMissingArgumentr9add_argis_asyncget_invocation_strbodyrget_funcrr^r)wrapperrrrrrexpected_itemsrrrfbr)defaultexecdict fully_wrappeds r rr sN Hj ) ):>*84N$l344#4T:=> > &&-Kff.5O66.%0L /"'');<<'9,,--$,,2F*7  " ":#5 6B  MM# '  3 ' {{*R-B-B-DD$r'<'<'>>'.HKKK@M }==  " "= 1 $(! + 288#7  s G!!HHcUc/nO[U[5(a U[4/n/n[U5nUHYn[U[5(aXnOUupE[U[5(d[ SU<35eUR XE45 M[ U$![an[ SU<SU<S35eSnAff=f![a [nNtf=f![[ 4a [ S5ef=f)Nz"expected" takes string name, sequence of string names, iterable of (name, default) pairs, or a mapping of {name: default}, not z (got: r1z"expected" takes string name, sequence of string names, iterable of (name, default) pairs, or a mapping of {name: default}, not %rz-all "expected" argnames must be strings, not )rHrIriterr ValueErrorr5)rr expected_itereargnamers r rrs  Hj ) )z*+NOX ! gz * * %"+  =#*  ':..RY[\ \w01%!( 1 OAI1NO OO %$ % z* = "<== =s5 BB:C B7B22B7:C  C C,c \rSrSrSr\(a\SSSS.r\S5r O\SS S \\ \ S .r\S 5r \ \ S SSS\ SS.r \ R\5 \R"5rSr\(a S$SjrSrO%S$Sjr\R*"S\R,5rSr\S5rS%SjrSrS&Sjr\(a\4SjrO\S4S jrS!rS"rS#r g)'ria The FunctionBuilder type provides an interface for programmatically creating new functions, either based on existing functions or from scratch. Values are passed in at construction or set as attributes on the instance. For creating a new function based of an existing one, see the :meth:`~FunctionBuilder.from_func` classmethod. At any point, :meth:`~FunctionBuilder.get_func` can be called to get a newly compiled function, based on the values configured. >>> fb = FunctionBuilder('return_five', doc='returns the integer 5', ... body='return 5') >>> f = fb.get_func() >>> f() 5 >>> fb.varkw = 'kw' >>> f_kw = fb.get_func() >>> f_kw(ignored_arg='ignored_val') 5 Note that function signatures themselves changed quite a bit in Python 3, so several arguments are only applicable to FunctionBuilder in Python 3. Except for *name*, all arguments to the constructor are keyword arguments. Args: name (str): Name of the function. doc (str): `Docstring`_ for the function, defaults to empty. module (str): Name of the module from which this function was imported. Defaults to None. body (str): String version of the code representing the body of the function. Defaults to ``'pass'``, which will result in a function which does nothing and returns ``None``. args (list): List of argument names, defaults to empty list, denoting no arguments. varargs (str): Name of the catch-all variable for positional arguments. E.g., "args" if the resultant function is to have ``*args`` in the signature. Defaults to None. varkw (str): Name of the catch-all variable for keyword arguments. E.g., "kwargs" if the resultant function is to have ``**kwargs`` in the signature. Defaults to None. defaults (tuple): A tuple containing default argument values for those arguments that have defaults. kwonlyargs (list): Argument names which are only valid as keyword arguments. **Python 3 only.** kwonlydefaults (dict): A mapping, same as normal *defaults*, but only for the *kwonlyargs*. **Python 3 only.** annotations (dict): Mapping of type hints and so forth. **Python 3 only.** filename (str): The filename that will appear in tracebacks. Defaults to "boltons.funcutils.FunctionBuilder". indent (int): Number of spaces with which to indent the function *body*. Values less than 1 will result in an error. dict (dict): Any other attributes which should be added to the functions compiled with this FunctionBuilder. All of these arguments are also made available as attributes which can be mutated as necessary. .. _Docstring: https://en.wikipedia.org/wiki/Docstring#Python cgrrrr r r FunctionBuilder.r cgrrrr r r rdr cgrrrr r r rr r7r8r9r:cB[R"U5up#pEUUUUS.$)Nr)inspect getargspec)rfr7r8r9r:s r _argspec_to_dict FunctionBuilder._argspec_to_dicts--4-?-?-B *D5 &" (* *r cgrrrr r r rrr cgrrrr r r rrr cgrrrr r r rrr )r7r8r9r:r;r<r+cn^[R"U5m[U4SjUR55$)Nc3@># UHnU[TU54v M g7fr)rM)r`rYargspecs r rb3FunctionBuilder._argspec_to_dict.. s$;$9Dww56$9s)r getfullargspecr_argspec_defaults)rr rs @r r r s3,,Q/G;$'$9$9;; ;r cgrrrr r r rsUr cgrrrr r r rs4r cg)Npassrrr r r rsr cg)Nrrr r r rs1r cg)Nz!boltons.funcutils.FunctionBuilderrrr r r rs%Hr )docrrmodulerindentr+filenamec XlURR5H-up4URUS5nUcU"5n[ XU5 M/ U(a[ SUR 5-5eg)Nr)r _defaultsr_rsetattrrr)r}rrrdefault_factoryrs r __init__FunctionBuilder.__init__sf "&.."6"6"8 A&&D/C{%' DS ! #9 3bggi?@ @r cZ[URURUR/5$zReturn function signature as a string. with_annotations is ignored on Python 2. On Python 3 signature will omit annotations if it is set to False. rFr7r8r9)r}with_annotationss r get_sig_strFunctionBuilder.get_sig_str)s& )DLL)-R9 9r c`[URURUR/5SS$)Nr*rs r r"FunctionBuilder.get_invocation_str2s.(DLL)-R99:2? ?r c U(a URnO0n[URURUR/UR 0U5$r))r+rFr7r8r9r;)r}r+r+s r r,r-6sH  "..  ()-)-)+)-)+)4 6 6r z \* # a star \s* # followed by any amount of whitespace , # followed by a comma \s* # followed by any amount of whitespace c Sn0nUR(a"[SUR55nSUS'[URURUR /UU040UD6nUR RSU5nUSS$)Nc3(# UHnX4v M g7frr)r`r)s r rb5FunctionBuilder.get_invocation_str..Ts$@/>&)J/>sc SU-$r rr#s r r 4FunctionBuilder.get_invocation_str..Vs#+r r?r/r0)r;rrFr7r8r9_KWONLY_MARKERsub)r} kwonly_pairs formatterssigs r rr1PsLJ#$@/3$@ @ ,E =)' (, (, (*(4(4(* 6+56C%%))"c2Cq9 r c ~[U5(d[SU<35e[U[R5(a[ (a [ S5eURRURR[URSS5[URS05[URS05S.nO=URUR[USS5[US05[US05S.nURURU55 [U5(aSUS 'U"S 0UD6$) z{Create a new FunctionBuilder instance based on an existing function. The original function will not be stored or modified. zexpected callable object, not zACannot build FunctionBuilder instances from partials in python 2.rON__annotations__r^)rrrr+rTrr)rSrrHrr_IS_PY2rrrQrrMrvr _inspect_iscoroutinefunction)rrrs r rFunctionBuilder.from_funccs~~$HI I dI-- . .w !dee"ii00!YY.. ' < F%,TYY8I2%N%diiR@ BF #mm!\\ 'lD A%,T3Db%I%dJ; =F  c**401 ' - -!%F: }V}r NcU=(d 0nUR=(d URnSnUS- nUR(aSU-n[URSUR-5nUR R SS5R SS5nURX`RSS 9URUS 9nURXq5 XnUR Ul URUl URUl[(d"UR UlUR$UlU(a%UR(R+UR,5 UR.UlU(aXxlU$) a;Compile and return a new function based on the current values of the FunctionBuilder. Args: execdict (dict): The dictionary representing the scope in which the compilation should take place. Defaults to an empty dict. add_source (bool): Whether to add the source used to a special ``__source__`` attribute on the resulting function. Defaults to True. with_dict (bool): Add any custom attributes, if applicable. Defaults to True. To see an example of usage, see the implementation of :func:`~boltons.funcutils.wraps`. zdef {name}{sig_str}:z {body}zasync rr_rF)r+)rsig_strrr)r _default_bodyr_indentr rreplaceformatr,r_compilerQrr:rpr@r<__kwdefaults__r+r?r^rvrrrO __source__) r}r add_sourcerrtmplrsrcrs r rFunctionBuilder.get_funcs1">ryy.D..%  ==d?Dtyy# "34yy  c*223<kkt-=-=u-=-U"hhT3 c$~  xx  MMw"&"5"5D #'#3#3D  MM  +++ !O r c [[[[[UR5[UR =(d /55555n[ USS5nU(aURU5 U$)zPGet a dictionary of function arguments with defaults and the respective values. r<N)rreversedrzipr7r:rMrv)r}rlr<s r get_defaults_dict!FunctionBuilder.get_defaults_dictsf8DXdii%8%-dmm.Ar%B"DEFG '7>  JJ~ & r Fc[UR5[[USS55-nU(a3UR5n[UVs/sH oDU;dM UPM sn5nU$s snf)Nr;r)tupler7rMrT)r} only_required arg_names defaults_dictans r get_arg_namesFunctionBuilder.get_arg_namess^$))$uWT<-L'MM  224MIQIb=9PrIQRIRs A)A)cXR;a[SU<SUR<S35eURRU5 U[LaUR =(d SU4-Ulg)zOAdd an argument with optional *default* (defaults to ``funcutils.NO_DEFAULT``).arg  already in func arg listrN)r7ExistingArgumentrr5rr:)r}arg_namers r rFunctionBuilder.add_argsW99$&xY]YbYb'cdd II  X &j(!%!4" B r cXR;a[SU<SUR<S35eXR;a[SU<SUR<S35eU(dCURR U5 U[ LaUR =(d SU4-UlgURR U5 U[ LaX RU'g)zAdd an argument with optional *default* (defaults to ``funcutils.NO_DEFAULT``). Pass *kwonly=True* to add a keyword-only argument r_r`raz kwonly arg listrN)r7rbrr;r5rr:r<)r}rcrkwonlys r rrds 99$&xY]YbYb'cdd??*&V^`d`i`i'jkk   **,%)]]%8bWJ$FDM &&x0*,4;''1 r c URnUR5nURU5 URUS5 [ UVs/sHoDU;dM X4PM sn5Ulgs snf![ ax URRU5 URRUS5 g![[ 4a* [SU<SUR<SU<35nXl Uef=ff=f)aRemove an argument from this FunctionBuilder's argument list. The resulting function will have one less argument per call to this function. Args: arg_name (str): The name of the argument to remove. Raises a :exc:`ValueError` if the argument is not present. Nr_z not found in z argument list: ) r7rTremoverrWr:rr;r<rPrrrc)r}rcr7d_dictrexcs r rFunctionBuilder.remove_argsyy'') L KK ! JJx &!d"Jd6k969d"JKDM#K 8 8&&x0##''$7 #J/ %/7D'JK'    8s/A1 A,A,1 C3<B5C35:C//C3cSUR[UR54-n[XS5n[ XB5 U$![ a ef=f)Nz<%s-%d>single)r!next_compile_countcompileexecrN)r}rOrr!codes r rJFunctionBuilder._compilesX}}d4+>+>&?AB 3(3D     s ? A )r:rT)NTTF)!rQrOrrrr@rrrr rstrr#rvrdcountror&r,rrerpVERBOSEr9rrrTr\rrrrJrrr r rrs+=~%)(4&2)57  *  *&*(4&2)5+//3,0 2  ;  ; *''$ $HJI&'__&N  9 ? 6&% ZZ  &@1f ,6 -7u &> r rc\rSrSrSrg)rirNrQrOrrrrr r rrr rc\rSrSrSrg)rbirNr{rr r rbrbr|r rb cUR5Vs/sHnU"U5(aX-OUPM nnURU5$s snf)z based on boltons.strutils.indent) splitlinesr6)r&marginnewlinekeylineindented_liness r rGrGsN#'//"35"3$),D v}t;"35 << ''5sA)total_orderingcxSS4SS4SS4/SS4SS 4SS 4/SS 4SS 4SS 4/SS4SS4SS4/S.n[[U55[U5-nU(d [S5e[U5nXH=upEXB;dM XEl[ [ U5RUl[XU5 M? U$)zClass decorator that fills in missing comparators/ordering methods. Backport of :func:`functools.total_ordering` to work with Python 2.6. Code from http://code.activestate.com/recipes/576685/ rc*X:=(d X:H(+$rrr|s r r total_ordering...$,*G$-%Hr __le__c X:=(d X:H$rrr|s r r r0T\%BT]%Br __ge__c X:+$rrr|s r r r2%5r c"X::+=(d X:H$rrr|s r r r5s%6%G$-%Gr rc"X:*=(a X:X+$rrr|s r r r7T]%H47H%Hr c X::+$rrr|s r r r9%6r c*X:=(d X:H(+$rrr|s r r r<rr c X:=(d X:H$rrr|s r r r>rr c X:+$rrr|s r r r@rr c"X:+=(d X:H$rrr|s r r rCs$&7%IDM%Ir c"X:=(a X:X+$rrr|s r r rErr c X:+$rrr|s r r rGrr )rrrrz6must define at least one ordering operation: < > <= >=) rrLrmaxrQrMintrr$)rconvertrootsrootopnameopfuncs r rr$s%HJBD57 8GIHJ68 9HJBD57 8IKHJ68 9- <CH G ,*+ +5z%mNF""(!(f!5!=!=V, ,  r cg)au Simple function that should be used when no effect is desired. An alternative to checking for an optional function type parameter. e.g. def decorate(func, pre_func=None, post_func=None): if pre_func: pre_func() func() if post_func: post_func() vs def decorate(func, pre_func=noop, post_func=noop): pre_func() func() post_func() Nr)r7rs r nooprUs( r rrurt)r8rN)NNN)NN)6r __future__rrJrxr rrdrVrrxrangerr@ NameErrorrvbytesrIiscoroutinefunctionrArPboltons.typeutilsrr ImportErrorobjectrr_IS_PY35rrFrr[rirnryrrrrrrrrrrrrrrbboolrGrrrr r rsB & *  KG6#*#>#> / 5J'   v % ?(dT""1074-.b: E  :'T0i''04)I--)X ,>:1z0r"?Jyx%P^f^B  j  z #'D(3(hG!CKuJG 6#5 6J Mp1/1sWD D* D9E ED'&D'* D65D69 E  E  EE E('E(