0Vh"4 dZddlZddlZddlZddlmZmZmZmZm Z m Z m Z m Z m Z mZddlmZej"Ze deZededefd Zed e ej(efd edd fd ZdZed e ej(e ee effd e ee efddfdZededefdZdZede dd e ej(e ee effd e ee efddfdZede d dedefdZede d d e ej(efd edd fdZdZefdej0deeeeefffdZefdeeeeeffdej0ddfdZede d dedeeefdefdZede ddedeee ee effdefdZdZGd d ZGd!deZd"ej<deeeffd#Zy)$a Decorator and context manager for saving and restoring flag values. There are many ways to save and restore. Always use the most convenient method for a given use case. Here are examples of each method. They all call ``do_stuff()`` while ``FLAGS.someflag`` is temporarily set to ``'foo'``:: from absl.testing import flagsaver # Use a decorator which can optionally override flags via arguments. @flagsaver.flagsaver(someflag='foo') def some_func(): do_stuff() # Use a decorator which can optionally override flags with flagholders. @flagsaver.flagsaver((module.FOO_FLAG, 'foo'), (other_mod.BAR_FLAG, 23)) def some_func(): do_stuff() # Use a decorator which does not override flags itself. @flagsaver.flagsaver def some_func(): FLAGS.someflag = 'foo' do_stuff() # Use a context manager which can optionally override flags via arguments. with flagsaver.flagsaver(someflag='foo'): do_stuff() # Save and restore the flag values yourself. saved_flag_values = flagsaver.save_flag_values() try: FLAGS.someflag = 'foo' do_stuff() finally: flagsaver.restore_flag_values(saved_flag_values) # Use the parsing version to emulate users providing the flags. # Note that all flags must be provided as strings (unparsed). @flagsaver.as_parsed(some_int_flag='123') def some_func(): # Because the flag was parsed it is considered "present". assert FLAGS.some_int_flag.present do_stuff() # flagsaver.as_parsed() can also be used as a context manager just like # flagsaver.flagsaver() with flagsaver.as_parsed(some_int_flag='123'): do_stuff() # The flagsaver.as_parsed() interface also supports FlagHolder objects. @flagsaver.as_parsed((module.FOO_FLAG, 'foo'), (other_mod.BAR_FLAG, '23')) def some_func(): do_stuff() # Using as_parsed with a multi_X flag requires a sequence of strings. @flagsaver.as_parsed(some_multi_int_flag=['123', '456']) def some_func(): assert FLAGS.some_multi_int_flag.present do_stuff() # If a flag name includes non-identifier characters it can be specified like # so: @flagsaver.as_parsed(**{'i-like-dashes': 'true'}) def some_func(): do_stuff() We save and restore a shallow copy of each Flag object's ``__dict__`` attribute. This preserves all attributes of the flag, such as whether or not it was overridden from its default value. WARNING: Currently a flag that is saved and then deleted cannot be restored. An exception will be raised. However if you *add* a flag after saving flag values, and then restore flag values, the added flag will be deleted with no errors. N) AnyCallableDictMappingSequenceTupleTypeTypeVarUnionoverload)flags _CallableT)boundfuncreturncyNrs F/home/dcms/DCMS/lib/python3.12/site-packages/absl/testing/flagsaver.py flagsaverrjargskwargs_FlagOverridercyrrrrs rrrorc(ttg|i|S)z7The main flagsaver interface. See module doc for usage.)_construct_overriderrrs rrrvs n >t >v >>r_ParsingFlagOverridercyrrrs r as_parsedr${rcyrrrs rr$r$rrc(ttg|i|S)aOverrides flags by parsing strings, saves flag state similar to flagsaver. This function can be used as either a decorator or context manager similar to flagsaver.flagsaver(). However, where flagsaver.flagsaver() directly sets the flags to new values, this function will parse the provided arguments as if they were provided on the command line. Among other things, this will cause `FLAGS['flag_name'].present == True`. A note on unparsed input: For many flag types, the unparsed version will be a single string. However for multi_x (multi_string, multi_integer, multi_enum) the unparsed version will be a Sequence of strings. Args: *args: Tuples of FlagHolders and their unparsed value. **kwargs: The keyword args are flag names, and the values are unparsed values. Returns: _ParsingFlagOverrider that serves as a context manager or decorator. Will save previous flag state and parse new flags, then on cleanup it will restore the previous flag state. )r!r"rs rr$r$s. 3 Ed Ef EErflag_overrider_clscyrrr(rrs rr!r!s rcyrr)r(rs rr!r!rrcyrrr*s rr!r!s rc|s|di|St|dk(rMt|dr?|r td|d}tj|r t dt ||iS|D]}t|trt|dk7rtd||\}}t|tjstd||j|vrtd|jz|||j<|di|S) a8Handles the args/kwargs returning an instance of flag_overrider_cls. If flag_overrider_cls is _FlagOverrider then values should be native python types matching the python types. Otherwise if flag_overrider_cls is _ParsingFlagOverrider the values should be strings or sequences of strings. Args: flag_overrider_cls: The class that will do the overriding. *args: Tuples of FlagHolder and the new flag value. **kwargs: Keword args mapping flag name to new flag value. Returns: A _FlagOverrider to be used as a decorator or context manager. rz?It's invalid to specify both positional and keyword parameters.z2@flagsaver.flagsaver cannot be applied to a class.z)Expected (FlagHolder, value) pair, found zCannot set --%s multiple timesr) lencallable ValueErrorinspectisclass TypeError_wrap isinstancetupler FlagHoldername)r(rrrargholdervalues rr!r!s    ' ''Y!^a)  K MM 7Dt J KK #T2 .. c c5 !SX] M NNMFE fe.. / M NN {{f 7&++E FFF6;;   %f %%r flag_valuescF|Dcic]}|t||c}Scc}w)a^Returns copy of flag values as a dict. Args: flag_values: FlagValues, the FlagValues instance with which the flag will be saved. This should almost never need to be overridden. Returns: Dictionary mapping keys to values. Keys are flag names, values are corresponding ``__dict__`` members. E.g. ``{'key': value_dict, ...}``. )_copy_flag_dict)r>r:s rsave_flag_valuesrAs)@K Kt$ D 12 2 KK Kssaved_flag_valuesct|}|D]N}|j|}| t||#||j|dk7r |d||_|||_Py)aRestores flag values based on the dictionary of flag values. Args: saved_flag_values: {'flag_name': value_dict, ...} flag_values: FlagValues, the FlagValues instance from which the flag will be restored. This should almost never need to be overridden. N_value)listgetdelattrr=__dict__)rBr>new_flag_namesr:saveds rrestore_flag_valuesrKsq $.)d  ! !$ 'E } k4 T  E(O 3"'/ D#(k$ )r overridescyrrr(rrLs rr6r6 r%rcyrrrNs rr6r6r%rcJtjfd}|S)aCreates a wrapper function that saves/restores flag values. Args: flag_overrider_cls: The class that will be used as a context manager. func: This will be called between saving flags and restoring flags. overrides: Flag names mapped to their values. These flags will be set after saving the original flag state. The type of the values depends on if _FlagOverrider or _ParsingFlagOverrider was specified. Returns: A wrapped version of func. cPdi5|i|cdddS#1swYyxYw)z/Wrapper function that saves and restores flags.Nrr)rrr(rrLs r_flagsaver_wrapperz!_wrap.._flagsaver_wrapper#s2  (i (# 4 "6 "###s%) functoolswraps)r(rrLrRs``` rr6r6s( ??4## rc8eZdZdZdefdZdedefdZdZdZ y ) rzOverrides flags for the duration of the decorated function call. It also restores all original values of flags after decorated method completes. rLc ||_d|_yr) _overrides_saved_flag_values)selfrLs r__init__z_FlagOverrider.__init__3sDO"Drrrctj|r tdt|j||j S)Nz'flagsaver cannot be applied to a class.)r3r4r5r6 __class__rW)rYrs r__call__z_FlagOverrider.__call__7s1t ? @@ t 77rctt|_ tjdi|jy#t |jtxYw)Nr)rAFLAGSrX_set_attributesrWrK)rYs r __enter__z_FlagOverrider.__enter__<sC.u5D  .doo. $1159 s 6Ac8t|jtyr)rKrXr_)rYexc_type exc_value tracebacks r__exit__z_FlagOverrider.__exit__Es//7rN) __name__ __module__ __qualname____doc__rrZrr]rarfrrrrr,s0 ###8:8*8  8rc>eZdZdZdeeeefffd ZdZxZ S)r"a0Context manager for overriding flags. Simulates command line parsing. This is simlar to _FlagOverrider except that all **overrides should be strings or sequences of strings, and when context is entered this class calls .parse(value) This results in the flags having .present set properly. rLc |jD]g\}}t|trt|tjj rt d|DrNtd|dt|dt|(di|y)Nc3<K|]}t|tywr)r7str).0 single_values r z1_ParsingFlagOverrider.__init__..Zs J js+ Jsz#flagsaver.as_parsed() cannot parse z6. Expected a single string or sequence of strings but z was provided.r) itemsr7rn collectionsabcrallr5typesuperrZ)rYrL flag_name new_valuer\s rrZz_ParsingFlagOverrider.__init__Us ) 1P 9 Is # Y  8 8 9 J J J  / {;//3I.?~ O PP P G!y!rctt|_ |jj D]+\}}t|j |dt|_-|jD](}tjt|j*y#t$r5}t|jttjd|d}~wt|jtxYw)NFzUnknown command line flag.) rAr_rXrWrrparseusing_default_value_assert_validators validatorsKeyErrorrKr UnrecognizedFlagError)rYrxunparsed_valuees rraz_ParsingFlagOverrider.__enter__as.u5D '+'<'<'>5 #)^ i~./4i,5>)   y!1! M$1159  ' '(D E1L $1159 sA?B C/0C C/) rgrhrirjr rnrrZra __classcell__)r\s@rr"r"Is'  "%Xc](:"; " rflagc|jj}|j|d<t|j|d<|S)aReturns a copy of the flag object's ``__dict__``. It's mostly a shallow copy of the ``__dict__``, except it also does a shallow copy of the validator list. Args: flag: flags.Flag, the flag to copy. Returns: A copy of the flag object's ``__dict__``. rDr~)rHcopyr=rEr~)rrs rr@r@zs;    $::$x.DOO,$| +r) rjrsrSr3typingrrrrrrr r r r abslr r_rrr9rnr$r! FlagValuesrArKr6rr"Flagr@rrrrsJKZ``` \ 2  J:   !!3& '36  ?  U5++U3 3E-FFGc8C=016M   J: F8 45 !!5hsm);#<< =C#&'-D  -.6@   -. !!3& '  %&R%* L!! L #tCH~  L$%*)sDcN23)!!) ). d#34JS#X&+5   d#:;:S%Xc](:";;<AK  .88:. N. b%**c3hr