.Ph dZddlZddlZddlZddlZddlZddlmZddlmZm Z ddlm Z  ddl m Z e d Z n#e$r eZ YnwxYwdddd iied d d def dZd+dZdZd,dZd-dZdZGddejZGddejZeZd.dZd/dZd/dZd0dZd/d Zd!ZGd"d#Z Gd$d%e!Z"Gd&d'e!Z#d(e$fd)Z%d*Z&dS)1zPython'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. N)formatannotation) FunctionType MethodType)total_ordering) make_sentinel NO_DEFAULT)var_namec d|zS)N*r names Q/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/boltons/funcutils.pyr<s 3:c d|zS)Nz**r rs rrr=s rc&dt|zSN=)reprvalues rrr>s#U "3rc d|zS)Nz -> r )texts rrr?s 6D=rc   fd} g}|rt|t|z }t|D]D\}}| |}|r||kr|| |||z z}||E|(||| |n|r|d|r?|D]<}| |}|r||vr|| ||z }||=|'|| | |dd|zdz}dvr||  dz }|S)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. cT|}|vr|d|zz }|S)Nz: r )argresult annotationsr formatargs rformatargandannotationz5inspect_formatargspec..formatargandannotationIs@3 +   d--k#.>??? ?F rNr (, )return)len enumerateappendjoin)argsvarargsvarkwdefaults kwonlyargskwonlydefaultsr r! formatvarargs formatvarkw formatvalue formatreturnsrr"specs firstdefaultirspec kwonlyargrs `` ` rinspect_formatargspecr:8s" E14yy3x==0 D//3%%c**  B\))++hq>> LL      [[!7!7!>!>??@@@ 499U## #c )F;-- 0 0X1F G GHHH Mrct|trtj|}ii}}t |D]}|r ||r t ||}n#t $rY.wxYw |j}n#t$rYGwxYw||j krWt|tr|||<rt|r|||<||fS)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. ) isinstancestrsysmodulesdirgetattr Exception __module__AttributeError__name__typecallable)modignoretypesfuncs attr_nameattr attr_mod_names rget_module_callablesrOis #sk#r5EXX$$  ffY''   3 **DD    H   OMM    H  CL ( (  dD ! ! $#E)   d^^ $#E)  %<s$ A A*)A*.A66 BBc^tjd|jDS)a#Takes 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'] c3HK|]}|jVdSN)__dict__items).0cts r zmro_items..sL)E)E-/*,):):)<)<)E)E)E)E)E)Er) itertoolschain from_iterable__mro__)type_objs r mro_itemsr]sE ? ( ()E)E3;3C)E)E)E E EErFc|i}t|D])} t||||<#t$r|rY&wxYw|S)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. )r@rArB)obj raise_excretks rdir_dictrcsm C XX S!__CFF        Js ) 99Tc t|j|j|jt |ddt |dd}t |dr |j|_|r|j|j|S)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__kwdefaults__) r__code__ __globals__rErAhasattrrirSupdate)orig copy_dictras r copy_functionrps& t}' M&t^TBB&t]DAA  C C CC t%&&1!0+ DM*** Jrcd}d}d}t|ds||_t|ds||_t|ds||_|S)ajClass 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||ko||k SrRr selfothers r__lt__z partial_ordering..__lt__DEM$G$%-6GGrc||ko||k SrRr rss r__gt__z partial_ordering..__gt__rwrc||ko||kSrRr rss r__eq__z partial_ordering..__eq__sDEM$CdemCrrvryr{)rlrvryr{)clsrvryr{s rpartial_orderingr}sg>HGGGGGCCC 3 ! !63: 3 ! !63: 3 ! !63: JrcDeZdZdZedZedZdZdS)InstancePartiala: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. c|jSrR__partialmethod__rts r_partialmethodzInstancePartial._partialmethod %%rcJtj|jg|jRi|jSrR functools partialmethodfuncr+keywordsrs rrz!InstancePartial.__partialmethod__)&tyN49NNN NNNrc"t||SrR)r)rtr_obj_types r__get__zInstancePartial.__get__s$$$$rN)rErC __qualname____doc__propertyrrrr rrrrsf&&X&OOXO%%%%%rrcJeZdZdZedZedZdZdZdS)CachedInstancePartialaThe ``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. c|jSrRrrs rrz$CachedInstancePartial._partialmethodrrcJtj|jg|jRi|jSrRrrs rrz'CachedInstancePartial.__partialmethod__rrc||_dSrR)rE)rtrrs r __set_name__z"CachedInstancePartial.__set_name__s  rct|dd|_|jj|_|jj|_|j}|t ||S |j|S#t$rt ||x|j|<}|cYSwxYw)NrE)rArErrrCrrSKeyError)rtr_rrras rrzCachedInstancePartial.__get__s j$77 y( ).} ;dC(( ( <% %   '1$'<'< >> 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) rzunexpected keyword args: %rr$c&g|] }|Sr r )rUa_reprs r z%format_invocation..Fs!///Qa///rc$g|] }||f Sr r )rUrbkwargss rrz%format_invocation..Hs!>>>!6!9~>>>rc6g|]\}}|d|Srr )rUrbvrs rrz%format_invocation..Ks3CCCtq!A**a**CCCrr#r%)popr TypeErrorr*keysr<dictsorted) rr+rkwa_text kwarg_itemskw_text all_args_textrs ` @rformat_invocationr6s FF64 E N5 "''))8L8LLMMM \rF YY////$/// 0 0F&$>>>>vf~~>>>  iiCCCC{CCCDDGM WM % %] % % %%rcrtj}|pg}pgtg}}|zD]1}||vr||||2dt sJfd|D} fd|D} fd| D} t || | S)aRender 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 |duSrRr rs rrz!format_exp_repr.. AIrc2g|]}t|dSrRrArUrr_s rrz#format_exp_repr..s% ; ; ;GCt $ $ ; ; ;rc6g|]}|t|dfSrRrrs rrz#format_exp_repr..s*GGGTwsD$//0GGGrc<g|]\}}|vr |||fSr r rUrvalopt_key opt_namess rrz#format_exp_repr..sB=== c ))ggcll)s )))r)rFrEsetaddr)rGr) r_ pos_names req_namesrrcn uniq_names all_namesrr+kw_itemss ` `` rformat_exp_reprrUsL c BRIRIEE2 JI% :   t%% G   ; ; ; ; ; ; ;DGGGGYGGGH=====X===H Rx 0 00rcjj}|pg}pgtg}}|zD]1}||vr||||2dt sJfd|D}fd|D} | sdt zg} d|d| } | S)aFormat 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 |duSrRr rs rrz$format_nonexp_repr..rrc6g|]}|t|dfSrRrrs rrz&format_nonexp_repr..s* D D D$dGCt,, - D D DrcBg|]\}}|vr ||d|Srr rs rrz&format_nonexp_repr..sL;;;ID#i''GGCLL''''rzid=%sz<{} {}> ) __class__rErrr)rGidformatr*) r_rrrrrrrrTlabelsras ` `` rformat_nonexp_reprrs"8  BRIRIEE2 JI% :   t%% G   D D D D) D D DE;;;;;;;;F %BsGG#$   2sxx// 0 0C Jrc 0ttf|d||d|S)aVDecorator 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 rwrapsrs4B > ?$x ? ?;= ? ??rc |g}n(t|tr|g}nt|}t|}t|tt fr!t dt|dd|dd}|dd}|dd} |r$t d | zt|tj r ||j ur|p|}t|p|} |D]2} | | #t $r |r | jY.wxYw|D]\} } | | | | jrd | z| _nd | z| _t-|| } | | | }| rt1|dr |jd=n | s||_|S)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 modify 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__)r<r=list_parse_wraps_expected classmethod staticmethodrrArrrrrFunctionBuilder from_func remove_argMissingArgumentr-add_argis_asyncget_invocation_strbodyrget_funcrlrSr)wrapperrrrrrexpected_itemsrrrfbrdefaultexecdict fully_wrappeds rrrsSN Hc " "":>>*844N$l344>i#4T:::=>> > &&--Kff.55O66.%00L =/"''));<<<'9,--+$',2F2F*7  " ":#5 6 6B  MM#        28#7   '!! W 3     {?*R-B-B-D-DD$r'<'<'>'>>'...HKKKK@@M) }==)  "= 1 1 )$( ! s*EEEc |g}nt|tr |tfg}g} t|}n(#t$r}t d|d|dd}~wwxYw|D]}t|tr! ||}nB#t$r t}Yn/wxYw |\}}n$#tt f$rt dwxYwt|tst d||||f|S)Nz"expected" takes string name, sequence of string names, iterable of (name, default) pairs, or a mapping of {name: default}, not z (got: r%z"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 )r<r=r iterr ValueErrorr))rr expected_itereargnamers rrrls  Hc " ",z*+NOX OOOjAI111NOO OO!22 gs # # = %"7+ % % %$ % =#* z* = = = "<=== ='3'' ZXWXXYY Yw01111 s38 AAA:BBBB!!!Cc .eZdZdZedddeeedZedZe eddd d ed d Z e ee j Zd ZddZejdejZdZedZddZdZddZedfdZdZdZdS)ra 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 cdSrRr r rrrzFunctionBuilder.sDrcdSrRr r rrrzFunctionBuilder.s$rcdSrRr r rrrzFunctionBuilder.sTr)r+r,r-r.r/r0r cRtj|fd|jDS)Nc2i|]}|t|Sr r)rUrMargspecs r z4FunctionBuilder._argspec_to_dict..s5777ggt,,777r)inspectgetfullargspec_argspec_defaults)r|frs @r_argspec_to_dictz FunctionBuilder._argspec_to_dictsA(++7777 # 5777 7rcdS)NFr r rrrzFunctionBuilder.sUrcdSrRr r rrrzFunctionBuilder.s4rcdS)Npassr r rrrzFunctionBuilder.srcdS)Nr r rrrzFunctionBuilder.s1rcdS)Nz!boltons.funcutils.FunctionBuilderr r rrrzFunctionBuilder.s%Hr)docrrmodulerindentr filenamec ||_|jD]8\}}||d}| |}t |||9|r$t d|zdS)Nr)r _defaultsrTrsetattrrr)rtrrrdefault_factoryrs r__init__zFunctionBuilder.__init__s "&."6"6"8"8 " " A&&D//C{%o'' D!S ! ! ! !  A3bggii?@@ @rTc l|r|j}ni}t|j|j|jg|ji|S)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. )r r:r+r,r-r/)rtwith_annotationsr s r get_sig_strzFunctionBuilder.get_sig_strsI  *KKK$TY%)\%)Z%'%)_%'%0 22 2rz \* # a star \s* # followed by any amount of whitespace , # followed by a comma \s* # followed by any amount of whitespace c d}i}|jrd|jD}d|d<t|j|j|jg||ifi|}|jd|}|ddS)Nci|]}||Sr r )rUrs rrz6FunctionBuilder.get_invocation_str..s*<<<$' <<.s cEkrr3rr)r/r:r+r,r-_KWONLY_MARKERsub)rt kwonly_pairs formatterssigs rrz"FunctionBuilder.get_invocation_strs  ? B<<+/?<<F)r)rsig_strrr)r _default_bodyr_indentrrreplacerrr_compilerErr.rer0rir r%rSrmrrrC __source__) rtr add_sourcerrtmplrsrcrs rrzFunctionBuilder.get_funcIs?">ry.D.%  = #d?Dty# "344y  c**223<<kktT-=-=u-=-U-U"hT33 c8$$$~  x  M"1#/  , M  + + ++  "!DO rc ttttt|jt|jpg}t |dd}|r|||S)z`Get a dictionary of function arguments with defaults and the respective values. r0N)rreversedrzipr+r.rArm)rtrar0s rget_defaults_dictz!FunctionBuilder.get_defaults_dict{s8DXdi%8%8%-dm.Ar%B%B"D"DEEFFGG '7>>  ' JJ~ & & & rFct|jtt|ddz}|r/|tfd|D}|S)Nr/r cg|]}|v| Sr r )rUan defaults_dicts rrz1FunctionBuilder.get_arg_names..s#QQQb=9P9Pr9P9P9Pr)tupler+rAr7)rt only_required arg_namesr;s @r get_arg_nameszFunctionBuilder.get_arg_namessm$)$$uWT<-L-L'M'MM  S 2244MQQQQIQQQRRIrcj||jvrtd|d|jd||jvrtd|d|jd|s9|j||t ur|jpd|fz|_dSdS|j||t ur ||j|<dSdS)zAdd an argument with optional *default* (defaults to ``funcutils.NO_DEFAULT``). Pass *kwonly=True* to add a keyword-only argument arg z already in func z arg listz kwonly arg listr N)r+ExistingArgumentrr/r)r r.r0)rtarg_namerkwonlys rrzFunctionBuilder.add_args ty "#[(#[#[ty#[#[#[\\ \ t & &"#b(#b#bty#b#b#bcc c 8 I  X & & &j((!%!4" B )( O " "8 , , ,j((07#H---)(rc |j}| |||dt fd|D|_n#t $ru |j||j|dn;#tt f$r'td|d|j d|}||_ |wxYwYnwxYwdS)a8Remove 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. Nc(g|]}|v|Sr r )rUrd_dicts rrz.FunctionBuilder.remove_arg..s""J"J"Ja6kk6!9kkkrrAz not found in z argument list: ) r+r7removerr<r.rr/r0rDrrrC)rtrCr+excrGs @rrzFunctionBuilder.remove_args0y'')) L KK ! ! ! JJx & & &!"J"J"J"Jd"J"J"JKKDMM 8 8 8 8&&x000#''$7777#J/   %o/7xxDD'JKK'   87 8 s)A** C)5B+C)+8C##C)(C)cd|jt|jfz} t||d}t ||n#t $rwxYw|S)Nz<%s-%d>single)rnext_compile_countcompileexecrB)rtr3rrcodes rr/zFunctionBuilder._compilesn}d4+>&?&?AB 3(33D x      s !A AT)NTTF)rErCrrrrrrrr=rrmrXcountrMrrrerNVERBOSErrrrr7r?r rrr/r rrrrs==~"&$0L".,%1\'++/(, ..77[7 *]'<'$9 $HHJJI&'''$Y_&&N   2222& RZ!  N&[<0000d   )358888$>     rrceZdZdS)rNrErCrr rrrrDrrceZdZdS)rBNrWr rrrBrBrXrrB crfd|D}||S)z based on boltons.strutils.indentc4g|]}|r|zn|Sr r )rUlinekeymargins rrz_indent..s>555),D ;v}}t555r) splitlinesr*)rr_newliner^indented_liness ` ` rr-r-sM55555"&//"3"3555N << ' ''rcdS)a 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 )r+rs rnooprds ( 4rrRrRrQ)rr N)NNN)NN)'rr>rTrrrXrrJrrr typeutilsrr ImportErrorobjectr=r:rOr]rcrpr}rrrrrrrrrrrrrBboolr-rdr rrris>  $$$$$$********766666(((((( 555JJJJJ $bb--,,3300)....b: E E E     >'''T%%%%%i'%%%<'''''I-'''T &&&&>:1:1:1:1z0000r"?"?"?"?Jyyyyx%%%Pssssssssl      j        z   #'D((((s?AA