BVhjSUdZddlZddlmZddlmZmZmZmZmZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlZddlmZmZmZmZmZmZddlZddlmZddlZddl m!Z!ddl m"Z"dd l m#Z#dd l$m%Z%dd l&m'Z'dd l&m(Z(dd l&m)Z)ddl*m+Z+ddl*m,Z,ddl*m-Z-ddl.m/Z/ddl.m0Z0ddl1m2Z2ddl1m3Z3ddl1m4Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddl:mm?Z?ddl>m@Z@ddl>mAZBddl>mCZCddl>mDZDdd l>mEZEdd!l>mFZFdd"l>mGZGdd#l>mHZHdd$l>mIZIdd%l>mJZJdd&l>mKZKdd'l>mLZMdd(l>mNZNdd)l>mOZOdd*l>mPZPdd+l>mQZQdd,lRmSZSdd-lRmTZTdd.lRmUZUdd/lRmVZVdd0lRmWZWdd1lRmXZXdd2lRmYZYdd3lRmZZZdd4lRm[Z[dd5l\m]Z]dd6l\m^Z^dd7l\m_Z_dd8l`maZadd9l`mbZbdd:l`mcZddd;lemfZfddlgmjZjdd?lgmkZkdd@lgmlZlddAlgmmZmddBlgmnZnddClompZpddDlqmrZrddElsmtZtddFlumvZvedGedHefIZwedJZxedKeydLIZzdMe{fdNZ| ddOl}m|Z|dMee{fdPZ ddQlmZdMe{fdRZdMe{fdSZdMe{fdTZdMe{fdUZ ddVeedMejefdWZevdXdMefdYZdZeeefd[eIjdMeee(jffd\Zevd]g^d_e'jd`e'jdMdfdaZevd]g^ dd`e'jd_e'jdce{dde{dMdf deZ dd`e'jd_e'jdce{dde{dMdf dfZdgdLdhe,j&die,j&dMdfdjZdkZdle'jdMdfdmZdnZdle'jdMdfdoZdMe{fdpZdMe{fdqZdMe{fdrZdMe{fdsZdtZdMe{fduZdMe{fdvZddwZdxeeMjBeefdMeeMjBeeffdyZdzeeMjBeefdMeeMjBeeffd{ZdzeeMjBeefdMeeMjBeeffd|ZdxeeMjBeefdMeeMjBeeffd}Zd~eege{fe{fdMeewgewffdZe jR ddejTdeye~deeeedfdMedfdZdewdMewfdZdeyexdMeyexfdZdewdMewfdZdezdMezfdZdedMeewgewffdZdewdMewfdZ ddedMeedHefgedffdZdewdMewfdZdeededMe{fdZdewdMewfdZdMeeeeffdZdMeeeeffdZdezdMezfdZdezdMezfdZdewdMewfdZdewdMewfdZdewdMewfdZe ddeyexde{dMeyexfdZe dddde{dMeeyexgeyexffdZevd ddeeyexde{dMeeeyexgeyexfeyexffdZdewdMewfdZdezdMezfdZdedMeewgewffdZddedMeewgewffdZdedHefdMedfdZdewdMewfdZe ddedHefdee+jde{de{dMedf dZe ddddee+jde{de{dMeedHefgedff dZ ddeedHefdee+jde{de{dMeeedHefgedfedff dZ ddeede{dMeedHefgedffdZdewdMewfdZdedHefdMedfdZedewdMewfdZedezdMeezfdZdeezewfdMeezewffdZeZdezdMezfdZːddZ̐d dZ͐d dZdewdMewfdZdewdMewfdZdewdMewfdZdeeeeefdMeedHefgedffdZejjddevd d de{deeeefdMe{fdĄZe jRde{dMedfdńZAe jRdMedfdƄZe jRdMedfdDŽZe jRdMedfdȄZe jRdMedfdɄZGdʄd˫ZGd̄dͫZGd΄de5jZdewdMewfdЄZdedMeewgewffd҄Zde{dMeewgewffdԄZdedMeewgewffdՄZdedMeewgewffdքZdedMeewgewffdׄZdedMeewgewffd؄ZdedMeewgewffdلZdedMeewgewffdڄZdedMeeezewfgeezewdfffd܄ZdedHefdMeezgezffdބZdedMeewgewffd߄ZdedMeewgewffdZdedMeedHefgedffdZdedMeezgezffdZdZGddZdbZevdGddLebjTZeaeeed<ejZdZevd d dedededee+jdee+jdMeeefjeefjff dZdedle'jdMee(jfdZd[eIjdedMdfdZe jRdZGddZe jRde{dMedfdZGddZevdddZy#e~$rYOwxYw#e$r ddQlmZn #e$rYnwxYwY^wxYw( zTest utils for tensorflow.N) OrderedDict)IterableIteratorCallable CollectionSequence)AnycastUnionOptionaloverloadTypeVar) parameterizeddescriptor_pool)message) text_format)flags) graph_pb2) node_def_pb2) tensor_pb2) config_pb2)meta_graph_pb2)rewriter_config_pb2)pywrap_sanitizers)tf2) device_lib)pywrap_tf_session)session) v2_compatforward_compatibility_horizon)backprop)context) def_function)_test_metrics_util)configdevice)dtypes)errors) errors_impl)gpu_util)importer)indexed_slices)ops) random_seed) sparse_tensor)tensor) tensor_shape) tensor_util) tfrt_utils)versions) array_ops)control_flow_util)control_flow_util_v2) gen_sync_ops)gradients_impl)math_ops) script_ops)summary_ops_v2) variables) ragged_ops) ragged_tensor)ragged_tensor_value)_pywrap_stacktrace_handler) googletest) tf_logging) server_lib)_pywrap_util_port)compat) deprecation)nest) tf_decorator) tf_inspect)traceback_utils)collections_abc)np_where)compare) tf_export_F.)bound_T_TCTensorFlowTestCasereturncyNFr[U/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/framework/test_util.pyis_xla_enabledr^ss r\)r^cyNr[r[r\r]is_mlir_bridge_enabledras r\)rac*tjS)zCheck if ASAN is enabled.)ris_asan_enabledr[r\r]rcrc  * * ,,r\c*tjS)zCheck if MSAN is enabled.)ris_msan_enabledr[r\r]rfrfrdr\c*tjS)zCheck if TSAN is enabled.)ris_tsan_enabledr[r\r]rhrhrdr\c*tjS)zCheck if UBSAN is enabled.)ris_ubsan_enabledr[r\r]rjrjs  + + --r\excludec tjtjDcgc]}t |j c}tj|Dcgc]}t |j c}z Scc}wcc}wr`) collectionsCountergc get_objectstype__name__)rkobjs r]_get_object_count_by_typertsc9IJ#49--JKA#49--ABCDJAs BB ztest.gpu_device_namectjD]2}|jdk(stj|j cSy)aReturns the name of a GPU device if available or a empty string. This method should only be used in tests written with `tf.test.TestCase`. >>> class MyTest(tf.test.TestCase): ... ... def test_add_on_gpu(self): ... if not tf.test.is_built_with_gpu_support(): ... self.skipTest("test is only applicable on GPU") ... ... with tf.device(tf.test.gpu_device_name()): ... self.assertEqual(tf.math.add(1.0, 2.0), 3.0) GPU)rlist_local_devices device_typerIas_strname)xs r]gpu_device_namer}s@  ( ( *#a}} ]]166 ""# r\ expected_opsgraphc i}ttj|j}|jD]q}|j |vs||j |j k7r5td|j d||j d|j |||j <st|jt|jk7r-td|jd|j|S)aAssert all expected operations are found. Args: expected_ops: `dict` of op name to op type. graph: Graph to check. Returns: `dict` of node name to node. Raises: ValueError: If the expected ops are not present in the graph. zExpected op for node z is different. z vs z+Not all expected ops are present. Expected z, found ) r rGraphDef as_graph_defnoder{op ValueErrorsetkeys)r~r actual_opsgdrs r]assert_ops_in_graphrs13* I   2 2 45"gg#d yyL dii DGG +))\$))% ?? r\ztest.assert_equal_graph_def)v1expectedactualc"t||ddy)a9Asserts that two `GraphDef`s are (mostly) the same. Compares two `GraphDef` protos for equality, ignoring versions and ordering of nodes, attrs, and control inputs. Node names are used to match up nodes between the graphs, so the naming of nodes must be consistent. This function ignores randomized attribute values that may appear in V2 checkpoints. Args: expected: The `GraphDef` we expected. actual: The `GraphDef` we have. Raises: AssertionError: If the `GraphDef`s do not match. TypeError: If either argument is not a `GraphDef`. T) checkpoint_v2hash_table_shared_nameNassert_equal_graph_def)rrs r]assert_equal_graph_def_v2rs&046r\Frrc t||||y)aAsserts that two `GraphDef`s are (mostly) the same. Compares two `GraphDef` protos for equality, ignoring versions and ordering of nodes, attrs, and control inputs. Node names are used to match up nodes between the graphs, so the naming of nodes must be consistent. Args: actual: The `GraphDef` we have. expected: The `GraphDef` we expected. checkpoint_v2: boolean determining whether to ignore randomized attribute values that appear in V2 checkpoints. hash_table_shared_name: boolean determining whether to ignore randomized shared_names that appear in HashTableV2 op defs. Raises: AssertionError: If the `GraphDef`s do not match. TypeError: If either argument is not a `GraphDef`. Nr)rrrrs r]assert_equal_graph_def_v1rs2=/1r\ct|tjs!tdt |j zt|tjs!tdt |j z|rt |t ||rt|t|tj|j|j}|rttj|y)Nz'Expected tf.GraphDef for actual, got %sz)Expected tf.GraphDef for expected, got %s) isinstancerr TypeErrorrqrr_strip_checkpoint_v2_randomized_strip_hash_table_shared_namerEqualGraphDefWrapperSerializeToStringAssertionErrorrIrz)rrrrdiffs r]rrs FI.. / =L))* ++ Hi00 1 ?N++, --#F+#H-!&)!(+  / /0H0H0J080J0J0L N$ t, -- r\testerabc|jt|jt|j|jj}|D]5}|j|}|j|}t t t jtj|}|r|}|} |jt|jjt|jjt|jj|jjD]9\} } |j| | j| |j|| ;$|j||8|j!d|j!dt#|j$|j$d|j|j$j&|j$j&|j!d|j!d|j||y)z?Compares MetaGraphDefs `a` and `b` in unit test class `tester`.collection_defT)r graph_defN) assertEqualrrrr rqrMessager0get_collection_proto_typelen bytes_listvaluezipParseFromStringassertProtoEquals ClearFieldrrr7) rrrcollection_keyska_valueb_value proto_typea_protob_proto a_value_item b_value_items r]assert_meta_graph_protos_equalr,s S))*C0@0@,AB$$))+/ +aq!Gq!Gd7??+S-J-J1-MNJ g g  g  && 'W-?-?-E-E)FH*-g.@.@.F.F.5.@.@.F.F+H3 &< - -  '2 3  '*!+&,, ,, akkF1;;//1E1EF,,{,,{1a r\z_temp_[0-9a-z]{32}/partrc|jD]}g}|jD]}ttj|j|j }|s7t |jdk(sP|jd}|sbtjtjt|s|j||D]}|j|=yNr)rattrr r TensorProtor3r string_valrematchrIas_bytes_SHARDED_SAVE_OP_PATTERNappend)rr delete_keysattr_keyattr_tensor_valueattr_tensor_string_values r]rr\snn dKII'  $))H"5"<"<> s#4#?#?@AE#4#?#?#B $ HHV__%=>- /   X &'  ))H  r\zhash_table_[0-9a-z\-]+c6|jD]}g}|jdk(rcd|jvrUtjt j t|jdjr|jd|D]}|j|=y)N HashTableV2 shared_name) rrrrrrIr_TABLE_SHARED_NAME_PATTERNsr)rrrrs r]rrosnndK ww-MTYY$> &//"<=))M*,, .=) ))H  r\c*tjSr`)rHIsGoogleCudaEnabledr[r\r]rrzs  . . 00r\c*tjSr`)rHIsBuiltWithROCmr[r\r]rr~  * * ,,r\c*tjSr`)rHIsBuiltWithXLAr[r\r]rrs  ) ) ++r\c*tjSr`)rHIsBuiltWithNvccr[r\r]rrrr\c|jdrtjS|jdrtjS|jds|jdrtjS|jdrtj S|jdrtj SJd|z)Narmaarch64ppcpowerpcx86s390xzUnknown CPU target: ) startswithrHIsAArch32AvailableIsAArch64AvailableIsPowerPCAvailableIsX86AvailableIsSystemZAvailabletargets r]IsCPUTargetAvailablers u  / / 11 #  / / 11 6#4#4Y#?  / / 11   + + -- !  / / 11/&//r\c*tjSr`)rHGpuSupportsHalfMatMulAndConvr[r\r]rrs  7 7 99r\c*tjSr`)rH IsMklEnabledr[r\r]rrs  ' ' ))r\c,tjyr`)rDInstallStacktraceHandlerr[r\r]InstallStackTraceHandlerrs557r\ input_tensorcgdgdgdd}t|tjr/|jj}t j |||St|}||Dcgc]}|| c}Scc}w)zConverts the input from the NHWC format to NCHW. Args: input_tensor: a 3-, 4-, or 5-D tensor, or an array representing shape Returns: converted tensor or shape array )rr)rrr)rrrr)rrr tensor_libTensorshapendimsr8 transposerrnew_axesrrs r] NHWCToNCHWrsn| @( j//0    $ $E   |Xe_ ==  E%-e_ 5LO 55 5s( A7input_shape_or_tensorcgdgdd}t|tj}|r|jj n|}|ddzdk7r t d|dxxdzcc<|j d|t|}|r,tj||}tj||S|Dcgc]}|| c}Scc}w)aTransforms the input from the NHWC layout to NCHW_VECT_C layout. Note: Does not include quantization or type conversion steps, which should be applied afterwards. Args: input_shape_or_tensor: a 4- or 5-D tensor, or an array representing shape Returns: tensor or shape array transformed into NCHW_VECT_C Raises: ValueError: if last dimension of `input_shape_or_tensor` is not evenly divisible by 4. )rrrrr)rrrrrrrrrzPLast dimension of input must be evenly divisible by 4 to convert to NCHW_VECT_C.) rrrras_listrrrr8reshaper)r permutations is_tensor temp_shape permutationtrs r]NHWCToNCHW_VECT_Crs$%);<,. 0A0AB) !!))+- ^a1    R.Q. AS_-+/.real_skip_if..wrapper"s/ ) { 4"6""r\r[)rrrs` r] real_skip_ifzskip_if..real_skip_if s# Nr\rS)rrs` r]skip_ifrs r b  r\test_obj error_typemessagesc #K|rtj|} dy#|$rU|rtfd|Dr4|jdj t t nYdydwwxYww)alContext manager to skip cases not considered failures by the tests. Note that this does not work if used in setUpClass/tearDownClass. Usage in setUp/tearDown works fine just like regular test methods. Args: test_obj: A test object provided as `self` in the test methods; this object is usually an instance of `unittest.TestCase`'s subclass and should have `skipTest` method. error_type: The error type to skip. Note that if `messages` are given, both `error_type` and `messages` need to match for the test to be skipped. messages: Optional, a string or list of strings. If `None`, the test will be skipped if `error_type` matches what is raised; otherwise, the test is skipped if any of the `messages` is contained in the message of the error raised, and `error_type` matches the error raised. Yields: Nothing. Nc38K|]}|tvywr`str).0res r] z skip_if_error..MsE7c!f,EzSkipping error: {}: {})rKflattenanyskipTestformatrqr")rrrr$s @r] skip_if_errorr+/sn2||H%H   sEHEE077QQHI J s+A>!A>A;A A61A>6A;;A>rc|Sz%No-op. TODO(b/74620627): Remove this.r[)rs r]enable_c_shapesr.Ss )r\clsc|Sr-r[r/s r] with_c_shapesr2Xs *r\cfd}|S)akDecorator for enabling CondV2 and WhileV2 on a test. Note this enables using CondV2 and WhileV2 after running the test class's setup/teardown methods. In addition to this, callers must import the while_v2 module in order to set the _while_v2 module in control_flow_ops. Args: fn: the function to be wrapped Returns: The wrapped function ctj}dt_ |i||t_S#|t_wxYwNT)r9ENABLE_CONTROL_FLOW_V2)rrenable_control_flow_v2_oldrs r]rz'enable_control_flow_v2..wrapperms?!2!I!I/3,L   1K.1K.1 >r[rrs` r]enable_control_flow_v2r:]s L .r\cDtjr|S|jjj D]b\}}t |s|j tjjs.wrappers$(D! Kr\r)rHrs r]disable_control_flow_v2rMsB2 .r\cfd}|S)zForce-enable outputing all intermediates from functional control flow ops. Args: fn: the function to be wrapped Returns: The wrapped function ctj}dt_ |i||t_S#|t_wxYwr5)r:/_EXPERIMENTAL_OUTPUT_ALL_INTERMEDIATES_OVERRIDE)rroutput_all_intermediates_oldrs r]rz0enable_output_all_intermediates..wrappersFLL!KOH'    'J &Jr8r[r9s` r]enable_output_all_intermediatesrRs' .r\ warmup_iters.NcDdtdtfdtdffd }|S)a*Decorator for asserting that no new Python objects persist after a test. Returns a decorator that runs the test multiple times executing eagerly, first as a warmup and then to let objects accumulate. The warmup helps ignore caches which do not grow as the test is run repeatedly. Useful for checking that there are no missing Py_DECREFs in the C exercised by a bit of Python. Args: warmup_iters: The numer of warmup iterations, excluded from measuring. Returns: A decorator function which can be applied to the test function. f.rXrTc@dfd }tj|S)Nc tj5tjd}d}t |j dr-|j j }|j j}n@|j jj }|j jj}tD]} |g|i||jt}tjtjj}ttj||}tj rHtj"j$Dcic]!}|t'tj(|#} }tdD]} |g|i||jtj rwtj"j$D]U} tj(| } j+| d} t'|| kDrt-d| | t'||fz~~ ~ W~ tjttj|||z }tjj|z } | r Jd| z|rJdt/|ztj0dddycc}w#1swYyxYw) zDWarms up, gets object counts, runs the test, checks for new objects.Nr+)rkrrzACollection %s increased in size from %d to %d (current items %s).z.The following functions were newly created: %sz,The following objects were newly created: %s)r$ eager_moderodisablehasattr_outcomer+skippedresultrange doCleanupsrtcollectlist_function_names get_referentsr0has_default_graphget_default_graphrmrget_collectiongetrr"enable)selfrr test_errors test_skipped_obj_count_by_typeregistered_function_names collectioncollection_sizes_beforecollection_key size_beforeleftover_functionsrVrSs r] decoratorzLassert_no_new_pyobjects_executing_eagerly..wrap_f..decorators    Y   4==( + ,,+.., ,,33+--55,|$ #A D "4 "6 " # 67 %,OO$5$I$I$K! 6$$[,?A  "!$ 5 5 7 C C% #c00<==% !% q #A D "4 "6 " #   " # 5 5 7 C C n++N;J155naHK:,"2!;JLMNN  &  &((lC E    OO  1 1 36O O % <   %% $ : ! " # $$ sYYP% QYYsEK02&K+E K0+K00K9rirWrXNrLmake_decorator)rVrtrSs` r]wrap_fz9assert_no_new_pyobjects_executing_eagerly..wrap_fs[x  & &q) 44r\rr )rSrxs` r])assert_no_new_pyobjects_executing_eagerlyrzs/&]5c"]5x ':]5~ -r\rVc<dfd }tj|S)a\Decorator for asserting that no new Tensors persist after a test. Mainly useful for checking that code using the Python C API has correctly manipulated reference counts. Clears the caches that it knows about, runs the garbage collector, then checks that there are no Tensor or Tensor-like objects still around. This includes Tensors to which something still has a reference (e.g. from missing Py_DECREFs) and uncollectable cycles (i.e. Python reference cycles where one of the objects has __del__ defined). Args: f: The test case to run. Returns: The decorated test case. c0dtfdtfdtjD}t tt j }tjj}tjj5|tj_ |r't j5 |fi|}dddn  |fi|}dddt j jtjtjDcgc]}|rt||vr|}}|r"t!dt#|t%|fzS#1swYxYw#1swYxYwcc}w)z>Finds existing Tensors, runs the test, checks for new Tensors.rXc t|tjtjt j t jfS#ttf$rYywxYwrZ) rrrr@Variabler4 Dimension TensorShapeReferenceErrorAttributeErrorrss r]_is_tensorflow_objectzGassert_no_new_tensors..decorator.._is_tensorflow_objectdsY#%,,i.@.@'11<3K3KMN Nn -sAA AAc3FK|]}|s t|ywr`)id)r#rsrs r]r%z;assert_no_new_tensors..decorator..ms$K/DS/I3Ks !!Nz)%d Tensors not deallocated after test: %s)boolrrorpr r$executing_eagerlyr0re _graph_keyGraph as_defaultrY _clear_cachesrarrrr") rirtensors_beforeoutside_executed_eagerlyoutside_graph_keyr^rs tensors_afterrrVs @r]rtz(assert_no_new_tensors..decoratoraspdK>>+KKN#D'*C*C*EF--/::    !#+z test_util.pyrz N)rrMisframe getframeinfo)rsrrs r]get_ignore_reasonz0_find_reference_cycle..get_ignore_reasonsb 8}s # :2237: :  c h  r\F leaves_onlyc ||r"dj||t|Stj|r$djtj|Stj |rdj|j S|r$djt|t|St|tr2djt||Dcgc] }||dc}St|tr2djt||Dcgc] }||dc}St|tr2d jt|t|jStj|r9d jt||j t|jSdjt|t|Scc}wcc}w) a Returns a custom human-readable summary of obj. Args: obj: the value to describe. denylist: same as denylist in get_ignore_reason. leaves_only: boolean flag used when calling describe recursively. Useful for summarizing collections. z{}{}z frame: {}z module: {}z{}, {}z list({}): {}T)rz tuple({}): {}zdict({}): {} keyszfunction({}) {}; globals ID: {})r*rqrMrrismodulerrrrlisttupledictrr isfunction __globals__)rsrrr$describers r]rz'_find_reference_cycle..describesh' ]],S(;T#Y GG#    7 7 < ==   S !   .. tCy"S'22 c4 $$ sGsK!hq(=KM M c5 !%% sGsK!hq(=KM M c4 "))"S'3sxxz?CC   %077 sGS\\2coo#68 8tCy"S'22LLs %G4 'G9 rreprs.ctj|}||fz}t|}|D]S} || t|}||vrg||<|||vs)||j||||| ||||<Uy)aBuilds a reference graph as -> . Args: obj: The object to start from. The graph will be built by recursively adding its referrers. graph: Dict holding the graph to be built. To avoid creating extra references, the graph holds object IDs rather than actual objects. reprs: Auxiliary structure that maps object IDs to their human-readable description. denylist: List of objects to ignore. N)ro get_referrersrr) rsrrr referrersobj_idrr_idbuild_ref_graphrrs r]rz._find_reference_cycle..build_ref_graphs"  %I9,&H WF . 1h ' /!u u %+ t $ +  V $ !UE8 4 H-%+.r\elpathc ||vry||D]j}||vrStjd||fzD]3}tj|j|dt|z5y|||||fzsjyy)z8Finds and prints a single cycle in the dependency graph.NzReference cycle sample:zunknown object TF)loggingerrorrgr")rrrrrp find_cycles r]rz)_find_reference_cycle..find_cycles  2Y d /0 BA -- !%6Q%?@ A B atqd{ 3 r\r[TF) r rr r"rrintrr) rrrsrrrrrrrs @@@@r]_find_reference_cyclersY S JsO  $@E 3  3$S/ 38< 3  3D. . #tCy. !.#s(^.c3h .  .>  #tCy. !#s(^ #s(O  ~ (  # "%%#uegue=N&.&MN a!UE2&  r\cdfd }|S)aUTest method decorator to assert that no garbage has been created. Note that this decorator sets DEBUG_SAVEALL, which in some Python interpreters cannot be un-set (i.e. will disable garbage collection for any other unit tests in the same file/shard). Args: f: The function to decorate. Returns: The decorated function. c ttjtj}tjtjtj t tj} |fi|}tj t tj}||kDr:ttj|dD]\}}t|dddk(s|dz}||kDrtjdttj|dD]r\}} tjd|t tj|z dtfd }tjd ||tjd d jtj|D cgc] } ||  c} tjd d jtj|D cgc] } ||  c} tjdt!|tjdtj|tjdtjt#|u||kDr-t'||D]}t)tj|sn|j+||tj|tj,|Scc} wcc} w#t$$rtjdYwxYw)z>Sets DEBUG_SAVEALL, runs the test, and checks for new garbage.N __module__rwastrzyThe decorated test created work for Python's garbage collector, likely due to a reference cycle. New objects in cycle(s):zObject %d of %drXcJd|jjt|fzS)Nz<%s %d>) __class__rrrrs r]_safe_object_strzFassert_no_garbage_created..decorator.._safe_object_str)s  6 63@@ @r\z Object type: %sz Referrer types: %s, z Referent types: %sz Object attribute names: %sz Object __str__:z Object __repr__:z!(Exception while printing object))rorZ get_debug set_debugDEBUG_UNCOLLECTABLErargarbage enumeraterDrrr"joinrrcdirrepr Exceptionr_rrrh) rirprevious_debug_flagsprevious_garbager^ new_garbageirsrrefrVs r]rtz,assert_no_garbage_created..decoratorsJJL<<>LL''(JJL2:: t v FJJLbjj/K%%bjj)9):;<&!S 3 b )U 2  + %% mm FGbjj)9):;<=&!S = --)1BJJ*:: < As A --+-=c-B C --$dii464D4DS4IJS#C(J'L M --$dii464D4DS4IJS#C(J'L M --6C A --+ , --  --, - --S "'=2%%%{3! Q /   %{3LL%&IIK M7KK  = --; < =s2.B L7L =LLBL LL76L7rr[rs` r]assert_no_garbage_createdrs ;z r\c d}g}t|j|D]9\}}t|ts|g}|j |Dcgc]}||fc};t j |Dcgc] }t|c}Scc}wcc}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 |dSNrr[)rs r]z+_combine_named_parameters..^s !A$r\)key)sortedr@rrr itertoolsproductr)r sort_by_key combinationsrvaluesrr^s r]_combine_named_parametersrOs+.0,FLLN < C~d+, - *r\cfd}|S)aDecorator for enabling nested_function_shape_inference on a test. This function returns a decorator intended to be applied to test methods in a `tf.test.TestCase` class. Doing so will set nested_function_shape_inference, reset the context, execute the test, then reset the context to the state it was in prior to this test. Example: class MyTest(test.TestCase): @enable_nested_function_shape_inference def testFoo(self): ... Args: fn: the function to be wrapped. Returns: The wrapped function. ctjjjr|i|Stjjj d |i|tjjj dS#tjjj dwxYwNTF)rr'&enable_nested_function_shape_inferencerresetrrrs r]rz7enable_nested_function_shape_inference..wrappers ||~<<BBD     LLN99??EI    lln;;AA%Helln;;AA%H $B/Cr[r9s` r]rrs. I .r\cfd}|S)a Decorator for enabling quantized_dtypes_training on a test. This function returns a decorator intended to be applied to test methods in a `tf.test.TestCase` class. Doing so will set quantized_dtypes_training, reset the context, execute the test, then reset the context to the state it was in prior to this test. Example: class MyTest(test.TestCase): @enable_quantized_dtypes_training def testFoo(self): ... Args: fn: the function to be wrapped. Returns: The wrapped function. ctjjjr|i|Stjjj d |i|tjjj dS#tjjj dwxYwr)rr' enable_quantized_dtypes_trainingrrrs r]rz1enable_quantized_dtypes_training..wrappers ||~66<<>     LLN3399$?C    lln55;;EBelln55;;EBrr[r9s` r]rrs. C .r\cfd}|S)zReturns the same fn. This will be removed once all usages are removed. Args: fn: the function to be wrapped. Returns: The wrapped function. c|i|Sr`r[rs r]rz,enable_eager_op_as_function..wrappers t v r\r[r9s` r]enable_eager_op_as_functionrs .r\only_as_functioncyr`r[r/rs r]with_eager_op_as_functionr r\cyr`r[rs r]rrrr\ztest.with_eager_op_as_functioncVdttdttfd}|||S|S)zReturns the same class. This will be removed once all usages are removed. Args: cls: class to decorate. only_as_function: unused argument. Returns: cls r/rXc|Sr`r[r1s r]rtz,with_eager_op_as_function..decorator's Jr\)rqrU)r/rrts r]rrs4T"X$r( _ S> r\cfd}|S)aDecorator for enabling graph_building_optimization on a test. This function returns a decorator intended to be applied to test methods in a `tf.test.TestCase` class. Doing so will enable graph_building_optimization, execute the test, then reset the feature flag to its default value. Example: class MyTest(test.TestCase): @enable_graph_building_optimization def testFoo(self): ... Args: fn: the function to be wrapped. Returns: The wrapped function. ctjjjr|i|Stjjj d |i|tjjj dS#tjjj dwxYwr)rr'graph_building_optimizationrrrs r]rz3enable_graph_building_optimization..wrapperFs ||~11779     LLN..44T:>    lln0066u=elln0066u=rr[r9s` r]"enable_graph_building_optimizationr0s, > .r\ctjjjr|S|jj j D]e\}}t|s|jtjjs|jdsMt||dzt|g|S)aAdds methods with graph_building_optimization enabled to the test suite. Example: @test_util.add_graph_building_optimization_tests class FooTest(test.TestCase): def testBar(self): ... Generated class: class FooTest(test.TestCase): def testBar(self): ... def testBarWithGraphBuildingOptimization(self): // Enable graph_building_optimization testBar(self) // Disable graph_building_optimization Args: cls: class to decorate. Returns: cls with new test methods added. benchmarkWithGraphBuildingOptimization)rr'rrr>r?r@rrrArBrCrErrFs r]%add_graph_building_optimization_testsr Ts: \\^//557 J\\&&(..09kdE ,,== >  % c499079 9 *r\ctdS)a Decorator for a function in a with_eager_op_as_function enabled test class. Blocks the function from being run with eager_op_as_function enabled. Args: unused_msg: Reason for disabling. Returns: The wrapped function with _disable_eager_op_as_function attr set to True. F) execute_func) _disable_test)rHs r]disable_eager_op_as_functionr}s E **r\flagc,dtdtffd }|S)aDecorator for setting XLA_FLAGS prior to running a test. This function returns a decorator intended to be applied to test methods in a `tf.test.TestCase` class. Doing so will allow users to set any xla flags exposed via the XLA_FLAGS environment variable, execute the test, then reset the XLA_FLAGS to the state it was in prior to this test. Example: class MyTest(test.TestCase): @set_xla_env_flag(flag='--xla_gpu_enable_fast_min_max=false') def testFoo(self): ... Args: flag: The xla flag to be set in the XLA_FLAGS env variable. Returns: A decorator which sets the configured flag in XLA_FLAGS for the decorated function. rVrXcFtjfd}|S)Nc8tjjd}}|r|dz|z}|tjd< |i||tjd=S|tjd<S#|tjd=w|tjd<wxYw)N XLA_FLAGS osenvironrg)rroriginal_xla_flags new_xla_flagsrVrs r] decoratedz6set_xla_env_flag..decorator..decorateds::>>+6m %+.@@ -bjj7$!&!  %jj%$6"**[ !  %jj%$6"**[ !s A00)B) functoolswraps)rVrrs` r]rtz#set_xla_env_flag..decorators&__Q 7 7 r\r)rrts` r]set_xla_env_flagrs02"& r\rJctjr tdtjddt j dddtddffd }|S) aRun a test case in v1 graph mode and inside tf.function in eager mode. WARNING: This decorator can only be used in test cases that statically checks generated graph. Attempting to evaluate graph or function results via. session.run() or self.evaluate() will fail. WARNING: This decorator can only be used for test cases that inherit from absl.testing.parameterized.TestCase. Args: func: Test case function to be decorated. Returns: Decorated test case function. z<`run_in_graph_mode_and_function` only supports test methods.) _v1_graphv1_graph) _functionfunctionrirWrun_moderXNc|dk(r8tjj5gidddy|dk(rtjfd}tj}|j5t j 5|ddddddtj|ytd|z#1swYyxYw#1swYAxYw#1swYExYw)Nr r"cgiyr`r[)rrJrrisr]function_in_eagerzLbuild_as_function_and_v1_graph..decorated..function_in_eagers T#D#F#r\zUnknown run mode %s) r0rrr%r"r$rYdismantle_graphr)rir#rrr&graph_for_eager_testrJs` `` r]rz1build_as_function_and_v1_graph..decorateds: 99; ! ! #$ T#D#F#$$ Z $$ !YY[  * * ,g.@.@.B ./ ,x7 88$$s/ CC/C##C/C #C, (C//C8)rMisclassrrnamed_parametersrrr"rJrs` r]build_as_function_and_v1_graphr,s}& F HH!!";";= ??49 99  9=90 r\ctjddgtjdddtffd }|S)z-Execute the test in async mode and sync mode.)AsyncT)rwFrirW async_modec|r9tjtj5|g|i|dddytjtj5|g|i|dddy#1swYyxYw#1swYyxYwr`)r$execution_modeASYNCSYNC)rir/rrrVs r]rtz-run_in_async_and_sync_mode..decorators  ! !'-- 0! $   !!  ! !',, /! $   !!!!!!s A6 B6A?B )rr*rrrrs` r]run_in_async_and_sync_moder4sP!!?K"@A ??1!*!!B! r\r'use_gpuassert_no_eager_garbagecyr`r[rJr'r5r6s r]rrr\cyr`r[r8s r]rrr9r\c`dtdtfdtdffd }|||S|S)a Execute the decorated test with and without enabling eager execution. This function returns a decorator intended to be applied to test methods in a `tf.test.TestCase` class. Doing so will cause the contents of the test method to be executed twice - once normally, and once with eager execution enabled. This allows unittests to confirm the equivalence between eager and graph execution (see `tf.compat.v1.enable_eager_execution`). For example, consider the following unittest: ```python class MyTests(tf.test.TestCase): @run_in_graph_and_eager_modes def test_foo(self): x = tf.constant([1, 2]) y = tf.constant([3, 4]) z = tf.add(x, y) self.assertAllEqual([4, 6], self.evaluate(z)) if __name__ == "__main__": tf.test.main() ``` This test validates that `tf.add()` has the same behavior when computed with eager execution enabled as it does when constructing a TensorFlow graph and executing the `z` tensor in a session. `deprecated_graph_mode_only`, `run_v1_only`, `run_v2_only`, and `run_in_graph_and_eager_modes` are available decorators for different v1/v2/eager/graph combinations. Args: func: function to be annotated. If `func` is None, this method returns a decorator the can be applied to a function. If `func` is not None this returns the decorator applied to `func`. config: An optional config_pb2.ConfigProto to use to configure the session when executing graphs. use_gpu: If True, attempt to run as many operations as possible on GPU. assert_no_eager_garbage: If True, sets DEBUG_SAVEALL on the garbage collector and asserts that no extra garbage has been created when running the test with eager execution enabled. This will fail if there are reference cycles (e.g. a = []; a.append(a)). Off by default because some tests may create garbage for legitimate reasons (e.g. they define a class which inherits from `object`), and because DEBUG_SAVEALL is sticky in some Python interpreters (meaning that tests which rely on objects being collected elsewhere in the unit test file will not work). Additionally, checks that nothing still has a reference to Tensors that the test allocated. Returns: Returns a decorator that will run the decorated test method twice: once by constructing and executing a graph in a session and once with eager execution enabled. rV.rXrTctjr tddfd }tj|S)Nzr`run_in_graph_and_eager_modes` only supports test methods. Did you mean to use `run_all_in_graph_and_eager_modes`?c.tjd j tj5|j d5|j jD]!}|jdk(s|j}i}n|j}t }|di|5 |gi|dddddddddd fd }r(tjt!t#|}|j%d|_tj(}|j+5tj,5|j d5|j/||fi|dddddddddtj0|y#1swYxYw#1swYxYw#1swYxYw#tjj$rY wxYw#1swYwxYw#1swY{xYw#1swYxYw) NzRunning %s in GRAPH mode. graph_mode XLATestCase)r5r'ctjdjs+tjd5|gi|dddy|gi|y#1swYyxYw)NzRunning %s in EAGER mode. /device:CPU:0rinforrr0r))rirrrVr5s r] run_eagerlyzWrun_in_graph_and_eager_modes..decorator..decorated..run_eagerlylse 0!**=zz/* % d $T $V $ % % D "4 "6 " % % AA%rYr[ru)rrCrrr$r>subTestrmrorrrrAcaseSkipTestr0reset_default_graphrrtearDown_tempdirrrrYsetUpr') rirrclass_ session_funcsession_kwargsrDr(r6r'rVr5s ` r]rzBrun_in_graph_and_eager_modes..decorator..decoratedYs ll. ;    ! %4<< #= %**, Bf-/!\\l!n  B  ,,L!'&AN-n- % d $T $V $ % % % # ! !+ %k 24  mmodm!YY[  ) ) +$    $ ,,| $$ D#F# $$$ ./A % % % % % %]] # #   .$$$$$$sGG -F782F7* F+7F7?GG<H G?#G3=G?H +F4 0F77G <GG GG0/G03G< 8G??H H  HrurMr)rrLrw)rVrr6r'r5s` r]rtz/run_in_graph_and_eager_modes..decoratorSsF!  D EE.0.0`  & &q) 44r\ry)rJr'r5r6rts ``` r]rrs>D658CH%65(9*=65p  T? r\ device_to_usecHdtdtfdtdffd }|S)aExecute the decorated test in v1 and v2 modes. The overall execution is similar to that of `run_in_graph_and_eager_mode`. Args: device_to_use: A string in the following format: "/device:CPU:0". assert_no_eager_garbage: If True, sets DEBUG_SAVEALL on the garbage collector and asserts that no extra garbage has been created when running the test with eager execution enabled. This will fail if there are reference cycles (e.g. a = []; a.append(a)). Off by default because some tests may create garbage for legitimate reasons (e.g. they define a class which inherits from `object`), and because DEBUG_SAVEALL is sticky in some Python interpreters (meaning that tests which rely on objects being collected elsewhere in the unit test file will not work). Additionally, checks that nothing still has a reference to Tensors that the test allocated. Returns: A decorator that runs a given test in v1 and v2 modes. rV.rXrTcd}t|rSdfd }tj|}d|j|<|S)Nwrapped_with_v1_v2_decoratorc|tjdj |jd5t j |gi|ddddfd }r(tjtt|}|jd|_tjt j|jd5|j!||fi|dddy#1swYxYw#t jj$rYwxYw#1swYyxYw)NzRunning %s in V1 mode.V1_modectjdjr+tj5|gi|dddy|gi|y#1swYyxYw)NzRunning %s in V2 mode.rB)rirrrRrVs r]run_v2zBrun_in_v1_v2..decorator..decorated..run_v2se -qzz: zz-( % d $T $V $ % % D "4 "6 " % %rEV2_moderu)rrCrrrFr disable_v2_behaviorrArHrIr0rJrrrKrLenable_v2_behaviorrM)rirrrYr6rRrVs ` r]rz2run_in_v1_v2..decorator..decorateds ll+QZZ8 \\) $ #  ' ' ) D "4 "6 " # # ! !& %f -/  mmodm ""$ << " tv5 # #]] # #   .s4D!DD D2D DD/.D/2D;Tru)r[rLrwr>)rV decorator_tagr tf_decoratedr6rRs` r]rtzrun_in_v1_v2..decoratorsG2Mq- hB ..q).decorated..inner_fs@T gn&78$!Q   4  r\) r0inside_functionrrrrr@r~rr>py_func)rre tensor_argsrargrgrfrVs`` @r]rz)py_func_if_in_function..decorateds      FHK "ND/!3 C*++Y-?-?@ A3a ! !   g{B 77r\rvrVrs` r]py_func_if_in_functionrms8&  $ $Q 22r\cdfd }|S)aRuns the decorated test twice--once as is, once inside a tf.function. This allows you to run a test both in eager execution and inside a tf.function, exercising the two execution modes supported in tf 2.0. The test assertions are automatically done inside tf.py_funcs, and tf.function ensures that they run in the proper order and with the proper side effects. Currently variable creation is not supported in tests annotated with this decorator since it's tricky to ensure the variable doesn't get repeatedly created when retracing the tf.function. Args: f: the test method to be decorated Returns: The decorated test method, which will run both in eager and inside a tf.function. cdfd }tj5|tj|ddddy#1swYyxYw)Nciyr`r[)rrVresr]bound_fz;also_run_as_tf_function..decorated..bound_fsr\F) autographrXN)r$rYr%r")rrerqrVs`` r]rz*also_run_as_tf_function..decoratedsG    8 i6lGu57 888s $A  Arsr[rls` r]also_run_as_tf_functionrts( 8 r\cyr`r[rLs r]deprecated_graph_mode_onlyrvr\cyr`r[rLs r]rvrvrwr\ctjrjjd}|t dt |jj jD]Q\}}t|s|jtjjsrrrJs r]rz-deprecated_graph_mode_only..decorated?sT  "    %T$V$%%4 "6 ""%%s AA )rMr)r>rgrErvr?r@rrrArBrCrLrw)rJsetupr{rrs` r]rvrvs, MM  g &E  dG7>?}}))+113? e 5/ //(-->> ?d6u=>? K#  $ $T9 55r\ct}t|D]]}|jtjj r|dk(r2t ||d}t|sKt||||_|S)z+Execute all tests in a class in graph mode.rN) rvrrrArBrCrDrrErs r]%run_all_in_deprecated_graph_mode_onlyr~Lsj-.#h0d OOH//@@ A  Ct $E c4./ 0 *r\cDs drdndfd||SS)aExecute the decorated test only if running in the specified mode. This function is intended to be applied to tests that exercise functionality that belongs to either only v2, or v1. If the test is run in the mode opposite of the specified one, it will simply be skipped. It shouldn't be used directly, instead, use the `run_v1_only` or `run_v2_only` wrappers that call it. `deprecated_graph_mode_only`, `run_v1_only`, `run_v2_only`, and `run_in_graph_and_eager_modes` are available decorators for different v1/v2/eager/graph combinations. Args: func: function to be annotated. If `func` is None, this method returns a decorator the can be applied to a function. If `func` is not None this returns the decorator applied to `func`. v2: a boolean value indicating whether the test should be skipped in v2, or v1. reason: string giving a reason for limiting the test to a particular mode. Returns: A decorator that will skip the test method in the specified version. zTest is only compatible with zv2 rctjrOtjD]5}|jj d}|!t d|SSfd}tj|S)NrMcvtj}|rr|sr|j|g|i|Sr`)renabledr))rirr tf2_enabledrVreasonv2s r]rz2_run_vn_only..decorator..decorateds:kkm  KB -- ''''r\) rMr)rqrGr>rgrErLrw)rVr/r|rrtrrs` r]rtz_run_vn_only..decoratorvs~!!#   )   !Wi. /  h  h( ( (I 66r\r[)rJrrrts ``@r] _run_vn_onlyrYs64 ,bUd,C DF78  T? r\ct|d|S)z2Only execute the test if Tensorflow is in v1 mode.FrJrrr)rrJs r] run_v1_onlyrs 4E& 99r\ct|d|S)z2Only execute the test if Tensorflow is in v2 mode.Trr)rJrs r] run_v2_onlyrs 4D 88r\cTtjr tddfd }|S)aJExecute the decorated test only if a GPU is available. This function is intended to be applied to tests that require the presence of a GPU. If a GPU is absent, it will simply be skipped. Args: func: function to be annotated. Returns: Returns a function that will conditionally skip the decorated test method. z*`run_gpu_only` only supports test methods.cRts|jd|g|i|S)NzTest requires GPUis_gpu_availabler)rirrrJs r]rzrun_gpu_only..decorateds+   mm'(  &t &v &&r\rrMr)rr+s` r] run_gpu_onlyrs, A BB' r\cTtjr tddfd }|S)aTExecute the decorated test only if a GPU is available. This function is intended to be applied to tests that require the presence of a CUDA GPU. If a CUDA GPU is absent, it will simply be skipped. Args: func: function to be annotated. Returns: Returns a function that will conditionally skip the decorated test method. z+`run_cuda_only` only supports test methods.cVtds|jd|g|i|S)NT) cuda_onlyzTest requires CUDA GPUrrs r]rz run_cuda_only..decorateds- d + mm,-  &t &v &&r\rrr+s` r] run_cuda_onlyrs, B CC' r\cTtjr tddfd }|S)a%Execute the decorated test only if a physical GPU or TPU is available. This function is intended to be applied to tests that require the presence of a physical GPU or TPU. It complies with the following rules: - If a GPU is available, the test will run on the GPU. - If a GPU is absent and a TPU is available, the test will run on the TPU. - If both GPU and TPU are absent, the test will be skipped. Args: func: function to be annotated. Returns: Returns a function that will conditionally skip the decorated test method. z,`run_gpu_or_tpu` only supports test methods.ctjdr |dg|i|Stjdr |dg|i|S|jdy)NrvTPUzTest requires GPU or TPU)r'list_physical_devicesr)rs r]rz!run_gpu_or_tpu..decoratedsZ ##E* $ / / // ##E* $ / / //MM,-r\rrr+s` r]run_gpu_or_tpurs,  C DD. r\horizonscs tdD]3}|t|dk(rtd|Dr'td|zdtdtfdtdffd }|S) aOExecutes the decorated test with the specified forward-compat horizons. Args: *horizons: A list of (year, month, day) tuples. If the list includes `None`, then the test will also be run with no forward-compatibility horizon set. Returns: A decorator that will execute the test with the specified horizons. zExpected at least one horizon.rc3<K|]}t|tywr`)rr)r#r|s r]r%z6with_forward_compatibility_horizons..s&Kaz!S'9&KszBad horizon value: %rrV.rXrTc~tjr tdfd}tj|S)NzA`with_forward_compatibility_horizons` only supports test methods.cD]1}| |i||\}}}t|||5|i|ddd3y#1swY>xYwr`r!)rrhorizonyearmonthdayrVrs r]rzIwith_forward_compatibility_horizons..decorator..decorated sc' ? T V & 4,T5#>  t v       s 9A rQ)rVrrs` r]rtz6with_forward_compatibility_horizons..decorators=! 0 11  & &q) 44r\)rrallrr )rrrts` r]#with_forward_compatibility_horizonsrs{  5 66:g _ \Q 3&K7&K#K .8 99: 58CH% 5(9*= 5 r\z5Use `tf.config.list_physical_devices('GPU')` instead.ztest.is_gpu_availablermin_cuda_compute_capabilityc`~ tjD]@}|jdk(stj|}|j xsd}|r||k\s@yy#t j$r>tfddDstjtYdydwwxYw)aReturns whether TensorFlow can access a GPU. Warning: if a non-GPU version of the package is installed, the function would also return False. Use `tf.test.is_built_with_cuda` to validate if TensorFlow was build with CUDA support. For example, >>> gpu_available = tf.test.is_gpu_available() >>> is_cuda_gpu_available = tf.test.is_gpu_available(cuda_only=True) >>> is_cuda_gpu_min_3 = tf.test.is_gpu_available(True, (3,0)) Args: cuda_only: limit the search to CUDA GPUs. min_cuda_compute_capability: a (major,minor) pair that indicates the minimum CUDA compute capability required, or None if no requirement. Note that the keyword arg name "cuda_only" is misleading (since routine will return true when a GPU device is available irrespective of whether TF was built with CUDA support or ROCm support. However no changes here because ++ Changing the name "cuda_only" to something more generic would break backward compatibility ++ Adding an equivalent "rocm_only" would require the implementation check the build type. This in turn would require doing the same for CUDA and thus potentially break backward compatibility ++ Adding a new "cuda_or_rocm_only" would not break backward compatibility, but would require most (if not all) callers to update the call to use "cuda_or_rocm_only" instead of "cuda_only" Returns: True if a GPU device of the requested kind is available. rv)rrTFc38K|]}|tvywr`r!)r#r|r$s r]r%z#is_gpu_available..Ns9qqCF{9r&)CUDAznot findN) rrxryr-#compute_capability_from_device_desccompute_capabilityr, NotFoundErrorrrrr")rr local_devicegpu_infoccr$s @r]rrsV "557  ! !U *?? M  ( ( 2F*b4O.O    " " 9$89 9 g mmCF  s(&A,AAAB-/4B((B-c#K|r trd}nd}tj|5ddddy#1swYyxYww)&Uses gpu when requested and available. /device:GPU:0rAN)rr0r))r5devs r]r)r)Us= !# C C zz#     s'A7 AAAc#VKtd5ddddy#1swYyxYww)rT)r5Nr(r[r\r]r5r5`s'd     s ) )&)c#hKtjd5ddddy#1swYyxYww)zForce the gpu to be used.rNr0r)r[r\r] force_gpurg+ zz/"     2& 2/2c#hKtjd5ddddy#1swYyxYww)zForce the cpu to be used.rANrr[r\r] force_cpurnrrc#K tjdtjy#tjwxYww)zEnables deterministic ops.N)r'enable_op_determinismdisable_op_determinismr[r\r]deterministic_opsrus2$   "  !!#F!!#sA 1A AA c(eZdZdZdefdZdefdZy)CapturedWritesz=A utility class to load the captured writes made to a stream.capture_locationc||_yr`)r)rirs r]__init__zCapturedWrites.__init__s ,Dr\rXct|j5}dj|j}ddd|S#1swYSxYw)z+Get the captured writes as a single string.rwN)openrr readlines)ritmp_file output_datas r]contentszCapturedWrites.contentssE d## $2GGH..01k2 2 s AA N)rrr __qualname____doc__r"rrr[r\r]rrsE-s-r\rceZdZdZdZdZy)FakeEagerSessionaFake session so tests that conditionally use placeholders can use eager. There are a number of tests that conditionally use placeholders for shape inference. The pattern is demonstrated here: ```python with self.cached_session() as sess: if static_shape: y = math_ops.matmul(x, ...) feed_dict = {} else: x_ph = array_ops.placeholder(...) y = math_ops.matmul(x_ph, ...) feed_dict = {x_ph: x} val = sess.run(y, feed_dict=feed_dict) ``` Since the feed_dict is empty when not using placeholders we should be able to call self.evaluate(), however this requires rewriting the test case. This class should be considered a stop-gap solution to get tests running with eager with minimal changes to the actual test. c||_yr`) _test_case)ri test_cases r]rzFakeEagerSession.__init__s DOr\c|jdi}|r td|s|r td|jj|S)a=Evaluate `fetches`. Fail if additional args are specified. Args: fetches: A Tensor or a nested list/tuple of Tensors. *args: Positional arguments **kwargs: Keyword arguments Raises: RuntimeError: If args or kwargs are specified. Returns: Tensors as numpy values. feed_dictzpfeed_dict is not supported when eager execution is enabled (in this case, sess.run(t) is shorthand for t.numpy()zuOptional args are not supported when eager execution is enabled (in this case, sess.run(t) is shorthand for t.numpy())pop RuntimeErrorrevaluate)rifetchesrrrs r]runzFakeEagerSession.runs_  ;+I  B CC v  B CC ?? # #G ,,r\N)rrrrrrrr[r\r]rrs. -r\rc"eZdZdZfdZxZS)ErrorLoggingSessionz3Wrapper around a Session that logs errors in run().c t||i|S#t$r>}t|tj st jt|d}~wwxYwr`) superrrrr+OutOfRangeErrorrrr")rirrr$rs r]rzErrorLoggingSession.runsQ W[$ )& ))  611 2 c!f  s A9AA)rrrrrr __classcell__rs@r]rrs;   r\rc:fd}tj|S)a%Disable autotuning during the call to this function. Some tests want to base assertions on a graph being isomorphic with a copy. To ensure this, this decorator disables autotuning. Args: func: Function to run with CuDNN autotuning turned off. Returns: Decorated function. ctjjd}dtjd<tjjd}d}|r|dz|z}|tjd<|i|}|tjd=n|tjd<|tjd=|S|tjd<|S)NTF_CUDNN_USE_AUTOTUNEfalserz--xla_gpu_autotune_level=0rr)rroriginal_tf_cudnn_use_autotunerrr^rJs r]rz)disable_cudnn_autotune..decorateds%'ZZ^^4K%L"*1BJJ&' 40M(3.>m+BJJ{ 4 "6 "F&. **, -,Jbjj()" **[ ! M!3bjj Mr\rvr+s` r]disable_cudnn_autotuners,  $ $T9 55r\ descriptionct|ts#tdjt |dt dt fd}|S)Nz&'description' should be string, got {}rJrXc:fd}tj|S)zEnable constant folding during the call to this function. Some tests fail without constant folding. Args: func: Function to run with constant folding turned on. Returns: Decorated function. ctj}tjd|i|}tj||SrZ)r TF_GetXlaConstantFoldingDisabled TF_SetXlaConstantFoldingDisabled)rr original_varr^rJs r]rz^enable_tf_xla_constant_folding..enable_tf_xla_constant_folding_impl..decorated sA&GGIl88?T$V$f88F mr\rvr+s` r]#enable_tf_xla_constant_folding_implzKenable_tf_xla_constant_folding..enable_tf_xla_constant_folding_impl s  & &tY 77r\)rr"rr*rqrS)rrs r]enable_tf_xla_constant_foldingrsJ K % =DD [ 88r8* -,r\r c,dtdtffd }|S)NrJrXc>fd}tj|S)Ncr|i|Syr`r[)rrr rJs r]rz;_disable_test..disable_test_impl..decorated s T$V$$ r\rv)rJrr s` r]disable_test_implz(_disable_test..disable_test_impl s%  & &tY 77r\r)r rs` r]r r  s8b8R8 r\c.t }t|S)z3Execute the test method only if xla is not enabled.r^r rr s r] disable_xlar( #%%, | $$r\c.t }t|S)z;Execute the test method only if MLIR bridge is not enabled.)rar rs r]disable_mlir_bridger/ s+--, | $$r\c.t }t|S)z4Execute the test method only if ASAN is not enabled.)rcr rs r] disable_asanr6 $&&, | $$r\c.t }t|S)z4Execute the test method only if MSAN is not enabled.)rfr rs r] disable_msanr= rr\c.t }t|S)z4Execute the test method only if TSAN is not enabled.)rhr rs r] disable_tsanrD rr\c.t }t|S)z5Execute the test method only if UBSAN is not enabled.)rjr rs r] disable_ubsanrK s%'', | $$r\unused_descriptionc\dtttfdtttdffd}|S)N cls_or_funcrXctj|r%tjryt t |St t dtf|fd}tj||S)z-Execute the test only if tfrt is not enabled.N.c>tjry|i|Sr`)r6rr{s r]rz:disable_tfrt..disable_tfrt_impl..decorated` s"     t&v& &r\) rMr)r6rr rVrr rLrw)rrrJs @r]disable_tfrt_implz'disable_tfrt..disable_tfrt_implV s^+&    C%% (38$k 2d'  ( (i @@r\)r rVrS)rr s r] disable_tfrtr R s3AU37^Ac2tm8LA$ r\rtc4dtdtffd }|S)aGenerate class-level decorator from given method-level decorator. It is expected for the given decorator to take some arguments and return a method that is then called on the test method to produce a decorated method. Args: decorator: The decorator to apply. *args: Positional arguments **kwargs: Keyword arguments Returns: Function that will decorate a given classes test methods with the decorator. r/rXc t|D]K}t||}t|s|jds-|dk7s3t ||i|M|S)z-Apply decorator to all test methods in class.testr)rrDrrrE)r/r{rrrtrs r]all_test_methods_implz3for_all_test_methods..all_test_methods_impl| sdC>c4 e %T__ ~-T59d5f5e<= > Jr\)rV)rtrrrs``` r]for_all_test_methodsrk s" r\c.t }t|S)z>This test is not intended to be run with XLA auto jit enabled.rrs r]no_xla_auto_jitr rr\c&dtdtfd}|S)NrJrXc:fd}tj|S)z-Allow fallback to TF even though testing xla.ctr4tjd}|i|}tj||S|i|Sr5)r^rTF_SetXlaEnableLazyCompilation)rr old_valuer^rJs r]rzFxla_allow_fallback..xla_allow_fallback_impl..decorated sM  &DDTJ t&v&88C T$V$$r\rvr+s` r]xla_allow_fallback_implz3xla_allow_fallback..xla_allow_fallback_impl s %  & &tY 77r\r)rrs r]xla_allow_fallbackr s8B828" ! r\c>dtdtfdtdfd}|S)aExecute test with TensorFloat-32 disabled. While almost every real-world deep learning model runs fine with TensorFloat-32, many tests use assertAllClose or similar methods. TensorFloat-32 matmuls typically will cause such methods to fail with the default tolerances. Args: description: A description used for documentation purposes, describing why the test requires TensorFloat-32 to be disabled. Returns: Decorator which runs a test with TensorFloat-32 disabled. rV.rXrTcjtjfd}tj|S)Nctj} tjd|i|tj|y#tj|wxYwrZ)r'!tensor_float_32_execution_enabled enable_tensor_float_32_execution)rrallowedrVs r]rzArun_without_tensor_float_32..decorator..decorated sN88:g9//6 46//8//8s A A!)rrrLrwrls` r]rtz.run_without_tensor_float_32..decorator s3__Q99  & &q) 44r\ry)rrts r]run_without_tensor_float_32r  s+$ 58CH% 5(9*= 5 r\c"tt|S)z:Execute all tests in a class with TensorFloat-32 disabled.)rr )rs r]run_all_without_tensor_float_32r" s 9; GGr\cZtjru|jdk(rftj|d}tj|d}tj ||g|i|}tj||jStjru|jdk(rftj|d}tj|d}tj ||g|i|}tj||jStj ||g|i|S)aRun matmul but cast float32 inputs to float64 if TensorFloat-32 is enabled. This effectively runs matmul without TensorFloat-32. It should only be used in tests when verifying some other op or functions works correctly, e.g. to test `tf.linalg.sqrtm` by matrix multiplying the output of the op by itself. In such cases, the matmul itself is not being tested so it's OK to run it with higher precision. If a matmul itself is being tested, or some other op which uses matmul, use `run_without_tensor_float_32` instead. This also casts complex64 inputs to complex128, since TensorFloat-32 can also be used with complex64 Args: a: First input to tf.linalg.matmul b: Second input to tf.linalg.matmul args: Other positional arguments to tf.linalg.matmul **kwargs: Other keyword arguments to tf.linalg.matmul Returns: A tensor with the same type as `a`. float32float64 complex64 complex128)r'rdtyper=r matmul)rrrrrets r]matmul_without_tf32r+ s0 --/AGGy4H a#A a#A //!Q 0 0 0C ==agg && //1agg6L a&A a&A //!Q 0 0 0C ==agg && ??1a 1$ 1& 11r\ceZdZdZy)EagerSessionWarnerctd)NaCTrying to access properties or call methods on the result of self.session(), self.cached_session(), etc while eager execution is enabled. If you're porting this test case to TF 2.0, either adapt the test to work with eager execution or insert a call to tf.disable_eager_execution() in the main() function of this test file.)r)rirs r] __getattr__zEagerSessionWarner.__getattr__ s   r\N)rrrrr/r[r\r]r-r- sr\r-z test.TestCaseceZdZdZdEfd ZfdZefdZfdZdZ de fdZ e jdeefd ZdFd Z dFd Zej(ej*d fd ZdGdZdZdZdeej8ej<d ffdZe j dHde e!jDde e#jHde%de%dee&jNf dZ(e j dHde e!jDde e#jHde%de%dee&jNf dZ)e je*jVd d dHde e!jDde e#jHde%de%dee&jNf dZ,Gdde-Z. dFde/de0fde e1e0dfde e2e e0fde.fd Z3e4dGd!Z5e4dGd"Z6d#Z7e4dGd$Z8d%Z9d&Z:dId'Z; dJd(Ze4dId+Z?e4dGd,Z@e4dGd-ZAe4d.ZBe4d/ZCe4d0ZDe4d1ZEdLd2ZFe4 dMd3ZGe4d4ZHe4d5ZIe jd6ZJd7ZKeLjfd8ZNdGd9ZOdGd:ZPe4dGfd; ZQd<ZRd=ZSdGd>ZTdNd?ZUeVjjZYeVjjZ[e jd@e&jNde%de%dee&jNfdAZ\de e!jDde e#jHde%de&jNfdBZ] dOde e!jDde e#jHde%dCe%de&jNf dDZ^xZ_S)PrWz2Base class for tests that need to test TensorFlow.ct||tjt rit j dt jdt jdt jdt jdtrdtj_ n#tdtj_ g|_d|_d|_d|_d|_y)N2rFT)rrrNdisable_traceback_filteringr^rTF_SetXlaAutoJitModeTF_SetXlaMinClusterSizerTF_SetTfXlaCpuGlobalJitrrar$enable_mlir_bridge_threadsrL_cached_session_test_start_time_set_default_seed)ri methodNamers r]rzTensorFlowTestCase.__init__ s GZ //1,,S1//266u=//588> -1goo*  ! --2goo*DMDMD D"Dr\cdt||jtjt j tjj t j tjjtj|jr#t jt j tj}d|_|j#j%dr|j'dt)j(|_y)N .test_sessionz Not a test.)rrM_ClearCachedSessionrandomseedr1DEFAULT_GRAPH_SEEDnpr0_default_graph_stackrrJr;set_random_seedr?_summary_statewriterrendswithr)timer:)ri summary_staters r]rMzTensorFlowTestCase.setUp& s GMO KK ../IINN;112""$ !!+"@"@A#11MM wwy/* mmM" IIKDr\cFt|tr t|yyr`)r setUpClass_ENABLE_AUTO_BOTH_MODESr)r/rs r]rLzTensorFlowTestCase.setUpClass@ s G&s+r\c8|jNtjd|jt t j |jz d|j D]}|j|jt|)y)Nz time(%s): %ssr) r:rrCrroundrIr8check_terminationr?rrK)rithreadrs r]rKzTensorFlowTestCase.tearDownF s} ( ll?DGGIt'<'<. s  r\T)expand_compositeszUnsupported type ro)r _eval_helperr2 is_sparseSparseTensorValuerrrrrB is_raggedrCRaggedTensorValue _eval_tensor row_splitsrr/ IndexedSlicesIndexedSlicesValuer[rK map_structurerrrqrr)rir3r$s r]rzTensorFlowTestCase._eval_tensor s ~  &    vx ((P  " "6 *001E1E1G171D1D1F171C1C1I1I1KM M $ $V ,$66 . 1 124 4 < < =22]]((*nn**,##+M M281C1C1I1I1K M M VW %(6<<*@<<> ! %%&968<> > P,T&\-B-B,EQGHaOPs8A3GAG7A-G%G0G5G G?#G::G?cH|ytj|j|Sr`)rKrr)ritensorss r]rzTensorFlowTestCase._eval_helper s#    d// 99r\c^tjr|j|Stj}t j |}|+|j5}|j|}dddn|j|}t j|S#1swYxYw)zEvaluates tensors and returns numpy values. Args: tensors: A Tensor or a nested list/tuple of Tensors. Returns: tensors numpy values. N) r$rrr0get_default_sessionrKr'rrpack_sequence_as)rirsessflattened_tensorsflattened_resultss r]rzTensorFlowTestCase.evaluate s  "   w ''  $ $ &d,,w/      :D"hh'89  : :!HH%67  " "7,= >>  : :s !B##B,rr'r5rc#Ktjr ty|j|||5}|j |||5|ddddddy#1swYxYw#1swYyxYww)asA context manager for a TensorFlow Session for use in executing tests. Note that this will set this session and the graph as global defaults. Use the `use_gpu` and `force_gpu` options to control where ops are run. If `force_gpu` is True, all ops are pinned to `/device:GPU:0`. Otherwise, if `use_gpu` is True, TensorFlow tries to run as many ops on the GPU as possible. If both `force_gpu and `use_gpu` are False, all ops are pinned to the CPU. Example: ``` python class MyOperatorTest(test_util.TensorFlowTestCase): def testMyOperator(self): with self.session(): valid_input = [1.0, 2.0, 3.0, 4.0, 5.0] result = MyOperator(valid_input).eval() self.assertEqual(result, [1.0, 2.0, 3.0, 5.0, 8.0] invalid_input = [-1.0, 2.0, 7.0] with self.assertRaisesOpError("negative input not supported"): MyOperator(invalid_input).eval() ``` Args: graph: Optional graph to use during the returned session. config: An optional config_pb2.ConfigProto to use to configure the session. use_gpu: If True, attempt to run as many ops as possible on GPU. force_gpu: If True, pin all ops to `/device:GPU:0`. Yields: A Session object that should be used as a context manager to surround the graph building and execution code in a test case. N)r$rr-_create_session"_constrain_devices_and_set_default)rirr'r5rrs r]rzTensorFlowTestCase.session= swV  "     vy 9T  4 4T7I N *   s45A9A- A!A- A9!A* &A--A62A9c#Ktjrt|y|j|||d}|j |||5}|dddy#1swYyxYww)a?Returns a TensorFlow Session for use in executing tests. This method behaves differently than self.session(): for performance reasons `cached_session` will by default reuse the same session within the same test. The session returned by this function will only be closed at the end of the test (in the TearDown function). Use the `use_gpu` and `force_gpu` options to control where ops are run. If `force_gpu` is True, all ops are pinned to `/device:GPU:0`. Otherwise, if `use_gpu` is True, TensorFlow tries to run as many ops on the GPU as possible. If both `force_gpu and `use_gpu` are False, all ops are pinned to the CPU. Example: ```python class MyOperatorTest(test_util.TensorFlowTestCase): def testMyOperator(self): with self.cached_session() as sess: valid_input = [1.0, 2.0, 3.0, 4.0, 5.0] result = MyOperator(valid_input).eval() self.assertEqual(result, [1.0, 2.0, 3.0, 5.0, 8.0] invalid_input = [-1.0, 2.0, 7.0] with self.assertRaisesOpError("negative input not supported"): MyOperator(invalid_input).eval() ``` Args: graph: Optional graph to use during the returned session. config: An optional config_pb2.ConfigProto to use to configure the session. use_gpu: If True, attempt to run as many ops as possible on GPU. force_gpu: If True, pin all ops to `/device:GPU:0`. Yields: A Session object that should be used as a context manager to surround the graph building and execution code in a test case. Tcrash_if_inconsistent_argsN)r$rr_get_cached_sessionrrirr'r5rrcacheds r]cached_sessionz!TensorFlowTestCase.cached_sessiono spZ  " T ""  % % t&Ed  2 243< >AG sA A' A A'A$ A'z8Use `self.session()` or `self.cached_session()` instead.c#K|jjdr|jdtjrdy|6|j |||d}|j |||5}|dddy|j||||5}|dddy#1swYyxYw#1swYyxYww)zUse cached_session instead.r>zTests that have the name "test_session" are automatically skipped by TensorFlow test fixture, as the name is reserved for creating sessions within tests. Please rename your test if you have a test with this name.NFr)rrHr)r$rrrrrs r]rzTensorFlowTestCase.test_session s wwy/* mm    " j '' 69(H  4 4T75>@ CI,  \\%) < *       s6A4B>6B&;B>B2 B>&B/+B>2B;7B>c eZdZdZ ddddedefdeeedfdeee effd Z dd Z dd Z dd Z d efdZddZy)!TensorFlowTestCase._CheckedThreadzA wrapper class for Thread that asserts successful completion. This class should be created using the TensorFlowTestCase.checkedThread() method. NtestcaserWr.rrc||_||_|dn||_|in||_t j |j |_d|_d|_ y)aConstructs a new instance of _CheckedThread. Args: testcase: The TensorFlowTestCase for which this thread is being created. target: A callable object representing the code to be executed in the thread. args: A tuple of positional arguments that will be passed to target. kwargs: A dictionary of keyword arguments that will be passed to target. Nr[rF) _testcase_target_args_kwargs threadingThread_protected_run_thread _exception_is_thread_joined)rirrrrs r]rz*TensorFlowTestCase._CheckedThread.__init__ sS  dndl*.,BDdj+1>Rvdl%%T-@-@Adldo$dr\rXc |j|ji|jy#t$r}||_Yd}~yd}~wwxYw)z?Target for the wrapper thread. Sets self._exception on failure.N)rrrrr)rir$s r]rz0TensorFlowTestCase._CheckedThread._protected_run s; djj1DLL1 s&) A>Ac8|jjy)zStarts the thread's activity. This must be called at most once per _CheckedThread object. It arranges for the object's target to be invoked in a separate thread of control. N)rstartrTs r]rz'TensorFlowTestCase._CheckedThread.start s  llr\cd|_|jj|j2|jj dt |jzyy)zBlocks until the thread terminates. Raises: self._testcase.failureException: If the thread terminates with due to an exception. TNzError in checkedThread: %s)rrrrrr|r"rTs r]rz&TensorFlowTestCase._CheckedThread.join sL $d ll  $ 83t;OOP %r\c6|jjS)zReturns whether the thread is alive. This method returns True just before the run() method starts until just after the run() method terminates. Returns: True if the thread is alive, otherwise False. )ris_aliverTs r]rz*TensorFlowTestCase._CheckedThread.is_alive s\\ " " $$r\c|jr|jr tdy|jj dy)aReturns whether the checked thread was properly used and did terminate. Every checked thread should be "join"ed after starting, and before the test tears down. If it is not joined, it is possible the thread will hang and cause flaky failures in tests. Raises: self._testcase.failureException: If check_termination was called before thread was joined. RuntimeError: If the thread is not terminated. This means thread was not joined with the main thread. zTThread was not joined with main thread, and is still running when the test finished.z A checked thread was not joined.N)rrrrr|rTs r]rPz3TensorFlowTestCase._CheckedThread.check_termination sB    ==?() )  >?r\NNrs)rrrrrrr r rrr"rrrrrrrPr[r\r]_CheckedThreadr s+/+/ %&%c"%uS#X' % c3h( %2 Q %$ %@r\rr.rrcltj||||}|jj||S)afReturns a Thread wrapper that asserts 'target' completes successfully. This method should be used to create all threads in test cases, as otherwise there is a risk that a thread will silently fail, and/or assertions made in the thread will not be respected. Args: target: A callable object to be executed in the thread. args: The argument tuple for the target invocation. Defaults to (). kwargs: A dictionary of keyword arguments for the target invocation. Defaults to {}. Returns: A wrapper for threading.Thread that supports start() and join() methods. )rWrr8r)rirrrr*s r] checkedThreadz TensorFlowTestCase.checkedThread! s1*  + +D&$ GCMM Jr\c |j||k(xstj||z |kd||||d|zndfzy)aAsserts that two floats are near each other. Checks that |f1 - f2| < err and asserts a test failure if not. Args: f1: A float value. f2: A float value. err: A float value. msg: An optional string message to append to the failure message. z%f != %f +/- %f%sNz (%s)rw) assertTruemathfabs)rif1f2errrhs r] assertNearzTensorFlowTestCase.assertNear; sN OO b-DIIb2g&#-/B RsgmB?0@Ar\c|jt|t||t||D],\}}|jt |t |||.y)aJAsserts that two float arrays are near each other. Checks that for all elements of farray1 and farray2 |f1 - f2| < err. Asserts a test failure if not. Args: farray1: a list of float values. farray2: a list of float values. err: a float value. msg: Optional message to report on failure. rwN)rrrrfloat)rifarray1farray2rrhrrs r]assertArrayNearz"TensorFlowTestCase.assertArrayNearM sW S\3w>(X- . 44r\cL|j|j||||y)zAsserts that two numpy arrays have near values. Args: ndarray1: a numpy ndarray. ndarray2: a numpy ndarray. err: a float. The maximum absolute difference allowed. msg: Optional message to report on failure. rwN)rr)rirrrrhs r]assertNDArrayNearz$TensorFlowTestCase.assertNDArrayNeara s# OOD%%h#>COHr\ctj|rYd} ~ yd} ~ wwxYw#t&$rT} d|dt3|d |dt3|d | }| j4ddz|zf| j4ddz| _d} ~ wwxYw)N[z][c32K|]}t|ywr`r!)r#rs r]r%z>TensorFlowTestCase._assertAllCloseRecursive.. s 6AQ 6s]rw_asdictz!Can't compare dict to non-dict, az vs b. zmismatched keys: az has keys z, but brw)rrrrhrzMismatched value: az is different from brrrhz=Mismatched length: a%s has %d items, but b%s has %d items. %szError: az has r : r)rBr_assertRaggedCloserr[rrrOMappingrassertItemsEqualrr_assertAllCloseRecursiverrrrrrNotImplementedErrorrrrr"rqr)rirrrrrrhpath_str a_is_dictr a_as_ndarray b_as_ndarrayr$ra_eleb_eles r]rz+TensorFlowTestCase._assertAllCloseRecursive sq!]%<% !!!QT#!Fr\c &|j||\}}|j|}|j|}|jtjk(sW|jtjk(s:|jtj k(s|jtj k(rt ||}t ||}|jtjk(s|jtjk(rt ||}t ||}|jtjjk(s'|jtjjk(rt || }t || }|j||||| y)aLike assertAllClose, but also suitable for comparing fp16 arrays. In particular, the tolerance is reduced to 1e-3 if at least one of the arguments is of type float16. Args: a: the expected numpy ndarray or anything can be converted to one. b: the actual numpy ndarray or anything can be converted to one. rtol: relative tolerance. atol: absolute tolerance. float_rtol: relative tolerance for float32. float_atol: absolute tolerance for float32. half_rtol: relative tolerance for float16. half_atol: absolute tolerance for float16. bfloat16_rtol: relative tolerance for bfloat16. bfloat16_atol: absolute tolerance for bfloat16. msg: Optional message to report on failure. rN) rrr(rCr$r&maxfloat16r*rrr) rirrrr float_rtol float_atol half_rtol half_atol bfloat16_rtol bfloat16_atolrhs r]assertAllCloseAccordingToTypez0TensorFlowTestCase.assertAllCloseAccordingToType3 s$> * *1a 0FQ A A 2::BJJ!6 2<<177bll#: z "d z "dww"**2:: 5 y !d y !d 6??111 6??111 } %d } %d14d )C G#M NN    s , 88c tj|stj|r|j|||S|r|nd}|j||\}}|j |}|j |}|j dks|j dkrI|j|j|jd|jd|jd|d|d nD|j|j|jd|jd|jd |||k(}tj|jjrPtj|tjtj |tj |}|g}tj"|stj$|}|j rF|t'|}|t'|}|j)d j+t'|n||}}|j)d |z|j)d |z|jj,|jj,k7r|jj,|jj,hj/hd rg} g} | |j0f| |j0ffD]N\} } | D]D} t3| t4r!| j)| j7d4| j)| FPtj8| }tj8| }tj:j=||dj?|yy)aAsserts that two numpy arrays or Tensors have the same values. Args: a: the expected numpy ndarray or anything can be converted to one. b: the actual numpy ndarray or anything can be converted to one. msg: Optional message to report on failure. rwrrrrz . Contents: z. rorznot equal where = {}znot equal lhs = %rznot equal rhs = %r>OSUzutf-8r)rN) rBr_assertRaggedEqualrrrrrrr*as_dtyper( is_floatingrCr logical_andrr logical_notrPrr*kindissubsetflatrr"encoderrassert_array_equalr)rirrrhsamerrr|ra_listb_listout_listflat_arritems r]assertAllEqualz!TensorFlowTestCase.assertAllEqual} s "m&=&=a&@  $ $Q3 //#"C  * *1a 0FQ A A ! qvv|  ''177$%GGQWWa>?  ''17777AGGS*+ FD qww++ ]]4 RXXa[!I Jd 5D 66$< ^^D !d  htn  htn  *11(4.AB!1 kk&*+ kk&*+ '',,!'',, & 77<< & / / @%+AFF#3faff5E"F $ Hh $d$$oodkk'23ood#  $ $ HHV  HHV jj##Aq$))D/#B9 r\cn |j|||xsd}td|z#t$rYywxYw)aAsserts that two numpy arrays or Tensors do not have the same values. Args: a: the expected numpy ndarray or anything can be converted to one. b: the actual numpy ndarray or anything can be converted to one. msg: Optional message to report on failure. Nrwz,The two values are equal at all elements. %s)r1r)rirrrhs r]assertNotAllEqualz$TensorFlowTestCase.assertNotAllEqual sG  !Q )C G#M NN    s ( 44c|j||\}}|j|}|jtj||y)zAssert element values are all greater than a target value. Args: a: The numpy `ndarray`, or anything that can be converted into a numpy `ndarray` (including Tensor). comparison_target: The target value of comparison. N)rr assertGreaterrCminrircomparison_targets r]assertAllGreaterz#TensorFlowTestCase.assertAllGreater sF"::1>OPQ Arvvay"34r\c|j||\}}|j|}|jtj||y)zAssert element values are all less than a target value. Args: a: The numpy `ndarray`, or anything that can be converted into a numpy `ndarray` (including Tensor). comparison_target: The target value of comparison. N)rr assertLessrCrr7s r] assertAllLessz TensorFlowTestCase.assertAllLess sD"::1>OPQ AOOBFF1I01r\c|j||\}}|j|}|jtj||y)aAssert element values are all greater than or equal to a target value. Args: a: The numpy `ndarray`, or anything that can be converted into a numpy `ndarray` (including Tensor). comparison_target: The target value of comparison. N)rrassertGreaterEqualrCr6r7s r]assertAllGreaterEqualz(TensorFlowTestCase.assertAllGreaterEqual sF"::1>OPQ ABFF1I'89r\c|j||\}}|j|}|jtj||y)zAssert element values are all less than or equal to a target value. Args: a: The numpy `ndarray`, or anything that can be converted into a numpy `ndarray` (including Tensor). comparison_target: The target value of comparison. N)rrassertLessEqualrCrr7s r]assertAllLessEqualz%TensorFlowTestCase.assertAllLessEqual sF"::1>OPQ A$56r\c |g}tj|}d|z}tj|dk(r|dzt|zgSt j ||D]:}|j |t|zdzt|t|z<t||kDr|j |dz|S)a@Generate a summary of ndarray subscripts as a list of str. If limit == N, this method will print up to the first N subscripts on separate lines. A line of ellipses (...) will be appended at the end if the number of subscripts exceeds N. Args: subscripts: The tensor (np.ndarray) subscripts, of the same format as np_where()'s return value, i.e., a tuple of arrays with each array corresponding to a dimension. E.g., (array([1, 1]), array([0, 1])). value: (np.ndarray) value of the tensor. limit: (int) The maximum number of indices to print. indent: (int) Number of characters to indent at the beginning of each line. Returns: (list of str) the multi-line representation of the subscripts and values, potentially with omission at the end. rrz[0] : rz...) rCrrr"rislicerrr)ri subscriptsrlimitindentlinesprefix subscripts r]_format_subscriptsz%TensorFlowTestCase._format_subscripts s* Ej)J 6\F wwu~x#e*, --%%j%81  ll6C N*U2uU9-./011 : ll6E>" Lr\c 6|j|}tj|jtjsItj|jtj st d|d|jttj|}tj|rQt dt|dtj|fzdj|j||z|rdndt|zdzt|z|rd nd z}|rtj||ntj||}tj ||rtj"||ntj$||}t|} tj| rUt d t| dtj||fzd zdj|j| |zy )aAssert that elements in a Tensor are all in a given range. Args: target: The numpy `ndarray`, or anything that can be converted into a numpy `ndarray` (including Tensor). lower_bound: lower bound of the range upper_bound: upper bound of the range open_lower_bound: (`bool`) whether the lower bound is open (i.e., > rather than the default >=) open_upper_bound: (`bool`) whether the upper bound is open (i.e., < rather than the default <=) Raises: AssertionError: if the value tensor does not have an ordered numeric type (float* or int*), or if there are nan values, or if any of the elements do not fall in the specified range. z The value of z= does not have an ordered numeric type, instead it has type: zS%d of the %d element(s) are NaN. Subscripts(s) and value(s) of the NaN element(s): rr(rr)rz2%d of the %d element(s) are outside the range %s. z5Subscript(s) and value(s) of the offending elements: N)rrC issubdtyper(floatingintegerrrPrrrrrKr" less_equallessr greater_equalgreater) rir lower_bound upper_boundopen_lower_boundopen_upper_boundnan_subscripts range_str violationsviolation_subscriptss r]assertAllInRangez#TensorFlowTestCase.assertAllInRanges4  f %F MM&,, 4 MM&,, 3 "FLL 2 33bhhv./N ww~  @ ~a !2776? 3 4 ))D++NFC D E FF *#sc+6FFM[!", #A& ') D E B C ))D++,@&I J K LL%r\c|j|}tj|jt |}tj |r$t dtj |||fzy)aAssert that elements of a Tensor are all in a given closed set. Args: target: The numpy `ndarray`, or anything that can be converted into a numpy `ndarray` (including Tensor). expected_set: (`list`, `tuple` or `set`) The closed set that the elements of the value of `target` are expected to fall into. Raises: AssertionError: if any of the elements do not fall into `expected_set`. z.%d unique element(s) are not in the set %s: %sN)rrC setdiff1dr'rrr)rir expected_setrs r]assertAllInSetz!TensorFlowTestCase.assertAllInSetYsk  f %F <<($|*< =D wwt} KGGDM<>? @@r\c|j|}t|ts|g}D]}|j|j| y)zAssert ndarray data type is equal to expected. Args: target: The numpy `ndarray`, or anything that can be converted into a numpy `ndarray` (including Tensor). expected_dtype: Expected data type. N)rrrrr()rirexpected_dtypearraysarrs r]assertDTypeEqualz#TensorFlowTestCase.assertDTypeEqualosH  f %F fd #xf2 syy.12r\c #&Ktr}nfd} d|j|jdzy#t$rJ}t ||r||s,t dt t|dt |Yd}~yd}~wwxYww)aReturns a context manager to enclose code expected to raise an exception. If the exception is an OpError, the op stack is also included in the message predicate search. Args: exception_type: The expected type of exception that should be raised. expected_err_re_or_predicate: If this is callable, it should be a function of one argument that inspects the passed-in exception and returns True (success) or False (please fail the test). Otherwise, the error message is expected to match this regular expression partially. Returns: A context manager to surround code that is expected to raise an exception. ctt|tjrAttj|}tt|j }|j }n t |}d}|!|d|jzz }|j}|!tjd|tj|S)Nz Caused by: z0Searching within error strings: '%s' within '%s') rr+OpErrorr r"rrr{ _original_oprrCrsearch)r$err_strrexpected_err_re_or_predicates r] predicatezDTensorFlowTestCase.assertRaisesWithPredicateMatch..predicates a (6>>1%!aii('tt"F'"n _rww. .'"n  G17 <yy5w??r\Nz not raisedzException of type z: )rr|rrrrrr"rq)riexception_typernror$s ` r]assertRaisesWithPredicateMatchz1TensorFlowTestCase.assertRaisesWithPredicateMatchs&,-.i @5  ii''-78 5 > *)A,!$q'lCF45 53?5s,B";B BAB B BBcB|jtj|Sr`)rqr+rj)rirns r]assertRaisesOpErrorz&TensorFlowTestCase.assertRaisesOpErrors  . .v~~/K MMr\c&|j|dS)NzJIncompatible shapes|Dimensions must be equal|required broadcastable shapes)rq)rirps r]#assertRaisesIncompatibleShapesErrorz6TensorFlowTestCase.assertRaisesIncompatibleShapesErrors  . .) **r\c|t|tjtjtj fst dt|t|tjtjtj fst dt|t|tj r|jjn |j}t|tj r|jjn |j}|j|||y)aAsserts that two Numpy or TensorFlow objects have the same shape. For Tensors, this compares statically known shapes at compile time, not dynamic shapes at runtime. Args: input_a: A Numpy ndarray, Numpy scalar, or a Tensor. input_b: A Numpy ndarray, Numpy scalar, or a Tensor. msg: Optional message to report on failure. Raises: TypeError: If the arguments have the wrong type. zLinput_a must be a Numpy ndarray, Numpy scalar, or a Tensor.Instead received zLinput_b must be a Numpy ndarray, Numpy scalar, or a Tensor.Instead received rwN) rrCrgenericrrrrq get_shaperrr1)riinput_ainput_brhshape_ashape_bs r]assertShapeEqualz#TensorFlowTestCase.assertShapeEquals g BJJ 8I8IJ K  "7m_ . // g BJJ 8I8IJ K  "7m_ . //0:""0$g!))+)0 /9""0$g!))+)0 c2r\c tj|}tj|}|j||d|d|d|y)aAsserts that the two given devices are the same. Args: device1: A string device name or TensorFlow `DeviceSpec` object. device2: A string device name or TensorFlow `DeviceSpec` object. msg: Optional message to report on failure. zDevices rnz are not equal. N)pydevcanonical_namer)ridevice1device2rhs r]assertDeviceEqualz$TensorFlowTestCase.assertDeviceEqualsB""7+G""7+G18'3GIr\c t||||y#t$r|j|j |j |j D]\}}|j |||\}}|j|}|j|}tj|jtjr|j|||||j||||YywxYw)a[Assert that two given dictionary of tensors are the same. Args: a: Expected dictionary with numpy ndarray or anything else that can be converted to one as values. b: Actual dictionary with numpy ndarray or anything else that can be converted to one as values. msg: Optional message to report on failure. rwN)rassertDictEqualrassertSameElementsrr@rrrCrOr(rPrr1) rirrrhrva_kb_krs r]rz"TensorFlowTestCase.assertDictEquals . gaC(  . affh1'').$!Q221ad; cs#s# ==BKK 0   a11  -   a11  -. .sC&C>=C>cPt|tjr9ttj |j |}|jSt|tjr=|j |}t|tjr|jS|St|tjr|jSt|tj r|jStj|tjS)z%Converts `a` to a nested python list.r)rrB RaggedTensorr rCrrto_listrrrCrtolistrr)rirs r] _GetPyListzTensorFlowTestCase._GetPyLists!]//0 "44dmmA6F Ga YY[ Az(( ) -- a%a4QXXZ;!; Arzz " XXZ A*<< = YY[ XXav & - - //r\c||j|}|j|}|j|||t|ttfsqt|ttfsZt j |r |jnd}t j |r |jnd}|j|||yyy)z*Asserts that two ragged tensors are equal.rN)rrrrrrBr ragged_rank)rirrrhr,r- a_ragged_rank b_ragged_ranks r]r!z%TensorFlowTestCase._assertRaggedEqual s __Q F __Q FVVS) q4- (Jq4-,H'4'>'>q'Aammqm'4'>'>q'Aammqm }mS9-I (r\c|j|}|j|}|j|||||t|ttfsqt|ttfsZt j |r |jnd}t j |r |jnd} |j|| |yyyr) r_assertListCloseRecursiverrrrBrrr) rirrrrrhr,r-rrs r]rz%TensorFlowTestCase._assertRaggedCloses __Q F __Q F""664sC q4- (Jq4-,H'4'>'>q'Aammqm'4'>'>q'Aammqm }mS9-I (r\c Z|jt|t|t|ttfr[|j |t |d|ztt |D]$}|j||||||||d|d&y|j||||||y)NzLength differs for %srr) rrqrrr assertLenrr_rr)rirrrrrhrrs r]rz,TensorFlowTestCase._assertListCloseRecursive!sT!Wd1g&!dE]# nnQA 7$ >?SV}=! &&qtQqT4s37'; == ##Aq$dC@r\rc#Ktjrdy|jj5|j5|r7t }|sd}|jj |5|dddn/|r|n(|jj d5|dddddddddy#1swYxYw#1swY&xYw#1swY*xYw#1swYyxYww)zFSet the session and its graph to global default and constrain devices.NrrA)r$rrrr}r))rirr5rgpu_names r]rz5TensorFlowTestCase._constrain_devices_and_set_default6s   " j :: " DOO$5  %&(&Hzz  * J   *zz  1 J             sd4C1C%,C3C8+C#C (C0C%8 C1C C C CC" C%%C.*C1cdttjdtjffd }t|||S)zSee session() for details.r'rXc }|&tjj}||_n5|s3|jr'tjj}|}d|_d|jj_t jj|jj_ t jj|jj_ |S)zReturns a config for sessions. Args: config: An optional config_pb2.ConfigProto to use to configure the session. Returns: A config_pb2.ConfigProto object. Fr) r$r'allow_soft_placement graph_optionsoptimizer_options opt_levelrRewriterConfigOFFrewrite_optionsconstant_foldingpin_to_host_optimization)r'r config_copyrs r]prepare_configz:TensorFlowTestCase._create_session..prepare_configUs"+] "))&:##(C(Coo'.. &+#:"//0"   "H U>&3I JJr\rc8|j2|j|||}||_||_||_||_|S|r|j|ur t d|r|j|ur t d|r|j|ur t d|jS)z'See cached_session() for documentation.)rr'rzThe graph used to get the cached session is different than the one that was used to create the session. Maybe create a new session with self.session()zThe config used to get the cached session is different than the one that was used to create the session. Maybe create a new session with self.session()zThe force_gpu value used to get the cached session is different than the one that was used to create the session. Maybe create a new session with self.session())r9r _cached_graph_cached_config_cached_force_gpur)rirr'rrrs r]rz&TensorFlowTestCase._get_cached_session{s #  ! !f ";d!d d"d(d k #(:(:%(G*+ + $(;(;6(I*+ + $)?)?-6*7    ! !!r\)runTestrr`NNTF)ư>rN)rrNN) rrrrMbP?r{Gz?rN) rFF)r)NNFT)`rrrrrrrM classmethodrLrKr?r"rZ contextlibcontextmanagerrrrerlrr7GRAPH_DEF_VERSIONGRAPH_DEF_VERSION_MIN_CONSUMERrzrrrr rCrr2rrr r0rrrrrSessionrrrJ deprecatedrrrrr rrrrmrrrrrrrrrrrr1r3r9r<r?rBrKr^rbrgrqrsr+InvalidArgumentErrorrur}rrrr!rrrETestCaseassertRaisesRegexassertRaisesRegexpassertCountEqualrrrrrrs@r]rWrW s:"<(4,, " C$*Xn-E**X<  -f))::  6 !PF: ? ++%%  ?:$(15 / cii /z--./ /  /   //b$(15 3 cii 3z--.3 3  3   33j;$!=>$(15  cii z--.      >:Z@vZ@~)-)- sCx  U38_ %tCH~&   4AA":: 5 I I 48Oz%)$($(#' GRGG@*.)-/3/3.2.22626(,.=.=`OO09C9Cv O O 5 5 2 2 : : 7 7B ).(- 8L8Lt@@* 2 2+5+5^M "66* 38 I..2 0 ::A"**<< ((99))&*7; ,,K cii ,Kz--.,K ,K  yy ,K`$(15)- "" cii ""z--."" "" #' ""  yy ""r\ASSIGNED_PORTSc6ddl}t5 |j}|dkDr>|t vr6t j|tjd||cdddSU#|j$r}t j d|d}~wwxYw#1swYyxYw)z,Returns an unused and unassigned local port.rNz@Flakes in portpicker library do not represent TensorFlow errors.i'zUsing local port %r) portpickerlockpick_unused_portNoFreePortFoundErrorrArIraddrrC)rport porterrors r]rrs  F**, $n44  *D1    , ,F!67K Gdd}|y#wxYww)ztf.gradients(...) implemented as tf.GradientTape context manager interface. This is useful to test tf.gradients() in tests that uses tf.GradientTape(). Yields: gradient tape instance that's implemented by tf.gradients() underneath. ceZdZdZddZy)=_fake_gradient_tape_context_manager..FakeGradientTapecyr`r[)rir|s r]watchzC_fake_gradient_tape_context_manager..FakeGradientTape.watch;s r\Nctj|||}t|ttfst |dk(sJ|dS|Sr)r< gradientsrrrr)rirr|grad_ysr^s r]gradientzF_fake_gradient_tape_context_manager..FakeGradientTape.gradient>sG))!Q8!dE]+V! !!  r\r`)rrrrrrr[r\r]FakeGradientTaper9s   r\rNr[)rs r]#_fake_gradient_tape_context_managerr/s&   Dsc>eZdZdZddZdej fdZdZy)AbstractGradientTapezAbstract GradientTape context manager that has multiple implementations. This is useful to test both tf.GradientTape() and tf.gradients() without duplicating tests. c ||_||_yr`) _use_tape _persistent)riuse_tape persistents r]rzAbstractGradientTape.__init__UsDN!Dr\rXc|jr&tj|j|_nt |_|jj S)N)r)rr# GradientTaper _tape_implr __enter__rTs r]rzAbstractGradientTape.__enter__Ys> ~~ --9I9IJdo;=do ?? $ $ &&r\c>|jj|||yr`)r__exit__)riexc_typeexc_valexc_tbs r]rzAbstractGradientTape.__exit__`sOOXw7r\Nr) rrrrrrr#rrrr[r\r]rrNs# "'..'8r\rrDc#tKt|tstdj|t j }|s|rt jdtj}tj| dtj|y#tj|wxYww)aFRuns functions eagerly if `run_eagerly` is true. WARNING: Setting `run_eagerly` to True in tests running in V1 graph mode *WILL NOT* make the tf.function to run eagerly because eager is disabled by default in V1. Instead, tf.function will run as a traced graph function. Ensures that the state (for running functions eagerly) is back to the initial `def_function.RUN_FUNCTIONS_EAGERLY` state. Args: run_eagerly: Boolean determining whether to run the function eagerly or not. Raises: ValueError if `run_eagerly` is not a boolean. Yields: Nothing. z*Expected bool for `run_eagerly` but got {}zrRunning tf.function eagerly in V1 graph mode is not supported. tf.function will be run as a traced graph function.N) rrrr*r$rrwarningr%functions_run_eagerlyrun_functions_eagerly)rDis_eager initial_states r]rrds( K & 4;;KH JJ & & (( k OO >?446-$$[16 &&}5L&&}5sBB8BB8B55B8c*eZdZdZdZddZdefdZy) TestDeltaz5A utility class to track increments to test counters.c@||_||_|jyr`)r{labelReset)rir{rs r]rzTestDelta.__init__sDIDJJJLr\rXNcbtj|j|j|_yr`r&test_counter_valuer{r last_valuerTs r]r zTestDelta.Resets!(;; 4::DOr\cttj|j|j}||jz Sr`r )rirs r]Getz TestDelta.Gets+  1 1$))TZZ HE 4?? ""r\rs)rrrrrrr rrr[r\r]rrs= #3#r\rztest.experimental.sync_devicesc0tjs tdtj}|D]>}t j |j5tjddd@tjy#1swY_xYw)aSynchronizes all devices. By default, GPUs run asynchronously. This means that when you run an op on the GPU, like `tf.linalg.matmul`, the op may still be running on the GPU when the function returns. Non-GPU devices can also be made to run asynchronously by calling `tf.config.experimental.set_synchronous_execution(False)`. Calling `sync_devices()` blocks until pending ops have finished executing. This is primarily useful for measuring performance during a benchmark. For example, here is how you can measure how long `tf.linalg.matmul` runs: >>> import time >>> x = tf.random.normal((4096, 4096)) >>> tf.linalg.matmul(x, x) # Warmup. >>> tf.test.experimental.sync_devices() # Block until warmup has completed. >>> >>> start = time.time() >>> y = tf.linalg.matmul(x, x) >>> tf.test.experimental.sync_devices() # Block until matmul has completed. >>> end = time.time() >>> print(f'Time taken: {end - start}') If the call to `sync_devices()` was omitted, the time printed could be too small. This is because the op could still be running asynchronously when the line `end = time.time()` is executed. Raises: RuntimeError: If run outside Eager mode. This must be called in Eager mode, outside any `tf.function`s. zFsync_devices() must only be called in Eager mode, outside tf.functionsN) r$rrr'list_logical_devicesr0r)r{r; SyncDevice async_wait)devicesrs r] sync_devicesrs@  " " $ P   ' ' )'  c CHH        s B  B )r[rrsr`)rrrZ)rwrr)NTNr)FN)grpcNN(rrmrcollections.abcrrrrrrrrorrrr@rrWrrItypingr r r r r rrA absl.testingrrrCgoogle.protobufrrrtensorflow.core.configrtensorflow.core.frameworkrrrtensorflow.core.protobufrrrtensorflow.pythonrrtensorflow.python.clientrrrrtensorflow.python.compatr tensorflow.python.compat.compatr"tensorflow.python.eagerr#r$r%tensorflow.python.frameworkr&r'r)rr*r+r,r-r.r/r0r1r2r3rr4r5r6r7tensorflow.python.opsr8r9r:r;r<r=r>r?r@tensorflow.python.ops.raggedrArBrCtensorflow.python.platformrDrErFrtensorflow.python.trainingrGtensorflow.python.utilrHrIrJrKrLrMrNtensorflow.python.util.compatrO#tensorflow.python.util.numpy_compatrPtensorflow.python.util.protobufrQ tensorflow.python.util.tf_exportrRrSrUrqrVrr^,tensorflow.python.framework.is_xla_test_truerra5tensorflow.python.framework.is_mlir_bridge_test_false ImportError4tensorflow.python.framework.is_mlir_bridge_test_truercrfrhrjrnr"rtr}rrNodeDefrrrrr MetaGraphDefrrrrrrrrrrrrrrrrrrr rrrrr+r.r2r:rGrMrRrzrrrrrrrrrrrrr rrr,r4rrrrmrtrvrun_deprecated_v1r~rrrrrrrrrrr5rrrrrrrrrr rrrrrrr rrrr r"r+r-rMrWrr__annotations__Lockrrrrrrrrrrrr[r\r]r6s"!#NN   @@&+#'(/20/38/!/61.I,+0:.7..3006+35<4320+36.0*,0+46<A1<14).'/-29836 T#s(+, T] e4 456  I Z-- -- -- .$.  D c]DD !"  # *sCx.), #|## #$: (R06  6*3*<*<6 616, ,-. #( 1   1  11! 1  1/1> #( .   .  ..! .  .6(! (!""(!""(! (!Z5 y/A/A d  7Y-?-?D1T1--,,-- 0:d:*d*86 ))49456 :  d3i '(6*"0 !2!2DI!=>"0 *  T#Y &'"0J !2!2DI!=> :  d3i '(D6 ))49456 :  d3i '(6*uXb$h/568RD"H;M4 -1    Y  CcD()  d^    F  r  tBx DH rb64 c4 c4 n"r0B&r0rr xS!"HY$778rj;3R;3B;3|p8C=psptpfMMM`N4 CH0E+FN2  +c3h   F  #  #   C C &"r"b"J"""J B 2   # b "X  " tBxj$r("#  +,"" $r(  8T"XJR( )48 34-.!2!"!H& s& s& R +S +XrdBh5G ++3+"r(:+\2 38 2 i2j "   04$)  38  Z++ ,"  i   /3$)   Z++ ,"  xS!"HY$778  *./3$) } 8CH% &} Z++ ,}}" }   hsCx !8I#6 67 Y }B$($)DC=D!DxS!"HY$778DN3b3R30 xS1 hy6I F RB  SXc] )6U37^)6c2g)6X/  s  s  <~: 9 rb2r2>"c3m,-" xS!"HY$778"JOQ "#=A77!)%S/!:7 7$Q7t  D Xd^    $    8D>    8D>   $8D>$$  6-6-r  !))  #6#6#6N--"r8J->  2$(); %S%XrdBh%7%%S%XrdBh-?%%c%htRx&8%%c%htRx&8%%c%htRx&8%%s%xb'9% uS"W~c2tm 4452S! seSj<%%2$();%!C!HbT2X,>!. xS!"HY$778FHH3%*9MH #2L    ?X",,X"X"v,5C y~~$ &'6:26 VV VVJ223 V  ../ V  4 !! "D):):$; ;< V(Vr(11 l""#(= =S=T=   <88, "6t"6"6"6J##" +,4-4EA  [    sHi!i*i'&i'*j0i76j7i?<j>i??jj