6biT$SrSSKrSSKrSSKrSSKrSSKJs Jr SSK J r SSK J r SSKJr SSKr/SQr"SS\R&R(\ R(5rSSjrS rS rS rSS jrSS jrSrSrSrSSjrSrSr Sr!Sr"SSjr#Sr$"SS\RJR&RLRN5r("SS\RJR&RLRN5r)\RJR&RLRTRVSr,\RZ"\RJR&RLRT\,\("5\)"54-S9r*\RJR&RLR\r.\RJR&RLR^r/\RJR&RLR`r0g!\a SrGNf=f) z$Utilities for unit-testing TF-Keras.N) parameterized) test_utils functionalsubclass sequentialc(^\rSrSrU4SjrSrU=r$)TestCase%c^>[RR5 [TU]5 gN)kerasbackend clear_sessionsupertearDown)self __class__s f/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/testing_infra/test_combinations.pyrTestCase.tearDown&s ##% )__name__ __module__ __qualname____firstlineno__r__static_attributes__ __classcell__)rs@rr r %s rr c^[cURS/5 /SQnUVs/sH/nU[RR U5;dM(SU3U4PM1 snmU4Sjn[ X5$s snf)aL Execute the decorated test with all TF-Keras saved model formats). This decorator is intended to be applied either to individual test methods in a `test_combinations.TestCase` class, or directly to a test class that extends it. Doing so will cause the contents of the individual test method (or all test methods in the class) to be executed multiple times - once for each TF-Keras saved model format. The TF-Keras saved model formats include: 1. HDF5: 'h5' 2. SavedModel: 'tf' Note: if stacking this decorator with absl.testing's parameterized decorators, those should be at the bottom of the stack. Various methods in `testing_utils` to get file path for saved models will auto-generate a string of the two saved model formats. This allows unittests to confirm the equivalence between the two TF-Keras saved model formats. For example, consider the following unittest: ```python class MyTests(test_utils.KerasTestCase): @test_utils.run_with_all_saved_model_formats def test_foo(self): save_format = test_utils.get_save_format() saved_model_dir = '/tmp/saved_model/' model = keras.models.Sequential() model.add(keras.layers.Dense(2, input_shape=(3,))) model.add(keras.layers.Dense(3)) model.compile(loss='mse', optimizer='sgd', metrics=['acc']) keras.models.save_model(model, saved_model_dir, save_format=save_format) model = keras.models.load_model(saved_model_dir) if __name__ == "__main__": tf.test.main() ``` This test tries to save the model into the formats of 'hdf5', 'h5', 'keras', 'tensorflow', and 'tf'. We can also annotate the whole class if we want this to apply to all tests in the class: ```python @test_utils.run_with_all_saved_model_formats class MyTests(test_utils.KerasTestCase): def test_foo(self): save_format = test_utils.get_save_format() saved_model_dir = '/tmp/saved_model/' model = keras.models.Sequential() model.add(keras.layers.Dense(2, input_shape=(3,))) model.add(keras.layers.Dense(3)) model.compile(loss='mse', optimizer='sgd', metrics=['acc']) keras.models.save_model(model, saved_model_dir, save_format=save_format) model = tf.keras.models.load_model(saved_model_dir) if __name__ == "__main__": tf.test.main() ``` Args: test_or_class: test method or class to be annotated. If None, this method returns a decorator that can be applied to a test method or test class. If it is not None this returns the decorator applied to the test or class. exclude_formats: A collection of TF-Keras saved model formats to not run. (May also be a single format not wrapped in a collection). Defaults to `None`. Returns: Returns a decorator that will run the decorated test method multiple times: once for each desired TF-Keras saved model format. Raises: ImportError: If abseil parameterized is not installed or not included as a target dependency. h5)r tf tf_no_traces_ct>^[R"T6[R"T5U4Sj55nU$))Decorator that constructs the test cases.c>US:Xa[TU/UQ70UD6 gUS:Xa[TU/UQ70UD6 gUS:Xa[TU/UQ70UD6 g[SU35e)8A run of a single test case w/ the specified model type.r r!r"Unknown model type: N)_test_h5_saved_model_format_test_tf_saved_model_format%_test_tf_saved_model_format_no_traces ValueError)r saved_formatargskwargsfs r decoratedTrun_with_all_saved_model_formats..single_method_decorator..decoratedslt#+AtEdEfE%+AtEdEfE/5aOOO #7 ~!FGGrrnamed_parameters functoolswrapsr0r1paramss` rsingle_method_decoratorArun_with_all_saved_model_formats..single_method_decorators=  ' ' 0   H  1 Hr)h5pyappendr!nestflatten_test_or_class_decorator) test_or_classexclude_formatssaved_model_formatsr-r9r8s @r run_with_all_saved_model_formatsrC+szf |v&60/L rww? ? +1\N \*/F ( $M KK5s 'A- A-c|[R"S5 U"U/UQ70UD6 SSS5 g!,(df  g=f)Nr rsaved_model_format_scoper0r@r.r/s rr)r).  , ,T 2 -)$)&) 3 2 2 - ;c|[R"S5 U"U/UQ70UD6 SSS5 g!,(df  g=f)Nr!rErGs rr*r*rHrIcz[R"SSS9 U"U/UQ70UD6 SSS5 g!,(df  g=f)Nr!F) save_tracesrErGs rr+r+s1  , ,Tu E -)$)&) F E Es , :cPU=(d /nURS5 [X5$)z=Runs all tests with the supported formats for saving weights.r")r<rC)r@rAs rrun_with_all_weight_formatsrNs%%+O>* +M KKrc^/SQnUVs/sH/nU[RRU5;dM(SU3U4PM1 snmU4Sjn[X5$s snf)a Execute the decorated test with all TF-Keras model types. This decorator is intended to be applied either to individual test methods in a `test_combinations.TestCase` class, or directly to a test class that extends it. Doing so will cause the contents of the individual test method (or all test methods in the class) to be executed multiple times - once for each TF-Keras model type. The TF-Keras model types are: ['functional', 'subclass', 'sequential'] Note: if stacking this decorator with absl.testing's parameterized decorators, those should be at the bottom of the stack. Various methods in `testing_utils` to get models will auto-generate a model of the currently active TF-Keras model type. This allows unittests to confirm the equivalence between different TF-Keras models. For example, consider the following unittest: ```python class MyTests(test_utils.KerasTestCase): @test_utils.run_with_all_model_types( exclude_models = ['sequential']) def test_foo(self): model = test_utils.get_small_mlp(1, 4, input_dim=3) optimizer = RMSPropOptimizer(learning_rate=0.001) loss = 'mse' metrics = ['mae'] model.compile(optimizer, loss, metrics=metrics) inputs = np.zeros((10, 3)) targets = np.zeros((10, 4)) dataset = dataset_ops.Dataset.from_tensor_slices((inputs, targets)) dataset = dataset.repeat(100) dataset = dataset.batch(10) model.fit(dataset, epochs=1, steps_per_epoch=2, verbose=1) if __name__ == "__main__": tf.test.main() ``` This test tries building a small mlp as both a functional model and as a subclass model. We can also annotate the whole class if we want this to apply to all tests in the class: ```python @test_utils.run_with_all_model_types(exclude_models = ['sequential']) class MyTests(test_utils.KerasTestCase): def test_foo(self): model = test_utils.get_small_mlp(1, 4, input_dim=3) optimizer = RMSPropOptimizer(learning_rate=0.001) loss = 'mse' metrics = ['mae'] model.compile(optimizer, loss, metrics=metrics) inputs = np.zeros((10, 3)) targets = np.zeros((10, 4)) dataset = dataset_ops.Dataset.from_tensor_slices((inputs, targets)) dataset = dataset.repeat(100) dataset = dataset.batch(10) model.fit(dataset, epochs=1, steps_per_epoch=2, verbose=1) if __name__ == "__main__": tf.test.main() ``` Args: test_or_class: test method or class to be annotated. If None, this method returns a decorator that can be applied to a test method or test class. If it is not None this returns the decorator applied to the test or class. exclude_models: A collection of TF-Keras model types to not run. (May also be a single model type not wrapped in a collection). Defaults to `None`. Returns: Returns a decorator that will run the decorated test method multiple times: once for each desired TF-Keras model type. Raises: ImportError: If abseil parameterized is not installed or not included as a target dependency. rr#ct>^[R"T6[R"T5U4Sj55nU$)r%c>US:Xa[TU/UQ70UD6 gUS:Xa[TU/UQ70UD6 gUS:Xa[TU/UQ70UD6 g[SU35e)r'rrrr(N)_test_functional_model_type_test_subclass_model_type_test_sequential_model_typer,)r model_typer.r/r0s rr1Lrun_with_all_model_types..single_method_decorator..decoratedsl\)+AtEdEfEz))!TCDCFC|++AtEdEfE #7 |!DEErr3r7s` rr99run_with_all_model_types..single_method_decorators=  ' ' 0   F  1 Fr)r!r=r>r?)r@exclude_models model_typesmodelr9r8s @rrun_with_all_model_typesr[sct;K! E 7 7 1UGe F ( $M KK5s 'A Ac|[R"S5 U"U/UQ70UD6 SSS5 g!,(df  g=f)Nrrmodel_type_scoperGs rrRrR..  $ $\ 2 -)$)&) 3 2 2rIc|[R"S5 U"U/UQ70UD6 SSS5 g!,(df  g=f)Nrr]rGs rrSrS3s.  $ $Z 0 -)$)&) 1 0 0rIc|[R"S5 U"U/UQ70UD6 SSS5 g!,(df  g=f)Nrr]rGs rrTrT8r_rIc ^^U(a[SU35eS/mU(dTRS5 U(d>[RRR 5(dTRS5 UU4Sjn[ X5$)a Execute the decorated test with all keras execution modes. This decorator is intended to be applied either to individual test methods in a `test_combinations.TestCase` class, or directly to a test class that extends it. Doing so will cause the contents of the individual test method (or all test methods in the class) to be executed multiple times - once executing in legacy graph mode, once running eagerly and with `should_run_eagerly` returning True, and once running eagerly with `should_run_eagerly` returning False. If Tensorflow v2 behavior is enabled, legacy graph mode will be skipped, and the test will only run twice. Note: if stacking this decorator with absl.testing's parameterized decorators, those should be at the bottom of the stack. For example, consider the following unittest: ```python class MyTests(test_utils.KerasTestCase): @test_utils.run_all_keras_modes def test_foo(self): model = test_utils.get_small_functional_mlp(1, 4, input_dim=3) optimizer = RMSPropOptimizer(learning_rate=0.001) loss = 'mse' metrics = ['mae'] model.compile( optimizer, loss, metrics=metrics, run_eagerly=test_utils.should_run_eagerly()) inputs = np.zeros((10, 3)) targets = np.zeros((10, 4)) dataset = dataset_ops.Dataset.from_tensor_slices((inputs, targets)) dataset = dataset.repeat(100) dataset = dataset.batch(10) model.fit(dataset, epochs=1, steps_per_epoch=2, verbose=1) if __name__ == "__main__": tf.test.main() ``` This test will try compiling & fitting the small functional mlp using all three TF-Keras execution modes. Args: test_or_class: test method or class to be annotated. If None, this method returns a decorator that can be applied to a test method or test class. If it is not None this returns the decorator applied to the test or class. config: An optional config_pb2.ConfigProto to use to configure the session when executing graphs. always_skip_v1: If True, does not try running the legacy graph mode even when Tensorflow v2 behavior is not enabled. always_skip_eager: If True, does not execute the decorated test with eager execution modes. **kwargs: Additional kwargs for configuring tests for in-progress TF-Keras behaviors/ refactorings that we haven't fully rolled out yet Returns: Returns a decorator that will run the decorated test method multiple times. Raises: ImportError: If abseil parameterized is not installed or not included as a target dependency. zUnrecognized keyword args: ) _v2_function v2_function) _v2_eagerv2_eager) _v1_session v1_sessioncv>^[R"T6[R"T5UU4Sj55nU$)r%c>US:Xa[TUT/UQ70UD6 gUS:Xa[TU/UQ70UD6 gUS:Xa[TU/UQ70UD6 g[SU35$)z2A run of a single test case w/ specified run mode.rhrfrdzUnknown run mode N)_v1_session_test_v2_eager_test_v2_function_testr,)rrun_moder.r/configr0s rr1Grun_all_keras_modes..single_method_decorator..decoratedsn<' D&B4B6BZ'q$888]*!!T;D;F;!$5hZ"@AArr3)r0r1ror8s` rr94run_all_keras_modes..single_method_decorators=  ' ' 0   B  1 Br)r,r<r! __internal__tf2enabledr?)r@roalways_skip_v1always_skip_eagerr/r9r8s ` @rrun_all_keras_modesrw=snX6vh?@@- .F  /0 boo1199;; 34( $M KKrcn[RRR5R 5 [ R "S5 URUS9 U"U/UQ70UD6 SSS5 SSS5 SSS5 g!,(df  N=f!,(df  N(=f!,(df  g=f)NF)ro)r!compatv1get_default_graph as_defaultrrun_eagerly_scope test_session)r0r@ror.r/s rrkrks{  ' ' ) 4 4 6  ) )% 0++6+:-1$1&1;1 7 6::1 0 7 6s;B&B B+B3B& B B B# B&& B4c[RRR5 [R "S5 U"U/UQ70UD6 SSS5 SSS5 g!,(df  N=f!,(df  g=f)NTr!rr eager_context eager_moderr}rGs rrlrlsU  & & 1 1 3  ) )$ / m -d -f -0 4 3 / / 4 3#A/ A A/ A, (A// A=c[RRR5 [R "S5 U"U/UQ70UD6 SSS5 SSS5 g!,(df  N=f!,(df  g=f)NFrrGs rrmrmsU  & & 1 1 3  ) )% 0 m -d -f -1 4 3 0 0 4 3rc*^U4SjnUbU"U5$U$)aDecorate a test or class with a decorator intended for one method. If the test_or_class is a class: This will apply the decorator to all test methods in the class. If the test_or_class is an iterable of already-parameterized test cases: This will apply the decorator to all the cases, and then flatten the resulting cross-product of test cases. This allows stacking the Keras parameterized decorators w/ each other, and to apply them to test methods that have already been marked with an absl parameterized decorator. Otherwise, treat the obj as a single method and apply the decorator directly. Args: test_or_class: A test method (that may have already been decorated with a parameterized decorator, or a test class that extends test_combinations.TestCase single_method_decorator: A parameterized decorator intended for a single test method. Returns: The decorated result. c>[U[RR5(a)[R R U4SjU55$[U[5(aUnURR5R5HYup#[U5(dMUR[RR5(dMG[!XT"U55 M[ [U5R#[U5UR$UR&URR55nU$T"U5$)Nc34># UH nT"U5v M g7fr r).0methodr9s r L_test_or_class_decorator.._decorate_test_or_class..s1>AF'//cs) isinstance collectionsabcIterable itertoolschain from_iterabletype__dict__copyitemscallable startswithunittest TestLoadertestMethodPrefixsetattr__new__r __bases__)objclsnamevaluer9s r_decorate_test_or_class9_test_or_class_decorator.._decorate_test_or_classs c;??33 4 4??001>A1  c4 C"||00288: E??t''88((C'>u'EF ; s)##S 3<< 8I8I8KCJ&s++rr)r@r9rs ` rr?r?s!2,( &}55 ""rcxUc4[RRR5(aS/OSS/nUcSS/n/nSU;a6U[RRR R S/US9- nSU;a7U[RRR R S/S/S9- nU$)aReturns the default test combinations for tf.keras tests. Note that if tf2 is enabled, then v1 session test will be skipped. Args: mode: List of modes to run the tests. The valid options are 'graph' and 'eager'. If None, uses ['graph', 'eager']. If an empty list is provided, then the test will run under the context based on tensorflow's version, e.g., graph for v1 and eager for v2. Defaults to `None`. run_eagerly: List of `run_eagerly` value to be run with the tests. When None, uses [True, False]. Note that for `graph` mode, run_eagerly value will only be False. Defaults to `None`. Returns: A list contains all the combinations to be used to generate test cases. eagergraphTF)mode run_eagerly)r!rrrsrttest combinationscombine)rrresults rkeras_mode_combinationsrs$ |,,4466WIWg >Ircj[RRRR S5/$rr!rrrrOptionalParameterrs rparameter_modifiers(KerasModeCombination.parameter_modifiers's* OO - - ? ? N  rrNrrrr__doc__rrrrrrrrs  rrc$\rSrSrSrSrSrSrg)KerasModelTypeCombinationi-aJCombination for TF-Keras model types when doing model test. It by default includes 'functional', 'subclass', 'sequential'. Various methods in `testing_utils` to get models will auto-generate a model of the currently active TF-Keras model type. This allows unittests to confirm the equivalence between different TF-Keras models. clURSS5nU[;a[R"U5/$/$NrU)rrrr^)rr/rUs rr*KerasModelTypeCombination.context_managers9s4ZZ d3 * *// ;< <Ircj[RRRR S5/$rrrs rr-KerasModelTypeCombination.parameter_modifiers@s* OO - - ? ? M  rrNrrrrrr-s rrtest_combinations)r)NN)NNFF)1rrr5rrtensorflow.compat.v2ryv2r! absl.testingr tf_keras.srcsrcrtf_keras.src.testing_infrarr; ImportErrorrrr rCr)r*r+rNr[rRrSrTrwrkrlrmr?rrrrrTestCombinationrrgeneratekeywords _defaultspartialrtimes NamedObjectrrrrs+!!&1=rww!7!7 pLf* * * LuLp* * *   iLX2. . 0#f!H  2??//<<LL ( OO%%55 2 OO - - 6 6 ? ?     OO%%..8:;<  //   + + 3 3 ))//oo""//;; c DsHHH