
    ΅i                    -   % S r SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK	r	SSK
r
SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKJ r J!r!  SSKJ"r"J#r#  SSKJ$r$  SSK%J&r&  SSK'J(r(  SSKJ)r)J*r*  SS	K+J,r,J-r-  SS
KJ.r.  SSK/J0r0  SSK1J2r2J3r3J4r4J5r5  SSKJ6r6  SSKJ7r7J8r8  SSK9J:r:  SSK;r;SSK<r=SSK>r>SSK?r?SSK@r?SSKAr?SSKBr?SSKCr?SSKDr?SSK?JErE  SSKFJGrGJHrH  SSKIJJrJ  SSKKJLrL  SSKMJNrNJOrOJPrPJQrQJRrR  SSKSJTrTJUrU  SSKVJWrW  SSKXJYrYJZrZJ[r[J\r\J]r]  SSKXJ^r^  SSK_J`r`  SSKaJbrb  SSKcJds  Jerf  SSKgJhrh   SSKiriSrjSrlSrmS rnS!roS"rpS#rqS$rr " S% S&\(5      rsS'qtSqu\3\s   \vS('   S'qwS'qxSqySqzSq{Sq|S'q}Sq~SqSqS'q/ q\\   \vS)'   SqS* rS+ r " S, S-5      r\GR                  " \5      r\?GR                  GR                  5         S.r\R"                  S/:X  a  S0r\GR                  S1S2SS3 S49r\\vS1'   \GR                  S5S6S7 SS89r\\vS5'   \GR&                  GR)                  S95      SLr\\vS:'   \" \?GR.                  S;5      =(       a    \?GR.                  GR0                  r\GR                  S<S=\SS>9r\\vS<'   \GR                  S?S@SSA9r\\vS?'   \GR                  SBSCSSA9r\\vSB'   \GR                  SDSE\(       + SS>9r\\vSD'   \GR=                  SFSGSSSH SI9r\3\   \vSF'   SJrSKr0 q0 qSL r\GRL                  " SMS'5      (       a  \" \GRL                  " SMS'5      5      q\GRL                  " SNS'5      (       a  \" \GRL                  " SNS'5      5      qSOSPSQSRSSST\?GRN                  GRQ                  5       4rSUrSr/ SVQr\" SW \ 5       5      rSX rSY\3\6   4SZ jr\& " S[ S\5      5       rSY\3\   4S] jrGSS^ jr " S_ S`5      r " Sa Sb5      rSc rSd r " Se Sf5      r " Sg Sh\5      r " Si Sj\5      r " Sk Sl\5      rSm r\#Sn 5       r\#So 5       r\#Sp 5       r\?GRN                  GR                  GR                  r\?GRN                  GR                  GR                  rSq rSr rSs rSt r\\?GRN                  GR                  l        \\?GRN                  GR                  l        Su rSv rGSSw jrGSSx jr       GSSY\\\4   4Sz jjrS{ rS| rS} rS~ rS rS rGSS jrS\4S jrS\\   SY\\   4S jrGSS jr\R"                  S:H  r\R"                  S/:H  r\R"                  S:H  r\GR                  " 5       S:H  r\GR                  " 5       S;   r\GR                  " 5       S;   r\GR                  " 5       S:H  rS r\" 5       r\(       a	  \#S 5       rO\#S 5       r\(       a  \#GSS j5       rO\#GSS j5       rS rS r\ " S S5      5       r\GR                  " 5       S:H  r\b" S5      r\b" S5      r\b" S5      r\?GR                  GR                  GR                  5       r\?GR                  GR                  GR                  5       =(       a'    \?GR                  GR                  GR                  5       r\?GR                  GR                  GR                  5       r\" SGR                  \GR                  " 5       S   GR                  S5      SS 5      =(       d    S5      r\?GR                  GR                  5       r\" \" \?S5      =(       a    \?GR                  GR                  5       5      r\?GR                  GR                  5       Gr \" S 5      Gr\" S 5      GrG\" \?\?GRN                  GRQ                  5       S5      Gr\" 5       Gr\?GRN                  GRQ                  5       Gr\b" S5      Gr\b" S5      Gr\b" S5      Gr	\b" S5      =(       a    \(       + Gr
\b" S5      Gr\b" S5      GrS\4S jGrSOG\" \GRL                  " SS'5      5      ;   Gr\GR                  " G\	(       + S5      GrSGr\\vS'   \GR                  SSS9Gr\\vS'   \GR                  SSS9Gr\\vS'   \GR                  SSS9Gr\\vS'   \GR                  SSS9Gr\\vS'   \GR                  SSS9Gr\\vS'   \GR                  SSS9Gr\\vS'   \GRL                  " SS5      S:H  Gr\GR                  SSS9Gr\\vS'   \GR                  SSS9Gr\\vS'   \GR                  SSS9Gr\\vS'   \GR                  SSS9Gr\\vS'   G\ =(       a    G\(       + =(       a    \?GR:                  GR                  =(       dc    \?GR:                  GR<                  =(       aD    \" SGR                  \?GR:                  GR<                  GR                  S5      SS 5      5      S:  GrG\ =(       aS    \?GR:                  GR                  =(       a4    \" \?GR:                  GR                  GR                  S5      S   5      S:  Gr \b" S5      =(       aS    \?GR:                  GR                  =(       a4    \" \?GR:                  GR                  GR                  S5      S   5      S:  Gr!G\!(       a  S Gr"OSGr"S Gr#\GR                  SS\RR                  " G\#SS9S9Gr$\\vS'   G\ (       a  S\GR&                  ;   as  \" \GRL                  " SS5      5      Gr%\?GR                  GRM                  5       Sy   S-  Gr'\?GR                  GRQ                  G\)" G\'G\%S-  -
  G\'-  G\%-  S5      5        \GRT                  " \?GR                  GR                  5       S5      Gr+S Gr, " S S\?GRZ                  GR\                  5      Gr/\GR                  SSS9Gr0\\vS'   \GR                  SSS9Gr1\\vS'   \GR                  SSS S9Gr2\\vS'   \GR                  SSS9Gr3\\vS'   G\2(       a  SSGK4r?S\?GRj                  GRl                  Gl7        S\?GRj                  GRl                  Gl8        S\?GRj                  GRl                  Gl9        G\0(       a$  SSGK:r?S\?GRv                  GRl                  Gl<        O$G\3(       + \?GRj                  GRl                  Gl=        S Gr>S Gr?S Gr@S GrAS GrBS GrCGSS jGrDSG\04S jGrEGSS jGrFGSS jGrGGSS jGrHGSS jGrIGSS jGrJGSS jGrK GSS\3\6S\24      SY\6S\24   4S jjGrL\GRL                  " S5      S:H  GrMG\M(       a)  S\?GR                  GR                  GR                  GlQ        \GR                  SSS9GrR\\vS'   \=GR                  \?GR"                  \=GR                  \?GR                  \=GR                  \?GR                  \=GR                  \?GR                  \=GR                  \?GR                  \=GR                  \?GR                  \=GR                  \?GR                  \=GR                  \?GR                  \=GR                  \?GR                  \=GR                  \?GR                  \=GR                  \?GR                  \=GR                  \?GR                  \=GR                  \?GR                  \=GR                  \?GR                  0GraS GrbS Grc\(       a  \?GR@                  G\a\=GR                  '   G\aGR                  5        V Vs0 s H  u  pX_M	     snn GrfG\fGR                  \?GR                  \=GR                  \?GR                  \=GR                  05        S\?GRj                  GRl                  GR                  4S jGrkGSSS.S jjGrlGSS\4S jjGrmS\\S4   4S jGrnS\\S4   4GS  jGroGS GrpS\\S4   4GS jGrqGS GrrGS GrsGSGSS.GS jjGrtGS GruGS GrvSY\\\4   4GS	 jGrwGSGS
 jGrxGS GryGSGSS.GS jjGrzGSGSS.GS jjGr{GS Gr|GS Gr}GS Gr~ " GS GS5      Gr " GS GS5      Gr " GS GS5      Gr " GS GS5      GrGS GrGSGS jGr " GS GS\5      GrGS GrGS GrGS  GrGS! GrGS" GrGS# GrGS$ GrGS% GrGS& GrGS' GrGS( GrGS) GrGS* GrGSGS+ jGrGS, GrGSGS- jGr\RF                  GS. 5       Gr\RF                  GS/ 5       GrGS0 GrGS1 GrGSGS2 jGr " GS3 GS45      Gr " GS5 GS65      Gr\#GS7 5       Gr\#GS8 5       Gr SSGKGrGS9 GrG\GR@                  GRC                  GS:G\" SG\GRD                  GRF                  /SGS;G\GRH                  GRJ                  GS<95        G\GR@                  GRC                  GS=G\" G\GRD                  GRF                  /SGS>G\GRH                  GRJ                  GS?95        G\GR@                  GRC                  GS@G\" G\GRD                  GRF                  /SGSAG\GRH                  GRL                  GS?95        G\GR@                  GRO                  \(       a  GS:O\GRL                  " GSBGS=5      5        GSE\SY\4GSF jGrGSG\GRV                  4GSH jGr " GSI GSJ\Y5      Gr " GSK GSL\[5      Gr " GSM GSN\]5      Gr " GSO GSP\]5      Gr " GSQ GSR\\5      Gr " GSS GSTG\5      Gr " GSU GSVG\5      Gr " GSW GSXG\5      Gr " GSY GSZG\5      Gr " GS[ GS\\GRl                  GRn                  5      Gr\#GS]\4GS^ j5       Gr " GS_ GS`5      Gr " GSa GSb\;GRV                  5      Gr " GSc GSdG\5      GrGSGSe jGrGSf GrGSgGrGShGrSG\4GSi jGrGSGSj jGr\?GR                  SO4GSk jGrGSlGSmGSn.GSo jGrGSp GrGSq GrGSr GrGSs GrGSt Gr\?GR                  SOGSu.GSv jGrGSw GrGSx GrGSy GrSGSz.GS{ jGrGS| GrGS} GrGS~ GrGS\GS\GS\SY\?R                  4GS jGrGSGS jGrGSGS jGrGS GrGS GrSGqGS GrGS GrGS Gr " GS GS\
GR                  5      GrGSGr\GR                  GSGSS9Gr\\vGS'   \GR                  " G\GS5      GrGS GrGSGS jGrGS Gr\#GS\SY\8S   4GS j5       Gr\?GR                  GS\?GR                  GS\?GR                  GS\?GR                  GS0GrGS GrGS Gr\RF                  GS 5       GrGS\SY\.4GS jGrGS GrGS GrGS GrGS\\   GS\?GR                  GS\?GR                  4GS jGrGS GrGS GrGS GrGS Gr\GR                  SY\4GS j5       Gr\4" GS5      GrGS\GRV                  GS\7G\   SYG\4GS jGrGS Gr\#GS 5       GrGS GrGS Gr " GS GSG\5      Gr " GS GSG\5      GrSSSSGS.GS jGr\#Sy\?R                  4GS j5       GrGS Gr GS GrGS GrGS GrGS GrGSG\\\24   4GS jGrg! \k a    Srj GNff = fs  snn f ! \k a    \GRP                  " GSCG\SGSD9   GNf = f(  a=  Importing this file must **not** initialize CUDA context. test_distributed
relies on this assumption to properly run. This means that when this is imported
no CUDA calls shall be made, including torch.cuda.device_count(), etc.

torch.testing._internal.common_cuda.py can freely initialize CUDA context when imported.
    N)MappingSequence)closingcontextmanager)deepcopy)	dataclass)Enum)partialwraps)productchain)Path)mean)AnyOptionalTypeVarUnion)Callable)IterableIterator)	MagicMock)Tensor)
ScriptDict
ScriptList)get_writable_path)open_source_signpost)
ModuleDict
ModuleListParameterDictParameterList
Sequentialregister_custom_op_symbolicunregister_custom_op_symbolic)make_tensor)BooleanPairNonePair
NumberPairPairTensorLikePair)not_close_error_metas)get_all_dtypes)_check_module_exists)cpp_extensionTFi  )gfx950)gfx942)gfx90a)gfx1030gfx1100gfx1101gfx1200gfx1201)r3   r4   )r5   r6   c                        \ rS rSrSrSrSrSrg)ProfilingModeo             N)__name__
__module____qualname____firstlineno__LEGACYSIMPLE	PROFILING__static_attributes__r=       ^/home/james-whalen/.local/lib/python3.13/site-packages/torch/testing/_internal/common_utils.pyr8   r8   o   s    FFIrF   r8    GRAPH_EXECUTORUNITTEST_ARGSc                      [         R                  R                  5       (       aH  [         R                  R                  S5      n U R                  R                  S5      S   nU[        ;   a  gg)Nr   :TF)torchcudais_availableget_device_propertiesgcnArchNamesplit
NAVI3_ARCH)propgfx_archs     rG   is_navi3_archrV      sR    zz  zz//2##))#.q1z!rF   c                  V    [         R                  R                  R                  " U 0 UD6$ N)rM   testing_utilsfreeze_rng_stateargskwargss     rG   r[   r[      s"    ==00$A&AArF   c                   |    \ rS rSr% 0 r\\S'   \SSSS S 4S j5       r\SSSS	 4S
 j5       r	\S\
4S j5       rSrg)TestEnvironment   repro_env_varsNFTc                 $    U(       a  U S:g  $ U S:H  $ )N01r=   )env_var_valdefaults     rG   <lambda>TestEnvironment.<lambda>   s    $+[CE+2DErF   c                      gNFr=   r=   rF   rG   rh   ri      s    erF   c                    UnS nUb  [         R                  " U5      nU" Xr5      nU" 5       nU=(       d    UnU(       a"  Ub  Xb:w  a  U(       d  U[        R                  U'   U [	        5       ;  d   SU  S35       eU[	        5       U '   U$ )Nzduplicate definition of flag ''osgetenvr`   rb   globals)	nameenv_varrg   include_in_repro
enabled_fnimplied_by_fnenabledrf   implieds	            rG   def_flagTestEnvironment.def_flag   s     ))G,K 6G/$W!47;MW^6AO**73 79$N(FtfA&NN$!	$rF   c                     U $ rX   r=   )maybe_val_strs    rG   rh   ri      s    }rF   c                     Uc  UO[         R                  " U5      nU" U5      nU(       a  XR:w  a  U[        R                  U'   U [	        5       ;  d   SU  S35       eU[	        5       U '   U$ )Nz!duplicate definition of setting 'rm   rn   )rr   rs   rg   rt   parse_fnvalues         rG   def_settingTestEnvironment.def_setting   sj     #?		'0B!16;O**73 79$Q(I$q&QQ$	$rF   returnc            	          SR                  [        R                  R                  5        V Vs/ s H  u  pU  SU 3PM     snn 5      $ s  snn f )N =)joinr`   rb   items)rs   r   s     rG   repro_env_var_prefix$TestEnvironment.repro_env_var_prefix   sT    xx/>/M/M/S/S/UW/U^W $9AeW-/UW X 	X Ws   A
r=   )r>   r?   r@   rA   rb   dict__annotations__staticmethodry   r   strr   rE   r=   rF   rG   r`   r`      sw     ND0  G# R  4 * X# X XrF   r`   zfile://win32zfile:///IS_CICIc                     [        U 5      $ rX   )bool)env_var_value_s     rG   rh   rh     s	    ](;rF   )rs   rt   ru   IS_SANDCASTLE
SANDCASTLEc                  4    [         R                  " S5      S:H  $ )NTW_JOB_USER
sandcastle)ro   rp   r=   rF   rG   rh   rh     s    "))M2lBrF   )rs   rv   rt   INSIDE_RE_WORKERIN_RE_WORKERIS_FBSOURCE	IS_FBCODEPYTORCH_TEST_FBCODE)rs   rg   rt   IS_REMOTE_GPUPYTORCH_TEST_REMOTE_GPU)rs   rt   DISABLE_RUNNING_SCRIPT_CHK"PYTORCH_DISABLE_RUNNING_SCRIPT_CHKPRINT_REPRO_ON_FAILUREPYTORCH_PRINT_REPRO_ON_FAILUREOPINFO_SAMPLE_INPUT_INDEX!PYTORCH_OPINFO_SAMPLE_INPUT_INDEXc                 "    U c  S $ [        U 5      $ rX   )int)vals    rG   rh   rh   7  s    :#c(:rF   )rs   rg   rt   r~   z.pytorch-disabled-tests.jsonzslow_tests.jsonc                     [         R                  R                  U 5      (       a+  [        U 5       n[        R
                  " U5      sS S S 5        $ [        R                  SU 5        0 $ ! , (       d  f       N&= f)Nz7Attempted to load json file '%s' but it does not exist.)ro   pathisfileopenjsonloadlogwarning)filenamefps     rG   maybe_load_jsonr   @  sL    	ww~~h(^r99R= ^KKI8TI ^s   A((
A6SLOW_TESTS_FILEDISABLED_TESTS_FILEcpurN   xpumetampsmtia)r   rN   r   )orinconcordgalenxaviernanojetsontegrathorc              #   P   #    U  H  o[         R                   " 5       ;   v   M     g 7frX   )platform).0rr   s     rG   	<genexpr>r   U  s     D))++s   $&c                 F   ^  [         R                  " T 5      U 4S j5       nU$ )Nc                     > [         (       a3  [        R                  " 5         [        R                  R                  5         T" U 0 UD6  g rX   )	IS_JETSONgccollectrM   rN   empty_cacher]   r^   fns     rG   wrappergcIfJetson.<locals>.wrapperY  s.    9JJLJJ""$
DFrF   )	functoolsr   r   r   s   ` rG   
gcIfJetsonr   W  s%    __R 
 NrF   r   c                      [         R                  " 5       n U  H  nUR                  nSUR                  ;  a  M!  UR                  S   n[	        U[
        R                  5      (       d  MQ  UR                  5       nUR                  SS5      Gt pVnU[        U5      R                  :X  d  M  UR                  S5      (       d  M  [        X75      R                  nUs  $    g ! [         a     g f = f)Nself.r;   test)inspectstackframef_locals
isinstanceunittestTestCaseidrsplittyper>   
startswithgetattr__func__	Exception)	r   
frame_infor   self_valtest_idr   cls_name	test_nametest_fns	            rG   extract_test_fnr   c  s    J$$EU^^+~~f-H(H$5$566"++-*1..a*@'itH~6669;O;OPV;W;W%h:CCG"N     s*   A$C *<C *C C C 
C+*C+c                   4    \ rS rSr% \\S'   \\S'   \\S'   Srg)TrackedInputiv  indexr   	type_descr=   N)	r>   r?   r@   rA   r   r   r   r   rE   r=   rF   rG   r   r   v  s    J	HNrF   r   c                  8    [        5       n U c  g [        U SS 5      $ Ntracked_input)r   r   r   s    rG   get_tracked_inputr   ~  s!    G7OT22rF   c                  R    [        5       n U c  g [        U S5      (       d  g S U l        g r   )r   hasattrr   r   s    rG   clear_tracked_inputr     s*    G7O,, GrF   c                   @    \ rS rSr    S	S jrS rS rS\4S jrSr	g)
TrackedInputIteri  Nc                     [        U5      U l        X l        X0l        U R                  c  S U l        X@l        U R                  c  S U l        [        5       U l        XPl        X`l        g )Nc                     U $ rX   r=   )xis     rG   rh   +TrackedInputIter.__init__.<locals>.<lambda>  s    arF   c                     U $ rX   r=   r   s    rG   rh   r     s    ArF   )		enumerate
child_iterinput_type_descitem_callbacktrack_callbackr   r   set_seedrestrict_to_index)r   r  r  r  r  r  r	  s          rG   __init__TrackedInputIter.__init__  sc     $J/. +%!/D,&"-D&(  "3rF   c                     U $ rX   r=   r   s    rG   __iter__TrackedInputIter.__iter__      rF   c                     U R                   (       a|  U R                  b^  [        R                  [        R
                  " U R                  R                  R                  S5      5      R                  5       S S S5      O[        n[        U5        [        U R                  5      u  p#U R                  b  X R                  :X  a  OM  U R                  [        X R!                  U5      U R"                  S95        U R%                  X25      $ )Nutf-8   little)r   r   r   )r  r   r   
from_byteshashlibsha256r@   encodedigestSEEDset_rng_seednextr  r	  _set_tracked_inputr   r  r  r  )r   seed	input_idx	input_vals       rG   __next__TrackedInputIter.__next__  s    }}
 ||/ NN7>>1188A$CCI68BQ$PQY[59 
 T" $(#8 I&&.IAWAW4W  	%8%8%CtOcOc	

 !!)77rF   r   c                 x    U R                   c  g [        U R                   S5      (       d  g XR                   l        g r   )r   r   r   )r   r   s     rG   r  #TrackedInputIter._set_tracked_input  s-    <<t||_55%2"rF   )r  r  r  r	  r  r   r  )NNTN)
r>   r?   r@   rA   r
  r  r!  r   r  rE   r=   rF   rG   r   r     s+    
 3>8.3 3rF   r   c                   $    \ rS rSrSrS rS rSrg)_TestParametrizeri  aX  
Decorator class for parametrizing a test function, yielding a set of new tests spawned
from the original generic test, each specialized for a specific set of test inputs. For
example, parametrizing a test across the set of ops will result in a test function per op.

The decision of how to parametrize / what to parametrize over is intended to be implemented
by each derived class.

In the details, the decorator adds a 'parametrize_fn' property to the test function. This function
is intended to be called later by one of:
  * Device-specific test instantiation via instantiate_device_type_tests(). Note that for this
    case there is no need to explicitly parametrize over device type, as that is handled separately.
  * Device-agnostic parametrized test instantiation via instantiate_parametrized_tests().

If the decorator is applied to a test function that already has a 'parametrize_fn' property, a new
composite 'parametrize_fn' will be created that generates tests with the product of the parameters
generated by the old and new parametrize_fns. This allows for convenient composability of decorators.
c                     [         e)a  
Parametrizes the given test function across whatever dimension is specified by the derived class.
Tests can be parametrized over any arbitrary dimension or combination of dimensions, such as all
ops, all modules, or all ops + their associated dtypes.

Args:
    test (fn): Test function to parametrize over
    generic_cls (class): Generic test class object containing tests (e.g. TestFoo)
    device_cls (class): Device-specialized test class object (e.g. TestFooCPU); set to None
        if the tests are not part of a device-specific set

Returns:
    Generator object returning 4-tuples of:
        test (fn): Parametrized test function; must support a device arg and args for any params
        test_name (str): Parametrized suffix for the test (e.g. opname_int64); will be appended to
            the base name of the test
        param_kwargs (dict): Param kwargs to pass to the test (e.g. {'op': 'add', 'dtype': torch.int64})
        decorator_fn (callable): Callable[[Dict], List] for list of decorators to apply given param_kwargs
)NotImplementedError)r   r   generic_cls
device_clss       rG   _parametrize_test#_TestParametrizer._parametrize_test  s
    ( "!rF   c                     [        US5      (       a*  UR                  nU R                  n[        X#5      Ul        U$ U R                  Ul        U$ )Nparametrize_fn)r   r.  r+  compose_parametrize_fns)r   r   old_parametrize_fnnew_parametrize_fns       rG   __call___TestParametrizer.__call__  sR    2'((!#!2!2!%!7!7 78J _B 	 !% 6 6B	rF   r=   N)r>   r?   r@   rA   __doc__r+  r2  rE   r=   rF   rG   r&  r&    s    $",rF   r&  c                     U U4S jnU$ )a  
Returns a parametrize_fn that parametrizes over the product of the parameters handled
by the given parametrize_fns. Each given parametrize_fn should each have the signature
f(test, generic_cls, device_cls).

The test names will be a combination of the names produced by the parametrize_fns in
"<new_name>_<old_name>" order. This order is done to match intuition for constructed names
when composing multiple decorators; the names will be built in top to bottom order when stacking
parametrization decorators.

Args:
    old_parametrize_fn (callable) - First parametrize_fn to compose.
    new_parametrize_fn (callable) - Second parametrize_fn to compose.
c              3     #    [        U" XU5      5      nU H  u  pgpU" XaU5       H  u  pp[        UR                  5       5      R                  UR                  5       5      nU(       a  [	        SU R
                   SU 35      e0 UEUEnSR                  UUS:w  a  US:w  a  SOSU5      nX4S jnU
UUU4v   M     M     g 7f)NzkParametrization over the same parameter by multiple parametrization decorators is not supported. For test "z8", the following parameters are handled multiple times: z{}{}{}rH   r   c                 H    [        U" U 5      5      [        U" U 5      5      -   $ rX   )list)param_kwargs
old_dec_fn
new_dec_fns      rG   merged_decorator_fnJcompose_parametrize_fns.<locals>.composite_fn.<locals>.merged_decorator_fn$  s!    
< 89DLAY<ZZZrF   )r8  setkeysintersectionRuntimeErrorr>   format)r   r)  r*  r0  r1  	old_testsold_testold_test_nameold_param_kwargsr:  new_testnew_test_namenew_param_kwargsr;  redundant_paramsfull_param_kwargsmerged_test_namer<  s                     rG   composite_fn-compose_parametrize_fns.<locals>.composite_fn  s     +DzJK	GPCX&6&xjI H*:#&'7'<'<'>#?#L#LM]MbMbMd#e #& (QQUQ^Q^P_ `FFVEW(Y Z Z %M'7$L;K$L!#+??=:G2:MR_ceRe3km3@$B  BL [  !13DFYZZ J HQs   C Cr=   )r0  r1  rM  s      rG   r/  r/    s    " );(:[, rF   c           	      6  ^  [        [        T 5      5       H  n[        T U5      n[        US5      (       d  M"  [	        T U5        U 4S jnUR                  UT SS9 H6  u  pEpgUR                   SU 3nU" U5       H  n	U	" U5      nM     U" T XUS9  M8     M     T $ )a5  
Instantiates tests that have been decorated with a parametrize_fn. This is generally performed by a
decorator subclass of _TestParametrizer. The generic test will be replaced on the test class by
parametrized tests with specialized names. This should be used instead of
instantiate_device_type_tests() if the test class contains device-agnostic tests.

You can also use it as a class decorator. E.g.

```
@instantiate_parametrized_tests
class TestFoo(TestCase):
    ...
```

Args:
    generic_cls (class): Generic test class object containing tests (e.g. TestFoo)
