BVh?fdZddlmZddlZddlZddlZddlZddlmZddl m Z ddl m Z e dgGd d Z e d gGd d Ze dgGddeZddZdZe dgdZe dgdZe dgGddZdZy)agFacilities for creating multiple test combinations. Here is a simple example for testing various optimizers in Eager and Graph: class AdditionExample(test.TestCase, parameterized.TestCase): @combinations.generate( combinations.combine(mode=["graph", "eager"], optimizer=[AdamOptimizer(), GradientDescentOptimizer()])) def testOptimizer(self, optimizer): ... f(optimizer)... This will run `testOptimizer` 4 times with the specified optimizers: 2 in Eager and 2 in Graph mode. The test is going to accept the same parameters as the ones used in `combine()`. The parameters need to match by name between the `combine()` call and the test signature. It is necessary to accept all parameters. See `OptionalParameter` for a way to implement optional parameters. `combine()` function is available for creating a cross product of various options. `times()` function exists for creating a product of N `combine()`-ed results. The execution of generated tests can be customized in a number of ways: - The test can be skipped if it is not running in the correct environment. - The arguments that are passed to the test can be additionally transformed. - The test can be run with specific Python context managers. These behaviors can be customized by providing instances of `TestCombination` to `generate()`. ) OrderedDictN) parameterized) tf_inspect) tf_exportz.__internal__.test.combinations.TestCombination)v1c"eZdZdZdZdZdZy)TestCombinationaCustomize the behavior of `generate()` and the tests that it executes. Here is sequence of steps for executing a test combination: 1. The test combination is evaluated for whether it should be executed in the given environment by calling `should_execute_combination`. 2. If the test combination is going to be executed, then the arguments for all combined parameters are validated. Some arguments can be handled in a special way. This is achieved by implementing that logic in `ParameterModifier` instances that returned from `parameter_modifiers`. 3. Before executing the test, `context_managers` are installed around it. c~y)a*Indicates whether the combination of test arguments should be executed. If the environment doesn't satisfy the dependencies of the test combination, then it can be skipped. Args: kwargs: Arguments that are passed to the test combination. Returns: A tuple boolean and an optional string. The boolean False indicates that the test should be skipped. The string would indicate a textual description of the reason. If the test is going to be executed, then this method returns `None` instead of the string. )TNselfkwargss ]/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/framework/test_combinations.pyshould_execute_combinationz*TestCombination.should_execute_combinationIs   cgS)zCReturns `ParameterModifier` instances that customize the arguments.r r s rparameter_modifiersz#TestCombination.parameter_modifiers[s Irc~gS)aPReturn context managers for running the test combination. The test combination will run under all context managers that all `TestCombination` instances return. Args: kwargs: Arguments and their values that are passed to the test combination. Returns: A list of instantiated context managers. r r s rcontext_managersz TestCombination.context_managers_s   IrN)__name__ __module__ __qualname____doc__rrrr rrr r :s $rr z0__internal__.test.combinations.ParameterModifierc>eZdZdZeZddZdZdZdZ dZ y) ParameterModifieraiCustomizes the behavior of a particular parameter. Users should override `modified_arguments()` to modify the parameter they want, eg: change the value of certain parameter or filter it from the params passed to the test case. See the sample usage below, it will change any negative parameters to zero before it gets passed to test case. ``` class NonNegativeParameterModifier(ParameterModifier): def modified_arguments(self, kwargs, requested_parameters): updates = {} for name, value in kwargs.items(): if value < 0: updates[name] = 0 return updates ``` Nc||_y)aConstruct a parameter modifier that may be specific to a parameter. Args: parameter_name: A `ParameterModifier` instance may operate on a class of parameters or on a parameter with a particular name. Only `ParameterModifier` instances that are of a unique type or were initialized with a unique `parameter_name` will be executed. See `__eq__` and `__hash__`. N)_parameter_name)r parameter_names r__init__zParameterModifier.__init__s *Drc ~~iS)aReplace user-provided arguments before they are passed to a test. This makes it possible to adjust user-provided arguments before passing them to the test method. Args: kwargs: The combined arguments for the test. requested_parameters: The set of parameters that are defined in the signature of the test method. Returns: A dictionary with updates to `kwargs`. Keys with values set to `ParameterModifier.DO_NOT_PASS_TO_THE_TEST` are going to be deleted and not passed to the test. r r rrequested_parameterss rmodified_argumentsz$ParameterModifier.modified_argumentss $ Ircl||uryt|t|ur|j|jk(Sy)z9Compare `ParameterModifier` by type and `parameter_name`.TF)typerr others r__eq__zParameterModifier.__eq__s6 u}  dtE{ "  ! !U%:%: :: rc&|j| SN)r)r's r__ne__zParameterModifier.__ne__s{{5! !!rcn|jrt|jSt|jS)z8Compare `ParameterModifier` by type or `parameter_name`.)rhashid __class__rs r__hash__zParameterModifier.__hash__s+  $&& ''  rr+) rrrrobjectDO_NOT_PASS_TO_THE_TESTr r$r)r,r1r rrrrps*(#H *&" rrz0__internal__.test.combinations.OptionalParameterceZdZdZdZy)OptionalParameteraGA parameter that is optional in `combine()` and in the test signature. `OptionalParameter` is usually used with `TestCombination` in the `parameter_modifiers()`. It allows `TestCombination` to skip certain parameters when passing them to `combine()`, since the `TestCombination` might consume the param and create some context based on the value it gets. See the sample usage below: ``` class EagerGraphCombination(TestCombination): def context_managers(self, kwargs): mode = kwargs.pop("mode", None) if mode is None: return [] elif mode == "eager": return [context.eager_mode()] elif mode == "graph": return [ops.Graph().as_default(), context.graph_mode()] else: raise ValueError( "'mode' has to be either 'eager' or 'graph', got {}".format(mode)) def parameter_modifiers(self): return [test_combinations.OptionalParameter("mode")] ``` When the test case is generated, the param "mode" will not be passed to the test method, since it is consumed by the `EagerGraphCombination`. cZ|j|vriS|jtjiSr+)rrr3r"s rr$z$OptionalParameter.modified_argumentss. 33 i""$5$M$M NNrN)rrrrr$r rrr5r5s@Orr5cfd}|S)aA decorator for generating combinations of a test method or a test class. Parameters of the test method must match by name to get the corresponding value of the combination. Tests must accept all parameters that are passed other than the ones that are `OptionalParameter`. Args: combinations: a list of dictionaries created using combine() and times(). test_combinations: a tuple of `TestCombination` instances that customize the execution of generated tests. Returns: a decorator that will cause the test method or the test class to be run under the specified conditions. Raises: ValueError: if any parameters were not accepted by the test method cg} D]}t|tsJdjt|j Dcgc]r\}\}}dj djt tj|djt tjt||tc}}}}|jtt|j ddj |fgzt|tr|}ix|_ }|jjj D]\}} |j!t"j$j&s0t| t(j*sKt-||i} t/j0|j2| ||t/j4t7| |t.j8|| j D]\} } t;|| | |St7|} t/j<|| Scc}}}w)zThe decorator to be returned.z_{}_{} testcase_namez_test{})test_combinations) isinstancerjoin enumerateitemsformatfilterstrisalnum _get_nameappendlistr&_test_method_ids__dict__copy startswithunittest TestLoadertestMethodPrefixtypes FunctionTypedelattrr&_update_class_dict_for_param_test_caser_ParameterizedTestIter_augment_with_special_arguments_NAMEDsetattrnamed_parameters)test_method_or_classnamed_combinations combinationikeyvaluename class_objecttest_method_ids test_methodmethods method_namemethod combinationsr;s r decoratorzgenerate..decorators# <  [ 11 1 WW"+;+<+<+>!?a#u //"''&c":;''&iq6I"JK M d  ;$$&'!1!1$!789: ;< <&-)l8::l#o+4499;AAC 7 $ OOH//@@ A {E$6$6 7 , %'  > >##Wot221!5FH$m&:&:DB C &-]]_ 7!k6 L+v 6 7 73 2CEk @] + +-? @ MM?sA7I r )rdr;res`` rgeneraterfs&(NT rcfd}|S)Nc j g} D];}|j j\}}|r(|jd|z=|r jdj |g D]!} j |j #t   fd}g} D]7}|j jD]}|j|9ttdr#tj|5|dddytj5} |D]}| j||dddy#1swYyxYw#1swYyxYw)zEA wrapped test method that can treat some arguments in a special way.z -  ctj j}D]b}|j j |j D]/\}}|t jur j|d+| |<1dt|jtt jdgz}|rtdj|tt jdgzjt|}|rtdj|i}|D]}|dk(r ||< |||< di|y)Nr zBThe test requires parameters whose arguments were not passed: {} .z9The test does not take parameters that were passed : {} .r )rgetfullargspecargsr$rIr?rr3popset differencerFkeys ValueErrorr@) r#customized_parameterargumentr\omitted_argumentsmissing_argumentskwargs_to_pass parametercustomized_parametersroriginal_kwargsr r`s rexecute_test_methodzO_augment_with_special_arguments..decorated..execute_test_method<so'66{CHH"7% 3FF  "$8 ::?%' %OHe '?? ? JJx &$F8   %%23>> d6;;=!VH, -/ 1178I1JL Ld6;;=1VH<=HH " #% ""(&):";= =n+8)  &*. #&,Y&7. # 8 #N#rnestedN)rIrrEskipTestr=extendrrnrhasattr contextlibr{ ExitStack enter_context)r rreasons_to_skiprYshould_executereasonrzrmanager context_stackrxryr;r`s`` @@r decoratedz2_augment_with_special_arguments..decorated%skkmOO(/ *EE     "nf uv~. /  mmDIIo./(F "";#B#B#DEF 56$$<()  11    ")'()) z8$   . /    !]' /G  % %g . /sE$; E0$E-0E9r )r`r;rs`` rrSrS$sCJ rz&__internal__.test.combinations.combinec |s tgSd}tt|j|}t|jd}t t|jdd}t di|}|d}|d}t |ts|g}|Dcgc]<}|D]5}ttt|j||fgz|7>c}}Scc}}w)aGenerate combinations based on its keyword arguments. Two sets of returned combinations can be concatenated using +. Their product can be computed using `times()`. Args: **kwargs: keyword arguments of form `option=[possibilities, ...]` or `option=the_only_possibility`. Returns: a list of dictionaries for each combination. Keys in the dictionaries are the keyword argument names. Each key has one value - one of the corresponding keyword argument values. c |dS)Nrr )ks rzcombine..s !A$r)r[rNr )rsortedr?rFdictcombiner<) r sort_by_keyfirstrest rest_combinedr[valuesvcombineds rrrms  M?+ vflln+> ?& v||~ q !% d6<<>"12& '$/D/- a# 8& FD !XF  #  &hnn./C8*<+NO O  s#AC(z$__internal__.test.combinations.timesc |sJt|dk(r|dS|d}t|dd}g}|D]}|D]}t|jj t|jr7t dj |j|j|jtt|jt|jz|S)aJGenerate a product of N sets of combinations. times(combine(a=[1,2]), combine(b=[3,4])) == combine(a=[1,2], b=[3,4]) Args: *combined: N lists of dictionaries that specify combinations. Returns: a list of dictionaries for each combination. Raises: ValueError: if some of the inputs have overlapping keys. rrNz"Keys need to not overlap: {} vs {}) lentimesrnrp intersectionrqr@rErrFr?)rrrcombined_resultsabs rrrs /]a A; 1+%!"&- Na N QVVX # #CM 2=DD FFHaffh ! !k$qwwy/DO*KLM NN rz*__internal__.test.combinations.NamedObjectc.eZdZdZdZdZdZdZdZy) NamedObjectz8A class that translates an object into a good test name.c ||_||_yr+)_name_obj)r r]objs rr zNamedObject.__init__sDJDIrc.t|j|Sr+)getattrr)r r]s r __getattr__zNamedObject.__getattr__s 499d ##rc&|j|i|Sr+)r)r rlrs r__call__zNamedObject.__call__s 499d %f %%rc6|jjSr+)r__iter__rs rrzNamedObject.__iter__s 99   rc|jSr+)rrs r__repr__zNamedObject.__repr__s ::rN) rrrrr rrrrr rrrrs@$& rrcTtjdt|t|S)Nz0[xX][0-9a-fA-F]+)resubrB)r\indexs rrDrDs #SZU <rs>$ &-6 ;C22D2j ="EG G FG T ="E%O)%OF%OP=@FR 3;"<"J 1b9:B 7B?@(=r