BVh2dZddlmZddlZddlZddlmZddlmZddlm Z ddlm Z dZ dZ dd Z d Zd Zd Zd ZGddeZy)aUtility functions for comparing proto2 messages in Python. ProtoEq() compares two proto2 messages for equality. ClearDefaultValuedFields() recursively clears the fields that are set to their default values. This is useful for comparing protocol buffers where the semantics of unset fields and default valued fields are the same. assertProtoEqual() is useful for unit tests. It produces much more helpful output than assertEqual() for proto2 messages, e.g. this: outer { inner { - strings: "x" ? ^ + strings: "y" ? ^ } } ...compared to the default output from assertEqual() that looks like this: AssertionError: != Call it inside your unit test's googletest.TestCase subclasses like this: from tensorflow.python.util.protobuf import compare class MyTest(googletest.TestCase): ... def testXXX(self): ... compare.assertProtoEqual(self, a, b) Alternatively: from tensorflow.python.util.protobuf import compare class MyTest(compare.ProtoAssertions, googletest.TestCase): ... def testXXX(self): ... self.assertProtoEqual(a, b) N) descriptordescriptor_pool)message) text_formatcjtj|stj|r+tj|tj|k(Stj|stj|r||k(St||z |t t|t|zkS)a'Returns True if x is close to y given the relative tolerance or if x and y are both inf, both -inf, or both NaNs. This function does not distinguish between signalling and non-signalling NaN. Args: x: float value to be compared y: float value to be compared relative_tolerance: float. The allowable difference between the two values being compared is determined by multiplying the relative tolerance by the maximum of the two values. If this is not provided, then all floats are compared using string comparison. )mathisnanisinfabsmax)xyrelative_tolerances W/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/util/protobuf/compare.pyisCloserHsz ZZ]djjm ::a=DJJqM )) ZZ]djjm 6M QU)CAA,?? ??ct|j|jD]]\}}d}|\}}|d} |jtjj k7rd}|g}| g} |j tjjk(s'|j tjjk(rgtt|| D]O\} \} } t| | |s|r| t||dj| <6t||dj| Q|j tjjk(s)|j tjjk(sG|j tjjk(r|j j"r|j j%j&r|j j(dj tjjk(stt+|j-t+| j-D]\} }t/|| ||;t|| D]\}}t/||||`y)aRecursively replaces the floats in actual with those in expected iff they are approximately equal. This is done because string equality will consider values such as 5.0999999999 and 5.1 as not being equal, despite being extremely close. Args: self: googletest.TestCase expected: expected values actual: actual values relative_tolerance: float, relative tolerance. TFrexpectedactualrN)zip ListFieldslabelrFieldDescriptorLABEL_REPEATEDtype TYPE_FLOAT TYPE_DOUBLE enumeratergetattrnamesetattr TYPE_MESSAGE TYPE_GROUP message_type has_options GetOptions map_entryfields_by_numberitervaluescheckFloatEqAndReplace)selfrrrexpected_fields actual_fields is_repeated expected_descexpected_values actual_valuesirre_va_vvas rr/r/_sD),V..0)5 $o}K%4"M?!!$Mj88GGGk()o$om j88CCC   !;!;!G!G G _m!DE6)!Va 1a+ , 89GFM!,11 21 5 FM!,111 56 j88EEE   !;!;!F!F F    : : G G G((44((335??  & & 7 7 : ? ?))66 7?))+,d=3G3G3I.J  hc3 ##5   7 DAq Qq=O  c5 rctj}t|tr&t j ||j |}||fD];}|r)|j} | r|jd| d||s1t|=|t||||t j||} t j||} t| dkr#t| dkr|j| | |ydjtj | j#d | j#d } | r|j|d | yy) aNFails with a useful error if a and b aren't equal. Comparison of repeated fields matches the semantics of unittest.TestCase.assertEqual(), ie order and extra duplicates fields matter. Args: self: googletest.TestCase a: proto2 PB instance, or text string representing one. b: proto2 PB instance -- message.Message or subclass thereof. check_initialized: boolean, whether to fail if either a or b isn't initialized. normalize_numbers: boolean, whether to normalize types and precision of numbers before comparison. msg: if specified, is used as the error message on failure. relative_tolerance: float, relative tolerance. If this is not provided, then all floats are compared using string comparison otherwise, floating point comparisons are done using the relative tolerance provided. rzInitialization errors:  Nri)msgTz : )rDefault isinstancestrrParse __class__FindInitializationErrorsfailNormalizeNumberFieldsr/MessageToStringlenassertMultiLineEqualjoindifflib unified_diff splitlines) r0r;bcheck_initializednormalize_numbersr>rpoolpberrorsa_strb_strdiffs rassertProtoEqualrXs56  "$3!Q[[]DAA qD b**,f  VR@AB  # q7I  % %a >%  % %a >%  Z%CJ.eU4 77U--d3U5E5Ed5KL ND  iic4() rc |jD]K\}}d}|jtjjk7rd}|g}d}|j tjj tjjtjjfvr|Dcgc] }t|}}n|j tjjtjjtjjtjjfvr|Dcgc] }t|}}n|j tjjk(r|Dcgc]}t|d}}nI|j tjj k(r"|Dcgc]}tt#|d}}|]|rA|j%|j&t)||j&j+|nt-||j&|d|j tjj.k(s)|j tjj0k(sn|j tjj.k(r|j2j4r|j2j7j8rk|j2j:dj tjj.k(st=|j?D] }tA|:|D] }tA|N|Scc}wcc}wcc}wcc}w)aNormalizes types and precisions of number fields in a protocol buffer. Due to subtleties in the python protocol buffer implementation, it is possible for values to have different types and precision depending on whether they were set and retrieved directly or deserialized from a protobuf. This function normalizes integer values to ints and longs based on width, 32-bit floats to five digits of precision to account for python always storing them as 64-bit, and ensures doubles are floating point for when they're set to integers. Modifies pb in place. Recurses into nested objects. Args: pb: proto2 message. Returns: the given pb, modified in place. TFNrr)!rrrrrr TYPE_INT64 TYPE_UINT64 TYPE_SINT64int TYPE_INT32 TYPE_UINT32 TYPE_SINT32 TYPE_ENUMr roundr!float ClearFieldr$r#extendr%r&r'r(r)r*r+r,r-r.rG)rSdescr.r3normalized_valuesrr:s rrGrGs$mmo-#ldFK zzZ//>>>kxf  yyZ//:://;;//;;==,22a3q622 z11<<!11==!11==!11;;= =,22a3q622 j00;; ;06715A;77 j00<< <7=>!5q1->>$  dii DII%%&78DII034 Z//<<< Z//::: ))z11>> >    ' '    & & ( 2 2    . .q 1 6 6  & & 3 3 4 ( %a !! $ % #A  " #W-#^ )C3 37>s%M"1M'1M,2M1c6t|tjSN)rAcollections_abcMappingvalues r_IsMaprp$s E?22 33rc\t|try t|y#t$rYywxYw)NFT)rArBr- TypeErrorrns r_IsRepeatedContainerrs(s0s K   s  ++c2d}||||}}t|trt|ts||k(Stt|j t|j zD] }||vs||vryt ||||r yy)a8Compares two proto2 objects for equality. Recurses into nested messages. Uses list (not set) semantics for comparing repeated fields, ie duplicates and order matter. Args: a: A proto2 message or a primitive. b: A proto2 message or a primitive. Returns: `True` if the messages are equal. ct|tjr td|j DSt |rt|j St|rttt|S|S)aVReturns a dictionary or unchanged pb bases on its type. Specifically, this function returns a dictionary that maps tag number (for messages) or element index (for repeated fields) to value, or just pb unchanged if it's neither. Args: pb: A proto2 message or a primitive. Returns: A dict or unchanged pb. c3>K|]\}}|j|fywrk)number).0rhros r z*ProtoEq..Format..LsJ;44;;&Js) rArMessagedictrrpitemsrsr"list)rSs rFormatzProtoEq..Format?sb"goo& J"--/J JJ  "((*  b ! )DH% && irFT)rAr{sortedsetkeysProtoEq)r;rOr~tags rrr2s* F1IQ! At Jq$$7 6M CMCM1 2c !|s!| QsVQsV $  rceZdZdZdZy)ProtoAssertionsa Mix this into a googletest.TestCase class to get proto2 assertions. Usage: class SomeTestCase(compare.ProtoAssertions, googletest.TestCase): ... def testSomething(self): ... self.assertProtoEqual(a, b) See module-level definitions for method documentation. c t|g|i|Srk)rX)r0argskwargss rrXz ProtoAssertions.assertProtoEqualxs D 24 26 22rN)__name__ __module__ __qualname____doc__rXrrrris  3rr)TFNN)rcollections.abcabcrlrLr google.protobufrrrrrr/rXrGrprsrobjectrrrrrsf +Z* &+#'@.B R 9*xA H44n3f3r