r.  c                    >^ [        T5      U4U4S jj5       n[        TU5      (       a
   SU 35       e[        TX5        g )Nc                    > T" U 40 UD6  g rX   r=   )r   r9  r   s     rG   instantiated_testZinstantiate_parametrized_tests.<locals>.instantiate_test_helper.<locals>.instantiated_testH  s    T*\*rF   zRedefinition of test )r   r   setattr)clsrr   r   r9  rR  r)  s     `  rG   instantiate_test_helper?instantiate_parametrized_tests.<locals>.instantiate_test_helperG  sH    4[5A + + {D11Q5J4&3QQ1K9rF   N)r)  r*  r   )rU  rr   r   r9  )tupledirr   r   delattrr.  r>   )
r)  	attr_name
class_attrrV  r   test_suffixr9  decorator_fn	full_name	decorators
   `         rG   instantiate_parametrized_testsra  ,  s    $ 3{+,	[)4
z#344 	Y'	: @J?X?X @Y @F;T==/;-8I *,7	  8 $)]ij@F# -4 rF   c                   *    \ rS rSrSr/ SQrSS jrSrg)subtesti[  a  
Explicit subtest case for use with test parametrization.
Allows for explicit naming of individual subtest cases as well as applying
decorators to the parametrized test.

Args:
    arg_values (iterable): Iterable of arg values (e.g. range(10)) or
        tuples of arg values (e.g. [(1, 2), (3, 4)]).
    name (str): Optional name to use for the test.
    decorators (iterable): Iterable of decorators to apply to the generated test.

arg_valuesrr   
decoratorsNc                 F    Xl         X l        U(       a  X0l        g / U l        g rX   rd  )r   re  rr   rf  s       rG   r
  subtest.__init__i  s    $	(2*rF   )re  rf  rr   NN)r>   r?   r@   rA   r4  	__slots__r
  rE   r=   rF   rG   rc  rc  [  s    
 5I;rF   rc  c                   >    \ rS rSrSrS
S jrS rS rS
S jrS r	S	r
g)parametrizeio  a	  
Decorator for applying generic test parametrizations.

The interface for this decorator is modeled after `@pytest.mark.parametrize`.
Basic usage between this decorator and pytest's is identical. The first argument
should be a string containing comma-separated names of parameters for the test, and
the second argument should be an iterable returning values or tuples of values for
the case of multiple parameters.

Beyond this basic usage, the decorator provides some additional functionality that
pytest does not.

1. Parametrized tests end up as generated test functions on unittest test classes.
Since this differs from how pytest works, this decorator takes on the additional
responsibility of naming these test functions. The default test names consists of
the test's base name followed by each parameter name + value (e.g. "test_bar_x_1_y_foo"),
but custom names can be defined using `name_fn` or the `subtest` structure (see below).

2. The decorator specially handles parameter values of type `subtest`, which allows for
more fine-grained control over both test naming and test execution. In particular, it can
be used to tag subtests with explicit test names or apply arbitrary decorators (see examples
below).

Examples::

    @parametrize("x", range(5))
    def test_foo(self, x):
        ...

    @parametrize("x,y", [(1, 'foo'), (2, 'bar'), (3, 'baz')])
    def test_bar(self, x, y):
        ...

    @parametrize("x,y", [(1, 'foo'), (2, 'bar'), (3, 'baz')],
                 name_fn=lambda x, y: '{}_{}'.format(x, y))
    def test_bar_custom_names(self, x, y):
        ...

    @parametrize("x, y", [subtest((1, 2), name='double'),
                          subtest((1, 3), name='triple', decorators=[unittest.expectedFailure]),
                          subtest((1, 4), name='quadruple')])
    def test_baz(self, x, y):
        ...

To actually instantiate the parametrized tests, one of instantiate_parametrized_tests() or
instantiate_device_type_tests() should be called. The former is intended for test classes
that contain device-agnostic tests, while the latter should be used for test classes that
contain device-specific tests. Both support arbitrary parametrizations using the decorator.

Args:
    arg_str (str): String of arg names separate by commas (e.g. "x,y").
    arg_values (iterable): Iterable of arg values (e.g. range(10)) or
        tuples of arg values (e.g. [(1, 2), (3, 4)]).
    name_fn (Callable): Optional function that takes in parameters and returns subtest name.
Nc                     UR                  S5       Vs/ s H  oDS:w  d  M
  UR                  5       PM     snU l        X l        X0l        g s  snf )N,rH   )rR   strip	arg_namesre  name_fn)r   arg_strre  rq  ss        rG   r
  parametrize.__init__  s@    8?c8J$V8J1SUgYQWWY8J$V$ %Ws
   	A
A
c                    [        U[        R                  5      (       a  [        U5      $ [        U[        R                  5      (       a  [        U5      $ [        U5      R                  S;   a  UR                  $ [        U[        [        [
        45      (       a   U S[        U5      R                  SS5       3$ U U 3$ )zcReturns a string representation for the given arg that is suitable for use in test function names. >   OpInfo
ModuleInfor   r   )r   rM   dtype
dtype_namedevicer   r   r>   formatted_namer   floatreplace)r   idxrr   r   s       rG   _formatted_str_reprparametrize._formatted_str_repr  s    eU[[))e$$u||,,u:%[!!%=='''UC011V1SZ//S9:;;VC5>!rF   c                     SR                  [        U R                  USS9 VVs/ s H  u  p4U R                  XU5      PM     snn5      $ s  snnf )Nr   Tstrict)r   ziprp  r  )r   r~  valuesavs        rG   _default_subtest_name!parametrize._default_subtest_name  sC    xxT^^]clpIqrIq11#!<Iqrssrs   A

c                     U(       a  UnU$ U R                   (       a  U R                   " U6 nU$ U R                  X5      nU$ rX   )rq  r  )r   r~  r  explicit_namesubtest_names        rG   _get_subtest_nameparametrize._get_subtest_name  sI    (L
 	 \\<<0L   55cBLrF   c           
   #     ^#    [        U R                  5      S:X  a  SnTU0 S 4v   g [        5       =pV[        U R                  5       GH  u  puS n/ n	[        U[        5      (       a=  Un
U
R                  nU
R                  n[        T5      U4S j5       nU
R                  n	UnOTn[        U R                  5      S:  a  [        U5      OU/n[        U5      [        U R                  5      :w  a;  [        S[        U5       S[        U R                  5       STR                   S	35      e[        [        U R                  US
S95      nU R                  XuUS9nU	4S jnXX4v   GM     XVL a  [!        T S35      eg 7f)Nr   rH   c                     / $ rX   r=   r   s    rG   rh   /parametrize._parametrize_test.<locals>.<lambda>  s    "rF   c                     > T" U 0 UD6$ rX   r=   r]   r^   r   s     rG   test_wrapper3parametrize._parametrize_test.<locals>.test_wrapper  s    #T4V44rF   r:   z+Expected # values == # arg names, but got: z values and z names for test ""Tr  )r  c                     U$ rX   r=   )r   rf  s     rG   r^  3parametrize._parametrize_test.<locals>.decorator_fn  s    %%rF   zf: An empty arg_values was passed to @parametrize. Note that this may result from reuse of a generator.)lenrp  objectr  re  r   rc  rr   r   rf  r8  rA  r>   r   r  r  
ValueError)r   r   r)  r*  r   r  check_exhausted_iteratorr~  
maybe_namerf  subr  gen_testr9  r^  s    `             rG   r+  parametrize._parametrize_test  s    t~~!#IB55
 178F(9!
(*
fg.. C ^^F!$J4[5 !5 "%J+H#H),T^^)<q)@fvhv;#dnn"55&)TUXY_U`Ta b5585H4IIZ[_[h[hZiij(l m m  $Ct$LM 223j2Y	/9 &  LGG=  :@ 1 D6 *X "X Y Y 2s   E:E=)rp  re  rq  rX   )r>   r?   r@   rA   r4  r
  r  r  r  r+  rE   r=   rF   rG   rl  rl  o  s#    6n
"t,YrF   rl  c                   $    \ rS rSrSrS rS rSrg)reparametrizei  aE  
Decorator for adjusting the way an existing parametrizer operates. This class runs
the given adapter_fn on each parametrization produced by the given parametrizer,
allowing for on-the-fly parametrization more flexible than the default,
product-based composition that occurs when stacking parametrization decorators.

If the adapter_fn returns None for a given test parametrization, that parametrization
will be excluded. Otherwise, it's expected that the adapter_fn returns an iterable of
modified parametrizations, with tweaked test names and parameter kwargs.

Examples::

    def include_is_even_arg(test_name, param_kwargs):
        x = param_kwargs["x"]
        is_even = x % 2 == 0
        new_param_kwargs = dict(param_kwargs)
        new_param_kwargs["is_even"] = is_even
        is_even_suffix = "_even" if is_even else "_odd"
        new_test_name = f"{test_name}{is_even_suffix}"
        yield (new_test_name, new_param_kwargs)

    ...

    @reparametrize(parametrize("x", range(5)), include_is_even_arg)
    def test_foo(self, x, is_even):
        ...

    def exclude_odds(test_name, param_kwargs):
        x = param_kwargs["x"]
        is_even = x % 2 == 0
        yield None if not is_even else (test_name, param_kwargs)

    ...

    @reparametrize(parametrize("x", range(5)), exclude_odds)
    def test_bar(self, x):
        ...

c                     Xl         X l        g rX   )parametrizer
adapter_fn)r   r  r  s      rG   r
  reparametrize.__init__  s    ($rF   c              #      #    U R                   R                  XU5       H4  u  pEpgU R                  XV5      nUc  M  U H  n	U	c  M  U	u  pXJX4v   M     M6     g 7frX   )r  r+  r  )r   r   r)  r*  r  r   r9  r^  adaptedadapted_itemrH  rI  s               rG   r+  reparametrize._parametrize_test!  sb     !!33DzR >X,ooi>G"$+L#/:F7'8HWW %, Ss   5AAA)r  r  Nr>   r?   r@   rA   r4  r
  r+  rE   r=   rF   rG   r  r    s    &N%XrF   r  c                   $    \ rS rSrSrS rS rSrg)
decorateIfi,  a  
Decorator for applying parameter-specific conditional decoration.
Composes with other test parametrizers (e.g. @modules, @ops, @parametrize, etc.).

Examples::

    @decorateIf(unittest.skip, lambda params: params["x"] == 2)
    @parametrize("x", range(5))
    def test_foo(self, x):
        ...

    @parametrize("x,y", [(1, 'foo'), (2, 'bar'), (3, 'baz')])
    @decorateIf(
        unittest.expectedFailure,
        lambda params: params["x"] == 3 and params["y"] == "baz"
    )
    def test_bar(self, x, y):
        ...

    @decorateIf(
        unittest.expectedFailure,
        lambda params: params["op"].name == "add" and params["dtype"] == torch.float16
    )
    @ops(op_db)
    def test_op_foo(self, device, dtype, op):
        ...

    @decorateIf(
        unittest.skip,
        lambda params: params["module_info"].module_cls is torch.nn.Linear and                 params["device"] == "cpu"
    )
    @modules(module_db)
    def test_module_foo(self, device, dtype, module_info):
        ...

Args:
    decorator: Test decorator to apply if the predicate is satisfied.
    predicate_fn (Callable): Function taking in a dict of params and returning a boolean
        indicating whether the decorator should be applied or not.
c                     Xl         X l        g rX   r`  predicate_fn)r   r`  r  s      rG   r
  decorateIf.__init__V  s    "(rF   c              #   ~   ^#    U R                   U R                  4S jn[        T5      U4S j5       nSnXV0 U4v   g 7f)Nc                 &    U" U 5      (       a  U/$ / $ rX   r=   )paramsr`  r  s      rG   r^  2decorateIf._parametrize_test.<locals>.decorator_fn]  s    F##!{"	rF   c                     > T" U 0 UD6$ rX   r=   r  s     rG   r  2decorateIf._parametrize_test.<locals>.test_wrapperc  s    (((rF   rH   )r`  r  r   )r   r   r)  r*  r^  r  r   s    `     rG   r+  decorateIf._parametrize_testZ  sH      ,0>>HYHY 	 
t	) 
	) 	L99s   :=r  Nr  r=   rF   rG   r  r  ,  s    (R):rF   r  c                  v   [         R                  R                  S5      n [         R                  R                  S5      n[         R                  R                  U 5        [         R                  R                  U5        U (       a'  U(       a  [        R
                  $ [        R                  $ [        R                  $ NT)rM   _C_jit_set_profiling_executor_get_graph_executor_optimizer8   rD   rC   rB   old_prof_exec_stateold_prof_mode_states     rG    cppProfilingFlagsToProfilingModer  k  s|    ((>>tD((??E	HH(()<=	HH))*=> *** '''###rF   c               #   J  #    Sn Sn[         (       d   e[         [        R                  :X  a>  [        R                  R                  S5      n [        R                  R                  S5      n S v   [         [        R                  :X  a?  [        R                  R                  U 5        [        R                  R                  U5        g g ! [         [        R                  :X  a?  [        R                  R                  U 5        [        R                  R                  U5        f f = f7f)NFT)rI   r8   rD   rM   r  r  r  r  s     rG   )enable_profiling_mode_for_profiling_testsr  y  s     >>000#hhBB4H#hhCCDIG]444HH001DEHH112EF 5>]444HH001DEHH112EF 5s    A(D#+C /AD#AD  D#c               #     #    [         R                  R                  S5      n [         R                  R                  S5      n S v   [         R                  R                  U 5        [         R                  R                  U5        g ! [         R                  R                  U 5        [         R                  R                  U5        f = f7fr  )rM   r  r  r  r  s     rG   enable_profiling_moder    s     ((>>tD((??EC,,-@A--.AB 	,,-@A--.ABs   ?CB ?CA CCc              #      #    [         R                  R                  U 5      n S v   [         R                  R                  U5        g ! [         R                  R                  U5        f = f7frX   )rM   r  _jit_set_num_profiled_runs)num_runsold_num_runss     rG   num_profiled_runsr    sE     8866x@L:++L9++L9s    A+A  A+!A((A+c                     SU;   aL  US	 [         (       d   e[         [        R                  :X  a$  [        5          U " U0 UD6  U " U0 UD6sS S S 5        $ U " U0 UD6$ ! , (       d  f       N= f)Nprofile_and_replay)rI   r8   rD   r  )callabler]   r^   s      rG   prof_callabler    sn    v%'(~~]444:<$)&)00 =< T$V$$	 =<s   A
A)c                      [        SU  S35      e)Nz>This test file is not meant to be run directly, use:

	python z TESTNAME

instead.)rA  )file_to_calls    rG   raise_on_run_directlyr    s#    
 ++7. 9"" # #rF   c                  (    [        [        /U Q70 UD6$ rX   )r  	func_callr\   s     rG   prof_func_callr        4T4V44rF   c                  (    [        [        /U Q70 UD6$ rX   )r  	meth_callr\   s     rG   prof_meth_callr    r  rF   c                      [         R                  R                  S5      n U b  U OSn[         R                  R	                  SU5      $ )NTEST_REPORT_SOURCE_OVERRIDEpython-unittestztest-reports)ro   environgetr   r   )overridetest_sources     rG   _get_test_report_pathr    s9     zz~~;<H&2(8IK77<<44rF   c                     S[        [        SS5      ;   n [        R                  " U (       + SS9nUR	                  SSSS	9  UR	                  S
SS9  UR	                  SS[
        S9  UR	                  S[        SS9  UR	                  SSSS9  UR	                  SSS9  UR	                  SS[
        [        5       [        (       a
  [        5       OS S9  UR	                  SSS9  UR	                  S[
        SS9  UR	                  S[        SS9  UR	                  S[
        S[        S9  UR	                  S[
        S[        S9  UR	                  SSS9  UR	                  S[
        SS 9  UR	                  S![        R                  SS"9  S# nS$[        R                  ;   d  S%[        R                  ;   aD  [        R                  " U[        R                  4S&9nUR!                  5         UR#                  5         UR%                  5       u  pEUR&                  S':X  a  [(        R*                  qOLUR&                  S(:X  a  [(        R.                  qO+UR&                  S):X  a  [(        R0                  qO
[3        5       qUR4                  qUR8                  qUR<                  qUR@                  q!URD                  q#URH                  q%URL                  q'URP                  q)URT                  q+URX                  q-UR\                  q/UR`                  q1URd                  q3[        [h        S*S5      (       d  URj                  [h        l6        [        R                  S+   /U-   q7[q        5         g ),Nzrun_test.py__file__rH   F)add_helpallow_abbrevz--subprocess
store_truez(whether to run each test in a subprocess)actionhelpz--accept)r  z--jit-executorz--jit_executor)r   z--repeatr:   )r   rg   z--test-bailoutsz--test_bailouts--use-pytest
--save-xml?)nargsr   constrg   z--discover-testsz--log-suffixz--run-parallel--import-slow-tests)r   r  r  --import-disabled-tests--rerun-disabled-tests--pytest-single-test)r   r  --showlocals)r  rg   c                 ,    [         R                  " U S9  g )Nargv)r   mainr  s    rG   run_unittest_help.parse_cmd_line_args.<locals>.run_unittest_help  s    4 rF   z-hz--help)targetr]   legacy	profilingsimpleACCEPTr   )9r   __main__argparseArgumentParseradd_argumentr   r   r  r   DEFAULT_SLOW_TESTS_FILEDEFAULT_DISABLED_TESTS_FILEBooleanOptionalActionsysr  	threadingThreadstartr   parse_known_argsjit_executorr8   rB   rI   rD   rC   r  rerun_disabled_testsRERUN_DISABLED_TESTSimport_slow_testsr   import_disabled_testsr   
log_suffix
LOG_SUFFIXrun_parallelRUN_PARALLELtest_bailoutsTEST_BAILOUTS
use_pytest
USE_PYTESTpytest_single_testPYTEST_SINGLE_TESTdiscover_testsTEST_DISCOVER
subprocessTEST_IN_SUBPROCESSsave_xmlTEST_SAVE_XMLrepeatREPEAT_COUNT
showlocals
SHOWLOCALS
expecttestacceptr  rJ   r  )is_running_via_run_testparserr  help_threadr]   	remainings         rG   parse_cmd_line_argsr)    s   " ,wxR/PP$$2I.IX]^F
|G  I

<8
(*:E

a8
)+<\R
|<
Cc35;@5 5 7d  L *<@
S"=
(sA>
-CsJab
13Nij
0F
.SB
x/M/MW\]! sxx8sxx/&&.?sxxkR--/ODH$&--			k	)&00			h	&&-- :;44,,O44J$$L&&MJ00''MMMM;;LJ:x// KK
XXa[MI-MNrF   c                 &    U R                  US9U R                  5         $ ! [         a8    U R                  SS9nUb  Us U R                  5         $ U R                  5         e [        R                   au    U R                  [        R                  5        S n U R                  SS9nO! [        R                   a     Of = fUb  Us U R                  5         $ U R                  5         e   U R                  5         e = f! U R                  5         f = f)Ntimeout   )waitKeyboardInterruptkillr  TimeoutExpiredsend_signalsignalSIGINT)pr,  exit_statuss      rG   wait_for_processr7    s    vvgv&< 	
;   ffQf'"0 	
- FFH$$ 	fmm$	&&&+K (( 		" 	
 FFH	 	
sQ   ! C;C> AC;B'&C;'B>;C;=B>>C;C> #C;;C> >Dc           	          [         R                  R                  5         [         R                  R                  5         [	        U [
        5      (       a   S5       e[        R                  " U SXX4S9n[        XeS9$ )Nz4Command to shell should be a list or tuple of tokensT)universal_newlinescwdenvstdoutstderrr+  )	r  r<  flushr=  r   r   r  Popenr7  )commandr:  r;  r<  r=  r,  r5  s          rG   shellrA  /  s_    JJJJ '3''_)__'TsTZjAA//rF   r:   c                 <   US:  d
   SU 35       e [        XX#XES9nUS:X  d  US:X  a  X4$ [        SU SU S3USS9  [	        U UUUUUUS-
  SS9$ ! [        R                   a6    US:X  a  [        S	US
-   S3USS9  SU4s $ [        S	US
-   SU S3USS9   N\f = f)Nr   z9Expecting non negative number for number of retries, got )r:  r;  r<  r=  r,  zGot exit code z, retrying (retries left=)T)filer>  zCommand took ><   zmin, returning 124|   zmin, retrying (retries left=r:   )r:  r;  r<  r=  r,  retries	was_rerun)rA  printr  r1  retry_shell)	r@  r:  r;  r<  r=  r,  rG  rH  	exit_codes	            rG   rJ  rJ  >  s    	1M	B7)LM
#V
	 >W\''YK'@	K	
$ !	 	 $$ 
a< B/AB
 	>!W]O+GyPQR	

s   A A 0BBBc                     [        U [        R                  5      (       a  U /$ / nU  H(  n[        U5        UR	                  [        U5      5        M*     U$ rX   )r   r   r   rI  extenddiscover_test_cases_recursively)suite_or_casercelements      rG   rN  rN  p  sL    -!2!233	B g
		1':; ! IrF   c                     U  Vs/ s H4  nSR                  UR                  5       R                  S5      SS  5      PM6     sn$ s  snf )Nr   )r   r   rR   )
test_casescases     rG   get_test_namesrV  y  s9    <FGJDCHHTWWY__S)"#./JGGGs   ;Ac                      [         R                  " 5       R                  [        5      n [	        U 5      n[        U5       H  n[        U5        M     g rX   )r   
TestLoaderloadTestsFromModuler  rN  rV  rI  )suiterT  rr   s      rG   _print_test_namesr[  |  s;    !55h?E07Jz*d +rF   c                 N    [        U5       Vs/ s H
  o US U2   PM     sn$ s  snf rX   range)lstnchunksr   s      rG   
chunk_listra    s&    %*7^4^
7
O^444s   "c                 b    [         R                  " SSU 5      n[         R                  " SSU5      $ )Nz.py$rH   /r   )rer  )r   strip_pys     rG   sanitize_test_filenamerf    s'    vvgr8,H66#tX&&rF   c                    SnU  H  nUn[        U[        R                  5      (       ad  [        UR                  5      S:  a  UR                  S   OS nUb5  [        U[        R                  5      (       a  U=(       a    [        U5      s  $ UnUc  M  [        U[        5      (       a  M  UR                  5       R                  SS5      S   R                  S5      S   nSn[        U SU 35        SnM     U$ )NTr   r   r:   z`This test class should extend from torch.testing._internal.common_utils.TestCase but it doesn't.z - failed. F)
r   r   	TestSuiter  _testslint_test_case_extensionr   r   rR   rI  )rZ  succeedtest_case_or_suite	test_case
first_test
test_classerrs          rG   rj  rj    s    G#&	((*<*<==9<=O=V=V9WZ[9[+2215aeJ%*ZASAS*T*TO#;<N#OO"I i22&\\^11#q9!<BB3GJ
xKu56 $ NrF   c                    U c  [         n [        U S   5      n[        [        -   n[        R
                  R                  X25      nU(       ap  UR                  SS5      n[        R                  " USS9  [        R
                  R                  X2 S[        R                  " S5      R                  5        S35      nU$ [        R                  " USS9  U$ )	Nr   r  zpython-pytestT)exist_ok-   z.xml)rJ   rf  r  r  ro   r   r   r}  makedirsurandomhex)r  pytesttest_filenametest_report_paths       rG   get_report_pathr{    s    |*473M$z1ww||$4D+334EW
$t477<<(8O1RZZXY]M^M^M`Laae:fgKK 40rF   xml_filec                    SS K Js  Jn  UR                  U 5      nUR	                  S5       H  nUR
                  R                  S5      nUc  M#  [        R                  " SU5      nUc  M?  UR                  S5      nUR                  S5      R                  SS5      nUR                  SU5        UR                  SU S35        M     UR                  U 5        g )	Nr   testcase	classnamez.^(test\.)?(?P<file>.*)\.(?P<classname>[^\.]*)$rD  r   rc  .py)xml.etree.ElementTreeetreeElementTreeparseiterattribr  rd  searchgroupr}  r>  write)r|  ETtreer~  full_classnameregex_resultr  rD  s           rG   sanitize_pytest_xmlr    s     '&88HDIIj)!,,[9!yy!RTbc &&{3	!!&)11#s;[),VvS\* * 	JJxrF   r  c                      " S S5      nU" 5       nSS K nUR                  " U  Vs/ s H  oDS:w  d  M
  UPM     sn/ SQ-   U/S9  UR                  $ s  snf )Nc                   $    \ rS rSrSS jrS rSrg)2get_pytest_test_cases.<locals>.TestCollectorPlugini  Nc                     / U l         g rX   testsr  s    rG   r
  ;get_pytest_test_cases.<locals>.TestCollectorPlugin.__init__  s	    $&DJrF   c                     UR                    HA  nU R                  R                  UR                  R	                  UR
                  5      5        MC     g rX   )r   r  appendconfigcwd_relative_nodeidnodeid)r   sessionitems      rG   pytest_collection_finishKget_pytest_test_cases.<locals>.TestCollectorPlugin.pytest_collection_finish  s5    

!!'.."D"DT[["QR &rF   r  r   N)r>   r?   r@   rA   r
  r  rE   r=   rF   rG   TestCollectorPluginr    s    	'	SrF   r  r   z-vv)z--collect-onlyz-qq--use-main-module)plugins)rx  r  r  )r  r  test_collector_pluginrx  args        rG   get_pytest_test_casesr    s]    S S 01
KK-u-0^^&' !&&& 	.s
   	AAc           	      
   [        5         U c  [        n [        (       a  [        R                  R                  [        5      (       aF  [        [        5       n[        R                  " U5      q	[        [        R                  S'   S S S 5        O[        R                  " S[         3SS9  [        (       a  [        R                  R                  [        5      (       aF  [        [        5       n[        R                  " U5      q[        [        R                  S'   S S S 5        O[        R                  " S[         3SS9  [        (       a  [!        5         g ["        R$                  " 5       R'                  [(        5      n[+        U5      (       d  [,        R.                  " S5        [0        (       a  U S   /[2        (       a  / S	QOS
/QU SS  Qn [4        (       Ga  / n[        (       a  UR7                  S5        [        (       a  UR7                  S5        [2        (       a  UR7                  S5        [8        (       a  UR7                  S5        [:        (       a  US[:        /-  n[2        (       a  [=        U 5      O;[?        U5       Vs/ s H%  oDRA                  5       RC                  SS5      S   PM'     snn/ nU GH/  n[,        RD                  /U S   /-   U-   U SS  -   [2        (       a  S/O/ -   U/-   nSRG                  U5      n	[8        (       a  S OSn
[I        X[8        (       a  SOSS9u  pUS:w  ax  SU;   aP  [        R                  RK                  SS5      n[        R                  RK                  SS5      nSU SU 3nUS-   U	-   n	[M        SU SU	 35        UR7                  U5        [O        U5      S:X  a  GM   SRQ                  [O        U5      SRG                  U5      5      5       e   g [R        S:  a  [?        U5      n[U        [W        U5      [R        5      n/ n[Y        [R        5       HK  n[,        RD                  /U -   SUS-    3/-   UU   -   nUR7                  [Z        R\                  " US S!95        MM     S"nU H  nU[_        U5      S:g  -  nM     U(       a   S#5       eg [2        (       a  U S$/-   nSn[:        (       a+  [a        S S%9n[M        S&U 35        UR7                  S'U 35        [b        (       a  [b        USS  -   nSS K2nS([        R                  S)'   URf                  " US*9n[:        (       a  [i        U5        [,        R.                  " US+:X  a  SOU5        g [:        (       as  SS K5nSS,K6J7n   " S- S.U5      n[a        5       nS/U ;   =(       d    S0U ;   nU(       a  [M        S&U 35        ["        Rf                  " U URq                  UU(       a  SOSUS19S29  g [r        S:  aa  [Y        [r        5       HM  n["        Rf                  " S"U S39Rt                  Rw                  5       (       a  M7  [,        R.                  " S45        MO     g ["        Rf                  " U S59  g ! , (       d  f       GN= f! , (       d  f       GN?= fs  snf )6Nr   z'slow test file provided but not found: r;   
stacklevelr   z+disabled test file provided but not found: r:   r   )r  z	--tb=longz--color=yesz--localsr  r  r  r  r  r   r  r   i  )r,  rG  TestDistBackendWithSpawnBACKENDrH   
WORLD_SIZEzBACKEND=z WORLD_SIZE=z#Test exited with non-zero exitcode z. Command to reproduce: z{} unit test(s) failed:
	{}z
	z--log-suffix=-shard-T)r9  FzSome test shards have failedr  )rx  zTest results will be stored in z--junit-xml-reruns=re   NO_COLOR)r]   r-  )_XMLTestResultc                   <   ^  \ rS rSrSrU 4S jrSU 4S jjrSrU =r$ )'run_tests.<locals>.XMLTestResultVerboseiL  a  
Adding verbosity to test outputs:
by default test summary prints 'skip',
but we want to also print the skip reason.
GH issue: https://github.com/pytorch/pytorch/issues/69014

This works with unittest_xml_reporting<=3.2.0,>=2.0.0
(3.2.0 is latest at the moment)
c                    > [         TU ]  X5        U R                  R                   H@  n[	        UR
                  [        5      (       d  M$  UR
                  S:X  d  M6  SU 3Ul        MB     g )Nskipzskip: )superaddSkipcallback__closure__r   cell_contentsr   )r   r   reasonc	__class__s       rG   r  /run_tests.<locals>.XMLTestResultVerbose.addSkipW  sO    -22A!!//377AOOv<U -36(*;	 3rF   c                 Z   > [         TU ]  5         U R                  SU R                  5        g )NXPASS)r  printErrorsprintErrorListunexpectedSuccesses)r   r  s    rG   r  3run_tests.<locals>.XMLTestResultVerbose.printErrors_  s$    #%##GT-E-EFrF   r=   r  )	r>   r?   r@   rA   r4  r  r  rE   __classcell__r  s   @rG   XMLTestResultVerboser  L  s    <G GrF   r  z	--verbose-v)output	verbosityresultclass)r  
testRunner)exitr  r  )<r)  rJ   r   ro   r   existsr   r   r   slow_tests_dictr  warningswarnr   disabled_tests_dictr  r[  r   rX  rY  r  rj  r  r  r"  r  r  r  r  r  r  rN  r   rR   
executabler   rJ  r  rI  r  rB  r  ra  rV  r^  r  r?  r7  r{  r  rx  r  r  	xmlrunnerxmlrunner.resultr  XMLTestRunnerr   resultwasSuccessful)r  r   rZ  
other_argsrU  rT  failed_teststest_case_full_namecmd
string_cmdr,  exitcoder   backend
world_size
env_prefixtest_batches	processesr   r@  failedr5  pytest_argsrz  rx  rK  r  r  r  verboses                                 rG   	run_testsr    s   | 77>>/**o&""&))B-0?

,-	 '& MMCOCTUbcd77>>-..)*b&*iim#4G

01 +*
 MMGH[G\]jkl} !55h?E#E**zG
>Hj:zl
 !"X
 
78?34:n-67=<77J ,6:!$'4STY4Z[4ZDWWY__S!$Q'4Z[ 	
 #-  DG9,z9DHD-7Z()RA$%& 
 #J22dG%cI]I]AcdeKH1}-1DD jjnnY;G!#b!AJ#+G9L!MJ!+c!1J!>J;H:E]^h]ijk##$78|$) >+J+Q+QL!6;;|#<,> >)1 $.6 
	4U;
!."<lK	|$A~~&-3GAw1O0PPS_`aSbbGZ--g$OP % A&q)Q..F 999z6	122=.d;34D3EFG!45E4FGH,{12>K!$

:KK[1	= 01 	i1n)4	3	G> 	G, +,%534D3EFG4I,C,C#"a, -D -. 	/ 
	|$A==e$7>>LLNN % 	4 k '& +*L \s   .Y+.Y.,Z 
Y+.
Y=linuxdarwinppc64le)x86_64i386)arm64aarch64s390xc                      [         R                  S:w  a  g[        SSS9 n U R                  5       nS S S 5        SU;   $ ! , (       d  f       SW;   $ = f)Nr  Fz/proc/cpuinfoascii)encodingvnni)r  r   r   read)fliness     rG   is_avx512_vnni_supportedr  y  sJ    
||w	o	0A 
1U? 
1	0U?s	   >
Ac               /   >  #    SU;   a  US   SLa  [        S5      eOSUS'   [        R                  " U 0 UD6n UR                  5         UR                  v   [
        R                  " UR                  5        g ! [
        R                  " UR                  5        f = f7f)NdeleteFzAonly TemporaryFileName with delete=False is supported on Windows.)UserWarningtempfileNamedTemporaryFilecloserr   ro   unlinkr]   r^   r  s      rG   TemporaryFileNamer    s     
 vhu,!"eff -  %F8''88	GGI&&LIIaffBIIaffs   6BA8 !B8"BBc               /      #    [         R                  " U 0 UD6 nUR                  v   S S S 5        g ! , (       d  f       g = f7frX   )r  r  rr   r  s      rG   r  r    s.     (($9&9Q&&L :99s   A1	A
?Ac              #      #     [         R                  " U S9nUv   [        R                  " U5        g ! [        R                  " W5        f = f7fN)suffix)r  mkdtempshutilrmtree)r  dir_names     rG   TemporaryDirectoryNamer    s7     	$''v6HNMM(#FMM(#s   A3 AAAc              #   p   #    [         R                  " U S9 nUv   S S S 5        g ! , (       d  f       g = f7fr   )r  TemporaryDirectory)r  ds     rG   r  r    s%     ((71G 877s   6%	6
36c                      [         R                  R                  5       n [        [         U S 5      n[        USS 5      =n=(       a    U" 5       $ )NrO   )rM   r  _get_privateuse1_backend_namer   )privateuse1_backend_nameprivateuse1_backend_modulerO   s      rG    is_privateuse1_backend_availabler    sD    $xxEEG!(0H$!O#$>PTUULi[g[iirF   c                 h   ^ S nXl         S H!  mST S3nU4S jn[        XU" U5      5        M#     U $ )Nc                     Xl         S U l        g rX   )_cb_value)r   cbs     rG   	lazy_init"make_lazy_class.<locals>.lazy_init  s    rF   )addr  multruedivfloordivmoddivmodpowlshiftrshiftandorxornegposabsinverteqneltlegtger   r   r   __c                 $   >^ ^ TS;  mU U4S jnU$ )N)r   r   c                    > U R                   b  U R                  5       U l        S U l         T(       d  [        U R                  T5      " U0 UD6$ [        [        T5      " U R                  /UQ70 UD6$ rX   )r  r  r   operator)r   r]   r^   rr   use_operators      rG   wrapped7make_lazy_class.<locals>.inner_wrapper.<locals>.wrapped  s_    88'"&((*DK#DH#"4;;5tFvFF"8T24;;PPPPrF   r=   )rr   r1  r0  basenames   ` @rG   inner_wrapper&make_lazy_class.<locals>.inner_wrapper  s    #?:LQ NrF   )r
  rT  )rU  r  rr   r4  r3  s       @rG   make_lazy_classr6    sH     L
 H:R 	 	=./), JrF   c                       \ rS rSrSrg)LazyVali  r=   Nr>   r?   r@   rA   rE   r=   rF   rG   r8  r8    s    rF   r8  r  numpyfairseqscipyr   r;   r  hpuc                  >    [         R                  R                  5       $ rX   )rM   acceleratorrO   r=   rF   rG   rh   rh     s    5#4#4#A#A#CrF   c                  D    [         R                  R                  5       S:  $ Nr:   )rM   r?  device_countr=   rF   rG   rh   rh     s    (9(9(F(F(H1(LrF   numbatransformersdilllibrosa
opt_einsumz3r   c                 F    [        U 5      S:w  a  U R                  S5      $ / $ )Nr   rn  )r  rR   r  s    rG   split_if_not_emptyrJ    s    q6Q;1773<.B.rF   !PYTORCH_TESTING_DEVICE_EXCEPT_FORzno dillNO_MULTIPROCESSING_SPAWNTEST_WITH_ASANPYTORCH_TEST_WITH_ASAN)rs   TEST_WITH_DEV_DBG_ASANPYTORCH_TEST_WITH_DEV_DBG_ASANTEST_WITH_TSANPYTORCH_TEST_WITH_TSANTEST_WITH_UBSANPYTORCH_TEST_WITH_UBSANTEST_WITH_ROCMPYTORCH_TEST_WITH_ROCMTEST_WITH_MTIAPYTORCH_TEST_WITH_MTIAPYTORCH_MIOPEN_SUGGEST_NHWCrd   re   TEST_WITH_SLOWPYTORCH_TEST_WITH_SLOWTEST_SKIP_FASTPYTORCH_TEST_SKIP_FASTTEST_WITH_CROSSREFPYTORCH_TEST_WITH_CROSSREFTEST_SKIP_CUDAGRAPHPYTORCH_TEST_SKIP_CUDAGRAPHg333333@   zcuda.bindingsc                     SSK nU tp#X!R                  R                  R                  R                  :w  a  [        SU 35      e[        U5      $ )zMakes calls to cuda-python's cuda runtime functions more
pythonic by throwing an exception if they return a status
which is not cudaSuccess
r   NzCUDA failure! )cuda.bindingsbindingsruntimecudaError_tcudaSuccessr  rX  )function_call_outputrN   errorotherss       rG   cuda_python_error_checkrl  A  sF    
 	-MM))55AAA~eW566= rF   c                     U c  gSU ;   a  U R                  S5      OU /n [        U  Vs/ s H  o3R                  S5      PM     sn5      nX$;   a	  XB   S:X  a  ggs  snf )NFrn  rL   TrueT)rR   r   )allocator_configr   optionvarmappings        rG   allocator_option_enabled_fnrs  P  sh    69=M6M'--c2TdSe.>?.>sIIcN.>?@GW_6 @s   AEXPANDABLE_SEGMENTSPYTORCH_CUDA_ALLOC_CONFexpandable_segments)rp  )rs   ru   NUM_PARALLEL_PROCS2i   @g333333?zRequires CUDAc                 0   ^  [        T 5      U 4S j5       nU$ )Nc                  X   > [         (       a  [        R                  " S5      eT" U 0 UD6  g )Nz$test doesn't currently with crossref)r^  r   SkipTestr   s     rG   r   skipIfCrossRef.<locals>.wrapperj  s(    ##$JKKrF   r   r   s   ` rG   skipIfCrossRefr~  i       
2Y   
 NrF   c                       \ rS rSrSS jrSrg)CrossRefModeir  r=   Nc                 ,    U=(       d    0 nU" U0 UD6nU$ rX   r=   )r   functypesr]   r^   rs         rG   __torch_function__CrossRefMode.__torch_function__s  s    2$!&!rF   )r=   N)r>   r?   r@   rA   r  rE   r=   rF   rG   r  r  r  s    rF   r  TEST_WITH_TORCHINDUCTORPYTORCH_TEST_WITH_INDUCTORTEST_WITH_AOT_EAGERPYTORCH_TEST_WITH_AOT_EAGERTEST_WITH_TORCHDYNAMOPYTORCH_TEST_WITH_DYNAMOc                  (    [         =(       d    [        $ rX   )r  r  r=   rF   rG   rh   rh     s    1H5HHrF   )rs   rv   TEST_WITHOUT_COMPILED_AUTOGRAD&PYTORCH_TEST_WITHOUT_COMPILED_AUTOGRAD@   c                     [         (       a3  [        R                  S   S:X  a  [        R                  " S5      " U 5      $ [         (       a  U $ [        R
                  " U 5      $ )Nr   rx  z'skipping numpy 2.0+ dynamo-wrapped test)r  np__version__r   r  expectedFailurer  s    rG   xpassIfTorchDynamo_npr    sH    !2c!9}}FGMM((4Lh.F.Ft.LLrF   c                 H    [         (       a  [        R                  " U 5      $ U $ rX   )TEST_ACLr   r  r  s    rG   
xfailIfACLr        -5X8##D)?4?rF   c                 H    [         (       a  [        R                  " U 5      $ U $ rX   )r  r   r  r  s    rG   xfailIfTorchDynamor    s    -B-B8##D)LLrF   c                 Z    [         R                  S:  a  [        R                  " U 5      $ U $ )N)r<   rb  )r  version_infor   r  r  s    rG   xfailIfPy312Plusr    s%    -0-=-=-H8##D)RdRrF   c                 t    [         (       a,  [        (       d!  [        (       d  [        R                  " U 5      $ U $ rX   )IS_LINUXrU  r   r   r  r  s    rG   xfailIfLinuxr    s'    -5XnnU^U^8##D)hdhhrF   c                 H    [         (       a  [        R                  " U 5      $ U $ rX   )
IS_WINDOWSr   r  r  s    rG   xfailIfWindowsr    s    -7Z8##D)ATArF   c                 L   ^  [        T [        5      (       d   S5       eU 4S jnU$ )z=
Usage:
@skipIfTorchDynamo(msg)
def test_blah(self):
    ...
z*Are you using skipIfTorchDynamo correctly?c                    >^  [        T [        5      (       d  [        T 5      U U4S j5       nU$ [        T [        5      (       d   e[        (       a  ST l        TT l        T $ )Nc                  X   > [         (       a  [        R                  " T5      eT" U 0 UD6  g rX   )r  r   r{  r]   r^   r   msgs     rG   r   5skipIfTorchDynamo.<locals>.decorator.<locals>.wrapper  s'    (("++C00''rF   T)r   r   r   r  __unittest_skip____unittest_skip_why__r   r   r  s   ` rG   r`  $skipIfTorchDynamo.<locals>.decorator  s[    "d##2Y( (
 N"d####  #'B '*B$	rF   r   r   r  r`  s   ` rG   skipIfTorchDynamor    s+     c3M!MM" rF   z.test doesn't currently work with torchinductorc                    ^ ^ UU 4S jnU$ )Nc                    >^  [        T [        5      (       d  [        T 5      UU U4S j5       nU$ [        T [        5      (       d   eT(       a  ST l        TT l        T $ )Nc                  P   > T(       a  [         R                  " T5      eT" U 0 UD6  g rX   r   r{  r]   r^   	conditionr   r  s     rG   r   7skipIfTorchInductor.<locals>.decorator.<locals>.wrapper  $    "++C00''rF   Tr   r   r   r  r  r   r   r  r  s   ` rG   r`  &skipIfTorchInductor.<locals>.decorator  sX    "d##2Y( (
 N"d#####'B '*B$	rF   r=   r  r  r`  s   `` rG   skipIfTorchInductorr    s    " rF   c                 :    [        U [        5      (       d   eS nU$ )zF
Usage:
@runWithoutCompiledAutograd(msg)
def test_blah(self):
    ...
c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                     > [         R                  R                  R                  5          T" U 0 UD6  S S S 5        g ! , (       d  f       g = frX   )rM   _dynamocompiled_autograd_disable)r]   r^   r  s     rG   r   >runWithoutCompiledAutograd.<locals>.decorator.<locals>.wrapper  s2    0099;d%f% <;;s	   	<
A
r}  r  r   s   ` rG   r`  -runWithoutCompiledAutograd.<locals>.decorator  s     	t	& 
	& rF   r  r  s     rG   runWithoutCompiledAutogradr    s$     c3 rF   c                 <   ^  [        T 5      [        L d   eU 4S jnU$ )z8
Decorator for running tests serially.  Requires pytest
c                 j   > [         (       a&  T(       a  [        R                  R                  U 5      $ U $ rX   )
has_pytestrx  markserialr   r  s    rG   r`  serialTest.<locals>.decorator  s$    :);;%%b))	rF   )r   r   )r  r`  s   ` rG   
serialTestr    s$     	?d""" rF   c                 "    S nU c  U$ U" U 5      $ )Nc                     SU l         U $ rk   )dynamo_strictrU  s    rG   r`  )unMarkDynamoStrictTest.<locals>.decorator
  s    !
rF   r=   )rU  r`  s     rG   unMarkDynamoStrictTestr  	  s     {~rF   c                 *   ^ U4S jnU c  U$ U" U 5      $ )z
Marks the test as 'strict'. In strict mode, we reset before and after the
test, and run without suppress errors.

Args:
- nopython: if we should run torch._dynamo.optimize with nopython={True/False}.
c                    >^ [         R                  " U 5      (       a  SU l        TU l        U $ U m[	        T5      U4S j5       nU$ )NTc                    > [         R                  R                  5         [        R                  R                  SS5         T" U 0 UD6  S S S 5        [         R                  R                  5         g ! , (       d  f       N-= f)N$torch._dynamo.config.suppress_errorsF)rM   r  resetr   mockpatchr   s     rG   r   8markDynamoStrictTest.<locals>.decorator.<locals>.wrapper$  sU    MM!$$%KUSD#F# TMM! TSs    	A00
A>)r   isclassr  dynamo_strict_nopythonr   )cls_or_funcr   r   nopythons     @rG   r`  'markDynamoStrictTest.<locals>.decorator  sJ    ??;''(,K%19K.	r	" 
	"
 rF   r=   )r  r  r`  s    ` rG   markDynamoStrictTestr    s!      %%rF   c                 8    [        U [        =(       a    [        S9$ )N)r  r  )r  rU  r  r  s    rG   skipRocmIfTorchInductorr  2  s    3.2\E\]]rF   c                    ^  U 4S jnU$ )Nc                    >^  [        T [        5      (       d  [        T 5      U U4S j5       nU$ [        T [        5      (       d   e[        [        R
                  :X  a  ST l        TT l        T $ )Nc                     > [         (       d   e[         [        R                  :X  a  [        R                  " T5      eT" U 0 UD6  g rX   )rI   r8   rB   r   r{  r  s     rG   r   ;skipIfLegacyJitExecutor.<locals>.decorator.<locals>.wrapper8  s9    %~%~!]%9%99"++C00''rF   T)r   r   r   rI   r8   rB   r  r  r  s   ` rG   r`  *skipIfLegacyJitExecutor.<locals>.decorator6  sc    "d##2Y( ( N"d####]111#'B '*B$	rF   r=   r  s   ` rG   skipIfLegacyJitExecutorr  5  s    & rF   r   .c                    ^ ^^^^ SSK JmJmJm  T c  S $ S[        S[
        S[        4   SS4UUU4S	 jjm[        R                  " T 5      S[        SS4U U4S
 jj5       nU$ )z|
Decorator function to create a dynamo test case. A function annotate with
this decorator takes as input a unittest object.
r   )CompileCounterr  optimize_assertNc                     [        U 5      $ rX   )make_dynamo_testr   s    rG   rh   "make_dynamo_test.<locals>.<lambda>U  s
    *2.rF   r   r   .r   c                    >^ ^^ SUUU 4S jjnT" 5       nU" 5         T" 5         T" U5      " U5      nU" 5         T" 5         g )Nc                     > T " T40 TD6  g rX   r=   )r   r^   r   s   rG   dummy6make_dynamo_test.<locals>.standard_test.<locals>.dummy\  s    tvrF   r  r=   )	r   r   r^   r  actualopt_fnr  r  r  s	   ```   rG   standard_test'make_dynamo_test.<locals>.standard_testW  s:    
	 	  ! (/rF   c                    > T" U TUS9$ )N)r   r^   r=   )r   r^   r   r  s     rG   r   !make_dynamo_test.<locals>.test_fng  s    
 	
rF   )torch._dynamo.testingr  r  r  r   r   r   r   )r   r   r  r  r  r  s   ` @@@@rG   r  r  L  sv     ML	z..S#X 
	   __R
c 
 
 
 NrF   PYTORCH_TEST_WITH_TVTEST_CUDA_MEM_LEAK_CHECK PYTORCH_TEST_CUDA_MEM_LEAK_CHECKc                 \     [         U    $ ! [         a    [         U R                     s $ f = frX   )numpy_to_torch_dtype_dictKeyErrorr   np_dtypes    rG   numpy_to_torch_dtyper
    s0    8(22 8(778s    ++c                 <     [        U 5        g! [         a     gf = fNTF)r
  r  r  s    rG   has_corresponding_torch_dtyper    s$    X&     
z3test doesn't currently work with nn module inliningc                    ^ ^ UU 4S jnU$ )Nc                    >^  [        T [        5      (       d  [        T 5      UU U4S j5       nU$ [        T [        5      (       d   eT(       a  ST l        TT l        T $ )Nc                  P   > T(       a  [         R                  " T5      eT" U 0 UD6  g rX   r  r  s     rG   r   9skipIfNNModuleInlined.<locals>.decorator.<locals>.wrapper  r  rF   Tr  r  s   ` rG   r`  (skipIfNNModuleInlined.<locals>.decorator  sX    "d##2Y( ( N"d#####'B '*B$	rF   r=   r  s   `` rG   skipIfNNModuleInlinedr    s    & rF   z-test doesn't currently work on the ROCm stackr  c                2   ^ U4S jnU (       a  U" U 5      $ U$ )Nc                 @   >^ ^ ST 3m[        T 5      U U4S j5       nU$ )NzskipIfRocm: c                  V   > [         (       a  [        R                  " T5      eT" U 0 UD6$ rX   rU  r   r{  r]   r^   r   r  s     rG   r   +skipIfRocm.<locals>.dec_fn.<locals>.wrapper  s)    ~''//4*6**rF   r}  r   r   r  r  s   ` @rG   dec_fnskipIfRocm.<locals>.dec_fn  s,    u%	r	+ 
	+
 rF   r=   r  r  r  s    ` rG   
skipIfRocmr        	 d|MrF   device_indexc                 T    [         R                  R                  U 5      R                  $ rX   )rM   rN   rP   rQ   )r!  s    rG   getRocmArchNamer#    s    ::++L9EEErF   archc                    ^ [         R                  R                  (       d  g[        5       m[	        U4S jU  5       5      $ )NFc              3   ,   >#    U  H	  oT;   v   M     g 7frX   r=   )r   r   rocmArchs     rG   r   "isRocmArchAnyOf.<locals>.<genexpr>  s     +dH}d   )rM   versionhipr#  any)r$  r'  s    @rG   isRocmArchAnyOfr-    s,    == H+d+++rF   c                    ^  U 4S jnU$ )Nc                 4   >^  [        T 5      UU 4S j5       nU$ )Nc                    > [         (       a+  [        T5      (       a  ST 3n[        R                  " U5      eT" U /UQ70 UD6$ )NzskipIfRocm: test skipped on rU  r-  r   r{  r   r]   r^   r  r$  r   s       rG   wrap_fn/skipIfRocmArch.<locals>.dec_fn.<locals>.wrap_fn  sD    ~/$"7"77v>''//d,T,V,,rF   r}  r   r3  r$  s   ` rG   r  skipIfRocmArch.<locals>.dec_fn       	r	- 
	-
 rF   r=   r$  r  s   ` rG   skipIfRocmArchr9         MrF   c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                  X   > [         (       a	  T" U 0 UD6  g [        R                  " S5      e)Nz+test currently only works on the ROCm stackr  r   s     rG   r   runOnRocm.<locals>.wrapper  s'    >##$QRRrF   r}  r   s   ` rG   	runOnRocmr>    s"    
2YS S
 NrF   c                    ^  U 4S jnU$ )Nc                 4   >^  [        T 5      UU 4S j5       nU$ )Nc                    > [         (       a+  [        T5      (       d  ST 3n[        R                  " U5      eT" U /UQ70 UD6$ )NzskipIfRocm: test only runs on r1  r2  s       rG   r3  .runOnRocmArch.<locals>.dec_fn.<locals>.wrap_fn  sD    ~od&;&;9$@''//d,T,V,,rF   r}  r5  s   ` rG   r  runOnRocmArch.<locals>.dec_fn  r7  rF   r=   r8  s   ` rG   runOnRocmArchrD    r:  rF   c                 H    [         (       a  [        R                  " U 5      $ U $ rX   )IS_S390Xr   r  r  s    rG   xfailIfS390XrG    r  rF   c                    ^  U 4S jnU$ )Nc                 B   > T(       a  [         R                  " U 5      $ U $ rX   )r   r  )r  r  s    rG   r   xfailIf.<locals>.wrapper  s    ++D11KrF   r=   )r  r   s   ` rG   xfailIfrK  
  s    
 NrF   z,test doesn't currently work on the XPU stackc                2   ^ U4S jnU (       a  U" U 5      $ U$ )Nc                 @   >^ ^ ST 3m[        T 5      U U4S j5       nU$ )NzskipIfXpu: c                  V   > [         (       a  [        R                  " T5      eT" U 0 UD6$ rX   TEST_XPUr   r{  r  s     rG   r   *skipIfXpu.<locals>.dec_fn.<locals>.wrapper  s)    x''//4*6**rF   r}  r  s   ` @rG   r  skipIfXpu.<locals>.dec_fn  s,    se$	r	+ 
	+
 rF   r=   r  s    ` rG   	skipIfXpurS    r   rF   c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                  X   > [         (       a  [        R                  " S5      eT" U 0 UD6  g )Nz$test doesn't currently work with MPS)TEST_MPSr   r{  r   s     rG   r   skipIfMPS.<locals>.wrapper"  '    8##$JKKrF   r}  r   s   ` rG   	skipIfMPSrY  !  r  rF   c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                  X   > [         (       a  [        R                  " S5      eT" U 0 UD6  g )Nz$test doesn't currently work with HPU)TEST_HPUr   r{  r   s     rG   r   skipIfHpu.<locals>.wrapper,  rX  rF   r}  r   s   ` rG   	skipIfHpur^  +  r  rF   c                  0    SSK Jn   U " 5       nUS   US   4$ )Nr   )_get_torch_rocm_versionr:   )#torch.testing._internal.common_cudar`  )r`  rocm_versions     rG   getRocmVersionrc  4  s     K*,LO\!_--rF   c                    ^  U 4S jnU$ )Nc                 4   >^  [        T 5      U U4S j5       nU$ )Nc                    > [         (       a>  [        5       nUb  Tb  U[        T5      :  a  SU ST S3n[        R                  " U5      eT" U /UQ70 UD6$ )NzROCm z is available but z	 required)rU  rc  rX  r   r{  )r   r]   r^   rocm_version_tupler  r   r*  s        rG   r3  :skipIfRocmVersionLessThan.<locals>.dec_fn.<locals>.wrap_fn<  sh    ~%3%5"%-DVY^_fYgDg$%7$88J7)S\]F"++F33d,T,V,,rF   r}  )r   r3  r*  s   ` rG   r  )skipIfRocmVersionLessThan.<locals>.dec_fn;  s     	r	- 
	- rF   r=   )r*  r  s   ` rG   skipIfRocmVersionLessThanrj  :  s    	 MrF   c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                  X   > [         (       d  [        R                  " S5      eT" U 0 UD6  g )Nz:test doesn't currently work without MIOpen NHWC activation)TEST_WITH_MIOPEN_SUGGEST_NHWCr   r{  r   s     rG   r   +skipIfNotMiopenSuggestNHWC.<locals>.wrapperH  s(    ,,##$`aarF   r}  r   s   ` rG   skipIfNotMiopenSuggestNHWCro  G  r  rF   z0test doesn't currently work on the Windows stackc                2   ^ U4S jnU (       a  U" U 5      $ U$ )Nc                 @   >^ ^ ST 3m[        T 5      U U4S j5       nU$ )NzskipIfWindows: c                  V   > [         (       a  [        R                  " T5      eT" U 0 UD6$ rX   )r  r   r{  r  s     rG   r   .skipIfWindows.<locals>.dec_fn.<locals>.wrapperT  s)    z''//4*6**rF   r}  r  s   ` @rG   r  skipIfWindows.<locals>.dec_fnQ  s,    "3%(	r	+ 
	+
 rF   r=   r  s    ` rG   skipIfWindowsru  P  r   rF   c                2   ^ U4S jnU (       a  U" U 5      $ U$ )Nc                 @   >^ ^ ST 3m[        T 5      U U4S j5       nU$ )NzskipIfWindowsXPU: c                     > [         (       a9  [        R                  R                  5       (       a  [        R
                  " T5      eT" U 0 UD6$ rX   )r  rM   r   rO   r   r{  r  s     rG   r   1skipIfWindowsXPU.<locals>.dec_fn.<locals>.wrapperc  s;    zeii4466''//4*6**rF   r}  r  s   ` @rG   r   skipIfWindowsXPU.<locals>.dec_fn`  s,    %cU+	r	+ 
	+
 rF   r=   r  s    ` rG   skipIfWindowsXPUr{  _  r   rF   c                     [         R                  R                  5       =(       aI    [         R                  R                  5       S:  =(       a!    [         R                  R	                  5       S:  n [         R                  R	                  5       n[        US-
  5       HJ  n[        US-   U5       H+  n[         R                  R                  X#5      (       a  M)  Sn   O   U (       a  MJ    O   [        U (       + S5      $ )N)rt  r   r;   r:   Fz cuda p2p access is not available)rM   rN   rO   get_device_capabilityrB  r^  can_device_access_peerskip_but_pass_in_sandcastle_if)cuda_p2p_access_availablenum_devicesr   js       rG   requires_cuda_p2p_accessr  n  s    

! 	+JJ,,.&8	+JJ##%* 
 **))+K;?#q1uk*A::44Q::,1) + )( $ *%%* rF   c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                    > [         R                  R                  R                  5       n T" U 0 UD6  [         R                  R                  R                  U5        g ! [         R                  R                  R                  U5        f = frX   )rM   backendsrN   preferred_linalg_libraryr]   r^   _preferred_backendr   s      rG   _fn.setLinalgBackendsToDefaultFinally.<locals>._fn  sb    "^^00IIK	MNN889KLENN889KL   A +Br}  r   r  s   ` rG   !setLinalgBackendsToDefaultFinallyr    s"    
2YM M JrF   c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                    > [         R                  R                  R                  5       n T" U 0 UD6  [         R                  R                  R                  U5        g ! [         R                  R                  R                  U5        f = frX   )rM   r  rN   preferred_blas_libraryr  s      rG   r  ,setBlasBackendsToDefaultFinally.<locals>._fn  sb    "^^00GGI	KNN667IJENN667IJr  r}  r  s   ` rG   setBlasBackendsToDefaultFinallyr    s"    
2YK K JrF   c                   F    \ rS rSrSSS.S jr\S 5       rS rS rS	 r	S
r
g)DeterministicGuardi  FT	warn_onlyfill_uninitialized_memoryc                (    Xl         X l        X0l        g rX   )deterministicr  r  )r   r  r  r  s       rG   r
  DeterministicGuard.__init__  s    *")B&rF   c                     U " [         R                  " 5       [         R                  " 5       [         R                  R                  R
                  S9$ )Nr  )rM   $are_deterministic_algorithms_enabled-is_deterministic_algorithms_warn_only_enabledutilsr  r  r  s    rG   _current_state!DeterministicGuard._current_state  s:    668IIK&+kk&?&?&Y&Y
 	
rF   c                     [         R                  " U R                  U R                  S9  U R                  [         R
                  R                  l        g )Nr  )rM   use_deterministic_algorithmsr  r  r  r  r  s    rG   _updateDeterministicGuard._update  s4    **4+=+=X>B>\>\!!;rF   c                 N    U R                  5       U l        U R                  5         g rX   )r  _restorer  r  s    rG   	__enter__DeterministicGuard.__enter__  s    ++-rF   c                 8    U R                   R                  5         g rX   )r  r  r   exception_typeexception_value	tracebacks       rG   __exit__DeterministicGuard.__exit__  s    rF   )r  r  r  r  N)r>   r?   r@   rA   r
  classmethodr  r  r  r  rE   r=   rF   rG   r  r    s2    38TX C
 
 
] rF   r  c                   &    \ rS rSrS rS rS rSrg)AlwaysWarnTypedStorageRemovali  c                 >    [        U[        5      (       d   eXl        g rX   )r   r   always_warn)r   r  s     rG   r
  &AlwaysWarnTypedStorageRemoval.__init__  s    +t,,,,&rF   c                     [         R                  R                  5       U l        [         R                  R	                  U R
                  5        g rX   )rM   storage&_get_always_warn_typed_storage_removalalways_warn_restore&_set_always_warn_typed_storage_removalr  r  s    rG   r  'AlwaysWarnTypedStorageRemoval.__enter__  s/    #(==#W#W#Y <<T=M=MNrF   c                 V    [         R                  R                  U R                  5        g rX   )rM   r  r  r  r  s       rG   r  &AlwaysWarnTypedStorageRemoval.__exit__  s    <<T=U=UVrF   )r  r  Nr>   r?   r@   rA   r
  r  r  rE   r=   rF   rG   r  r    s    'OWrF   r  c                   &    \ rS rSrS rS rS rSrg)CudaSyncGuardi  c                     Xl         g rX   )mode)r   sync_debug_modes     rG   r
  CudaSyncGuard.__init__  s    #	rF   c                     [         R                  R                  5       U l        [         R                  R	                  U R
                  5        g rX   )rM   rN   get_sync_debug_modedebug_mode_restoreset_sync_debug_moder  r  s    rG   r  CudaSyncGuard.__enter__  s-    "'**"@"@"B

&&tyy1rF   c                 V    [         R                  R                  U R                  5        g rX   )rM   rN   r  r  r  s       rG   r  CudaSyncGuard.__exit__  s    

&&t'>'>?rF   )r  r  Nr  r=   rF   rG   r  r    s    $2@rF   r  c                   &    \ rS rSrS rS rS rSrg)SwapTensorsGuardi  c                     Xl         g rX   )use_swap_tensors)r   r  s     rG   r
  SwapTensorsGuard.__init__  s     0rF   c                     [         R                  R                  5       U l        U R                  b*  [         R                  R                  U R                  5        g g rX   )rM   
__future__$get_swap_module_params_on_conversionswap_tensors_restorer  $set_swap_module_params_on_conversionr  s    rG   r  SwapTensorsGuard.__enter__  sD    $)$4$4$Y$Y$[!  ,AA$BWBWX -rF   c                 V    [         R                  R                  U R                  5        g rX   )rM   r  r  r  r  s       rG   r  SwapTensorsGuard.__exit__  s    ==d>W>WXrF   )r  r  Nr  r=   rF   rG   r  r    s    1Y
YrF   r  c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                     > [        [        R                  " 5       [        R                  " 5       S9    " S S5      nU" 5          T" U 0 UD6  S S S 5        S S S 5        g ! , (       d  f       N= f! , (       d  f       g = f)Nr  c                   $    \ rS rSrSrS rS rSrg)HwrapDeterministicFlagAPITest.<locals>.wrapper.<locals>.CuBLASConfigGuardi	  CUBLAS_WORKSPACE_CONFIGc                     [         R                  R                  U R                  5      U l        S[         R                  U R                  '   g )Nz:4096:8ro   r  r  cublas_var_namecublas_config_restorer  s    rG   r  RwrapDeterministicFlagAPITest.<locals>.wrapper.<locals>.CuBLASConfigGuard.__enter__	  s1    13@T@T1UD.7@BJJt334rF   c                     [         R                  R                  U R                  5      nU R                  c   Ub  [         R                  U R                  	 g g U R                  [         R                  U R                  '   g rX   r  )r   r  r  r  cur_cublas_configs        rG   r  QwrapDeterministicFlagAPITest.<locals>.wrapper.<locals>.CuBLASConfigGuard.__exit__
	  sa    (*

t7K7K(L%119,8 "

4+?+? @ 9 <@;U;U

4#7#78rF   )r  N)r>   r?   r@   rA   r  r  r  rE   r=   rF   rG   CuBLASConfigGuardr  	  s    ";AVrF   r  )r  rM   r  r  )r]   r^   r  r   s      rG   r   -wrapDeterministicFlagAPITest.<locals>.wrapper  sl    ::<MMOQV V #$D#F# %#Q Q" %$#Q Qs#   A/	AA/
A,	(A//
A=r}  r   s   ` rG   wrapDeterministicFlagAPITestr    s     
2Y$ $( NrF   c                    ^  U 4S jnU$ )Nc                 4   >^  [        T 5      U U4S j5       nU$ )Nc                  `   > [        T5         T" U 0 UD6  S S S 5        g ! , (       d  f       g = frX   )r  )r]   r^   r   swaps     rG   r   4wrapSwapTensorsTest.<locals>.dec_fn.<locals>.wrapper	  s$    !$'D#F# (''s   	
-r}  )r   r   r  s   ` rG   r  #wrapSwapTensorsTest.<locals>.dec_fn	  s     	r	$ 
	$ rF   r=   )r  r  s   ` rG   wrapSwapTensorsTestr  	  s     MrF   c                   .   ^  \ rS rSrU 4S jrS rSrU =r$ )r  i$	  c                 .   > [         TU ]  5         Xl        g rX   )r  r
  swap_values)r   r  r  s     rG   r
  swap.__init__%	  s    &rF   c              #   h   #    U R                    H  n[        U5      " U5      SU 30 S 4v   M      g 7f)Nswap_c                     / $ rX   r=   r  s    rG   rh   (swap._parametrize_test.<locals>.<lambda>+	  s    QSrF   )r  r  )r   r   r)  r*  r  s        rG   r+  swap._parametrize_test)	  s4     $$D%d+D1U4&>2|SS %s   02)r  )r>   r?   r@   rA   r
  r+  rE   r  r  s   @rG   r  r  $	  s    'T TrF   r  c                    ^ ^ [         mT(       a-   [        R                  " [        R                  " SS/5      5        [        T 5      U U4S j5       nU$ ! [
         a    Sm N%f = f)Nr;   Fc                  P   > T(       d  [         R                  " S5      eT" U 0 UD6  g )Nz*PyTorch was compiled without numpy supportr  )r]   r^   r   numpy_supports     rG   r   +skipIfCompiledWithoutNumpy.<locals>.wrapper9	  s%    ##$PQQrF   )
TEST_NUMPYrM   
from_numpyr  arrayrA  r   )r   r   r  s   ` @rG   skipIfCompiledWithoutNumpyr  -	  sd     M	" RXXq!f-. 2Y   
 N  	"!M	"s   ,A A#"A#c                    ^ ^ UU 4S jnU$ )Nc                    > T" U T5      $ rX   r=   )r   rz  r   s    rG   run_test_function)_test_function.<locals>.run_test_functionB	  s    $rF   r=   )r   rz  r  s   `` rG   _test_functionr  A	  s     rF   c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                     > [         R                  R                  R                  (       d  [        R
                  " S5      eT" U 0 UD6  g )NzIXNNPACK must be enabled for these tests. Please build with USE_XNNPACK=1.)rM   r  xnnpackrw   r   r{  r   s     rG   r    skipIfNoXNNPACK.<locals>.wrapperG	  s5    ~~%%--##$opprF   r}  r   s   ` rG   skipIfNoXNNPACKr  F	  r  rF   c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                     > [         R                  R                  (       d  [        R                  " S5      eT" U 0 UD6  g )NzPyTorch compiled without Lapack)rM   r  
has_lapackr   r{  r   s     rG   r   skipIfNoLapack.<locals>.wrapperP	  s/    xx""##$EFFrF   r}  r   s   ` rG   skipIfNoLapackr  O	  r  rF   c                 .    [         R                  " S5      $ )a,  Wraps the decorator to hide the import of the `core`.

Args:
    op_name: Check if this op is registered in `core._REGISTERED_OPERATORS`.
    message: message to fail with.

Usage:
    @skipIfNotRegistered('MyOp', 'MyOp is not linked!')
        This will check if 'MyOp' is in the caffe2.python.core
z"Pytorch is compiled without Caffe2)r   r  )op_namemessages     rG   skipIfNotRegisteredr  X	  s     ===>>rF   c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                  X   > [         (       d  [        R                  " S5      eT" U 0 UD6  g )Nz'test require SciPy, but SciPy not found)
TEST_SCIPYr   r{  r   s     rG   r   skipIfNoSciPy.<locals>.wrapperf	  s'    z##$MNNrF   r}  r   s   ` rG   skipIfNoSciPyr  e	  r  rF   c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                  h   > S[         R                  ;   a  [        R                  " S5      eT" U 0 UD6$ )NPYTEST_CURRENT_TESTzdoes not work under pytest)ro   r  r   r{  r   s     rG   r1  skip_if_pytest.<locals>.wrappedo	  s1     BJJ.##$@AA4"6""rF   r}  )r   r1  s   ` rG   skip_if_pytestr  n	  s     
2Y# #
 NrF   c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                  X   > [         (       d  [        R                  " S5      eT" U 0 UD6  g )Nz)test required PyTorched compiled with XPUrO  r   s     rG   r   skipIfNoXPU.<locals>.wrapperx	  s'    x##$OPPrF   r}  r   s   ` rG   skipIfNoXPUr#  w	  r  rF   c                 N   ^  [        T 5      U 4S j5       nSUR                  S'   U$ )Nc                  X   > [         (       d  [        R                  " S5      eT" U 0 UD6  g )N<test is slow; run with PYTORCH_TEST_WITH_SLOW to enable test)rZ  r   r{  r   s     rG   r   slowTest.<locals>.wrapper	  s'    ~##$bccrF   T	slow_test)r   __dict__r   s   ` rG   slowTestr*  	  s0    
2Y   
 %)G[!NrF   c                 "    U (       a  [         $ S $ )Nc                     U $ rX   r=   r  s    rG   rh   slowTestIf.<locals>.<lambda>	  s    rF   )r*  )r  s    rG   
slowTestIfr.  	  s     83m3rF   c                    ^  U 4S jnU$ )Nc                 D   > [        U SS5      (       a  T(       + U l        U $ )N_do_cuda_memory_leak_checkT)r   r1  r  s    rG   dec&skipCUDAMemoryLeakCheckIf.<locals>.dec	  s"    23T::09MB)	rF   r=   r  r2  s   ` rG   skipCUDAMemoryLeakCheckIfr5  	       JrF   c                    ^  U 4S jnU$ )Nc                 D   > [        U SS5      (       a  T(       + U l        U $ )N_do_cuda_non_default_streamT)r   r9  r  s    rG   r2  'skipCUDANonDefaultStreamIf.<locals>.dec	  s"    24d;;1:]B*	rF   r=   r4  s   ` rG   skipCUDANonDefaultStreamIfr;  	  r6  rF   c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                     > [         R                  " 5          [         R                  " S5        T" U 0 UD6  S S S 5        g ! , (       d  f       g = f)Nignore)r  catch_warningssimplefilterr   s     rG   r   "suppress_warnings.<locals>.wrapper	  s6    $$&!!(+ '&&s	   ?
Ar}  r   s   ` rG   suppress_warningsrB  	  s     
2Y    NrF   c                   ^ Tc  0 m[        U [        R                  5      (       a{  U R                  (       d   eTR	                  U R
                  U R
                  5      n[        R                  " 5          U R                  USSS9nU R                  Ul        S S S 5        U$ [        R                  " U 5      (       a<  U R                  5       R                  U R                  5       5      R                  U 5      $ [        U [        5      (       a  U  Vs/ s H  n[        UT5      PM     sn$ [        U [         5      (       a  [!        U4S jU  5       5      $ [#        U 5      $ ! , (       d  f       W$ = fs  snf )NrN   T)rx  rz  copyc              3   <   >#    U  H  n[        UT5      v   M     g 7frX   )to_gpu)r   otype_maps     rG   r   to_gpu.<locals>.<genexpr>	  s     6#QVAx((#s   )r   rM   r   is_leafr  rx  no_gradtorequires_grad
is_storagenewresize_sizecopy_r8  rF  rX  r   )objrH  tresrG  s    `   rG   rF  rF  	  s   #u||$${{{LLCII.]]_&&qd&;C # 1 1C  
			#		wwy  ,22377	C		-01Sq(#S11	C		6#666} _ 
 2s   4#EE1
E.c                 B    [         R                  " U 5      R                  $ rX   )r   getfullargspecr]   r  s    rG   get_function_arglistrX  	  s    !!$',,,rF   c                     U c  [         n [        R                  " U 5        [        R                  " U 5        [
        (       a   [        R                  R	                  U 5        g g rX   )r  rM   manual_seedrandomr  r  r  )r  s    rG   r  r  	  s@    |	d
KKz
		t rF   c              #      #    [         R                  " 5       n[         R                  " U 5         S v   [         R                  " U5        g ! [         R                  " U5        f = f7frX   )rM   get_default_dtypeset_default_dtype)rx  saved_dtypes     rG   r^  r^  	  sE     ))+K	E"-,,   ,A%A
 A%
A""A%c              #      #    [         R                  " / 5      R                  5       n[         R                  " U 5         S v   [         R                  " U5        g ! [         R                  " U5        f = f7frX   )rM   tensorr   set_default_tensor_type)tensor_typesaved_tensor_types     rG   rc  rc  	  sQ     R(--/	!!+.9%%&78%%&78s   ;A4A A4A11A4c                     U R                  5       S:X  a  [        S5      $ U R                  5       S:X  a  [        U R                  S5      5      $ [        S U R                  5        5       6 $ )Nr   r:   c              3   8   #    U  H  n[        U5      v   M     g 7frX   r]  )r   rs  s     rG   r   iter_indices.<locals>.<genexpr>	  s     5}!U1XX}s   )dimr^  rQ  r   )rb  s    rG   iter_indicesrj  	  sQ    zz|qQxzz|qV[[^$$5v{{}566rF   c                 <     [        U 5        g! [         a     gf = fr  )r  	TypeError)rS  s    rG   is_iterablerm  	  s#    S	 r  c                     [        U [        R                  5      (       a  g [        U 5      S:X  a  U$ [	        U 5       H$  n[        U[        R                  5      (       a  M$    g   g! [
         a     gf = f)zReturns True if iterable is an iterable of tensors and False o.w.

If the iterable is empty, the return value is :attr:`include_empty`
Fr   T)r   rM   r   r  r  rl  )iterableinclude_emptyrT  s      rG   is_iterable_of_tensorsrq  	  sj     (ELL))	x=A  hAa..     s"   A' +A' "A' $A' '
A43A4c                        \ rS rSrS rS rSrg)CudaNonDefaultStreami 
  c                 F   [         R                  R                  5       n/ U l        [	        [         R                  R                  5       5       H  nU R                  R                  [         R                  R                  U5      5        [         R                  R                  US9nU R                  S   R                  5         [         R                  R                  UR                  UR                  UR                  S9  M     [         R                  R                  U5        g )Nrz  r  	stream_idr!  device_type)rM   rN   current_devicebeforeStreamsr^  rB  r  current_streamStreamsynchronizer  _cuda_setStreamrw  r!  rx  _cuda_setDevice)r   beforeDevicer	  deviceStreams       rG   r  CudaNonDefaultStream.__enter__
  s     zz002uzz..01A%%ejj&?&?&BC ::,,A,6Lr"..0HH$$|/E/E2>2K2K1=1I1I % K	 2 	  .rF   c                    [         R                  R                  5       n[        [         R                  R	                  5       5       Hg  n[         R
                  R                  U R                  U   R                  U R                  U   R                  U R                  U   R                  S9  Mi     [         R
                  R                  U5        g )Nrv  )rM   rN   ry  r^  rB  r  r~  rz  rw  r!  rx  r  )r   exc_type	exc_valuer  r  r	  s         rG   r  CudaNonDefaultStream.__exit__
  s     zz002uzz..01AHH$$t/A/A!/D/N/N262D2DQ2G2T2T151C1CA1F1R1R % T 2 	  .rF   )rz  Nr>   r?   r@   rA   r  r  rE   r=   rF   rG   rs  rs   
  s    //rF   rs  c                   *    \ rS rSrSS jrS rS rSrg)CudaMemoryLeakChecki
  Nc                 ^    Uc  UR                  5       OUU l        Xl        SSKJn  U" 5         g )Nr   )initialize_cuda_context_rng)r   rr   r~  ra  r  )r   r~  rr   r  s       rG   r
  CudaMemoryLeakCheck.__init__
  s&    %)\HKKMt	  	T#%rF   c                    / U l         / U l        [        R                  R	                  5       n[        U5       H{  n[        R                  R                  U5      nUS:  d  M*  [        R                  " 5         [        R                  R                  5         [        R                  R                  5           O   [        U5       H{  nU R                   R                  [        R                  R                  U5      5        [        R                  R                  U5      u  pEXT-
  nU R                  R                  U5        M}     g Nr   )caching_allocator_beforesdriver_beforesrM   rN   rB  r^  memory_allocatedr   r   r  _cuda_clearCublasWorkspacesr   r  mem_get_info)r   r  r   caching_allocator_mem_allocated
bytes_freebytes_totaldriver_mem_allocateds          rG   r  CudaMemoryLeakCheck.__enter__)
  s    )+&  jj--/{#A.3jj.I.I!.L+ /2

446

&&( $ {#A**11%**2M2Ma2PQ&+jj&=&=a&@#J#.#; &&';<	 $rF   c                 ^   Ub  g Sn[         R                  R                  5       n[        U5       HV  n[         R                  R                  5         [         R                  R                  U5      nXpR                  U   :  d  MT  Sn  O   U(       d  g [        R                  " 5         [         R                  R                  5         [        U5       GHY  nSn[        S5       H  n[         R                  R                  U5      n[         R                  R                  U5      u  pX-
  nSnSnXpR                  U   :  a  SnXR                  U   :  a  SnU(       a  M|  U(       a  M  Sn  O   U(       d  M  W(       aX  W(       dQ  SU R                   SU R                  U    SW SU SU R                  U    S	W S
3n[        R                  " USS9  GM  U(       d  GM  W(       d  GM  SU R                   SU R                  U    SW SU SU R                  U    S	W S
3n[!        U5      e   g )NFTr<   zOCUDA caching allocator reports a memory leak not verified by the driver API in z)! Caching allocator allocated memory was z and is now reported as z on device z#. CUDA driver allocated memory was z and is now r   r;   r  z$CUDA driver API confirmed a leak in )rM   rN   rB  r^  r  r  r  r  r   r   r   r  r  rr   r  r  rA  )r   r  r  r  discrepancy_detectedr  r   r  r   r  r  r  caching_allocator_discrepancydriver_discrepancyr  s                  rG   r  CudaMemoryLeakCheck.__exit__@
  sH   
  %jj--/{#AHH002.3jj.I.I!.L+.1O1OPQ1RR'+$ $ $ 	



 {#A#'  1X27**2M2Ma2P/*/***A*A!*D'
'2'?$05-%*"25S5STU5VV481'*=*=a*@@)-&559K9K+0(# & (,5G88<		{ CAAEA_A_`aAb@c d11P0Q R$$%3 ';;?;N;Nq;Q:RR^_s^ttuw ca0..3E3E >dii[ IAAEA_A_`aAb@c d11P0Q R$$%3 ';;?;N;Nq;Q:RR^_s^ttu	w #3''c $rF   )r  r  rr   r~  rX   r  r=   rF   rG   r  r  
  s    &=.S(rF   r  c              #   f   #     S v   g ! U  a  n[         R                  " SU 35      UeS nAff = f7f)Nznot implemented: r  )r  es     rG   skip_exception_typer  
  s:     @ @"3A3 78a?@s   1	 1.).1c              #     #     S v   g ! [         R                   a    e [         a  nSn[        USS 5      nUb  SUR                   3nSR                  [        S U/U Q75      5      n[        SS[        R                  " SSR                  [        S U/U Q75      5      05      S9  S	U S
3n[        UR                  5      S:  a*  UR                  S    SU 3/UR                  SS  Q7Ul        e S nAff = f7f)NrH   _tracked_inputz"PYTORCH_OPINFO_SAMPLE_INPUT_INDEX=r   test_reprostest_failurerepro)	subsystemrr   
parameterszE
To execute this test, run the following from the base repo dir:
    zL

This message can be suppressed by setting PYTORCH_PRINT_REPRO_ON_FAILURE=0r:   r   
)r   r{  r   r   r   r   filterr   r   dumpsr  r]   )repro_partsr  sample_isolation_prefixr   	repro_str	repro_msgs         rG   print_repro_on_failurer  
  s    !  "$#3T:$(J=K^K^J_&`#HHVD+B*Q[*QRS	#zzSXXfT4K3Zk3Z&[\	
K KN	 qvv;!2i[1?AFF12J?AF;s%   C7	 C7C4CC//C44C7c                      SU;   a/  [         R                  R                  S:  a  UR                  S5        [         R                  " U 0 UD6$ )Nmin_satisfying_examples)r<   8   r   )
hypothesisr*  __version_info__popsettingsr\   s     rG   r  r  
  sA    $.:3E3E3V3VZd3dJJ01""D3F33rF   
pytorch_ci2   )derandomizesuppress_health_checkdatabasemax_examplesr  dev
   )r  r  r  r  debugi  PYTORCH_HYPOTHESIS_PROFILEzEFail to import hypothesis in common_utils, tests are not derandomizedr  r   c                    SSK Jn  U" 5        Vs/ s H  o"R                  PM     nn[        5        Vs/ s H  n[	        U5      [        S5      S  PM     nnU R                  S5      n[        U5      S:  aI  US   U;   a@  [        U5      S:  a  US   U;   a  SR                  USS 5      $ SR                  USS 5      $ U $ s  snf s  snf )Nr   )get_device_type_test_basesztorch.r   r  r:   rS  )*torch.testing._internal.common_device_typer  rx  r,   r   r  rR   r   )r   r  r   device_suffixesdtdtype_suffixestest_name_chunkss          rG    remove_device_and_dtype_suffixesr  
  s    U.H.JK.J}}.JOK8F8HI8H"c"gc(mn-8HNI s+
q %5b%9^%K 1$)9")=)P88,Qr233xx(2.// LIs
   C!Cr   c                   ^ ^	^
^^ [        T R                  5      R                  S5      S   R                  S5      S   m	[        T R                  5      mS[         4U	UU 4S jjm
[        U
4S j[         5       5      (       aD  S[        T T R                  5      R                  S	'   [        (       d  [        R                  " S
5      e[        (       Gd  SnSn[        R                  5        GH+  u  nu  pET
" U5      (       d  M  [        [        [         [         ["        [$        [&        [(        [*        [*        [,        [        S.m[/        [1        U4S jU5      5      n[3        U5      S:  ae  SR5                  U5      nSR5                  TR7                  5       5      n[9        SU S3SU SU S3SSU 35        [/        [1        U4S jU5      5      nU/ :X  d  [        U4S jU 5       5      (       d  GM  SnSU SU/ :X  a  SOS SSR5                  U5       S3n  O   U(       a!  [:        (       d  [        R                  " U5      eU(       d#  [:        (       a  Sn[        R                  " U5      e[<        (       ah  [?        T T R                  5      (       aL  [        T T R                  5      R                  RA                  S	S5      (       d  [        R                  " S 5      eg g g )!Nrm   r:   r   r  r  c                    > U R                  5       n[        U5      S:  a  gUS   nUS   SS R                  S5      S   nTR                  U5      =(       a    UTR                  T4;   $ )Nr;   Fr   r:   r  r   )rR   r  r   _testMethodName)r  target_test_partstarget_testnametarget_classnamer  sanitized_testnamer   s       rG   matches_test%check_if_enable.<locals>.matches_test
  sv    "LLN !A%+A.,Q/"5;;C@D ##$45y?tOcOcewNx;xyrF   c              3   4   >#    U  H  nT" U5      v   M     g 7frX   r=   )r   r   r  s     rG   r   "check_if_enable.<locals>.<genexpr>  s     
4Oq<??O   Tr(  r&  FrH   )macmacoswinwindowsr  rocmr   asandynamodynamo_wrappedinductorslowc                    > U T;  $ rX   r=   r5  platform_to_conditionals    rG   rh   !check_if_enable.<locals>.<lambda>%  s    !CZ:ZrF   r   , zTest z# is disabled for some unrecognized zplatforms: [z]. Please edit issue z to fix the platforms zLassigned to this flaky test, changing "Platforms: ..." to a comma separated zDsubset of the following (or leave it blank to match all platforms): c                    > U T;   $ rX   r=   r  s    rG   rh   r  0  s    a;R6RrF   c              3   .   >#    U  H
  nTU   v   M     g 7frX   r=   )r   r   r  s     rG   r   r  2  s     )f\ePX*A(*K\es   z7Test is disabled because an issue exists disabling it:  for allzplatform(s) z. If you're seeing this on your local machine and would like to enable this test, please make sure CI is not set and you are not using the flag --import-disabled-tests.zcTest is enabled but --rerun-disabled-tests verification mode is set, so only disabled tests are runz8test is fast; we disabled it with PYTORCH_TEST_SKIP_FAST)!r   r  rR   r  r  r,  r  r   r)  rZ  r   r{  r   r  r   IS_MACOSr  r  rU  rP  rM  r  r  r8  r  r  r   r?  rI  r  r\  r   r  )r   should_skipskip_msgdisabled_test	issue_url	platformsinvalid_platformsinvalid_plats_strvalid_platsr  r  r  r  s   `        @@@@rG   check_if_enabler  
  s   DNN#))#.q177<R@I9$:N:NO
zS 
z 
z 
4O
444DHd**+44[A~##$bcc=5H5N5N5P1M1IM**#%%)%*#*3&; 7*1' %)0Z\e)f$g!()A-(,		2C(D%"&)),C,H,H,J"KKE-0ST():(;;PQZP[[qrh`al`mnp !%V,RT]%^ _I?c)f\e)f&f&f"&K!XYbXcbbAdiiXaNbMc dq qH I 6QL 33##H--33*H##H--~4--..wtTEYEY7Z7c7c7g7ghsuz7{7{##$^__ 8|. rF   c                   X   ^  \ rS rSrSr\" SS5      R                  rS rU 4S jr	Sr
U =r$ )RelaxedBooleanPairiQ  zPair for boolean-like inputs.

In contrast to the builtin :class:`BooleanPair`, this class also supports one input being a number or a single
element tensor-like.
r   c                   [         R                  [        R                  4n/ U R                  QU R
                  QUQ7n[        XR                  5      (       a  [        X%5      (       d:  [        X R                  5      (       a  [        X5      (       d  U R                  5         X4 Vs/ s H  o`R                  XcS9PM     sn$ s  snf Nr   )	rM   r   r  ndarray_supported_types_supported_number_typesr   _inputs_not_supported_to_boolr   r  expectedr   tensor_or_array_typesother_supported_typesinputs          rG   _process_inputs"RelaxedBooleanPair._process_inputsY  s     49<<2L o$"7"7 o$:V:V oYn o 5 566:h;f;f8%:%:;;
6@i@i&&(:@9KL9Ke+9KLLLs   'Cc                  > [        U[        R                  5      (       a  [        UR	                  5       5      $ [        U5      U R                  ;   a  [        U5      $ [        U[        R                  [        R                  45      (       as  [        U[        R                  5      (       a  UR                  5       OUR                  nUS:  a  U R                  [        SU S3US9  [        UR	                  5       5      $ [        TU ]=  XS9$ )Nr:   zHOnly single element tensor-likes can be compared against a boolean. Got  elements instead.r  )r   r  numberr   r  r   r  rM   r   r  numelrQ  _failr  r  r  )r   	bool_liker   r  r  s       rG   r  RelaxedBooleanPair._to_boolf  s    i++	()))_ < <<	?"	ELL"**#=>>)3Iu||)L)LIOO%R[R`R`Eqy

 '!35	   	())7#I#55rF   r=   )r>   r?   r@   rA   r4  r(   r  r  r  r  rE   r  r  s   @rG   r  r  Q  s-    
 )A.??M6 6rF   r  c                      ^  \ rS rSrSr\\R                  \\R                  \
\R                  0rSSSS. S
U 4S jjjrS rU 4S jrS	rU =r$ )RelaxedNumberPairiz  a  Pair for number-like inputs.

In contrast to the builtin :class:`NumberPair`, this class also supports one input being a single element
tensor-like or a :class:`enum.Enum`. (D)Type checks are disabled, meaning comparing 1 to 1.0 succeeds even when
``check_dtype=True`` is passed.

In addition, this class uses looser default tolerances for :class:`float` and :class:`complex` inputs. Also
supports overriding the absolute and relative tolerance through the ``@precisionOverride`` and
``@toleranceOverride`` decorators.
        N)rtol_overrideatol_overridecheck_dtypec                   > [         TU ]  " X4SS0UD6  [        U R                  U5      U l        [        U R                  U5      U l        g )Nr  Fr  r
  maxrtolatol)r   r  r  r  r  r  other_parametersr  s          rG   r
  RelaxedNumberPair.__init__  sA     	QuQ@PQ		=1			=1	rF   c                v   [         R                  [        R                  4n/ U R                  QUQ7n[        XR                  5      (       a  [        X%5      (       d:  [        X R                  5      (       a  [        X5      (       d  U R                  5         X4 Vs/ s H  o`R                  XcS9PM     sn$ s  snf r  )rM   r   r  r  r  r   r  
_to_numberr  s          rG   r  !RelaxedNumberPair._process_inputs  s     49<<2L P$"7"7 P:O PF$9$9::z(?j?jx)>)>??JvDmDm&&(<B;MN;M%-;MNNNs   B6c                *  > [        U[        R                  [        R                  45      (       a  [        U[        R                  5      (       a  UR                  5       OUR                  nUS:  a  U R                  [        SU S3US9  UR                  5       n[        U[        5      (       a  [        U5      nU$ [        U[        5      (       a  [        U5      $ [        TU ]9  XS9n[        U5      U R                   ;  a  U R#                  5         U$ )Nr:   zGOnly single element tensor-likes can be compared against a number. Got r  r  )r   rM   r   r  r  r  rQ  r  r  r  r   r   r	   r  r  r   _TYPE_TO_DTYPEr  )r   number_liker   r  r  r  s        rG   r  RelaxedNumberPair._to_number  s    kELL"**#=>>+5k5<<+P+PK%%'VaVfVfEqy

 '!35	   !%%'F&$''VMT**{##W'';FF|4#6#66**,MrF   r  r  r  )r>   r?   r@   rA   r4  r   rM   int64r|  float32complex	complex64r  r
  r  r  rE   r  r  s   @rG   r  r  z  sX    	 	U[[u}}N 69Y]2	2 2O rF   r  c                   <   ^  \ rS rSrSrSSS.U 4S jjrS rSrU =r$ )TensorOrArrayPairi  ag  Pair for tensor-like inputs.

On the one hand this class is stricter than the builtin :class:`TensorLikePair` since it only allows instances of
:class:`torch.Tensor` and :class:`numpy.ndarray` rather than allowing any tensor-like than can be converted into a
tensor. On the other hand this class is looser since it converts all inputs into tensors with no regard of their
relationship, e.g. comparing a :class:`torch.Tensor` to :class:`numpy.ndarray` is fine.

In addition, this class supports overriding the absolute and relative tolerance through the ``@precisionOverride``
and ``@toleranceOverride`` decorators.
r  r  r  c                   > [         TU ]  " X40 UD6  [        U R                  U5      U l        [        U R                  U5      U l        g rX   r  r   r  r  r  r  r  r  s         rG   r
  TensorOrArrayPair.__init__  s:    >-=>		=1			=1	rF   c                   ^  T R                  X[        R                  [        R                  4S9  U 4S jX4 5       u  pX4 H  nT R                  XSS9  M     X4$ )Nr  c              3   F   >#    U  H  nTR                  U5      v   M     g 7frX   )
_to_tensor)r   r   r   s     rG   r   4TensorOrArrayPair._process_inputs.<locals>.<genexpr>  s     S@RuDOOE22@Rs   !r  )_check_inputs_isinstancerM   r   r  r  _check_supported)r   r  r  r   allow_subclassesrb  s   `     rG   r  !TensorOrArrayPair._process_inputs  sZ    %%fU\\2::<V%WS@RS(F!!&!0 )rF   r  )	r>   r?   r@   rA   r4  r
  r  rE   r  r  s   @rG   r$  r$    s#    	 ;>S 2 2
   rF   r$  c                   <   ^  \ rS rSrSrSSS.U 4S jjrS rSrU =r$ )TypedStoragePairi  z4Pair for :class:`torch.storage.TypedStorage` inputs.r  r%  c                   > U R                  X[        R                  R                  S9  [        TU ]  " X40 UD6  [        U R                  U5      U l        [        U R                  U5      U l        g Nr  )	r-  rM   r  TypedStorager  r
  r  r  r  r'  s         rG   r
  TypedStoragePair.__init__  sW    %%fEMM<V<V%W>-=>		=1			=1	rF   c                    [         R                  " UR                  [         R                  [         R                  [         R
                  [         R                  [         R                  [         R                  [         R                  [         R                  [         R                  [         R                  0R                  UR                  UR                  5      UR                  S9$ )Nrx  rz  )rM   rb  _untyped_storagequint8uint8quint4x2quint2x4qint32int32qint8int8r  rx  rz  )r   typed_storages     rG   r+  TypedStoragePair._to_tensor  s    ||**ekkekkUZZ c-%%}':':; ''

 
	
rF   r  )	r>   r?   r@   rA   r4  r
  r+  rE   r  r  s   @rG   r2  r2    s    >:=S 2 2
 
rF   r2  c                   f   ^  \ rS rSr% Sr\\\\S4   4   \S'   Sr	\
\   \S'   U 4S jrS rS	rU =r$ )
UnittestPairi  af  Fallback ABC pair that handles non-numeric inputs.

To avoid recreating the mismatch messages of :meth:`unittest.TestCase.assertEqual`, this pair simply wraps it in
order to use it with the :class:`Pair` "framework" from :func:`are_equal`.

Define the :attr:`UnittestPair.CLS` in a subclass to indicate which class(es) of the inputs the pair should support.
.CLSN	TYPE_NAMEc                 \   > U R                  XU R                  S9  [        TU ]  " X40 UD6  g r4  )r-  rF  r  r
  )r   r  r  r  r  s       rG   r
  UnittestPair.__init__  s-    %%fDHH%E>-=>rF   c                    [         R                  " 5       n UR                  U R                  U R                  5      $ ! UR
                   a  n[        U5      n S nAOS nAff = fU R                  =(       dD    [        U R                  [        5      (       a  U R                  OU R                  S   R                  nU R                  [        UR                  5        SU 35        g )Nr   z comparison failed: )r   r   assertEqualr  r  failureExceptionr   rG  r   rF  r   r>   r  AssertionErrortitle)r   rm  rj  r  	type_names        rG   compareUnittestPair.compare  s    %%'		((dmmDD)) 	e*C	 NNh:dhh3M3MtxxSWS[S[\]S^&h&h	

>ioo&7%88LSE#RSs   %= A"AA"r=   )r>   r?   r@   rA   r4  r   r   rX  r   rG  r   r   r
  rP  rE   r  r  s   @rG   rE  rE    sB     
tU49%%	&&#Ix}#?	T 	TrF   rE  c                        \ rS rSr\\4rSrSrg)
StringPairi  stringr=   N)	r>   r?   r@   rA   r   bytesrF  rG  rE   r=   rF   rG   rS  rS    s    ,CIrF   rS  c                       \ rS rSr\rSrg)SetPairi  r=   N)r>   r?   r@   rA   r>  rF  rE   r=   rF   rG   rW  rW    s    
CrF   rW  c                       \ rS rSr\rSrg)TypePairi
  r=   N)r>   r?   r@   rA   r   rF  rE   r=   rF   rG   rY  rY  
  s    
CrF   rY  c                       \ rS rSr\rSrg)
ObjectPairi  r=   N)r>   r?   r@   rA   r  rF  rE   r=   rF   rG   r[  r[    s    
CrF   r[  c                   (   ^  \ rS rSrU 4S jrSrU =r$ ),AssertRaisesContextIgnoreNotImplementedErrori  c                    > Ub3  [        U[        5      (       a  U R                  R                  SU 35        [        TU ]  XU5      $ )Nznot_implemented: )
issubclassr(  rm  skipTestr  r  )r   r  r  tbr  s       rG   r  5AssertRaisesContextIgnoreNotImplementedError.__exit__  sB    Jx9L$M$MNN##&7	{$CDwR88rF   r=   )r>   r?   r@   rA   r  rE   r  r  s   @rG   r]  r]    s    9 9rF   r]  new_valc              #      #    [         R                  " 5       n[         R                  " U 5         S v   [         R                  " U5        g ! [         R                  " U5        f = f7frX   )rM   is_warn_always_enabledset_warn_always)rc  old_vals     rG   set_warn_always_contextrh  !  sE     **,G	'"'g&g&r`  c                       \ rS rSrSrSrg)NoTesti+  Fr=   N)r>   r?   r@   rA   __test__rE   r=   rF   rG   rj  rj  +  s    HrF   rj  c            
         ^  \ rS rSr% Sr\\S'   Sr\\S'   Sr\	\S'   \
R                  rSrS r\S	\4S
 j5       r\R"                  S\S	S4S j5       r\S	\4S j5       r\R"                  S\S	S4S j5       rSrSrSrSSU 4S jjrSTS jrS rS rS rS rSUU 4S jjrSSSS.S jrSVU 4S jjrSVU 4S jjrS r S r!S r"S r#S r$S  r%STU 4S! jjr&STS" jr'S# r(S$ r)\*SS%.S& j5       r+S'SS(.S) jr,SS*.S+ jr-SS*.S, jr.SS*.S- jr/SS*.S. jr0S/ r1             SWS0 jr2S1 r3S2 r4 SVS3 jr5SXS4 jr6SXS5 jr7 STSSSSSSSSS6.S7\8\9\:\;\:/\:4   4      S8\8\   S9\8\   4S: jjjr<STSSS;.S7\8\:   S8\8\   S9\8\   S	S4S< jjjr=SXS= jr>S>\?S?\@\?   S	S4S@ jrAU 4SA jrBU 4SB jrCSC rDSD rESYSE jrF\GSYSF j5       rHSTSG jrISTSH jrJSZSI jrKSYSJ jrLS[SK jrM\*STSL j5       rN\*SM 5       rO STSN\PR                  SO\:SP\8\:   S	S4SQ jjrRSRrSU =rT$ )\r   i0  r   
_precision_rel_tolF_default_dtype_check_enabledNc                 *   [         R                  R                  5       (       a    [         R                  R                  5         gg! [         aC  n[        S[        R                  S9  [        [        U5      [        R                  S9   S nAgS nAff = f)NzDTEST SUITE EARLY TERMINATION due to torch.cuda.synchronize() failurerD  TF)	rM   rN   is_initializedr}  rA  rI  r  r=  r   )r   rtes     rG   _should_stop_test_suite TestCase._should_stop_test_suiteC  sk    ::$$&&

&&(
    \cfcmcmnc#hSZZ0s   A 
B9BBr   c                     U R                   $ rX   rm  r  s    rG   	precisionTestCase.precisionQ  s    rF   precc                     Xl         g rX   rw  r   rz  s     rG   rx  ry  U  s    rF   c                     U R                   $ rX   rn  r  s    rG   rel_tolTestCase.rel_tolY  s    }}rF   c                     Xl         g rX   r~  r|  s     rG   r  r  ]  s    rF   c                   > US:w  a  Un[         TU ]  U5        [        XS 5      nUGbb  [        (       aW  U =R                  [        USS5      -  sl        U R                  (       a&  [
        (       d  U R                  XR                  5        U =R                  [        USS5      -  sl        U R                  (       a&  [
        (       d  U R                  XR                  5        U R                  (       a  U R                  US 5        [        (       ay   S n[        R                  " [        U 5      5      nU" U5      n[        U 5      R                   nSU SU S	U 3n["        R%                  5       n	X/n
U R                  UU
4S
 j5        g g g ! [&         a'  n[(        R+                  S[-        U5      S9   S nAg S nAff = f)NrunTestr1  Tr9  c                       [        [        5      $ rX   )r  r(  r=   rF   rG   rh   #TestCase.__init__.<locals>.<lambda>~  s    ;NOb;crF   c                 2   [        U 5      R                  n[        U5       HR  u  p#US:X  d  M  US:  a   [        R                  R
                  " US U 6 OSn[        R                  R                  XS9s  $    [        R                  R                  U 5      S   $ )Nr   r   rH   )r  r:   )r   partsr  ro   r   r   relpathrR   )abs_test_pathr  r   partbase_dirs        rG   _get_rel_test_path-TestCase.__init__.<locals>._get_rel_test_path  s|     !%] 3 9 9'0'7GA#v~GH1u277<<r+CRT')ww}'U U (8  "ww}}];A>>rF   zpython r   r   c                     [        U 5      $ rX   )r  )r  s    rG   rh   r    s
    8N{8[rF   zcould not print repro string)extra)r  r
  r   r  r1  r  wrap_with_cuda_policyassertLeaksNoCudaTensorsr9  enforceNonDefaultStream_ignore_not_implemented_errorwrap_with_policyr   r   getfiler   r>   r`   r   r   r   infor   )r   method_name
methodNametest_methodr  r  ry  
class_nametest_run_cmdenv_var_prefixr  r  r  s               rG   r
  TestCase.__init__h  s    "$K%d6"''//7;Hdfj3kk/22::..{<Y<YZ ,,Ebdh0ii,//

**;8T8TU11%%k3cd%%K? %,OODJ$?M$6}$EM!%d!4!4J%,]O1ZL+#WL%4%I%I%KN#1"@K))#+6[]- &! #R ! KHH;3q6HJKs   A7F 
F=F88F=c                 B    Uc  U R                  5       OUn[        X5      $ rX   )r   r  )r   rr   s     rG   r  !TestCase.assertLeaksNoCudaTensors  s     Ltwwyd"4..rF   c                     [        5       $ rX   )rs  r  s    rG   r   TestCase.enforceNonDefaultStream  s    #%%rF   c                 p    [         R                  " S[         R                  5      nUR                  SU5      $ )NaF  
            \x1B  # ESC
            (?:   # 7-bit C1 Fe (except CSI)
                [@-Z\\-_]
            |     # or [ for CSI, followed by a control sequence
                \[
                [0-?]*  # Parameter bytes
                [ -/]*  # Intermediate bytes
                [@-~]   # Final byte
            )
        rH   )rd  compileVERBOSEr  )r   r   ansi_escapes      rG   _remove_ansi_escapeTestCase._remove_ansi_escape  s1    jj 
" ZZ
 r5))rF   c                     UR                  S5      nU Vs/ s H*  o3R                  5       R                  S5      (       a  M(  UPM,     nnSR                  U5      $ s  snf )Nr  #)rR   ro  r   r   r   input_stringr  linefiltered_liness        rG   remove_comment_linesTestCase.remove_comment_lines  sM    ""4(+0U54

8O8OPS8T$5Uyy(( Vs   'AAc                     UR                  S5      nU Vs/ s H  o3R                  5       S:w  d  M  UPM     nnSR                  U5      $ s  snf )Nr  rH   )rR   ro  r   r  s        rG   remove_empty_linesTestCase.remove_empty_lines  sF    ""4(+0G54JJLB4F$5Gyy(( Hs
   A
A
c                   > [        U[        5      (       a  UO
[        U5      nU R                  U5      nU R                  U5      nU(       a"  U R                  U5      nU R                  U5      nU(       a"  U R	                  U5      nU R	                  U5      n[
        TU ]  [        U[        5      (       a  UO
[        U5      X#S-   5      $ rA  )r   r   r  r  r  r  assertExpectedInline)r   r  expectr  ignore_commentsignore_empty_linesr  s         rG   r  TestCase.assertExpectedInline  s    %fc22F))&1))&1..v6F..v6F,,V4F,,V4Fw+j6M6MFSVW]S^`fophpqqrF   T)r  suppress_suffix
post_mungec                     U" 5         U R                  SS9  g ! U a9  n[        XuUS-   S9nU(       a  U" U5      nU R                  XUS-   S9   S nAg S nAff = f)Nr:   )r  r  )r  Did not raise when expected tor  )	munge_excr  fail)	r   r  r  r  r  r  r  r  mungeds	            rG   assertExpectedInlineMunged#TestCase.assertExpectedInlineMunged  sm    		J 			6	7  	qqQF#F+%%TAX &  	s    A/AAc                 T   > Uc  [         R                  " S5      n[        TU ]  X5      $ NrM   )logging	getLoggerr  
assertLogsr   loggerlevelr  s      rG   r  TestCase.assertLogs  s(    >&&w/Fw!&00rF   c                 T   > Uc  [         R                  " S5      n[        TU ]  X5      $ r  )r  r  r  assertNoLogsr  s      rG   r  TestCase.assertNoLogs  s(    >&&w/Fw#F22rF   c                     [        X5      nSSKJn  U R                  5       R	                  5       nU(       a)  SU;   d  SU;   a  [        XU R                  X25      5        g g g )Nr   )	TEST_CUDAgpurN   )r   ra  r  r   lowerrT  wrap_method_with_policy)r   r  policyr  r  fullnames         rG   r  TestCase.wrap_with_cuda_policy  sR    d0 	B779??$%8+v/ADt'C'CK'XY 0B9rF   c                 P    [        X5      n[        XU R                  X25      5        g rX   )r   rT  r  )r   r  r  r  s       rG   r  TestCase.wrap_with_policy  s!    d04#?#?#TUrF   c                 \   ^^ [        T5      UU4S j5       n[        R                  " X05      $ )Nc                 X   > T" 5          T" U0 UD6  S S S 5        g ! , (       d  f       g = frX   r=   )r   r]   r^   methodr  s      rG   r   1TestCase.wrap_method_with_policy.<locals>.wrapper   s    '' s   	
))r   r  
MethodType)r   r  r  r   s    `` rG   r   TestCase.wrap_method_with_policy  s.     
v	( 
	( ..rF   c                 8    U R                  XR                  5      $ rX   )r  r  )r   r  s     rG   wrap_with_cuda_memory_check$TestCase.wrap_with_cuda_memory_check  s    ++F4Q4QRRrF   c                 L    U R                   R                   SU R                   3$ )Nr   )r  r>   r  r  s    rG   _dynamo_test_keyTestCase._dynamo_test_key	  s%    ..))*!D,@,@+ABBrF   c                 H    [         R                  R                  X#S9" U5      $ )N)r  )rM   r  optimize)r   r   r  r  s       rG   
compile_fnTestCase.compile_fn  s    }}%%g%A"EErF   c           
      V  >^  [        U[        R                  5      n[        TT ]  nUR
                  n[        =(       d    [        =(       d    [        nSnSnSnU(       a   [        R                  " [        U5      5      n	[        R                  R                  U	5      n
[        R                   " SU
5      nUb3  UR#                  S5      n[        (       a  SSKJn  X;  nSnUS:X  a  SnOSnS[        R,                  ;   a  [        R,                  S   S:X  a  SnSnU(       aT  [/        T T R0                  5      n[3        US	5      (       a  UR4                  nO [3        US	5      (       a  UR4                  nOUn[/        US
S5      =(       a    UnU(       d  U(       a  [6        R8                  R;                  5         [6        R<                  R?                  S5        U(       a  U(       + nO$[6        R8                  R@                  RB                  nU(       a'  [6        RD                  R@                  RG                  SS9O[H        RJ                  " 5       n[        RL                  RG                  SU5         U   [        (       a  T RO                  USU5      nGO[        (       d  [        (       Ga  [        (       a  T RO                  USU5      nOT RO                  USU5      nT RQ                  5       nU 4S jn[        (       a	  SnSSKJ)n  OSnSSKJ*n  UU;   aT  [/        T T R0                  5      n[        R                  RW                  UU5      n[Y        T T R0                  U" UU5      5        U 4S jn[        (       a	  SnSSKJ-n  OSnSSKJ.n  UU;   aT  [/        T T R0                  5      n[        R                  RW                  UU5      n[Y        T T R0                  U" UU5      5        SSKJ/n  [6        R8                  R@                  R`                  (       a  UU;   a  [c        5       " U5      nU" US9  S S S 5        S S S 5        U(       d  U(       a  [6        R8                  R;                  5         OQ[6        R8                  R@                  R`                  (       a(  [6        R8                  R`                  R;                  5         U(       a  T Re                  5       (       a  URg                  5       (       aq  [i        5       n[j        b.  SSK6J7n  U" UU5      nURp                  Ul9        SUl:        S Ul;        URx                  R{                  US!45        URg                  5       SL d   eUR}                  5         g g g ! [(        [*        4 a     GNf = f! , (       d  f       GNa= f! , (       d  f       GNk= f)"NFz.*/test/(.*).pyr:   )FIXME_inductor_non_strictTtest_opsSTRICT_DEFAULTre   r  r  rg   )size_assertsr  aot_eager_decomp_partitionr  eager_noexceptc                 8   >^ ^ [        T 5      U UU4S j5       nU$ )Nc                     >  T" U 0 UD6  [        ST S35      e! [          a  nTR                  U5         S nAN/S nAff = f)Nz#Unexpected success, please remove ``)BaseExceptionr`  rA  )r]   r^   r  r  	file_namer   s      rG   r   =TestCase._run_custom.<locals>.expect_failure.<locals>.wrapperg  sP    -t.v. +-PQZP[[\+]^^  - - MM!,,-s    
?:?r}  r  r  r   r   s   `` rG   expect_failure,TestCase._run_custom.<locals>.expect_failuref  s"    1X_ _ #NrF   ztest/inductor_expected_failures)inductor_expected_failuresztest/dynamo_expected_failures)dynamo_expected_failuresc                 8   >^ ^ [        T 5      U UU4S j5       nU$ )Nc                    >  T" U 0 UD6  [        TTR                  5      n[        USS5      (       a  TR                  S5        g TR                  ST S35        g ! [          a  nTR                  U5         S nANpS nAff = f)N__unittest_expecting_failure__Fzunexpected successz'This test passed, maybe we can remove `r  )r  r`  r   r  )r]   r^   r  r  r  r  r   s       rG   r   =TestCase._run_custom.<locals>.ignore_failure.<locals>.wrapper}  s    -t.v. ")t/C/C!D"6+KUSS MM*>? MM,ST]S^^_*`a  - - MM!,,-s   A 
B %A;;B r}  r  s   `` rG   ignore_failure,TestCase._run_custom.<locals>.ignore_failure|  s"    1X	b 	b #NrF   ztest/inductor_skips)inductor_skipsztest/dynamo_skips)dynamo_skips)compiled_autograd_skipsr  r   )	_TestInfor  TestSuiteEarlyFailurez%TestSuite execution was aborted early)?r   r   
TestResultr  run__self__r  r  r  r   r  r   ro   r   abspathrd  matchr  dynamo_test_failuresr  OSErrorrl  r  r   r  r   r  rM   r  r  compiler
set_stancer  suppress_errors	_inductorr  
contextlibnullcontextr  r  r  r  r  r   rT  r   r  r  r  r  rt  r  r   r  r  r  ERRORr  elapsed_timetest_descriptionfailuresr  stop)r   r  using_unittest	super_runtest_clscompiledstrict_defaultshould_reset_dynamoshould_disable_size_assertsr   	full_pathr
  r   r  strict_moder  r  r  maybe_disable_size_assertskeyr  subdirexpected_failuresr  r  r  skipsr  rU  r  r  s   `                             rG   _run_customTestCase._run_custom  sZ   #FH,?,?@GK	%% )Z,?ZCZ# ',#tH~6GGOOD1	!3Y?$${{1~H..S)1)R.2+#z1:>7)-  2::-::./36%)N!$(<(<=K{O44)77?33&44,8%=uER(-MM!!!),
 "-oO#mm22BBO + OO""((e(<'') 	# ]]  !GY[u"" OOI7SU]^	&&*A*A** $	:x PI !%	;KX VI++-# +*>Fe<Fc++$T4+?+?@F "VS 9ID$"6"6vy8YZ# +*2FM0FK%<$T4+?+?@F "VS 9ID$"6"6vy8YZI==''99cE\>\ : <Y GIV$E \vYH -MM!]]!!33MM++113 d::<<##%%z , ;$VT2D"+//DK(+D%,CD) &&.U'VW++-666KKM =>] Y' H \v[uYYs>   !BU0 *U0 -V0F=V-V0VV
V	V
V(c                     [         R                  " 5        n[        (       a  UR                  [	        5       5        U R                  US9  S S S 5        g ! , (       d  f       g = f)Nr  )r  	ExitStackr^  enter_contextr  r&  )r   r  r   s      rG   r  TestCase.run  sH    !!#u!!##LN3   $##s   4A
A!c                    [        U 5        [        5         [        R                  R                  R                  5       U l        [        R                  R                  R                  5         U R                  (       a)  [        R                  " 5       [        R                  :X  d   e[        R                  " 5       U l        g rX   )r  r  rM   sparsecheck_sparse_tensor_invariants
is_enabled_check_invariantsenablero  r]  r|  is_grad_enabled_prev_grad_stater  s    rG   setUpTestCase.setUp  s{     "'!L!L!W!W!Y 	33::<,,**,;;; !& 5 5 7rF   c                    [        U S5      (       ab  U R                  (       a)  [        R                  R                  R                  5         O([        R                  R                  R                  5         U R                  (       a)  [        R                  " 5       [        R                  :X  d   e[        U S5      (       a!  [        R                  " U R                  5        g g )Nr0  r3  )r   r0  rM   r-  r.  r1  disablero  r]  r|  set_grad_enabledr3  r  s    rG   tearDownTestCase.tearDown  s     4,--%%;;BBD;;CCE,,**,;;; 4+,,""4#8#89 -rF   )r[  c          
        ^ ^ SUs=::  a	  T T-  ::  d  O   UT T45       eUU 4S jn[         R                  " T S-   U[         R                  " S5      S9nS=pU" X5      n
U
(       a  U[        U
T5      :  ao  UnT S-
  nU" X5      nX-
  S:  a9  X-   S-  nU" X5      nUS:X  d  X.T-  -
  [        UT5      :  a  XpOUnX-
  S:  a  M9  XpU(       d   eXx* S R	                  T5        U
(       a  X(T-  -
  [        U
T U-
  5      :  a  U	nTS-
  nU" UU5      nUU-
  S:  aJ  UU-   S-  nU" UU5      nUS:X  d!  X(T-  -
  UT U-
  -  -
  [        UT U-
  5      :  a  UUnnOUnUU-
  S:  a  MJ  UUpU	(       d   eUST U-
  S-    R	                  U	5        U
(       a  [        X(T-  -
  U	T U-
  -  -
  TU	-
  TU	-
  S-   -  S-  5      u  nnSUTU	-
  S-   -  -   n[        R                  " SU-  5      nUUS-   -  SU-  :  a  US-  nUUUS-   -  S-  -
  nUS:  a  U	S:  a   e[         R                  " US-
  XGR                  S9TU	-
  S-   -  USU& UUUU-   S-   === [         R                  " US-   XGR                  S9-  sss& OSnX(T-  -
  U	T U-
  -  -
  nUU==   U-  ss'   U(       a*  [         R                  " T UR                  S9nUSS U   USS& UnUR                  SS	9  UR                  US9$ )
ax  Return crow_indices of a CSR tensor with size (n_rows, n_cols) and
the number of specified elements nnz.

If random is True, the column counts of rows are in random
order. Otherwise, the column counts of rows are defined by the
used sampling method.

Sampling method
---------------

The used sampling method was introduced in
https://pearu.github.io/csr_sampling.html, and here we give
only an overall description of the method.

Notice that crow_indices can be defined as cumsum(counts)
where counts is a sequence of non-negative integers satisfying
the following conditions:

  len(counts) == n_rows + 1
  counts.max() <= n_cols

while counts[i + 1] is interpreted as the number of specified
elements in the i-th row.

The used sampling method aims at increasing the diversity of
CSR samples, that is, a CSR sample should contain (i) rows
that are all filled, (ii) rows with no elements at all, and
(iii) rows that are partially filled. At the same time and for
the given total number of specified elements (nnz), there
should be minimal preference to rows with a given number of
elements.  To achieve this, the sampling method is built-up on
using a sawteeth model for counts. In the simplest case, we
would have

  counts = arange(n_rows + 1) % (n_cols + 1)

that has equal number of all possible column counts per row.
This formula can be used only for specific input values of
n_rows, n_cols, and nnz. To generalize this model to any
combinations of inputs, the counts model above is extended
with an incomplete sawtooth, and the right and lower
rectangular parts that will guarantee that

  counts.sum() == nnz

for any combination of n_rows, n_cols, and nnz. Basically,
we'll find a maximal window in (n_rows + 1, n_cols + 1)-grid
that is able to hold a sequence of sawteeth and so-called
final correction, while the external part of the window is
filled with counts to meet the nnz constraint exactly.
r   c                 z   > TU-
  TU-
  S-   -  S-  nTU -
  TU-
  S-   -  nUTU -
  TU-
  S-   -  -  X3S-
  -  S-  -   $ )Nr:   r;   r=   )nmMKn_colsn_rowss       rG   sawteeth-TestCase._make_crow_indices.<locals>.sawteeth  sb    
 !
Q/14A!
Q/A!!a89AQK1<LLLrF   r:   r   r8  r;   Nru  )ri  )rM   zerosrz  r  fill_r  mathisqrtarangerandpermcumsum_rL  )rB  rA  nnzrz  rx  r[  rC  countsr=  r>  Nn_leftn_rightN_rightn_middleN_middlem_leftm_rightm_middleqr  r5  kcorrpermcrow_indicess   ``                        rG   _make_crow_indicesTestCase._make_crow_indices  sy   l C*6F?*AS&&,AA*	M VaZuU\\%=PQ	QNAv& FqjGw*G"Q&",2#H0q=CV*;$;c(F>S$S'/W%F "Q& qH123Kf%6z!SFQJ%77 FqjGq'*GF"Q&"W,2#Ax0q=Cf*$4x6A:7N$NQTU]_ehi_iQj$j'/WGW%F F"Q& GqH11VaZ!^$**1-#F
*Q&1*-==!A:&1*q.9Q>@DAqA!a((A

1q5!AAE{QU"QqAE{a''DQQU,,,,q1uE--PTZ]^T^abTbcF1QK1QUQY5<<AU==#YY AV#a6A:&66D 	q	T	 >>&?DD)F12J #f--rF   r=   )	blocksize
dense_dimsc          
      ~  ^ ^^^^^^ SSK Jn	  SSKJn
  Sn[	        U4S j[        [        T5      5       5       5      (       d  US:X  d   S5       e[        T5      U:  d   eT(       aS  [        T5      S:X  d	   TT45       eTSU-
     TS   -  S:X  d	   TT45       eTSU-
     TS	   -  S:X  d	   TT45       eTu  pOS	=p[        T5      mT[        T5      U-
  S  mUUUUUU 4S
 jnTS SU-
   nU
" XS	5      nU[        R                  [        R                  1;   a  TSU-
     U-  TSU-
     U-  nnOTSU-
     U-  TSU-
     U-  nnX,U-  -  n[        U5       Vs/ s H  nU" UUU5      PM     nn[        [        [        USS065      n[        R                  " [        U5      5      R                   " / UQUPTQTQ76 n[        R                  " [        U5      5      R                   " / UQSP76 n[        R                  " [        U5      5      R                   " / UQSP76 n[        R"                  " UUUTTUTS9$ s  snf )Nr   )r  )reducer;   c              3   4   >#    U  H  nTU   S :  v   M     g7fr   Nr=   r   r	  rQ  s     rG   r   5TestCase.genSparseCompressedTensor.<locals>.<genexpr>w  s     9(8147Q;(8r  invalid argumentsrS  r  r:   c           	        > TR                  XUTTS9n[        R                  " UTTS9n[        U 5       HI  nX5S-      X5   -
  n[        R                  " [        R
                  " UTTS9S U 5      u  XCU   X5S-      & nMK     T[        R                  :w  a  SOSnT[        R                  :w  a  SOSn	[        U4T-   T-   TTXS9n
XU4$ )Nrz  rx  r8  r:   r  r   r;   rz  rx  lowhigh)r\  rM   rE  r^  sortrJ  r;  r%   )n_compressed_dimsn_plain_dimsrL  compressed_indicesplain_indicesr   countr   rj  rk  r  r^  
dense_sizerz  rx  index_dtyper   s              rG   random_sparse_compressedDTestCase.genSparseCompressedTensor.<locals>.random_sparse_compressed  s    !%!8!89JZ]flt!8  "A!KK;vNM,-*q514F4IITYT^T^NN<{6RSYTYZU\Q34F1u4MNPQ . ,"!C,1!D #)!3j!@W\beqF}<<rF   r  T)rQ  rx  layoutrz  )r/  r  r   ra  r  r^  r  rX  rM   
sparse_csr
sparse_bsrmapr8  r  r   r  reshapesparse_compressed_tensor)r   rQ  rL  rv  rz  rx  rs  r^  r_  r  ra  
sparse_dim
blocksize0
blocksize1rt  batch_shapen_batchrm  rn  blocknnzr   sparse_tensorssparse_tensors_itr  ro  rp  rr  s   ``  ````                  @rG   genSparseCompressedTensor"TestCase.genSparseCompressedTensors  s    $
9c$i(8999SAXZGZZE4yJ&&&y>Q&9y(99&Z(9Q<71<OtY>OO<Z(9Q<71<OtY>OO<%."J
&''JT{3t9z134

	= 
	= +BO,1-e&&(8(899.22
?.Cz.QSWXZ]gXgShlvSv||.22
?.Cz.QSWXZ]gXgShlvSv|
23glmtguvgubc23DlT\]guvc>&G$&GHT"345==n{nHnW`ncmn"[[.?)@AII[;[XZ[D):$;<DDVkVSUV--.@-.44uU[djl 	l ws   H:)r_  c                F    U R                  X[        R                  UXESUS9$ )Nr=   rv  rz  rx  rs  r^  r_  )r  rM   rw  r   rQ  rL  rz  rx  rs  r_  s          rG   genSparseCSRTensorTestCase.genSparseCSRTensor  s2    --d@P@PY_49^`mw . y 	yrF   c                F    U R                  X[        R                  UXESSS9$ )Nr=   r   r  )r  rM   
sparse_cscr  s          rG   genSparseCSCTensorTestCase.genSparseCSCTensor  s2    --d@P@PY_49^`mn . p 	prF   c                f    [        U5      S:X  d   eU R                  X[        R                  UXVX'S9$ Nr;   r  )r  r  rM   rx  r   rQ  r^  rL  rz  rx  rs  r_  s           rG   genSparseBSRTensorTestCase.genSparseBSRTensor  A    9~"""--d@P@PY_49^g . @ 	@rF   c                f    [        U5      S:X  d   eU R                  X[        R                  UXVX'S9$ r  )r  r  rM   
sparse_bscr  s           rG   genSparseBSCTensorTestCase.genSparseBSCTensor  r  rF   c                 j  ^ [        U4S j[        U5       5       5      (       d  US:X  d   S5       eU/[        TUS  5      -   n[        XuUSSS9n[        R
                  " X#US9n	U	R                  [        R                  " TS U 5      R                  S5      R                  U	5      5        U	R                  [        R                  5      n	U(       a9  U	S S 2S US-  2S	4   n
U	S S 2S US-   S-  2S	4   n[        R                  " X/S5      n	[        R                  " X[        R                  " T5      XeS
9nU(       d  UR                  5       nO-UR                  5       R!                  5       R#                  S5      nXR%                  5       R!                  5       UR'                  5       R!                  5       4$ )Nc              3   4   >#    U  H  nTU   S :  v   M     g7frc  r=   rd  s     rG   r   +TestCase.genSparseTensor.<locals>.<genexpr>  s     :(9147Q;(9r  r   rf  r  r:   ri  ru  r;   .r8  F)r  r^  r8  r%   rM   randmul_rb  	unsqueezerL  longcatsparse_coo_tensorSizecoalescedetachclone_coalesced__indices_values)r   rQ  r|  rL  is_uncoalescedrz  rx  v_sizer  r   i1i2r   s    `           rG   genSparseTensorTestCase.genSparseTensor  sk    :j(9:::cQh[H[[Fd:;/00UKJJzv6	u||D*-.88;>>qABDD1kqk3&'B1'qQ',-B		2(A&A##A%**T*:%W

A 
  "..u5A**,$$&		(9(9(;;;rF   c              #   2  ^ ^'^(^)^*^+#    Uc  [         R                  nU[         R                  [         R                  [         R                  [         R
                  1;   nU(       Ga  T R                  XX4UXxU	U
UUSS9 H  u  nnU(       a  [        S U 5       5      nU[         R                  L am  [        U5      S:X  d   eUR                  SS5      nUc   eU(       a&  US   R                  U5      R                  5       v   M  US   R                  U5      v   M  U[         R                  L a  [         R                  " U0 UD6v   M  U(       a)  UR                  US9  [         R                   " U0 UD6v   M   e   gS	 m)S
 m*U)U*4S jm+U(U+4S jm(U'4S jm'Uc  / SQ/ SQ/SS// SQ4/ SQ/ SQ// SQ/ SQ// SQ/ SQ/// SQ/ SQ// SQ/ SQ// SQ/ SQ///SS/SS/4/ SQ/ SQ/ SQ/ SQ/ SQ/ SQ/ SQ/ S Q/S/SS!/4SS"/S#S$//SS/SS///S%/U(       a  S/O/ 4/nS4U 4S' jjnU GH  u  nnnU(       d  U Vs/ s H  nU(       a  M  UPM     nnU(       a  U(       d  M:  [         R"                  " U[         R                  S(9nU(       d  UR$                  S":  a  Mv  U GHA  nT(" UU5      U   nU GH*  nUSS&  Vs/ s H  nUR'                  X$S)9PM     nnT'" US&   U5      R'                  X#S)9n[)        X#UR*                  U-   S*9nUb  UR                  US+9  / UQUP7UR-                  5       4v   U
(       aw  UR$                  S":  ag  S, Ha  u  nnU Vs/ s H  nU" UUUS-9PM     n n/ U QUP7UR-                  5       4v   U(       d  M@  U" US&SS-9n!/ U QU!P7UR-                  5       4v   Mc     U(       d  GM	  U" US&SS-9n!/ UQU!P7UR-                  5       4v   GM-     GMD     GM     U	(       Ga  S.S//U(       a  / S0QOS/4S1/ S2QS/4S3S//S/44 GHr  u  n"nnU GHc  nU GHX  nU[         R                  :X  a  Sn[         R.                  " U"U-   X#S)9nGOU[         R                  :X  a;  [         R.                  " [        U"5      SX$S)94n[         R.                  " S/UQ7X#S)9nGOU[         R                  :X  aS  [         R"                  " S/U"S   S-   -  X$S)9n#[         R.                  " SX$S)9n$U#U$4n[         R.                  " S/UQ7X#S)9nGODU[         R                  :X  aR  [         R"                  " S/U"S   S-   -  X$S)9n%[         R.                  " SX$S)9n&U%U&4n[         R.                  " S/UQ7X#S)9nOU[         R                  :X  aZ  [         R"                  " S/U"S   US   -  S-   -  X$S)9n#[         R.                  " SX$S)9n$U#U$4n[         R.                  " S/UQUQ7X#S)9nOpU[         R
                  :X  aZ  [         R"                  " S/U"S   US   -  S-   -  X$S)9n%[         R.                  " SX$S)9n&U%U&4n[         R.                  " S/UQUQ7X#S)9nO e[)        X#U"U-   S*9nUb  UR                  US+9  / UQUP7U4v   GM[     GMf     GMu     ggs  snf s  snf s  snf 7f)5av  Generator of simple inputs for tensor constructors of the given layout.

The generated tensor inputs have the following properties:

- tensor shapes are minimal but not trivial
- tensor values are sorted sequences for COO and CSR formats, e.g. [1, 2, 3, 4]
- the generated tensors represent the same mathematical tensor for all layouts
- the generated tensors include regular, zero-sized, and optionally, batched or/and hybrid tensors.
- the generated tensors include contiguous or non-contiguous tensors both in indices and values

If output_tensor is True, yield tensors with the given
layout. Otherwise, yield inputs to the corresponding tensor
constructors:

  - sparse compressed input is defined as
    (compressed_indices, plain_indices, values), dict(size=expected_size_from_shape_inference, device=device, dtype=dtype,
                                                      pin_memory=pin_memory)

  - sparse COO input is defined as
    (indices, values), dict(size=expected_size_from_shape_inference, device=device, dtype=dtype, pin_memory=pin_memory)

  - strided input is defined as
    (values,), dict(device=device, dtype=dtype)
NF)rz  rx  rs  
pin_memoryenable_batchenable_hybridenable_zero_sizedenable_non_contiguous_indicesenable_non_contiguous_valuesenable_batch_variable_nseoutput_tensorc              3   @   #    U  H  oR                  5       v   M     g 7frX   r  )r   r  s     rG   r   2TestCase.generate_simple_inputs.<locals>.<genexpr>  s      >As   r:   rQ  r   )rv  c                    U R                   nUS   US   -  S:X  d   X!45       eUS   US   -  S:X  d   X!45       eU R                  SUS   US   US   -  US   5      R                  SS5      R                  S5      R                  S5      n[        R
                  " SUR                  5       S-   5      R                  UR                   5      nUS:g  U-  $ )Nr   r:   r  rS  )shaperz  	transposer,  rM   rI  r  )patternr^  basesizeblockpattern	block_idss        rG   get_blockpattern9TestCase.generate_simple_inputs.<locals>.get_blockpattern  s    }}HA;1-2IX4II2A;1-2IX4II2"??2+4Q<+3A;)A,+F+4Q<9 :C2r9J33r7SVSVWYSZ  Q(:(:(<q(@AII,J\J\]I A%22rF   c                    U R                   n[        U5      S:X  d   U5       e[        R                  " U S:g  5      n[        R                  " U5      n[        R
                  " US   S-   [        R                  S9n[        R                  " US   R                  US   S9S5      USS & US   n[        R
                  " U[        R                  S9n[        R                  " SS[        US   5      -   [        R                  S9nXvU'   [        R                  " U R                  SS5      S:g  5      n[        R                  " U5      n	[        R
                  " US   S-   [        R                  S9n
[        R                  " U	S   R                  US   S9S5      U
SS & U	S   nUR                  SS5      U   n[        R                  X74[        R                  XEU4[        R                  XU4[        R                  U40$ )Nr;   r   r:   rx  )	minlength)r  r  rM   wherer   rE  r  cumsumbincountrI  r  
sparse_coorw  r  strided)r  r  indicescoo_indicesr[  col_indicesstrided_valuesr  	indices_Tcoo_indices_Tccol_indicesrow_indices
csc_valuess                rG   get_sparse_data8TestCase.generate_simple_inputs.<locals>.get_sparse_data!  s   }}Hx=A%/x/% kk'Q,/G++g.K ;;x{QekkJL$||KN,C,ChWXk,C,Z\]^L%a.K"[[EN
 \\!QWQZ%8LF&,7#G$5$5a$;q$@AI!KK	2M ;;x{QekkJL$||M!,<,E,EPXYZP[,E,\^_`L'*K'11!Q7	BJ$${&;$$|&&I$$|*&MMMN#46 6rF   c                 :  > T" U 5      nT" X5      nT" U5      nU[         R                     S   nU[         R                     S   n[         R                  " UR	                  SS5       VVs/ s H,  u  pxXWUS   -  US-   US   -  2XS   -  US-   US   -  24   PM.     snn5      n	X[         R
                     S   S-
     n
[         R                  / U[         R                     S S QU	P7[         R                  / U[         R
                     S S QU
P70UE$ s  snnf )Nr   r:   r;   )	rM   r  r  r   r  r  rx  rw  r  )r  r^  nonblock_datar  
block_datar  block_indicesbibj
bsr_values
bsc_valuesr  r  s              rG   get_sparse_data_with_blockCTestCase.generate_simple_inputs.<locals>.get_sparse_data_with_blockE  sT   +G4M+G?L(6J*5==9!<N&u'7'78;M4A4K4KAq4Q&S4Q&" '5)A,5FQR[\]R^G^5^57A,5FQR[\]R^G^5^6_ '`4Q&S TJ $u/?/?$@$Ca$GHJ$$&U
53C3C(DRa(H&U*&U$$&U
53C3C(DRa(H&U*&U%#% %&Ss   +3D
c                   >^
 U R                   n[        U5      S::  a  T" X5      $ 0 n[        U 5       GH  u  pET" XQ5      R                  5        GHo  u  nm
UR	                  U5      nU[
        R                  L a  [
        R                  " [
        R                  " S[        T
S   5      4U[
        R                  S9T
S   45      nUc  UT
S   4=osU'   M  US   R                  [
        R                  " US   U4S5      5        US   R                  [
        R                  " US   T
S   45      5        M  Uc.  [        U
4S j[        [        T
5      5       5       5      =osU'   GM  [        [        T
5      5       H@  n	Xy   R                  [
        R                  " Xy   T
U	   R                  S5      45      5        MB     GMr     GM     U$ )Nr;   r:   r  r   c              3   L   >#    U  H  nTU   R                  S 5      v   M     g7frc  )r  )r   r  r	  s     rG   r   QTestCase.generate_simple_inputs.<locals>.get_batch_sparse_data.<locals>.<genexpr>o  s$     ?i[hVW!q@Q@Q[hs   !$)r  r  r  r   r  rM   r  r  fullr  set_rX  r^  r  )r  r^  rQ  
batch_datar   r  rv  r  ext_coo_indices1r  r	  get_batch_sparse_datar  s             @rG   r  >TestCase.generate_simple_inputs.<locals>.get_batch_sparse_dataY  s   ==D4yA~1'EE J$W-!6t!G!M!M!OIFA'^^F3F!1!11 ,199ejj!S1YQRZ_ZeZe6fhijkhl5m+n(!>;KQqT:RRF%7"1INN599fQiAQ5RTU+VW"1INN599fQi15F+GH!>:??i[`adefag[h?i:iiF%7%*3q6] &	uyy&)QqT^^TUEV9W/X Y &3! "P .& rF   c           	      $  > U(       d  U $ [        U [        5      (       d=  U R                  S:  a-  [        R                  " U  Vs/ s H  nT" X!5      PM     sn5      $ U S:X  a#  [        R
                  " U[        R                  S9$ [        R                  " US   [        R                  S9n[        USS 5       H<  u  pE[        R                  " U[        R                  S9SUS-   -  -  nUS   US   -   nM>     UR                  U 5        U$ s  snf )a)  Generates a tensor of shape densesize with values equal to

  base + i_1 * 10^0 + ... + i_d * 10^{d - 1}

at indices i_1, ..., i_d (with 0 <= i_j < densesize[j] for any 1 <= j <=
len(densesize))

This mapping produces unique values as long as
densesize[i] < 10 for all i in range(len(densesize)).
r   r  r:   Nr  ).N)N.)
r   r   ndimrM   r   rE  r  rI  r  add_)base	densesizebr  r   r	  ygenerate_valuess          rG   r  8TestCase.generate_simple_inputs.<locals>.generate_valuesu  s     dC((TYY]{{4#P4aOA$A4#PQQqy{{9EKK@@Yq\=A!)AB-0LL%++6"Q-HiL1Y</ 1 FF4LH $Qs   D)r:   r;   r   )r:   r   r<   r;   r:   )r:   r<   )r=   r;   r  r-  )r:   r;   r<   )r:   r   r   )r   r;   r   r;   r<   r=   r  )r   r:   r   r;   r   r;   )r   r:   r   r   r;   r   )r<   r<   r<   r   r   r   )r   r   r   r   r   r   )r   r-  r      r  r  )r-  r   r-  r  r  r  )r   r   r   r   rt  rt  )   r  r  r   rt  rt  r  r;   r<   r  )r:   r:   r  c                 :  > TR                  U R                  5       5        US:  a  XR                  -   nUS:  a  XR                  :  d   e[        SUS-   5      n[        R
                  " / U R                  S U QU R                  U   U-  PU R                  US-   S  Q7U R                  U R                  S9n/ [        S 5      4U-  Q[        US U5      P7nXE   R                  U 5      nTR                  UR                  5       5        TR                  X5        U$ )Nr   r;   r:   r8  )
assertTrueis_contiguousr  r  rM   rE  r  rx  rz  slicerR  assertFalserK  )rT  ri  offsetsteptmp
dim_slicesr  r   s          rG   non_contiguous_copy<TestCase.generate_simple_inputs.<locals>.non_contiguous_copy  s    OOAOO-.QwFFl!8ff,,q&1*%D++WWqwws|d/BWQWWSSTWXEVW_`_f_fopowowxCMU4[NS0M5t3LMJ%%a(AQ__./Q"HrF   r  rh  )rz  rx  rQ  r  >   r   r:   rS  r   )ri  r  )r;   r   r:   r;   )r=   r  r  )r   r;   )r  r  )r<   r;   )r   r   )r  r   )rM   r  rw  r  rx  r  generate_simple_inputsrX  r  r  r  rz  r  r  r  updater{  rb  r  rL  r   r  rD  empty),r   rv  rz  rx  rs  r  members_pin_memoryr  r  r  r  r  r  r  patternsis_compressed_sparse_layoutr]   r^   rQ  r  r  
blocksizes
densesizesrs  r^  datar  r  r  r  ri  r  indices_copyvalues_copyr  r[  r  r  r  r  r  r  r  r  s,   `                                      @@@@@rG   r  TestCase.generate_simple_inputs  s    L ++K&,1A1A5CSCSUZUeUeglgwgw0x&x# $ ; ;FY^GQIUN_ZwYuVoJO !< !Qf &  > >>DU]]*t9>)>!::fd3D+++!"1good3>>@@"1good33u///114B6BB0MMM088$I&II11!Q2 		3"	6H	%(	8	2 4 %v.0BD 	  	 ! $*6"2RJ@ %$$$$$$$& )/x"f? q6q6q6q6 %X0IrT9UHB	  08+GZ )3=A1a
=:ll7%++>GGLL1$4'	,Wi@H!+IOSTWUWyYy!qtt6tEyGY,T"XyADDFD`F!7==S\C\]F!-<,G,V,fkkm;;49I->MS&dk+ldk_`,?sSY,ZdkL+l"9L"9&"96;;="HH;;.A&bYZ.[&B&Bk&BFKKM&Q Q .? 43&9&bQR&S555v{{}DD) ", ( 08B fX]'9QSPTU5t<fXt,50*j
 ",I%/	!U]]2&(G%*[[(Y2FPV%dF#u'7'77',{{3x=!F'f&hG%*[[!i%]F#u'7'77+0<<x{Q8OX^+rL*/++a*ZK'3[&AG%*[[!i%]F#u'7'77+0<<x{Q8OX^+rL*/++a*ZK'3[&AG%*[[!i%]F#u'7'77+0<<x{iXYl?Z]^?^8_hn  ,CL*/++a*ZK'3[&AG%*[[!1Li1L)1LU[%iF#u'7'77+0<<x{iXYl?Z]^?^8_hn  ,CL*/++a*ZK'3[&AG%*[[!1Li1L)1LU[%iF$1!%VxR[G[!\%1"MMZM@000&88A &0 ",5 ? > Z ,ms?   H/Z7ZZA-Z9Z
B ZZ$ Z*Z7K Zc                 ~    UR                   [        R                  :X  a  UR                  5       nUR	                  5       $ rX   )rv  rM   r  r  to_dense)r   rT  s     rG   safeToDenseTestCase.safeToDense!  s+    88u'''

Azz|rF   c                 
   UR                  5       nUR                  UR                  UR                  pnUR                  UR                  UR                  pn	U" U	/U
Q70 UD6nU" U/UQ70 UD6nU R                  " X4SS0UD6  g )Nexact_deviceF)r:  r   r]   r^   rK  )r   torch_fnref_fnsample_inputr^   numpy_samplen_inpn_argsn_kwargst_inpt_argst_kwargsr  r  s                 rG   compare_with_referenceTestCase.compare_with_reference)  s    #))+"."4"4l6G6GI\I\x"."4"4l6G6GI\I\x%5&5H5%5&5H5HHHrF   c                    [         (       d   e[        U[        R                  5      (       ah  Ub   eUb   eUR	                  5       R                  5       nUR                  [        R                  L a  UR                  5       nUR                  5       nUn	Og[        R                  " [        5      n
[        R                  U
[        R                  '   [        R                  " X:U   S9n[        R                  " X4US9n	U" U5      nU" U	5      R                  5       n[        U[        R                   5      (       a   [        R"                  " U5      nU	R                  [        R                  L aY  UR                  [        R                  L a<  UR                  [        R                  L a  UR'                  [        R                  5      nU R(                  " X40 UD6  g ! [$         a'    [        R"                  " UR                  5       5      n Nf = f)Nr  rh  )r  r   rM   r   r  r   rx  bfloat16r|  r:  rD  torch_to_numpy_dtype_dictr  r   r  rb  r  r   r   rL  rK  )r   r  np_fntensor_likerz  rx  r^   t_cpur  rT  r	  	np_resulttorch_results                rG   compare_with_numpyTestCase.compare_with_numpy8  s~   zzk5<<00>!>= =&&(,,.E{{enn,AA		34A "

AenneH5A[uEA!H	{( i,,?!,,Y7	
 ww%..(\-?-?5>>-QV_VeVeinititVt+u{{;;F;  ? ",,Y^^-=>	?s   :G .H
Hc                 *    U R                   " USS0UD6$ )Nexact_dtypeF)rK  )r   r]   r^   s      rG   assertEqualIgnoreTypeTestCase.assertEqualIgnoreTypeZ  s     C5CFCCrF   c                 "   [        U[        5      (       d  [        R                  " U5      U-  n[        U[        R                  5      (       d-  [        R                  " U5      [        R
                  " U5      -  nU R                  " X/UQ70 UD6$ )zHTests if tensor x equals to y, if y to be broadcast to x.shape.
        )r   r   rM   	ones_liker   rb  rK  )r   r   r  r]   r^   s        rG   assertEqualBroadcasting TestCase.assertEqualBroadcasting_  sk     !X&&"Q&A!U\\**"U\\!_4A6t6v66rF   )r  r  	equal_nanr1  r  exact_layoutexact_strideexact_is_coalescedr  r  r  c                l  ^ Sn[        S X4 5       5      (       a  S nU" U5      nU" U5      nO[        U[        R                  5      (       a?  [        U[        5      (       a*  [        R
                  " X!R                  UR                  S9nO][        U[        5      (       aH  [        U[        R                  5      (       a)  [        R
                  " XR                  UR                  S9n[        U[        R                  5      (       a?  UR                  (       a.  UR                  [        R                  :X  a  UR                  5       n[        U[        R                  5      (       a?  UR                  (       a.  UR                  [        R                  :X  a  UR                  5       n[        UU[        [        [        [         ["        [$        [&        [(        [*        4	[        [,        [.        [0        [2        [        R4                  R6                  R8                  R:                  4[<        [>        [@        [B        4UU RD                  UU RF                  UUUU	U
US9nU(       aU  U/nURI                  5       S   RK                  [        T[L        5      (       a  U RN                  (       a
  U4S j5      eT5      eg )NTc              3      #    U  H@  n[        U[        R                  5      =(       a    [        UR                  5      (       + v   MB     g 7frX   )r   r  r  r  rx  )r   r   s     rG   r   'TestCase.assertEqual.<locals>.<genexpr>  s8      
jpafJubjj)\2OPUP[P[2\.\\jps   AA
c                     [        U [        R                  [        R                  45      (       a  U R                  5       $ [        U 5      $ rX   )r   rM   r   r  r  tolistr8  r   s    rG   to_list%TestCase.assertEqual.<locals>.to_list  s3    )3EELL"**;U)V)Vu||~g\`af\ggrF   r8  )
pair_typessequence_typesmapping_typesr  r  r  r  r8  check_devicer  check_layoutcheck_stridecheck_is_coalescedr   c                    > U  ST 3$ )Nr  r=   )generated_msgr  s    rG   rh   &TestCase.assertEqual.<locals>.<lambda>  s    -3%'@rF   )(r,  r   rM   r   r   	as_tensorrx  rz  	is_nestedrv  r  unbindr+   r'   r  r  r$  r2  rS  rW  rY  r[  r!   r   r    r   r  r  datasetSubsetr   r   r   r   r  rx  r  to_errorr   longMessage)r   r   r  r  r  r  r8  r1  r  r9  r:  r;  __tracebackhide__rB  error_metass      `           rG   rK  TestCase.assertEqualj  s	   " !  
kljp
 
 
h 
A
A 5<<((Z8-D-DBA8$$Au||)D)DBA a&&1;;188u}};T
Aa&&1;;188u}};T
A+"!! 
   ((// #JzJ,,..%#%%1A!
F &-K//#A&// FPPSUXEYEY^b^n^n@	  ux	 	 rF   r  c                    U R                  [        US9   U R                  " XU4XES.UD6  S S S 5        g ! , (       d  f       g = f)Nr  r  )assertRaisesrM  rK  )r   r   r  r  r  r  r^   s          rG   assertNotEqualTestCase.assertNotEqual  s;    ~37Q3GTGG 877s	   5
Ac                     U R                  UR                  UR                  5        U R                  UR                  UR                  5        U R                  UR                  UR                  5        g rX   )rK  rz  rx  	is_sparse)r   r   r  s      rG   assertEqualTypeStringTestCase.assertEqualTypeString  sJ    188,!''*akk2rF   rS  ro  c                 ^    U H  n[        U5      [        U5      :X  d  M    g    [        S5      e)Nzobject not found in iterable)r   rM  )r   rS  ro  elems       rG   assertObjectInTestCase.assertObjectIn  s-    D#w"T("  ;<<rF   c                    > U R                   (       a   [        X5      n UR                  SX#5      S n$ [        TU ]  " U/UQ70 UD6$ ! S nf = f)NrY  )r  r]  handler  rY  )r   expected_exceptionr]   r^   contextr  s        rG   rY  TestCase.assertRaises  sX    --<=OV ~~ndC 7'(:LTLVLL s   A Ac                    > [        U S5      (       a&  U R                  [        ;  a  U R                  S:w  a  SnU R                  (       a  [	        XU5      nUR                  SX45      $ [        TU ]  " X/UQ70 UD6$ )Nrx  r   rH   assertRaisesRegex)r   rx  NATIVE_DEVICESr  r]  re  r  rj  )r   rf  expected_regexr]   r^   rg  r  s         rG   rj  TestCase.assertRaisesRegex  sz     4''D,<,<N,RW[WgWgkpWpN--B".:G>>"5tDD7,-?aRVaZ`aarF   c                   ^ S mU4S jn[         R                  " 5       n[         R                  " 5          [        R                  R                  SU5         U" U0 UD6  S S S 5        U(       a  [         R                  " 5         U R                  T5        g ! , (       d  f       N<= f! U(       a  [         R                  " 5         f f = f)Nc                 
   > U mg rX   r=   )
unraisableraiseds    rG   record_unraisable6TestCase.assertNoUnraisable.<locals>.record_unraisable   s    FrF   zsys.unraisablehook)r   	isenabledr7  r   r  r  r1  assertIsNone)r   r  r]   r^   rr  prevrq  s         @rG   assertNoUnraisableTestCase.assertNoUnraisable  s    	  ||~


	$$%9;LM$)&) N 		&! NM 		 s#    B% 	BB% 
B"B% %Cc                     S nSU;   a  US   nUS	  U" U0 UD6  U R                  SS9  g ! U a%  nU R                  [        U5      U5         S nAg S nAff = f)Nsubnamer  r  )assertExpectedr   r  )r   r  r  r]   r^   rz  r  s          rG   assertExpectedRaisesTestCase.assertExpectedRaises  sm    Y'Gy!	d%f%
 			6	7	  	A0	s   * AAAc                     [         R                  " SS9 n[         R                  " S5        [        S5         U" 5         SSS5        U R	                  [        U5      S:H  U5        SSS5        g! , (       d  f       N5= f! , (       d  f       g= f)z4
Test if :attr:`callable` does not raise a warning.
TrecordalwaysNr   )r  r?  r@  rh  r  r  )r   r  r  wss       rG   assertNotWarnTestCase.assertNotWarn!  sb     $$D1R!!(+(.
 /OOCGqL#.	 21.. 21s!   "A?A.&A?.
A<	8A??
Bc              #   f  ^^#    [         R                  " U5      m[        R                  " SS9 n[        R                  " S5        [        S5         Sv   SSS5        [        U5      S:X  a  U R                  S5        U R                  [        U4S jU 5       5      5        U R                  [        U4S jU 5       5      T S	U Vs/ s H)  n[        UR                  5      TL d  M  UR                  PM+     sn 35        SSS5        g! , (       d  f       N= fs  snf ! , (       d  f       g= f7f)
zContext manager for code that *must always* warn

This filters expected warnings from the test and fails if
the expected warning is not caught. It uses set_warn_always() to force
TORCH_WARN_ONCE to behave like TORCH_WARN
Tr  r  Nr   zno warning caughtc              3   R   >#    U  H  n[        UR                  5      TL v   M     g 7frX   )r   r  )r   wcategorys     rG   r   0TestCase.assertWarnsOnceRegex.<locals>.<genexpr>:  s     HRQYY8 ;Rs   $'c              3   x   >#    U  H/  n[         R                  " T[        UR                  5      5      v   M1     g 7frX   )rd  r
  r   r  )r   r  r  s     rG   r   r  <  s'     Br!BHHWc!))n55rs   7:r  )rd  r  r  r?  r@  rh  r  r  r  r,  r   r  )r   r  regexr  r  r  s    `   @rG   assertWarnsOnceRegexTestCase.assertWarnsOnceRegex+  s      **U#$$D1R!!(+(. /2w!|		-.OOCHRHHIOOBrBB)2"T"QQYY88Syqyy"TUVX 21.. U 21sG   +D1"D D
A2D D(D8	D 	D1

D	D  
D.*D1c                   ^^
^^ [        T[        5      (       d  [        S5      eS nU R                  R                  nU" U R                  5       US-   5      m[        R                  R                  [        R                  U   R                  5      n[        R                  R                  [        R                  R                  U5      ST5      m
SmU(       a  T
SU-   -  m
SU S3mT
S	-  m
S
nU
UUU4S jn [        T
5       nUR                  5       nS
S
S
5        [.        (       a0  [0        R2                  " SSU5      n[0        R2                  " SST5      mUR5                  SS[6        R8                  R:                   S35      n[&        R(                  (       a  UT:w  a  U" S5      $ g
[=        U S5      (       a  U R?                  UT5        g
U RA                  TU5        g
! , (       d  f       N= f! [          ao  n	U	R"                  ["        R$                  :w  a  e [&        R(                  (       a  U" S5      s S
n	A	$ [+        ST T ST S[,        R                   ST S3
5      S
eS
n	A	ff = f)al  
Test that a string matches the recorded contents of a file
derived from the name of this test and subname.  This file
is placed in the 'expect' directory in the same directory
as the test script. You can automatically update the recorded test
output using --accept.

If you call this multiple times in a single function, you must
give a unique subname each time.
zassertExpected is strings onlyc                 N    U R                  U5      (       a  U [        U5      S  $ U $ rX   )r   r  )textprefixs     rG   remove_prefix.TestCase.assertExpected.<locals>.remove_prefixM  s'    v&&CKL))KrF   r   r  rH   rs  z (rC  z.expectNc           	         > [        SU  ST T ST 35        [        TS5       n[        R                  " SST5      nUR	                  U5        S S S 5        g ! , (       d  f       g = f)Nz
Accepting r  :

r  z(producer_version): "[0-9.]*"z\1: "CURRENT_VERSION")rI  r   rd  r  r  )update_typer  s_tagexpected_file	munged_idrs  subname_outputs      rG   accept_output.TestCase.assertExpected.<locals>.accept_outputd  s^    J{m5N;K5QRPSTUmS)Q?7<	 *))s   *A
A%r  zI got this output for r  zC

No expect file exists; to accept the current output, run:
python r   z	 --acceptzCppOp\[(.+?)\]zCppOp[]z#producer_version: "CURRENT_VERSION"zproducer_version: "r  zupdated outputassertMultiLineEqual)!r   r   rl  r  r?   r   ro   r   realpathr  modulesr  r   dirnamer   r  r  errnoENOENTr#  r  rA  r  r  rd  r  r}  rM   onnxproducer_versionr   r  rK  )r   rs  rz  r  	module_id	test_filer  r  r  r  r  r  r  s    `        @@@rG   r{  TestCase.assertExpected?  s*    !S!!<==	 NN--	!$'')Y_=	GG$$S[[%;%D%DE	RWW__Y%?%-%.0 S7]*M!'!_N"	 		Tm$668 % :vv/HEH()Q7A ##1!%**"="=!>a@
 1}$%566  t344 ))(A6  H-A %$ 		Tww%,,&""$X..".yk.9Iqc R  ( 1 12!I;iIJ PTT		TsB   8G1 G G1  
G.*G1 .G1 1
I*;;I%6I*<)I%%I*c                 V    [         R                  " SSU5      nU R                  X5        g )Nz__torch__[^ ]+rH   )rd  r  r{  )r   rs  rz  s      rG   assertExpectedStripMangled#TestCase.assertExpectedStripMangled  s#    FF$b!,A'rF   c                     Ub  Ub  [        S5      eX:  a  gX!-
  nUb  Xe::  a  gU SU SU S3nO Uc  Sn[        Xc5      S:X  a  gU SU SU S3nU R                  XG5      nU R                  U5      e)	zAssert that ``first`` is greater than or almost equal to ``second``.

The equality of ``first`` and ``second`` is determined in a similar way to
the ``assertAlmostEqual`` function of the standard library.
Nz specify delta or places not bothz not greater than or equal to z within z deltar  r   z places)rl  round_formatMessagerL  )r   firstsecondplacesr  deltadiffstandardMsgs           rG   assertGreaterAlmostEqual!TestCase.assertGreaterAlmostEqual  s     !3>???~}"G#A&RWQXX^_K~T"a'"G#A&RXQYY`aK!!#3##C((rF   c                    UR                   R                   Vs/ s H)  nUR                  S:X  d  M  UR                  S:X  d  M'  UPM+     nnU R	                  U5        U HX  nUR
                   Vs0 s H'  owR                  UR                  R                  5       _M)     nnUR                  S5      U:X  d  MX    O   U R                  WS   U5        U R                  UR                  SS5      U5        g s  snf s  snf )NATenzorg.pytorch.atenr/  overload_namerH   )graphnodeop_typedomainr  	attributerr   rs  decoder  rK  )	r   
onnx_modelr/  r  r5  all_aten_nodesopattrattrss	            rG   assertAtenOpTestCase.assertAtenOp  s    %/%5%5%:%: U%:YY&0 56XXAS5S %: U' B<>LLILDYY/LEIyy$0 !
 	z*H5?B7GU
 Js   C2C2C2/.C7c                 n   SU-   S-   n[        S5         U(       a&  U R                  [        USS9   U" 5         SSS5        O U" 5         SSS5        [        SSS
9   U(       a'  U R                  [        U5         U" 5         SSS5        O[        R                  " SS9 n[        R                  " S5        U" 5         U HK  n[        U[        5      (       d  M  U R                  [        R                  " U[        U5      5      SL 5        MM     SSS5        SSS5        g! , (       d  f       N= f! [         a5  nS[        U5      ;   a   U R	                  S[        U5      -   S	-   5        e SnAff = f! , (       d  f       GN/= f! , (       d  f       N|= f! , (       d  f       N= f! , (       d  f       g= f)a  Checks that an operation produces a nondeterministic alert when
expected while `torch.use_deterministic_algorithms(True)` is set.

Args:
  fn (callable): Function to check for a nondeterministic alert

  caller_name (str): Name of the operation that produces the
      nondeterministic alert. This name is expected to appear at the
      beginning of the error/warning message.

  should_alert (bool, optional): If True, then the check will only pass
      if calling `fn` produces a nondeterministic error/warning with the
      expected message. If False, then the check will only pass if
      calling `fn` does not produce an error. Default: `True`.
^z: does not have a deterministic implementation, but you setTz9expected a non-deterministic error, but it was not raisedr  Nz,does not have a deterministic implementationzEdid not expect non-deterministic error message, but got one anyway: "r  r  r  r  )r  rj  rA  r   r  assertWarnsRegexr  r  r?  r@  r   r  rd  r  )r   r   caller_nameshould_alertalert_messager  r  r   s           rG   check_nondeterministic_alert%TestCase.check_nondeterministic_alert  sz   " k),hh  %++$%W , Y D	Y YD &,  5**#%' D' '
 ,,D9Q))(3D#$%g{;; OOBIImS\,RVZ,Z[ $% : 65)Y Y $ EQO		68;A?ADEF  &%0' '
 :9 65s   E2D	E2D0F&:FF&6F5FF&
D-	)E20
E/:0E**E//E22
F
F	F&
F#	F&&
F4c                     SS K nUR                  " [        R                  SU /UR                  UR                  US9 nUR                  5       u  pEXE4sS S S 5        $ ! , (       d  f       g = f)Nr   -c)r<  r=  r;  )r  r?  r  r  PIPEcommunicate)coder;  r  r5  r<  r=  s         rG   run_process_no_exception!TestCase.run_process_no_exception  s[    ^^T4(????	

  }}V#
 
 
s   A
A*c                     [         R                  R                  5       nSUS'   UR                  SS 5        UR                  SS 5        [        R                  XS9u  p#UR                  S5      $ )Nre   PYTORCH_API_USAGE_STDERRr   TEST_SHOWLOCALS)r;  r  )ro   r  rD  r  r   r  r  )r  r;  _stdoutr=  s       rG   runWithPytorchAPIUsageStderr%TestCase.runWithPytorchAPIUsageStderr  s`    jjoo*-&' 	d!4(";;D;J}}W%%rF   rD  import_stringexpected_failure_messagec           	      F   SU SU S3nU(       a*  U R                  [        [        R                  " U5      5      O[        R
                  " 5       nU    [        R                  " [        R                  SU/[        R                  R                  [        R                  R                  [        5      5      [        R                  S9   SSS5        g! [        R                    a*  n[        UR"                  R%                  S5      5      SeSnAff = f! , (       d  f       g= f)a  
Attempts weights_only `torch.load` in a subprocess. This is used to test that
weights_only `torch.load` works as expected without global imports.

Args:
    file (pathlib.Path): The path to the checkpoint to load.
    import_string (str): import string to add to the script
    exected_failure_message (str, optional): The expected failure message if the
        checkpoint fails to load. If None, the test will pass
zimport torch;ztorch.load(r'z', weights_only=True)r  )r:  r=  r  N)rj  rA  rd  escaper  r  r  check_outputr  r  ro   r   r  r  r  STDOUTCalledProcessErrorr  r  )r   rD  r  r  scriptcmr  s          rG   _attempt_load_from_subprocess&TestCase._attempt_load_from_subprocess  s      !}TFBWX ( ""<;S1TU-7-C-C-E 	 	G''^^T62 (8(8(BC%,, R 00 G"188??7#;<$FG Rs+   DA3CD%%D

DD
D )r0  rm  r3  rn  )r  r  rX   )r   FFri  )NNNNNTTTTTFTNr  )rH   )NNNT)Ur>   r?   r@   rA   rm  r|  r   rn  ro  r   r  maxsize_diffThresholdmaxDiffrt  propertyrx  setterr  r1  r9  r  r
  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r&  r  r4  r9  r   r\  r  r  r  r  r  r  r  r  r$  r.  r2  r6  r   r   r   r   rK  rZ  r^  r   r   rb  rY  rj  rw  r|  r  r   r  r{  r  r  r  r  r  r  pathlibr   r  rE   r  r  s   @rG   r   r   0  s    JHe */ $. [[NG 5   e       ^^E d   "'"' %*!3Kj/&*)
)r  34TVZ81
3

ZV/SCFbJ8,:$ 48K. K.Z egst ,l\ WX y WX p bc @
 bc @
<: '+%)+/*.26,0-115=A<@9>-1(,P9d
I  /3 <DD
	7 ?C	Y %)$($Y %XseSj%9 9:;	Y 5/Y 5/YvH/3TH H%e_H;CE?H`dH
3=# =# =4 =
Mb.".8/ X X&N.`()<H6\r 
$ 
$ & & 37	GllG G #+3-	G
 
G GrF   r   c                       \ rS rSrSrg)TestCaseBasei2  r=   Nr9  r=   rF   rG   r  r  2  s    
 	rF   r  c                 $   SSK Jn  SSKJnJn  [
        R                  R                  U" U 5      S   5      n[        [
        R                  R                  [
        R                  R                  [        5      S5      5      n[
        R                  R                  Xe5      n[
        R                  R                  U5      (       a  U$  UR                  U SS9 n[        Xq(       a  SOS	5       n	UR                  5       n
U	R!                  U
5        S S S 5        S S S 5        U$ ! , (       d  f       N= f! , (       d  f       U$ = f! UR"                   a<  nS
U  S3n[$        R&                  " U[(        SS9  [*        R,                  " U5      UeS nAff = f)Nr   )urlsplit)requestrj  r;   r     r+  wbr  zcould not download test file 'rm   r  )urllib.parser  urllibr  rj  ro   r   r3  r   r   r  r  r  urlopenr   r  r  URLErrorr  r  RuntimeWarningr   r{  )urlbinaryr  r  rj  r   data_dirr   f1f2r  r  r  s                rG   download_filer  :  s   %%wwa 01H bggooh.G!PQH77<<+D	ww~~d,__S"_-T$TW5X\^779DHHTN 6Y-  6Y5X-- >> ,.se15c>a8$!+,sN   E D1,"D D1	E  
D.	*D11
E ;E  E F7F

Fc                  X   [        [        R                  " [        R                  [        R                  5      5       n U R	                  [        R
                  [        R                  S5        U R                  S5        U R                  5       u  pUsSSS5        $ ! , (       d  f       g= f)aj  
Finds an available port and returns that port number.

NOTE: If this function is being used to allocate a port to Store (or
indirectly via init_process_group or init_rpc), it should be used
in conjunction with the `retry_on_connect_failures` decorator as there is a potential
race condition where the allocated port may become unavailable before it can be used
r:   )	localhostr   N)	r   socketAF_INETSOCK_STREAM
setsockopt
SOL_SOCKETSO_REUSEADDRbindgetsockname)sockr   ports      rG   find_free_portr	  N  sl     
v~~v/A/AB	Ct))6+>+>B		"#""$	 
D	C	Cs   AB
B)zAddress already in usezconnect() timed out.c                 V   ^ ^ T c  [        [        TS9$ [        T 5      UU 4S j5       nU$ )zqReruns a test if the test returns a RuntimeError and the exception
contains one of the strings in connect_errors.)connect_errorsc            	      &  >^ SnUn  T" U 0 UD6$ ! [          au  m[        U4S jT 5       5      (       aU  US-  nUS:X  a  [        SU S[        T5       35      Te[        R                  " [
        R
                  " 5       5         S m@M  e S m@ff = f)Nr  c              3   >   >#    U  H  o[        T5      ;   v   M     g 7frX   )r   )r   connect_errorrj  s     rG   r   =retry_on_connect_failures.<locals>.wrapper.<locals>.<genexpr>p  s     W}E
2s   r:   r   zFailing after z retries with error: )rA  r,  r   timesleepr[  )r]   r^   	n_retriestries_remainingrj  r	  r  s       @rG   r   *retry_on_connect_failures.<locals>.wrapperh  s    	#	T,V,, WWWW#q(O&!+*^I;F[\_`e\f[g+hiottJJv}}/s    
BA)B
BB)r
   retry_on_connect_failuresr   )r  r	  r   s   `` rG   r	  r	  a  s5     |0PP
4[  NrF   c                     ^ ^^^ U UUU4S jnU$ )Nc                 :   >^  [        T 5      UUU UU4S j5       nU$ )Nc            	      J  > T
Tp2US:  a	   T" U 0 UD6$  T" U 0 UD6$ ! T a9  nU SUS S3n[        U5        [        R                  " U5        US-  n S nAOS nAff = fUS:  a  M\  NT! T a4  n[        R                  " ST
 S[        U5       35      T	(       a  UeUeS nAff = f)Nr:   z, Retrying in r	  z seconds...zSkipping after z consecutive )rI  r	  r	  r   r{  r   )r]   r^   mtriesmdelayr  r  ExceptionToCheckdelayr  skip_after_retriestriess         rG   f_retry*retry.<locals>.deco_retry.<locals>.f_retry}  s    "EF1* d-f--|$)&)) (  C~fQZ{CC#JJJv&aKF	  1* $ |''/%cRSfX(VWbt]^{z{{|s+    A( A/AA(B"./BB"r}  )r  r!	  r	  r	  r	  r 	  s   ` rG   
deco_retryretry.<locals>.deco_retry|  s(    	q	| 	| 
	| rF   r=   )r	  r 	  r	  r	  r#	  s   ```` rG   retryr%	  {  s     " rF   c                    X::  d   e[         R                  " X X#S9n[         R                  R                  USS9u  pVn[	        U 5       H  nX:  a  SXh'   M  Xh   S:X  d  M  SXh'   M     XVR                  U5      R                  S5      -  U-  $ )Nr8  Ffull_matricesr   r:   rS  )rM   randnlinalgsvdr^  rL  r  )	lrankrx  rz  Aurs  vhr   s	            rG   random_square_matrix_of_rankr1	    s    99A5A||7HA"1X9ADTQYAD	 
 U%%b))R//rF         ?gMbP?)r   sigmac                 ~   [         R                  [         R                  [         R                  [         R                  [         R                  [         R                  [         R                  [         R                  0n[         R
                  " X@US9nUR                  S5      nUR                  S5      n[         R                  R                  USS9u  pn[         R                  " USS [        Xx5      4-   XP   US.6U-  U-   R                  SSS9R                  R                  U 5      nXR                  S5      -  U-  $ )	z
Returns a random rectangular matrix (batch of matrices)
with singular values sampled from a Gaussian with
mean `mean` and standard deviation `sigma`.
The smaller the `sigma`, the better conditioned
the output matrix is.
r8  rS  r  Fr'	  NT)
descending)rM   r|  doublecfloatcdoubler  rQ  r*	  r+	  r)	  minrl  r  rL  r  )rx  rz  r   r3	  r  primitive_dtyper   r>  r=  r/	  r   r0	  rs  s                rG   random_well_conditioned_matrixr;	    s     	U[[ellekku||	O 	

5f5A	r
A	r
A||7HA"	uSbzSYL09OX^	_bg	gjn	n	bT	"66""U) B2%%rF   c                    U R                  5       (       d  U $ U R                  R                  (       d  U R                  R                  (       a  [        R
                  nO#U R                  [        R                  :X  a  SnOSnU R                  U R                  S-   5      nXS'   U R                  5       US'   US   nUR                  U R                  5        U$ )NTrb  r  ).r   ).r:   )r  rx  is_floating_point
is_complexrG  nanrM   r   	new_emptyr  r  requires_grad_rM  )rT  r   r  s      rG   noncontiguous_likerB	    s    ?? 	ww  AGG$6$6	
EJJ	[[4(F6NXXZF6NF^F
!//*MrF   c                     UR                  S[        R                  5      nUR                  SS5      n[        R                  " XU 4-   X4S.6nXUR                  -   R                  S5      nU$ Nrx  rz  r   r8  r;   )r  rM   r6	  r)	  mTdiv_r,	  batchesr^   rx  rz  r.	  s         rG   random_symmetric_matrixrI	    V    JJw-EZZ%(FgA&uDA	
TTAHrF   c                 p    US   US   :X  d   e[        X US9nX3R                  -   R                  S5      nU$ )Nr  rS  rh  r;   )r%   rE	  rF	  )rz  rx  r  rT  s       rG   make_symmetric_matricesrL	    s=    9b	!!!E6A	
TTAHrF   c                     UR                  S[        R                  5      nUR                  SS5      n[        R                  " XU 4-   X4S.6nXUR                  -   R                  S5      nU$ rD	  )r  rM   r6	  r)	  mHrF	  rG	  s         rG   random_hermitian_matrixrO	    rJ	  rF   c                     UR                  S[        R                  5      nUR                  SS5      n[        R                  " XU 4-   X4S.6nXUR                  -  $ )aC  
Returns a batch of random symmetric positive-semi-definite matrices.
The shape of the result is batch_dims + (matrix_size, matrix_size)
The following example creates a tensor of size 2 x 4 x 3 x 3
>>> # xdoctest: +SKIP("undefined variables")
>>> matrices = random_symmetric_psd_matrix(3, 2, 4, dtype=dtype, device=device)
rx  rz  r   r8  )r  rM   r6	  r)	  rE	  rG	  s         rG   random_symmetric_psd_matrixrQ	    sJ     JJw-EZZ%(FgA&uDAtt8OrF   r8  c                R    [         R                  " X0U 4-   XS.6nXDR                  -  $ )aC  
Returns a batch of random Hermitian positive-semi-definite matrices.
The shape of the result is batch_dims + (matrix_size, matrix_size)
The following example creates a tensor of size 2 x 4 x 3 x 3
>>> # xdoctest: +SKIP("undefined variables")
>>> matrices = random_hermitian_psd_matrix(3, 2, 4, dtype=dtype, device=device)
r8  )rM   r)	  rN	  matrix_sizerx  rz  
batch_dimsr.	  s        rG   random_hermitian_psd_matrixrV	    s'     	j#==e[Att8OrF   c                    UR                  S[        R                  5      nUR                  SS5      n[        R                  " XU 4-   X4S.6n[        R                  " XUR
                  5      [        R                  " XUS9S-  -   $ )Nrx  rz  r   r8  h㈵>)r  rM   r6	  r)	  matmulrE	  eye)rT	  rU	  r^   rx  rz  r.	  s         rG   random_symmetric_pd_matrixr[	     sp    JJw-EZZ%(Fj#==	0A<<44 
))KV
<t
CD DrF   c                     US   US   :X  d   e[        X US9n[        R                  " US   XS9S-  nX3R                  -  U-   $ )Nr  rS  rh  rX	  )r%   rM   rZ	  rE	  )rz  rx  r  rT  r   s        rG   make_symmetric_pd_matricesr]	    sM    9b	!!!E6A		%)F84?Att8a<rF   c                ~    [         R                  " X0U 4-   XS.6nXDR                  -  [         R                  " XUS9-   $ )a=  
Returns a batch of random Hermitian positive-definite matrices.
The shape of the result is batch_dims + (matrix_size, matrix_size)
The following example creates a tensor of size 2 x 4 x 3 x 3
>>> # xdoctest: +SKIP("undefined variables")
>>> matrices = random_hermitian_pd_matrix(3, 2, 4, dtype=dtype, device=device)
r8  )rM   r)	  rN	  rZ	  rS	  s        rG   random_hermitian_pd_matrixr_	    s;     	j#==	0Att8eiiHHHrF   )rM  c                 J   [         R                  " 5          [        X0US9n[         R                  R	                  USS9u  pVnUR
                  R                  (       a  UR                  R
                  OUR
                  n[        US   US   5      n	[         R                  " SU	S-   XS9n
U
SS S2==   S	-  ss'   U
R                  5       R                  S
5        XZR                  UR
                  5      -  U-  nS S S 5        WR                  U5        U$ ! , (       d  f       N!= f)Nrh  Fr'	  r  rS  r;   r8  r:   g      r2	  )rM   rK  r%   r*	  r+	  rx  r>	  realr9	  rI  reciprocal_r  rL  rA	  )rz  rx  rM  r  rT  r/	  r   r0	  
real_dtyperX  rs  r   s               rG   4make_fullrank_matrices_with_distinct_singular_valuesrd	    s    	E:<<##AU#;b%&WW%7%7QVV\\QWW
b	59% LLAEC	!$Q$3 	
R  agg"$! 
" ]#H% 
s   C#D
D"c                 r   UR                  S[        R                  5      nUR                  SS5      nUR                  SS5      nUR                  SS5      nU(       a4  [        R                  R                  (       d  [        R
                  " XXES9$ [        R                  " X U4-   XES9nUR                  5       S:X  a  U$ [        R                  R                  USS	9u  pn[        X5      n[        R                  " S
US
-   -  S
XUS9nU(       a  SXS
-
  '   US:  a  SUS'   XR                  S5      -  U-  $ )zReturn rectangular matrix or batches of rectangular matrices.

Parameters:
  dtype - the data type
  device - the device kind
  singular - when True, the output will be singular
rx  rz  r   silentFsingularr8  r   r'	  r:   r;   rS  )r  rM   r6	  r  r  onesr)	  r  r*	  r+	  r9	  linspacer  )rowscolumnsrU	  r^   rx  rz  rf	  rg	  r.	  r/	  r   r0	  rX  rs  s                 rG   random_matrixrl	  4  s
    JJw-EZZ%(FZZ%(Fzz*e,Hehh))zz$uDDJ0MAwwyA~||7HA"DAqAE{AqfEAa%q5 AaDB2%%rF   c                 H   UR                  S[        R                  5      nUR                  SS5      nUR                  SS5      nUR                  SS5      n/ UQU PUP7n[        R                  " X   5      n	[        R
                  " XUS.6U	-  n
U
R                  U5        U
$ )	a  Return rectangular matrix or batches of rectangular matrices
with entries being iid and sampled from N(0, sigma^2) such that
the variance of (A @ A.T)[..., i, j] is 1 if reduction_dim=-1, or
the variance of (A.T @ A)[..., i, j] is 1 if reduction_dim=-2.

Parameters:
  dtype - the data type
  device - the device kind
  requires_grad - whether output requires grad
  reduction_dim - the row/column dimension to re-scale.
                Expected to be either -1 (columns) or -2 (rows).
rx  rz  r   rM  Freduction_dimr  r8  )r  rM   r6	  rG  sqrtr)	  rA	  )rj	  rk	  rU	  r^   rx  rz  rM  rn	  r  	red_scalerU  s              rG   'random_matrix_with_scaled_reduction_dimrq	  S  s     JJw-EZZ%(FJJ6MJJ3M(j($((E		%./I
++u&
9I
EC}%JrF   c                 `    [        X/UQ70 UD6n[        X/UQ70 UD6nUR                  U5      $ )zNReturn rectangular matrix or batches of rectangular matrices with
given rank.
)rl	  rY	  )r-	  rj	  rk	  rU	  r^   BCs          rG   random_lowrank_matrixru	  l  s:     	d8:88Ad;j;F;A88A;rF   rj	  colsnum_indicesc           	        ^ / n[         R                  " X -  5      n[        [        U5      5      n[        U 5       H0  mUR	                  U4S j[
        R                  " XTS9 5       5        M2     [        R                  " USU 5      $ )z\Generate indices for a row x cols matrix, preferring at least one index per row if possible.c              3   ,   >#    U  H	  nTU4v   M     g 7frX   r=   )r   r  r  s     rG   r   4_generate_indices_prefer_all_rows.<locals>.<genexpr>}  s     P'O!1v'Or)  )rX  N)	rG  ceilr8  r^  rM  r[  choicesrM   rb  )rj	  rv	  rw	  r  	n_per_rowr  r  s         @rG   !_generate_indices_prefer_all_rowsr~	  u  sh    G		+,-IuT{#K4[Pv~~k'OPP  <<-..rF   {Gz?c                    UR                  S[        R                  5      nUR                  SS5      n[        [	        X5      [        X-  U-  5      5      n[        XU5      n[        R                  " XdUS9nU[        R                  " U V	V
s/ s H  u  p[        X-
  5      S-  * PM     sn
n	XES9R                  5       -  n[        R                  " UR                  5       XU4US9nUR                  5       $ s  sn
n	f )a   Return rectangular random sparse matrix within given density.

The density of the result approaches to given density as the size
of the matrix is increased and a relatively small value of density
is specified but higher than min(rows, columns)/(rows * columns)
for non-singular matrices.
rx  rz  r   r8  r;   ru  )r  rM   r6	  r  r9	  r   r~	  r)	  rb  r|  expr  rT  r  )rj	  rk	  densityr^   rx  rz  nonzero_elementsr  r  r   r  r.	  s               rG   random_sparse_matrixr	    s     JJw-EZZ%(F3t-s4>G3K/LM/?OPG[[)vFF ellAU15\1_,A^bbddF		VG_VTA::< Bs   C7c           
         SSK nUR                  S[        5       S   5      nUR                  SUR                  5      nUR                  SS5      n[	        U 5       Vs0 s H  nXw4[        US-   5      U -  _M     nnSS	 jn	X-  U -  n
[        U5      U
:  a  [        R                  " SU S-
  5      n[        R                  " SU S-
  5      nX{:w  aZ  [        R                  " SS
UR                  -  5      nUR                  " U5      nUR                  " U5      nU	" XX{XSS9  U	" XX{XSS9  [        U5      U
:  a  M  / / / nnn[        UR                  5       5       H;  u  u  p{nUR                  U5        UR                  U5        UR                  U5        M=     UR                   " UU/5      nUR"                  " UUX 4XVS9$ s  snf )a  Return random sparse positive-definite matrix with given density.

The eigenvalues of the matrix are defined as::
  arange(1, matrix_size+1)/matrix_size

Algorithm:
  A = diag(arange(1, matrix_size+1)/matrix_size)
  while <A density is smaller than required>:
      <choose random i, j in range(matrix_size), theta in [0, 2*pi]>
      R = <rotation matrix (i,j,theta)>
      A = R^T A R
r   NrM   rx  rz  r   r:   Tc                 2   [        U5       H  nU(       a  Xr4Xs4pOX'4X74pU R                  US5      U R                  U	S5      pXJ-  X[-  -   U* U
-  XK-  -   pU
(       a  XU'   OU R                  US 5        U(       a  XU	'   Mv  U R                  U	S 5        M     g r  )r^  r  r  )r  rN  r   r  cssnleftrX  ikjkaikajks               rG   multiply)random_sparse_pd_matrix.<locals>.multiply  s    qA!B!BxxAQx"(*RC#I,@RT"RT" rF   r;   )r	  Fr8  r  )rG  r  rq   r6	  r^  r|  r  r[  randintuniformpicossinsortedr   r  rb  r  )rT	  r	  r^   rG  rM   rx  rz  r   r  r	  
target_nnzr  thetar	  r	  icoordsjcoordsr  r  indices_tensors                       rG   random_sparse_pd_matrixr	    s    JJw	' 23EJJw-EZZ%(F;')' FE!a%L;..' 	 )#" &4J
d)j
 NN1kAo.NN1kAo.6NN1a$''k2E%B%BTb4@Tb5A d)j
   "2rfWGDJJL)	qqa * \\7G"45N"">6K;U]brrK)s   Gc                    U H  nU[         R                  :w  d  M  [         R                  " SXBUS9nU R                  XER                  5        U R                  X%R
                  5        U R                  X5R                  5        M     g )Nr  )rx  rv  rz  )rM   float16rE  assertIsrx  rv  rK  rz  )r   dtypesrv  rz  rx  outs         rG   do_test_dtypesr	    s\    EMM!++fEPCMM%+MM&**-VZZ0 rF   c                 8  ^ ^ [         R                  " SS/5      mU U4S jnS n[         R                  " 5       nU" [         R                  " T5      U[         R                  SS S5        U" [         R
                  " TS5      U[         R                  SS S5        U GH  nUR                  S1 GH  nU" U5      n	[         R                  " TXsX(S9n
U" XX#S U5        U
R                  5       nU" [         R                  " TXX(S	9XrUS U5        U" U
R                  T5      XrUS S5        U" U
R                  TXSS
9XUS S5        U" [         R                  " U
5      XrUS S5        U" [         R                  " XX#SS9XUS S5        U[         R                  Ld  M  U[         R                  :w  d  M  Sn[         R
                  " TXX#US9n
U" XX#X5        U" U
R                  TUS-   5      XrX<S-   S5        U
R                  5       nU" [         R
                  " TUS-   XX(S	9XrX<S-   U5        U" U
R                  TUS-   XSS
9XX<S-   S5        U" [         R                  " XS-   5      XrX<S-   S5        U" [         R                  " XS-   XUSS9XX<S-   S5        GM     GM     g )Nr;   r<   c                   > TR                  TU R                  5        TR                  XR                  5        TR                  X R                  5        TR                  U R
                  U5        U R                  (       a  Ub  TR                  X0R                  5        Ub2  U R                  T5      R                  U5      nTR                  X5        g g rX   )
rK  r  r	  rx  rv  rM  is_cudarz  rO  rF  )	rb  rx  rv  rz  r   rM  fillr   r  s	          rG   check_value'do_test_empty_full.<locals>.check_value  s    -e\\*fmm,--}=>>f0V]]3::e$**51DV* rF   c                     SR                  [        U 5      R                  S5      SS 5      nU(       d  [        R                  $ [
        R                  " U5      " [        5      R                  $ )Nr   r:   r  )r   r   rR   rM   r  r/  
attrgetter)rx  modules     rG   get_int64_dtype+do_test_empty_full.<locals>.get_int64_dtype  sO    #e***3/"56;;""6*51777rF   r  Fg      )rx  rz  rv  rM  )r	  rz  rv  rM  )rx  rz  rM  )rx  rv  rz  rM  r:   r  r-  )rM   r  r]  r
  r  r  r=	  rO  r@	  
empty_liker	  r  new_full	full_like)r   r	  rv  rz  r	  r	  default_dtyperx  rgint64_dtyper  r	  fvr  s   `            @rG   do_test_empty_fullr	    st   JJ1vE	+8 ++-ME"M5=="dER

5#&u}}b$PUV**E2B)%0KEf_A&$;%%'CEs&cvtR9E*E64OE[`a#VT5B((+UFD%P((fkpq#VT5B EMM)f8H8H.HJJubfcefAfb=AJJub1f5ufSTfV[\eegEJJub1f#U[n!662?AJJub1fKfkJl'aHEOOAAv6vTUvW\]EOOAAv2=U[kpr'aH3 3 rF   c                       [         R                  R                  [         R                  R                  [        R
                  S   5      5      n U R                  S5      (       a  U qg g ! [         a     g f = f)Nr   r  )	ro   r   r	  r  r  r  endswithrunning_script_pathr   )running_files    rG   set_running_script_pathr	    s^    wwrww'7'7'DE  ''". ( s   A%A) )
A65A6c                 "   [         c  g [        R                  R                  [        R                  R	                  [
        R                  " U R                  5      5      5      nU[         :X  d#   SU R                  5        S[          SU S35       eg )NzClass of loaded TestCase "z(" is not defined in the running script "z", but in "zE". Did you accidentally import a unittest.TestCase from another file?)	r	  ro   r   r	  r  r   r  r  r   )rm  test_case_class_files     rG   $check_test_defined_in_running_scriptr	    s    "77??277+;+;GOOIL_L_<`+ab#66 E:TU^UaUaUcTd e11D0E[QePf gE9E E6rF   c                     [        5         [        R                  " 5       nU HF  n[        (       d  U H  n[	        U5        M     UR
                  (       d  M5  UR                  U5        MH     U$ rX   )r	  r   rh  r   r	  ri  addTest)loaderr  r  
test_suite
test_groupr   s         rG   
load_testsr	  !  sZ    ##%J
))"4T: #z*  rF   c                        \ rS rSrS rS rSrg)BytesIOContexti-  c                     U $ rX   r=   r  s    rG   r  BytesIOContext.__enter__.  r  rF   c                     g rX   r=   )r   r]   s     rG   r  BytesIOContext.__exit__1  s    rF   r=   Nr  r=   rF   rG   r	  r	  -  s    rF   r	  g-q=TEST_WITH_SLOW_GRADCHECK PYTORCH_TEST_WITH_SLOW_GRADCHECKzETests that don't use gradcheck don't need to run on slow_gradcheck CIc                     SSS.n[         (       a  SUS'   UR                  5        H  u  pEUR                  U5      nUb  UOUX$'   M!     [        R                  R
                  " X40 UD6$ NT)check_batched_grad	fast_modeFr	  )r	  r   r  rM   autograd	gradcheck)r   inputsr^   default_valuesr"  r   rX  s          rG   r	  r	  F  sn     #N
  &+{#$**,
JJsO=ae -
 >>##B9&99rF   c                     SSS.n[         (       a  SUS'   UR                  5        H  u  pVUR                  U5      nUb  UOUX5'   M!     [        R                  R
                  " XU40 UD6$ r	  )r	  r   r  rM   r	  gradgradcheck)r   r	  grad_outputsr^   r	  r"  r   rX  s           rG   r	  r	  \  sp     #N
  &+{#$**,
JJsO=ae -
 >>''LKFKKrF   c                 p    U R                  [        X40 UD65        U R                  [        X40 UD65        g rX   )r  r	  r	  )rm  apply_fnr	  r^   s       rG   _assertGradAndGradgradChecksr	  q  s4     8>v>?xB6BCrF   r   c              #      #    [         R                  " 5       n [         R                  " U 5        S v   [         R                  " U5        g ! [         R                  " U5        f = f7frX   )ro   getcwdchdir)r   old_cwds     rG   set_cwdr	  x  s;     iikG

s   A%A
 A%
A""A%rX	  g?c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                 F   > T" U /UQ70 UDSS0D6  T" U /UQ70 UDSS0D6  g )N	coalescedTFr=   )r   r]   r^   r  s      rG   r1  coalescedonoff.<locals>.wrapped  s1    	$00040	$11151rF   r}  )r  r1  s   ` rG   coalescedonoffr	    s     
1X2 2 NrF   c                    U R                  5       nSU R                  U R                  5       S-
  SS2   -   n[        R                  " X R
                  S9R                  S5      R                  S5      nU R                  5       S:  a%  UR                  S5        X-  R                  S5      nOX-  n[        R                  " X3R                  5       S   5      nU=(       a$    [        R                  " X3R                  5       5      nU$ )N)r:   r:   r   r  ru  )r  r  r|  rM   rb  rz  cumprodflip
unsqueeze_sumallcloserl  unique)rs  r  hash_coeffshash_indicesrU  s        rG   is_coalesced_indicesr	    s    jjlG!!3Ab!899K<<HH=EEbINNrRL||~#.33A6- ..'8'8':1'=
>C 
E%../B/B/DECJrF   c               #      #    [         R                  " 5       (       a0   [         R                  " 5         S v   [         R                  " 5         g S v   g ! [         R                  " 5         f = f7frX   )r   rt  r7  r1  r=   rF   rG   
disable_gcr	    s9     	||~~	JJLIIK IIKs   A,A A,A))A,lib_namec                 *   [        [        R                  5      R                  5       R                  nUS-  U -  n[
        R                  R                  U5      (       a  U$ [        [        5      R                  5       R                  S   nUS-  S-  U -  $ )Nlibr;   build)	r   rM   r  resolveparentro   r   r  parents)r	  
torch_rootr   s      rG   find_library_locationr	    sz     enn%--/66J(D	ww~~dh'')11!4J%'(22rF   c                    ^  U 4S jnU$ )z
Similar to unittest.skip, however in the sandcastle environment it just
"passes" the test instead to avoid creating tasks complaining about tests
skipping continuously.
c                 j   >^  [         (       d  ST l        TT l        T $ [        T 5      U U4S j5       nU$ )NTc                  V   > [        STR                   ST 3[        R                  S9  g Nz	Skipping z% on sandcastle for following reason: rq  rI  r>   r  r=  r]   r^   r  r  s     rG   r   ?skip_but_pass_in_sandcastle.<locals>.decorator.<locals>.wrapper  s+    Idmm_,QRXQYZadakaklrF   )r   r  r  r   )r  r   r  s   ` rG   r`  .skip_but_pass_in_sandcastle.<locals>.decorator  s:    }%)D")/D&K	t	 
	 rF   r=   )r  r`  s   ` rG   skip_but_pass_in_sandcastler 
    s    
 rF   c                 V   ^ ^ [        5       m[        T 5      U U4S j5       nTUl        U$ )zq
Returns a function that calls the real implementation of a method
in addition to passing args to a mock object.
c                 ,   > T" U0 UD6  T" U /UQ70 UD6$ rX   r=   )r   r]   r^   r  r  s      rG   r   mock_wrapper.<locals>.wrapper  s%    dfd,T,V,,rF   )r   r   r  )r  r   r  s   ` @rG   mock_wrapperr
    s0    
 ;D
6]- - GLNrF   c           
          [        U  Vs/ s H  n[        U[        5      (       d  M  UPM     snUR                  5        Vs/ s H  n[        U[        5      (       d  M  UPM     sn-   5      $ s  snf s  snf )zBReturns a set of all Tensor objects in the given args and kwargs. )r>  r   r   r  )r]   r^   r  r  s       rG   get_tensors_fromr
    sX    t?tz#v'>t?!==?D?ajF.C?DE F F?Ds   A-A-A2
A2
	byte_listrx  rz  c                 8   [         R                  [        R                  [         R                  [        R
                  [         R                  [        R                  [         R                  [        R                  [         R                  [        R                  [         R                  [        R                  [         R                  [        R                  [         R                   [        R"                  [         R$                  [        R&                  [         R(                  [        R*                  [         R,                  [        R*                  [         R.                  [        R0                  [         R2                  [        R0                  0nX1   n[        R4                  " U5      nS nUR6                  (       a  [9        U 5      US-  :X  d   eU" U 5        UR;                  [        R<                  U-  " U S U 6 5      R>                  nUR;                  [        R<                  U-  " XS  6 5      R>                  nUSU-  -   n	OH[9        U 5      U:X  d   eU" U 5        UR;                  [        R<                  U-  " U 6 5      R>                  n	[         R@                  " XUS9$ )Nc                 :    U  H  nSUs=::  a	  S::  a  M   e   e   g )Nr      r=   )r
  bytes     rG   check_bytes$bytes_to_scalar.<locals>.check_bytes  s%    D###### rF   r;   y              ?rh  )!rM   rA  ctypesc_int8r;  c_uint8uint16c_uint16uint32c_uint32uint64c_uint64int16c_int16r?  c_int32r  c_int64r   c_boolr   c_floatr"  float64c_double
complex128sizeofr>	  r  from_bufferc_byter   rb  )
r
  rx  rz  dtype_to_ctypectype	num_bytesr
  ra	  imagrU  s
             rG   bytes_to_scalarr'
    s   

FMMV^^foofoofooV^^V^^V^^

FMMv~~v&//.N !Ee$I$ 9~)a-000I  &--)";z	""$ %%*U 	  &--)";z""$ %%*U 	R$Y9~***I!:!  	 <<%88rF   c                     [         R                  " U R                  U R                  U R                  U R
                  U R                  S9n[        R                  " X5      nU R                  Ul	        U$ )zBBased on http://stackoverflow.com/a/6528148/190597 (Glenn Maynard))rr   argdefsclosure)
r  FunctionType__code____globals__r>   __defaults__r  r   update_wrapper__kwdefaults__)r  gs     rG   	copy_funcr2
    sW    1::q}}1::#$>>#$==	2A 	  &A''AHrF   c                    ^  U 4S jnU$ )z
Given a list of test names which are defined by a superclass of the
class this decorates, mark them as expected failure.  This is useful
if you are doing poor man's parameterized tests by subclassing a generic
test class.
c                 ~   > T H5  n[        X[        R                  " [        [	        X5      5      5      5        M7     U $ rX   )rT  r   r  r2
  r   )rU  rT  r  s     rG   deco#xfail_inherited_tests.<locals>.deco   s4    A CH44Yws5OPQ  
rF   r=   )r  r5
  s   ` rG   xfail_inherited_testsr7
    s     KrF   c                    ^ ^ U U4S jnU$ )z
Similar to unittest.skipIf, however in the sandcastle environment it just
"passes" the test instead to avoid creating tasks complaining about tests
skipping continuously.
c                 x   >^  T(       a0  [         (       a  [        T 5      U U4S j5       nU$ ST l        TT l        T $ )Nc                  V   > [        STR                   ST 3[        R                  S9  g r	  r	  r	  s     rG   r   Bskip_but_pass_in_sandcastle_if.<locals>.decorator.<locals>.wrapper2  s(    Idmm_4YZ`YabilisistrF   T)r   r   r  r  )r  r   r  r  s   ` rG   r`  1skip_but_pass_in_sandcastle_if.<locals>.decorator/  s=    }tu u)-&-3*rF   r=   )r  r  r`  s   `` rG   r  r  )  s     rF   c                 <    [        U 5      R                  S5      S   $ )zBReturns the pretty name of the dtype (e.g. torch.int64 -> int64). r   r:   )r   rR   r  s    rG   ry  ry  >  s    u:C ##rF   c                      S[         4S jn Sn[        U5       Vs/ s H	  o " 5       PM     nn[        U5      n[        USUS-
   5      $ s  snf )zZMeasure and return approximate number of cycles per millisecond for torch.cuda._sleep
    r   c                  @   [         R                  R                  SS9n [         R                  R                  SS9nU R                  5         [         R                  R	                  S5        UR                  5         UR                  5         SU R                  U5      -  nU$ )NT)enable_timingi@B )rM   rN   Eventr  _sleepr}  r  )r  endcycles_per_mss      rG   measure"get_cycles_per_ms.<locals>.measureH  sy    

  t 4jjT2

'"

%"4"4S"99rF   r  r;   )r|  r^  r	  r   )rE
  numr   valss       rG   get_cycles_per_msrI
  C  sS    
U $ C$Sz*z!GIzD*$<DQq!"" +s   A	Tr   samplesc                 ~     [        [        U5      5      $ ! [         a  n[        R                  " S5      UeSnAff = f)z
Returns the first sample from an iterable of samples, like those returned by OpInfo.
The test will be skipped if no samples are available.
z%Skipped! Need at least 1 sample inputN)r  r  StopIterationr   r{  )r   rK
  r  s      rG   first_samplerN
  c  s=    
PDM"" P GHaOPs    
<7<c                     [        U [        R                  5      (       a  [        R                  " U 5      $ [        U [        5      (       a  [        [        [        U 5      5      $ U $ rX   )r   rM   r   r  r   rX  ry  clone_input_helperrA  s    rG   rP
  rP
  o  sG    %&&{{5!!%""S+U344LrF   c              #   d   #     [        XU5        Sv   [        X5        g! [        X5        f = f7f)zBContext manager/decorator to test ONNX export with custom operatorNr"   )opnamesymbolic_fnopset_versions      rG   	custom_oprU
  x  s(     =#FG%f<%f<s   0  0-0c                 $   U " U6 n[         R                  " U5       HT  n[        U[        R                  5      (       d  M$  UR
                  (       d  M7  UR                  5       R                  SS9  MV     [         R                  " U5       Vs/ s H0  n[        U[        R                  5      (       d  M$  UR                  PM2     nn[         R                  " U5       H+  n[        U[        R                  5      (       d  M$  S Ul        M-     X64$ s  snf )NT)retain_graph)	pytreetree_leavesr   rM   r   rM  r	  backwardgrad)r   
graph_inpsinpsoutsr	  inpgradss          rG   outs_and_gradsra
    s    z?D!!$'c5<<((S->->->GGID1 ( "(!3!3D!9[!9#ZU\\=ZXSXX!9E[!!$'c5<<((CH ( ;	 \s   #D3Dc                     [        XU5      u  pE[        X#U5      u  pgU R                  XF5        U R                  XW5        g rX   )ra
  rK  )r   m1m2r]
  r1g1r2g2s           rG   compare_equal_outs_and_gradsri
    s:    Bd+FBBd+FBRRrF   c                   L    \ rS rSrSrS rSSSSS.S jrSSSSS.S jrS	 rS
r	g)TestGradientsi  Tc                 0   ^ [        T5      U4S j5       nU$ )Nc                 8   > T" U R                  5       /UQ70 UD6$ rX   )r  )rT  r]   r^   inplace_variants      rG   r  ,TestGradients._get_safe_inplace.<locals>._fn  s    "1779>t>v>>rF   r}  )r   rn
  r  s    ` rG   _get_safe_inplaceTestGradients._get_safe_inplace  s!    			? 
 	? 
rF   FNcheck_forward_adcheck_backward_adr	  check_batched_forward_gradc                <  ^^^^ US;   d   eTc  U R                  S5        TR                  U[        R                  " U5      R                  5      (       d*  U R                  STR
                   S[        U5       35        U4S jn
TR                  =(       a    UR                  nTR                  XSU[        S9nU GH  mTR                  (       a  U
" T5      (       a  M$  S n[        TR                  5      (       a:  [        TR                  TR                  TR                   R#                  5       5      nOC[%        [        TR                  4TR                  TR                   R#                  5       5      5      n[%        S U 5       5      nU H  nU R'                  UR(                  S	5        M!     S
 mUUUU4S jnUS:X  aG  Uc  TR*                  nU R-                  [/        UUUSTR0                  TR2                  UUSU	S9
5        GMM  US;   ax  U R5                  USS9  S H_  nUTR6                  STR0                  TR2                  S.nUS:X  a  SUS'   SUS'   SUS'   SUS'   U R-                  [9        UU40 UD65        Ma     GM  U R-                  SSS9  GM     g )N)r	  bwgrad_bwgradfwgrad_bwgradz!Skipped! Variant not implemented.z	Skipped! z does not support dtype c                    > [        U S5      (       a  U R                  TR                  5       L $ U TR                  5       L $ )N__wrapped__)r   rz
  get_inplace)variantr  s    rG   
is_inplace/TestGradients._check_helper.<locals>.is_inplace  s:    w..**bnn.>>>bnn...rF   T)rM  include_conjugated_inputssmall_inputs_onlyc              3      #    U  H;  n[        U[        R                  5      (       d  M$  UR                  (       d  M7  Uv   M=     g 7frX   )r   rM   r   rM  )r   r   s     rG   r   .TestGradients._check_helper.<locals>.<genexpr>  s*     "lh:a;V1[\[j[j11hs   #AA	AzA sampled input has a gradient before running autograd. This usually means that (at least) one input tensor is reused across different SampleInputs. Please create a new tensor for each SampleInput.c                 l   [        U5      (       ai  / nU H^  n[        U[        R                  5      (       a+  UR                  (       a  UR                  X   5        US-   nMM  UR                  U5        M`     X24$ [        U[        R                  5      (       a  UR                  (       a	  X   US-   4$ X4$ rA  )rq  r   rM   r   rM  r  )r	  r_
  r  tensor_listr   s        rG   _input_recomposition_helper@TestGradients._check_helper.<locals>._input_recomposition_helper  s    )#.."$K %a661??'..v/@A(1AI'..q1 ! '11U\\22s7H7H!,i!m;;>)rF   c                    > / nSnT	" U TR                   U5      u  p2UR                  U5        TR                   H  nT	" XU5      u  p2UR                  U5        M!     0 nTR                  R	                  5        H  u  pgT	" XU5      u  p2X5U'   M     T
R
                  " T/UQ70 UD6nTR                  b  TR                  U5      $ U$ r  )r   r  r]   r^   r   gradcheck_wrapperoutput_process_fn_grad)r	  positional_argsr  r_
  r   r^   rX  r  r  r
  r  sampler|
  s            rG   r   'TestGradients._check_helper.<locals>.fn  s    "$	!<VV\\S\!]&&s+A%@I%VNC#**3/ %
 "MM//1DA%@I%VNC #1I 2 --gRR6R00<!88@@rF   r	  )r	  check_grad_dtypes
nondet_tolr	  rs
  rt
  check_undefined_gradru
  )rw
  rx
  z-Cannot run forward AD check for gradgradcheckr  )FT)gen_non_contig_grad_outputsr	  r
  r
  r	  rx
  check_fwd_over_revFcheck_rev_over_revr	  r
  zUnknown check requested!)r`  supports_dtyperM   rz  r   rr   r   test_conjugated_samplesr>	  sample_inputsr	  broadcasts_inputrq  r   r   r]   r^   r  rX  ru  r[
  r	  r  r	  gradcheck_nondet_tolgradcheck_fast_moder  check_batched_gradgradr	  )r   rz  rx  r  r|
  checkrs
  rt
  r	  ru
  r}
  r
  rK
  all_argsgradcheck_argsrT  r   r
  r^   r
  r
  s      ``              @@rG   _check_helperTestGradients._check_helper  s   GGGG?MM=>  V(<(A(ABBMMIbggY.Fs5zlST	/
 %'$>$>$S5CSCS!""6`y5M # O F&&:g+>+> H%fll33 v{{FMM<P<P<RS V]]EYEYE[!\]""lh"llN $!!!&&#UV $* , #%-)+)>)>&	"n=O<@575L5L464J4J;K<M?CE_!a b <<  !17f g3@/7R.0.G.G-1&(&=&=%'%;%;F /7;347<347<349>56OOM"n$O$OP 4A  +EF{ rF   c                *    U R                  XX4SUXgUS9	$ )Nr	  rr
  )r
  )	r   rz  rx  r  r|
  rs
  rt
  r	  ru
  s	            rG   _grad_test_helperTestGradients._grad_test_helper  s+    !!&k\l4E=W " Y 	YrF   c                     X1R                  [        R                  " U5      R                  5      ;  a  U R	                  S5        UR
                  (       d$  UR                  (       d  U R	                  S5        g g g )Nz4Skipped! Op doesn't support autograd for this dtype.z Skipped! autograd not supported.)supported_backward_dtypesrM   rz  r   r`  supports_autogradsupports_forward_ad)r   r  rz  rx  s       rG   _skip_helperTestGradients._skip_helper  sV    44U\\&5I5N5NOOMMPQ##B,B,BMM<= -C#rF   r=   )
r>   r?   r@   rA   r1  rp
  r
  r
  r
  rE   r=   rF   rG   rk
  rk
    s=    K TYlp)-%pGd QVim-1eY>rF   rk
  c                   D    \ rS rSrS rS r\R                  S 5       rSr	g)NestedTensorTestCasei!  c                 ~    S nU R                  [        R                  " X15      [        R                  " X25      5        g )Nc                     [        U [        R                  5      (       a?  U R                  (       a.  U R                  [        R
                  :X  a  U R                  5       $ U $ rX   )r   rM   r   rO  rv  jaggedrP  r  s    rG   _unbind_njtsHNestedTensorTestCase.assertEqualIgnoringNestedInts.<locals>._unbind_njts%  s9    !U\\**q{{qxx5<<?Wxxz!rF   )rK  rX
  tree_map)r   r  r  r
  s       rG   assertEqualIgnoringNestedInts2NestedTensorTestCase.assertEqualIgnoringNestedInts"  s+    	 	96??<;[\rF   c                     U R                  X5        S n[        R                  " X15      n[        R                  " X25      nU R                  XE5        g )Nc                 ~    [        U [        R                  5      (       a  U R                  (       a  U R                  $ S $ rX   )r   rM   r   rO  r  r  s    rG   _get_njt_shapesGNestedTensorTestCase.assertEqualNoncontigAware.<locals>._get_njt_shapes2  s3     a..1;;  rF   )r
  rX
  r
  rK  )r   r  r  r
  a_shapesb_shapess         rG   assertEqualNoncontigAware.NestedTensorTestCase.assertEqualNoncontigAware-  sC     	**10	 ???6???6,rF   c              #      #    [         R                  R                  R                  nUR                  R                  5       nUR                  n Sv   X1l        X!l        g! X1l        X!l        f = f7f)z>Context manager to branch and restore the nested tensor state.N)rM   nested	_internalnested_tensor_tensor_symint_registryrD  _tensor_id_counter)r   nested_tensor_moduleoriginal_tensor_symint_registryoriginal_tensor_id_counters       rG   branch_nested_state(NestedTensorTestCase.branch_nested_state=  sc       %||55CC*>*V*V*[*[*]'%9%L%L"	[6P3;Z8 7Q3;Z8s   AA0A A0A--A0r=   N)
r>   r?   r@   rA   r
  r
  r  r   r
  rE   r=   rF   rG   r
  r
  !  s)    	]-  	[ 	[rF   r
  )r  suppress_prefixrD  r  c          	      d  ^ SSK Jn  Tc%  [        R                  " 5       SU-      R                  mU" T5      mU" [        U 5      5      nU4S jn[        R                  " SUU5      n[        R                  " SSU5      n[        R                  " SS	U5      n[        R                  " S
SU5      n[        R                  " TU" [        R                  R                  T5      5      U5      n[        R                  " U" [        R                  R                  [        R                  R                  [        R                  5      S5      5      SU5      n[        R                  " SSU[        R                  S9nU(       ao  [        R                  " SSU[        R                   S9n[        R                  " SSU[        R                   S9n[        R                  " SSU[        R                   S9nU(       a  [        R                  " SSU5      n[        R                  " SSU[        R                  S9nU$ )Nr   )_as_posix_pathr:   c                 ~   > U R                  S5      T:w  a  gU R                  S5      S:X  a  gU R                  S5      $ )Nr;   rH   r<   z<module>r   )r  )r>  rD  s    rG   
repl_framemunge_exc.<locals>.repl_frameT  s9    771: 771:#wwqzrF   z@( *)File "([^"]+)", line \d+, in (.+)\n(\1  .+\n( +[~^]+ *\n)?)+zline \d+zline Nz.py:\d+z.py:Nzhttps:/([a-zA-Z0-9_.-]+)z
https://\1rH   z%attempting to trace CALL_FUNCTION:.*$z8attempting to trace CALL: a function call, e.g. f(x, y):)flagsz\n*Set TORCH_LOGS.+z$\n*You can suppress this exception.+z\n*Set TORCHDYNAMO_VERBOSE=1.+zCannot export model.+\n\nz +$)torch._dynamo.trace_rulesr
  r   r   r   r   rd  r  ro   r   r3  r   r  rM   r  	MULTILINEDOTALL)r  r  r
  rD  r  r
  rs  r
  s      `    rG   r  r  J  s   8|}}q4x(11$Ds1vA 	K		A
 	{Ha(A
z7A&A
*M1=A
t^BGG$4$4T$:;Q?A
~bggll277??5>>+JBOPRTVWXA
0B	ll		A FF)2q		BFF:BSFF4b!299MFF/Q7
vr1BLL1AHrF   c              #     ^#    U4S jn [         R                  " 5         [         R                  " [         R                  5        / nUv   [         R                  " 5         UR	                  [        U[         R                  5      5        [        U5      nUS:  aV  [        R                  " U S3SS9   SSK
n[        R                  " SU  ST S	3SS9  USU   H  nUR                  U/S
S9  M     [         R                  " S5        g! [         a    [        R                  " SSS9   N8f = f! [         R                  " S5        f = f7f)a  Wrap around operations you want to ensure are not leaking tensor memory.

This code intentionally ignores other reference cycles, which can be benign and which we have plenty
of in pytorch code.  It focuses on any reference cycles that directly or indirectly result holding a Tensor alive,
since this is likely a more serious leak than typical python refcycles.

limit specifies how many tensors to dump debug graphs for (default=1)
c                    > [        U T5      $ rX   )r   )rS  matched_types    rG   	match_obj'check_leaked_tensors.<locals>.match_obj  s    #|,,rF   r   zH tensors were found in the garbage. Did you introduce a reference cycle?r;   r  NzDumping first z objgraphs of leaked zs rendered to pngr  )	max_depthz6`pip install objgraph` to enable memory leak debugging)r   r   	set_debugDEBUG_SAVEALLrM  r  garbager  r  r  objgraphshow_backrefsImportError)limitr
  r
  garbage_objsnum_garbage_objsr
  r1
  s    `     rG   check_leaked_tensorsr
  y  s    -



R%%& 


F9bjj9:|,aMM#$$lmz{f$UG+@N_`mn &fu-A**A3"*= . 	Q	  fVcdef 	Qs;   EB&D+ 2=D /ED(%D+ 'D((D+ +EEc                     [         R                  " 5       n [        R                  R	                  U 5      (       aH  [
        (       a'  [        R                  " SSU /[        R                  S9  g[        R                  " U SS9  gg)zC
Removes the default root folder under which extensions are built.
rmz-rf)r<  T)ignore_errorsN)r.   get_default_build_rootro   r   r  r  r  r  r  r  r  )default_build_roots    rG    remove_cpp_extensions_build_rootr
    s\     '==?	ww~~()): NND%);<Z__UMM,DA *rF   c           	         [         R                  R                  U S5      n[         R                  R                  U S5      nX4 H?  n[         R                  R                  U5      (       d  M)  [        R
                  " U5        MA     [        R                  SSSU SSSU/	n[        X@[         R                  S9nUS	:w  a  [        S
U  35      eS n[         R                  " U5       H6  u  pxn	U H*  n
SU
;   d  M  [         R                  R                  Xz5      nM,     M8     Uc  [        SU  35      eU[        R                  ;  a!  [        R                  R                  S	U5        g g )Nr	  installz-mpipr  z--no-build-isolationz--root)r:  r;  r   z"build failed for cpp extension at z	-packagesz)installation failed for cpp extension at )ro   r   r   r  r  r  r  r  rA  r  rA  walkinsert)extension_root	build_dirinstall_dirr	  r  return_codemod_install_dirrootdirectoriesr   	directorys              rG   install_cpp_extensionr
    s#   ^W5I'',,~y9K%77>>!MM! &
 >>4	>4I_aikv
wCRZZ@Ka??OPQQO " 41$Ii'"$'',,t"? % !5
 F~FVWXXchh&?+ 'rF   c                 0   ^  [        T 5      U 4S j5       nU$ )Nc                     > S nT" U SU0UD6$ )Nc                  8   [         (       a  [        R                  " U 0 UD6$ SU;  d   e[        5        nUR	                  SS5      (       a  [        SU S3[        R                  S9  X!S'   [        R                  " U 0 UD6sS S S 5        $ ! , (       d  f       g = f)Nbuild_directoryr  Fz$Using temporary extension directory z...rq  )r  r.   load_inliner  r  rI  r  r=  )r]   r^   temp_dir_names      rG   r
  8scoped_load_inline.<locals>.wrapper.<locals>.load_inline  s    z$00$A&AA$F222')]::i//@sSZ]ZdZde,9()$00$A&A	 *))s   AB
Br
  r=   )r]   r^   r
  r  s      rG   r   #scoped_load_inline.<locals>.wrapper  s     
	B T={=f==rF   r}  r  s   ` rG   scoped_load_inliner
    s     
4[> > NrF   c                 H    [         R                  S 5       nU" 5       " U 5      $ )Nc               3      #    [         R                  R                  R                  R                  n [         R                  R                  R
                  R                  n[         R                  R                  R                  R                  n[         R                  R                  R                  R                  n[         R                  R                  R
                  R                  n[         R                  R                  R                  R                  n S v   U [         R                  R                  R                  l        U[         R                  R                  R
                  l        U[         R                  R                  R                  l        U[         R                  R                  R                  l        U[         R                  R                  R
                  l        U[         R                  R                  R                  l        g ! U [         R                  R                  R                  l        U[         R                  R                  R
                  l        U[         R                  R                  R                  l        U[         R                  R                  R                  l        U[         R                  R                  R
                  l        U[         R                  R                  R                  l        f = f7frX   )	rM   r  mkldnnconvfp32_precisionrnnrY	  cudnnrN   )old_mkldnn_conv_pold_mkldnn_rnn_pold_mkldnn_matmul_pold_cudnn_conv_pold_cudnn_rnn_pold_cuda_matmul_ps         rG   recover,recover_orig_fp32_precision.<locals>.recover  s    !NN1166EE >>0044CC#nn33::II >>//44CC....22AA!NN//66EE	J8IENN!!&&57GENN!!%%4:MENN!!((77GENN  %%46EENN  $$38IENN&&5 9JENN!!&&57GENN!!%%4:MENN!!((77GENN  %%46EENN  $$38IENN&&5s    DLH C7LC8LL)r  r   )r   r	  s     rG   recover_orig_fp32_precisionr    s*    J J" 9R=rF   c                 8   ^ ^ [         R                  mU U4S jnU$ )Nc                 6   >^  [        T 5      U UU4S j5       nU$ )Nc                    > T" TR                   TR                  TR                  5      (       a  T" U /UQ70 UD6$ [        R                  " S5      e)NzPython version mismatch)majorminormicror   r{  )r   r]   r^   r   	predicatevis      rG   r3  <skipIfPythonVersionMismatch.<locals>.dec_fn.<locals>.wrap_fn  sE    288RXX66$0000''(ABBrF   r}  )r   r3  r  r  s   ` rG   r  +skipIfPythonVersionMismatch.<locals>.dec_fn  s"    	r	C 
	C
 rF   )r  r  )r  r  r  s   ` @rG   skipIfPythonVersionMismatchr    s    			B MrF   updatesc                    ^  U 4S jnU$ )Nc                 4   >^  [        T 5      U U4S j5       nU$ )Nc                 F  > T Vs0 s H  o3[        X5      _M     nnTR                  5        H  u  p5[        XU5        M      T" U /UQ70 UD6UR                  5        H  u  p6[        XU5        M     $ s  snf ! UR                  5        H  u  p6[        XU5        M     f = frX   )r   r   rT  )	r   r]   r^   memberoriginal_valuesr   original_value	test_funcr  s	          rG   r   6patch_test_members.<locals>.decorator.<locals>.wrapper  s     LSS7wt'<<7OS ")e, "1: 777 />.C.C.E*FD.9 /F T />.C.C.E*FD.9 /Fs   A4A9 9'B r}  )r  r   r  s   ` rG   r`  %patch_test_members.<locals>.decorator  s!    	y		: 
	:  rF   r=   )r  r`  s   ` rG   patch_test_membersr!    s    & rF   r  rX   )NNNNN)NNNNNr:   Frk   )z'test doesn't currently work with dynamo)z2test doesn't currently work with compiled autogradr  )z@test doesn't currently work with torchinductor on the ROCm stack)z4test doesn't currently work with legacy JIT executor)r   )F)r<   r<   F)r	  (  r4  r  r  rD  r
  r  r   r   r  r   ior   r  rG  r/  ro   r  r   r[  rd  r  r3  r	  r  r  r  r  r	  r  r   r  collections.abcr   r   r   r   r   dataclassesr   enumr	   r
   r   	itertoolsr   r   r   
statisticsr   typingr   r   r   r   r   r   r   unittest.mockr   r#  r:  r  r  rM   torch.backends.cudnntorch.backends.mkltorch.backends.mpstorch.backends.xnnpack
torch.cudar   torch._Cr   r   torch._utils_internalr   torch._logging.scriber   torch.nnr   r   r   r    r!   
torch.onnxr#   r$   torch.testingr%   torch.testing._comparisonr&   r'   r(   r)   r*   r+   $torch.testing._internal.common_dtyper,   torch.utils._import_utilsr-   torch.utils._pytreer  _pytreerX
  torch.utilsr.   rx  r  r
  r  
MI350_ARCH
MI300_ARCH
MI200_ARCH	NAVI_ARCHrS   
NAVI4_ARCHr8   r   rI   r   r  r  r   r  r  r"  r   r  r  r  r  rJ   r8  r   r  rV   r[   r`   r  r>   r   r  disable_global_flagsFILE_SCHEMAry   r   r   r   r  r  r   r   _utils_internalr   _is_fbcode_defaultr   r   r   r   r   r   r   r  r  r  r  r   rp   r  r  rk  "DEVICE_LIST_SUPPORT_PROFILING_TESTALLOW_XPU_PROFILING_TESTcheck_namesr,  r   r   r   r   r   r   r   r&  r/  ra  rc  rl  r  r  r  r  r  r  ScriptFunctionr2  r  ScriptMethodr  r  r  r  r  r  r)  r7  rA  rX  rJ  rN  rV  r[  ra  rf  rj  r{  r  r  r  r  r  r  machineIS_PPCIS_X86IS_ARM64rF  r  IS_AVX512_VNNI_SUPPORTEDr  r  r  r6  r8  getfilesystemencodingIS_FILESYSTEM_UTF8_ENCODINGr  TEST_FAIRSEQr  mklrO   TEST_MKLr
  ops_is_mkldnn_acl_supportedr  r   rV  r|  r   mac_verrR   MACOS_VERSIONr   rP  r=  r\  rN   r  TEST_ACCELERATORTEST_MULTIACCELERATORr   custom_device_modTEST_PRIVATEUSE1TEST_PRIVATEUSE1_DEVICE_TYPE
TEST_NUMBATEST_TRANSFORMERS	TEST_DILLTEST_LIBROSATEST_OPT_EINSUMTEST_Z3rJ  
NOTEST_CPUskipIfskipIfNoDillrL  rM  rO  rQ  rS  rU  rW  rm  rZ  r\  r^  r`  r*  r+  TEST_CUDA_GRAPHTEST_CUDA_CUDSSTEST_CUDA_PYTHON_BINDINGSrl  rs  rt  	num_procsr  gb_availableset_per_process_memory_fractionr  
skipUnlessrequires_cudar~  	overridesTorchFunctionModer  r  r  r  r  torch._dynamor  r  accumulated_recompile_limitlog_compilation_metricsissue_3_13_0_warningtorch._inductor.configr  fallback_randomr  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  TEST_WITH_TVfxexperimental_configtranslation_validationr  bool_r;  r
  r
  r
  rA  r
  r?  r  r	  r   r
  r"  r
  r  r
  r  intcr   r(  r	  r'  	complex32inline_inbuilt_nn_modulesr  r  r#  r-  r9  r>  rD  rG  rK  rS  rY  r^  rc  rj  ro  ru  r{  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r#  r*  r.  r5  r;  rB  rF  rX  r  r^  rc  rj  rm  rq  rs  r  r  r  r  r  register_profileHealthChecktoo_slow	Verbositynormalr  load_profiler  ImportWarningr  r   r  r  r  r$  r2  rE  rS  rW  rY  r[  rU  _AssertRaisesContextr]  rh  rj  r  r  r	  ADDRESS_IN_USECONNECT_TIMEOUTr	  r%	  r6	  r1	  r;	  rB	  rI	  rL	  rO	  rQ	  rV	  r[	  r]	  r_	  rd	  rl	  rq	  ru	  r~	  r	  r	  r	  r	  r	  r	  r	  r	  BytesIOr	  GRADCHECK_NONDET_TOLr	  skipIfSlowGradcheckEnvr	  r	  r	  r	  halfdtype2prec_DONTUSEr	  r	  r	  r	  r 
  r
  r
  rx  rz  r'
  r2
  r7
  r  ry  	lru_cacherI
  rJ
  rN
  rP
  rU
  ra
  ri
  rk
  r
  r  r
  r
  r
  r
  r  r  r   r!  )r"  r   s   00rG   <module>r     s         	   	     	    	     
       - .  !  $ $    % . #           + 3 6  &  < ? : $ $ %J 


C	#
#
D   +/-( /
  
 S	 
B_X _XD !  # # %<<7K &&;	 ' t  &..B	 / t  ZZ^^$67tCd C E!!=1 &	%% 
 "**!	 + 	4  &..% / t  $3#;#; 0 $< $ D   /77,]	  8     ,;+F+F/ : ,G , 8C=  = +   99##%bii0A2&FGO99"B'')"))4I2*NOvuxx?e?e?gh &< " WDDD	(+ &   38L1 3!?3 ?3B1 1h&R,^; ;(CY# CYL4X% 4Xn<:" <:~$ G G C C : : HH##,,	HH!!**		%#
55 $2    !/   5L^ D0" 	/ 39/dH5'&# ('S	 'd3i '$]!~ <<7"\\W$
<<8#				y	(				1	1!55( 45      $ $  
jB 	 	 	 "779WD !'*
#I.!'*
>>**,>>  --/_EII4D4D4]4]4_>>**,chhx//1!4::3?CDJK99!!#u%B%))*@*@*BCJJ##%	CD  LM E588#I#I#KTR 35 $xxEEG !'*
(8  (	#I.?x<&|4
t
$/# / (3VXZ)[\\
9}i8 "' $ &&//$ 0    /77,  8     '//$ 0   (00% 1   '//$ 0   '//$ 0   !#		*G MQT T &//$ 0   '//$ 0   +33( 4  D 
 ,44) 5  T   %8!8 	MM V
]]T5%--*;*;*A*A#*Fq*K!LMQTT 
 d!3!3!cEMM<N<N<T<TUX<YZ[<\8]ac8c0A 	MMF3u}}1177<Q?@BF  ! #	 ,44%  !<EZ[ 5  T  %3BII2C89I::**,Q/'9L	JJ..ulYQT_6TXd5dgp5prs/tu##EJJ$;$;$=O5??44  !0 8 8( !9 !  
 ,44) 5  T  .66&H 7  t 
 (7'?'?$4 (@ (  
 79EMM438EMM005EMM-%15. 6T1S.M@MSiB8 M"9*$&<^0 (,##s(#$#c3h#N yy/0C7;?EHH!!8 "1!9!9. ": " $  HHEJJHHEKKIIELLIIELLIIELLGGEJJHHEKKHHEKKHHEKKJJEMMJJEMMJJEMMLLEOOMME$$ *8 
 */bgg& >W=\=\=^_=^\cU[=^_      	NNBJJ	OOR\\"  	>mm""<<2!P F# F,%S/ ,	sCx 		c3h 	@ N  .c3h .$V  'Y  ,   2
W 
W 	@ 	@
Y 
YR:T T(
?4(- - - 9 97./ /4y( y(v @ @ " "L$x4 ((#-#9#9#B#B"C **11	34 ((#-#9#9#B#B"C **11		34 ((#-#9#9#B#B"C **22		45 $$299-I5#Q  K`(++ K`l&6 &6R:
 :z   2
~ 
,T4 T6 
l |  98==3U3U 9 'T ' ' 
Gz"" GD0	8 	,(  *(#' 42 16U 	0 @C% & &4* AFUZ 	 	D
I _d  *&>2
/C 
/s 
/ 
/QVQ]Q] 
/*6sr13Hl  E	RZZ   !0!9!9. ": " $ 
 "K :,L*D # (4.   kk4llDjj$nnd, &  3C 3D 3(F%9tCy %9 %9ell %9P *$
 #5 # #< CLPx(( P8A; P1 P = =	H>H H>\&[8 &[R %)$TPQ , ,^  u|| ' 'TB,:&*S#X Cu  JZ: `j  xMMY[huvwxs7   $A[ A[FEA[ [A[[A[[A[:[9A[: