
    sg                    `   d dl mZ d dlZd dlZd dlmZ d dlmZmZm	Z	 d dl
Z
d dlmZ d dlmZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dlmZ d dlmZ d d	l m!Z!m"Z"m#Z# d d
l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ d dl,m-Z-m.Z. d dl/m0Z0 ddl1m2Z2 ddl3m4Z4 g dZ5e5D  cg c]  }  ejl                  d|  d       c} Z7g dZ8ed<d       Z9d=dZ:d>dZ;d<dZ<d<dZ=d<dZ>d<dZ?d<dZ@d<dZAd<dZBd<dZCdd 	 	 	 	 	 	 	 	 	 	 	 	 	 d?d!ZD	 	 	 	 	 	 d@d"ZEdd 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dAd#ZF	 	 	 	 	 	 	 	 	 	 dBd$ZG	 	 	 	 	 	 	 	 	 	 dBd%ZHdd 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dCd&ZId'd'd(	 	 	 	 	 	 	 	 	 	 	 dDd)ZJ	 	 	 	 	 	 	 	 	 	 dEd*ZKedFd+       ZL	 	 	 	 dGd,ZM	 	 	 	 dHd-ZN	 	 	 	 dId.ZO ed/      ZP ed0      ZQ ed1      ZR ed2      ZSdd 	 	 	 	 	 	 	 	 	 	 	 dJd3ZT	 	 	 	 	 	 	 	 	 	 dKd4ZU ed5      ZVdd 	 	 	 	 	 	 	 dLd6ZW	 	 	 	 	 	 	 	 dMd7ZX	 	 	 	 	 	 	 	 	 	 dNd8ZYdd 	 	 	 	 	 dOd9ZZdd 	 	 	 	 	 dPd:Z[dd 	 	 	 	 	 	 	 	 	 dQd;Z\yc c} w )R    )annotationsN)defaultdict)CallableIterableSequence)cpp)arg_parser_output_exprscpp_dispatch_exprscpp_dispatch_targetdispatch_lambda_argsdispatch_lambda_exprsdispatch_lambda_return_strhas_tensor_optionsPythonSignaturePythonSignatureDeprecatedPythonSignatureGroup!PythonSignatureNativeFunctionPair	signaturesignature_from_schemastructseq_fieldnames)CodeTemplatewith_native_function)
cpp_stringparse_native_yamlparse_tags_yaml)ArgumentBaseOperatorNameFunctionSchemaNativeFunction
SchemaKindTypeVariant)FileManagersplit_name_params)
YamlLoader   )is_tensor_list_type)should_trace)Salias
contiguousis_cuda	is_sparseis_sparse_csrsizestridesym_size
sym_stridesym_storage_offset	sym_numelz.*_backwardz#.*_backward_(out|input|weight|bias)z
.*_forwardz.*_forward_outz.*_jvp_unsafe_viewtensorz2_?sparse_(coo|compressed|csr|csc|bsr|bsc)_tensor.*z_range.*_sparse_add_outz_sparse_div.*z_sparse_mul.*z_sparse_sub.*_sparse_dense_add_outindex	index_outunique_dim_consecutivez	_cumsum.*z
_cumprod.*z_sum.*z_prod.*z_th_.*z_thnn_.*zrange.*z_solve.*z
_inverse.*z_cholesky.*z_triangular_solve.*z_qr.*z_svd.*sliceitem_local_scalar_denseto_to_copy_to_copy_out_reshape_copy_reshape_copy_outcopy_sparse_to_sparse_copy__foreach_copynumpy_Tmatrix_HmTmHznonzero(_(out|numpy))?set_dataz.*_overrideabledatais_leaf	output_nr_versionrequires_grad_retains_gradset_
_fw_primal)fake_quantize_per_tensor_affine_cachemask*fake_quantize_per_channel_affine_cachemask!_new_zeros_with_same_feature_meta_has_same_storage_numel_reshape_aliasreplace_copyzfill.Tensorzfill.Scalarzlift.*normal_functionalnbytesitemsize_batch_norm_with_update_batch_norm_with_update_out_batch_norm_no_update^$)z?add.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> TensorzHadd_.Scalar(Tensor(a!) self, Scalar other, Scalar alpha=1) -> Tensor(a!)z?sub.Scalar(Tensor self, Scalar other, Scalar alpha=1) -> TensorzHsub_.Scalar(Tensor(a!) self, Scalar other, Scalar alpha=1) -> Tensor(a!)z/mul.Scalar(Tensor self, Scalar other) -> Tensorz8mul_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!)z/div.Scalar(Tensor self, Scalar other) -> Tensorz8div_.Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!)c                   d| j                   v rd| j                   vryt        j                  | j                        }t        D ]  }|j                  |      s y t        | j                        }t        D ]	  }||k(  s	 y y)N	generated	view_copyFT)tagsr   namefuncSKIP_PYTHON_BINDINGSmatchstrSKIP_PYTHON_BINDINGS_SIGNATURES)frg   
skip_regexr   patterns        b/var/www/html/venv/lib/python3.12/site-packages/torchgen/packaged/autograd/gen_python_functions.pyshould_generate_py_bindingrq      s~     affAFF!:88AFFD* 
D! AFFI2 i     c                    d|  S )NTHPVariable_ )rg   s    rp   get_pycnamerv      s    $  rr   c                b    t        |       dk(  xr  | d   j                  j                         dk(  S )Nr'   r   )lenr   arguments_count)	overloadss    rp   is_noargr{      s.    y>QP9Q<#9#9#I#I#Kq#PPrr   c                Z    | j                   d u xr t        j                  | j                  v S N)python_moduler#   methodvariantsrm   s    rp   is_py_variable_methodr      s#    ??d"Cw~~'CCrr   c                Z    | j                   d u xr t        j                  | j                  v S r}   )r~   r#   functionr   r   s    rp   is_py_torch_functionr      s%    ??d"Ew'7'71::'EErr   c                     | j                   dk(  S )Nnnr~   r   s    rp   is_py_nn_functionr      s    ??d""rr   c                     | j                   dk(  S )Nfftr   r   s    rp   is_py_fft_functionr      s    ??e##rr   c                     | j                   dk(  S )Nlinalgr   r   s    rp   is_py_linalg_functionr          ??h&&rr   c                     | j                   dk(  S )Nnestedr   r   s    rp   is_py_nested_functionr      r   rr   c                     | j                   dk(  S )Nsparser   r   s    rp   is_py_sparse_functionr      r   rr   c                     | j                   dk(  S )Nspecialr   r   s    rp   is_py_special_functionr      s    ??i''rr   Tsymintc          
        t        | |d      }t        ||      j                  }t        t	        t
        |            }t        ||d      }t        ||t        d dd|       t        ||d      }	t        ||	t        dddd	|
       t        ||	t        ddd|       t        ||	t        ddd|       t        ||	t        ddd|       t        ||	t        ddd       t        ||	t        ddd|       t        ||	t         ddd|       t#        ||	d d       t%        ||	d d       t'        |      dfd}
|j)                  d|
       y )NF)install_dirtemplate_dirdry_runTr   zpython_variable_methods.cppr   r   torchzpython_torch_functions.cpp   )r   
num_shardsr   torch.nnzpython_nn_functions.cpp	torch.fftzpython_fft_functions.cpptorch.linalgzpython_linalg_functions.cpptorch.nestedzpython_nested_functions.cpptorch.sparsezpython_sparse_functions.cpptorch.specialzpython_special_functions.cppc                     yNTru   fns    rp   <lambda>zgen.<locals>.<lambda>m      rr   zpython_return_types.cppc                     yr   ru   r   s    rp   r   zgen.<locals>.<lambda>p  r   rr   zpython_return_types.hc                 p    ddj                  t              D  cg c]  } d|  d|  d c}       iS c c} w )Nenum_of_valid_tags z	
.value("z", at::Tag::))joinsorted)tag
valid_tagss    rp   gen_tags_enumzgen.<locals>.gen_tags_enumu  sD     EKJEWXcz#l3%q9X
 	
 Ys   3
zpython_enum_tag.cpp)returndict[str, str])r$   r   native_functionslistfilterrq   load_signaturescreate_python_bindingsr   create_python_bindings_shardedr   r   r   r   r   r   r   "create_python_return_type_bindings)create_python_return_type_bindings_headerr   write)outnative_yaml_pathtags_yaml_pathdeprecated_yaml_pathtemplate_pathr   fmr   methods	functionsr   r   s              @rp   genr     s    
=%	PB(.  F#=?OPQ.0DTRG
%   02FuUI"
$	 
! 
" 
% 
% 
% 
& '
I(A .
I(? !0J
 HH"M2rr   c                    t        t              }| D ]Q  } ||j                        s||j                  j                  j                  j                     j                  |       S |S r}   )r   r   r   rh   rg   append)pairspredgroupedpairs       rp   group_filter_overloadsr     s^     	D   ?DMM&&++00188>? Nrr   c          
        
 g g 
g g t        ||      }t        |j                         t              D ]  }||   }	j	                  t        |||	||             j	                  t        |||	|             j                  t        ||	|             
j	                  d|j                   d         j                   
fd       y)+Generates Python bindings to ATen functionskeyr   r   #include <ATen/ops/.h>c                 B    ddj                          d  z   dS )N@generated from /)generated_commentops_headerspy_forwards
py_methodspy_method_defstemplate_dir_for_comments)filenamer   r   r   r   r   s   rp   r   z(create_python_bindings.<locals>.<lambda>  s9    !$ < < >?q
K"L&&$,
 rr   N)r   r   keysrk   r   method_impl
method_defextendforward_declsbasewrite_with_template)r   r   r   moduler   r   r   r   rg   rz   r   r   r   r   s   `   `     @@@@rp   r   r     s     JK "NK$UD1Gw||~3/ ADM	fivN	
 	jvyPQ=yHI03?@A 	
 	
rr   c                \   	
 g 	g 
t        ||      }t        |j                         t              D ]]  }||   }t	        |      \  }}	j                  |sdndj                  |             
j                  |sdndj                  |             _  j                   	
fd       y)z
    Generate function to initialize and return named tuple for native functions
    which returns named tuple and registration invocations in `python_return_types.cpp`.
    r   r   
c                 >    ddj                          d  z   dS )Nr   r   r   )r   py_return_typespy_return_types_registrationsr   )r   r   py_return_types_definitionr   s   rp   r   z4create_python_return_type_bindings.<locals>.<lambda>  s3    !$ < < >?q
K"L9-J	
 rr   N)r   r   r   rk   1generate_return_type_definition_and_registrationsr   r   r   )r   r   r   r   r   rg   rz   definitionsregistrationsr   r   s   `  `     @@rp   r   r     s     -//1!$UD1Gw||~3/ 

DM	%V&
"] 	#))!Btyy'=	
 	&,,#B=)A	


 	
	rr   c                    g t        ||      }t        |j                         t              D ]6  }||   }t	        |      }j                  |sdndj                  |             8  j                   fd       y)z
    Generate function to initialize and return named tuple for native functions
    which returns named tuple and relevant entry for the map in `python_return_types.cpp`.
    r   r   r   c                 <    ddj                          d  z   dS )Nr   r   r   )r   py_return_types_declarationsr   )r   r   r   s   rp   r   z;create_python_return_type_bindings_header.<locals>.<lambda>  s0    !$ < < >?q
K"L,H
 rr   N)r   r   r   rk   !generate_return_type_declarationsr   r   r   )	r   r   r   r   r   rg   rz   declarationsr   s	   `  `    @rp   r   r     s     /1 $UD1Gw||~3/ 
DM	8C$++"B		,(?	

 	
rr   c          
         t        ||      }	 	 	 	 d
d}		 	 	 	 dfd}
| j                  ||j                         ddd| j                          d| z   i|	|
|h d       y	)r   c                     | d   j                   S )Nr   )r   )kvs    rp   key_funcz0create_python_bindings_sharded.<locals>.key_func  s     !uzzrr   c           	         | \  }}d|j                    dgt        t        ||            t        ||      gt	        ||      gdS )Nr   r   r   r   )r   r   r   r   )r   r   r   r   r   )r   rg   fn_pairsr   r   r   s      rp   env_funcz0create_python_bindings_sharded.<locals>.env_func  sd     h1$))C@AdHV LMD&(6&Q  *$PQ
 	
rr   r   r   r   r   >   r   r   r   r   )base_envkey_fnenv_callabler   sharded_keysN)r   @tuple[BaseOperatorName, list[PythonSignatureNativeFunctionPair]]r   rk   )r   r	  r   zdict[str, list[str]])r   write_shardeditemsr   )r   r   r   r   r   r   r   r   r   r  r  s      ` ` `   rp   r   r     s     %UD1GL	

L
	
  < < >?q
K"L
 S  rr   F)skip_deprecatedpyic                   t         dfd       }t        t        ||             }t        ||      }|r|S ||z   S )Nc                6    t        t        |       |       S )Nr   r  r   r   )r   r   )rm   r   r  s    rp   gen_signature_pairsz,load_signatures.<locals>.gen_signature_pairs4  s    0&c:
 	
rr   r  )rm   r    r   r   )r   r   mapload_deprecated_signatures)r   r   r   r  r  r  r   
deprecateds     ` `   rp   r   r   ,  sT     
 
 (*:;<E+#FJ $5;);;rr   c               v   t        t              }| D ]*  }||j                  j                     j	                  |       , g }t        |      5 }t        j                  |t              }d d d        D ]  }	t        j                  |	d         t        |	d         \  }
|
j                  d      r|
j                  dd      }
dt        j                  d      ij                  j                   D ci c]  }|j                  | c}D ]  }|v r|v rJ d|         	 	 	 	 dfd	}d
}||
   D ]  } ||j"                  j$                        s d}t'        |j"                  j(                  ||      }|j	                  t+        t-        |j                  |j.                  |j0                  |j2                  |j4                  |j6                  t9              |j:                  	      |j"                                |rJ d|
 dt=                       |S # 1 sw Y   xY wc c}w )N)Loaderrg   aten_outr   1Scalarz*deprecation definiton: Unrecognized value c                h   	r?t        j                  | j                  j                  | j                  j                        }n| j                  j
                  }t        |      D ]p  \  }}|t              k  rO|   }|
v r
|   }d }n|   }|j                  }|j                  }||j                  k7  s||j                  k7  sa y|j                  p y t        j                        t        | j                        k(  xr0 t        d t        j                  | j                        D              S )NFc              3  ,   K   | ]  \  }}||k(    y wr}   ru   ).0abs      rp   	<genexpr>zKload_deprecated_signatures.<locals>.is_schema_compatible.<locals>.<genexpr>  s      K1aQKs   )	itertoolschain	argumentsr   flat_non_outflat_all	enumeraterx   type
annotationdefaultreturnsallzip)aten_schemar$  iargarg_nameschema_typeschema_annotation
schema_arg	call_argsis_outknown_constantsschemaschema_args_by_names           rp   is_schema_compatiblez8load_deprecated_signatures.<locals>.is_schema_compatiblem  s"    %OO))--{/D/D/Q/Q	 (11::	#I. %3s9~%(|H?2&5h&?,0)%8%B
&0oo,6,A,A)"chh.2Cs~~2U${{*$%" v~~&#k.A.A*BB s K#&v~~{7J7J#KK H rr   FT)category_overrider   r  )	rg   
input_argsinput_kwargsoutput_argstensor_options_argsr   deprecated_schemadeprecated_args_exprsr+  r  zNo native function with name z matched signature:
  )r.  r   r   bool)r   r   r   rg   r   openyamlloadr&   r   parser%   endswithreplacer"   r$  r&  r   rh   r   r;  r   r   r<  r=  r>  r?  r   tupler+  rk   )r   r   r   r  r   r   resultsrm   deprecated_defsr  	aten_namer  rg   r:  any_schema_found
python_sigr5  r6  r7  r8  r9  s                   @@@@@rp   r  r  B  si    CNdBSG 2##$++D12 8:G	"	# :q))Aj9: & S[
%%j&890F1CD	9##F+!))&"5I
 H%
 392B2B2K2KLQqvvqyL 	CD++t/FC;D6BCF	C	'		 	@ !I& 	D'(:(:;#."&--"A"A	J NN17'__#-#8#8%/%<%<$.$:$:,6,J,J)00*0.3I.> * 2 2
 "]]	: 	[*9+5LSQW[MZ	[eS[j Nq: : Ms   H)8H6)H3c                    t        j                  | j                        }t        | j                  j                        }dj                  |g|z         S )N_)r   rg   rh   r   r+  r   )rm   rg   
fieldnamess      rp   gen_structseq_typename_keyrR    s<    88AFFD%affnn5J88TFZ'((rr   c                z   i }g }| D ]  }t        |j                  j                  j                        }|s/t	        j
                  |j                  j                        }t        |j                        }|j                  |      }|d|sdn
t        |       }|||<   |j                  d| d| d        ||fS )zr
    Generate block of named tuple type def inits, and add typeref snippets
    to declarations that use them
    
NamedTupler   zstatic PyTypeObject* z = generated::get__structseq();
r   r   rh   r+  r   rg   rR  getrx   r   )rz   	typenamestypedefsoverloadrQ  rg   tn_keytypenames           rp   emit_structseq_callr]    s     	  H )(*;*;*@*@*H*HI
xx))../+H,=,=>==(#hBCM#JKH (IfOOZ1$}H  Yrr   c                   i }g }g }| D ]  }t        |j                  j                  j                        }|s/dj	                  d |D              }t        j                  |j                  j                        }t        |j                        }|j                  |      }	|	| d|sdn
t        |       }	|	||<   |j                  d| d| d|	 d| d	t        |       d
|	 d|	 d|	 d       |j                  d| d| d        ||fS )z
    Generate block of function in `python_return_types.cpp` to initialize
    and return named tuple for a native function which returns named tuple
    and registration invocations in same file.
    , c              3  (   K   | ]
  }d | d  yw){"z", ""}Nru   )r  r   s     rp   r!  zDgenerate_return_type_definition_and_registrations.<locals>.<genexpr>  s     BSG,Bs   rT  r   PyTypeObject* get_zI_structseq() {
    static PyStructSequence_Field NamedTuple_fields[] = { z(,  {nullptr} };
    static PyTypeObject zh;
    static bool is_initialized = false;
    static PyStructSequence_Desc desc = { "torch.return_types.z", nullptr, NamedTuple_fields, zB };
    if (!is_initialized) {
        PyStructSequence_InitType(&z, &desc);
        zm.tp_repr = (reprfunc)torch::utils::returned_structseq_repr;
        is_initialized = true;
    }
    return &z;
}
z$addReturnType(return_types_module, "z", generated::get_z_structseq());)r   r   rh   r+  r   r   rg   rR  rW  rx   r   )
rz   rX  r   r   rZ  rQ  fieldsrg   r[  r\  s
             rp   r   r     sc    	   K!M  )(*;*;*@*@*H*HI
BzBBxx))../+H,=,=>==(zK"SEU)VWH (If& <<B8 D!
 #@@DvEdehisetdu v$$,: .		
  J     6tf<NtfTbc= D %%rr   c                t   i }g }| D ]  }t        |j                  j                  j                        }|s/t	        j
                  |j                  j                        }t        |j                        }|j                  |      }|| d|sdn
t        |       }|||<   |j                  d| d        |S )z
    Generate block of function declarations in `python_return_types.h` to initialize
    and return named tuple for a native function.
    rT  r   rb  rU  rV  )rz   rX  r   rZ  rQ  rg   r[  r\  s           rp   r   r     s     	  !L J)(*;*;*@*@*H*HI
xx))../+H,=,=>==(&
\2s<?P"QR  !)If"4TF- HIJ  rr   a  \
// ${name}
static PyObject * ${pycname}(PyObject* self_, PyObject* args, PyObject* kwargs)
{
  ${method_header}
  static PythonArgParser parser({
    ${signatures}
  }, /*traceable=*/${traceable});

  ParsedArgs<${max_args}> parsed_args;
  auto _r = parser.parse(${self_}, args, kwargs, parsed_args);
  ${check_has_torch_function}
  switch (_r.idx) {
    ${dispatch}
  }
  ${method_footer}
}

z&case ${overload_index}: {
  ${body}
}
ao  // ${name}
static PyObject * ${pycname}(PyObject* self_, PyObject* args, PyObject* kwargs)
{
  ${method_header}
  static PythonArgParser parser({
    ${signatures}
  }, /*traceable=*/${traceable});

  ParsedArgs<${max_args}> parsed_args;
  auto _r = parser.parse(${self_}, args, kwargs, parsed_args);
  ${check_has_torch_function}
  ${dispatch}
  ${method_footer}
}

z// ${name}
static PyObject * ${pycname}(PyObject* self_, PyObject* args)
{
  ${method_header}
  ${check_has_torch_function}
  ${dispatch}
  ${method_footer}
}

c                  t        |       }t        |      }t        |      \  }}dg}	|	|z  }	|	|rdgng z  }	|rg ndgdgz   }
t        d |D              rdnd}t	        ||      }t        |      d	k(  }g }g }t        |      D ]  \  }}|j                  j                  |      }|j                  t        t        |             d
       t        |||      }|j                  |st        j                  ||      n|        |rt        }n|rt         }nt"        }|j                  | ||	t%        d |D              ||t'        | |||      ||
|rd
      S d
      S )z?
    Generate a python binding for all overloads of an op.
    HANDLE_TH_ERRORSz/const Tensor& self = THPVariable_Unpack(self_);Py_RETURN_NONE;END_HANDLE_TH_ERRORSc              3  F   K   | ]  }t        |j                          y wr}   )r)   r   r  os     rp   r!  zmethod_impl.<locals>.<genexpr>  s     J1l1::6Js   !truefalser   r'   ,)overload_indexbodyc              3  P   K   | ]  }|j                   j                            y wr}   )r   ry   rj  s     rp   r!  zmethod_impl.<locals>.<genexpr>  s     FqQ[[002Fs   $&)rg   r   noargr   self_nullptr)
rg   pycnamemethod_headermax_args
signatures	traceablecheck_has_torch_functiondispatchmethod_footerrs  )rv   r{   r]  r,  group_overloadsrx   r'  r   signature_strr   r   rk   emit_dispatch_casePY_VARIABLE_CASE
substitutePY_VARIABLE_METHOD_NOARGS$PY_VARIABLE_METHOD_VARARGS_SINGLETONPY_VARIABLE_METHOD_VARARGSmaxgen_has_torch_function_check)rg   r   rz   r   r   ru  rr  structseq_initsstructseq_typenamesrv  r|  ry  grouped_overloadsis_singletonrx  r{  ro  rZ  r   dispatch_bodytemplates                        rp   r   r   }  s    $GYE+>y+I(O('(M_$M?E	:;2M !R'8&9>T=UUMJ	JJPWI8G&9 ()Q.LJH$-.?$@ 

 &&44F4C	ZI78:;*85HQWX   ''-M (  	
	

 ,	7-#FIFF!=	"
 #g    &/   rr   c               f    |r	|rd|  dS y|rdnd}|rdddd	d
ddd|   nd}d| d| d|xs d dS )NzMif(check_has_torch_function(self_)) {
  return handle_torch_function(self_, "z");
}
r   rs  rt  THPVariableFunctionsModuleTHPNNVariableFunctionsModuleTHPFFTVariableFunctionsModule THPLinalgVariableFunctionsModule THPNestedVariableFunctionsModule THPSparseVariableFunctionsModule!THPSpecialVariableFunctionsModule)r   r   r   r   r   r   r   THPVariableClasszAif(_r.has_torch_function()) {
  return handle_torch_function(_r, z, args, kwargs, z, "ztorch.Tensorru   )rg   r   rr  r   rs  	namespaces         rp   r  r    s     ((,v .  G9E  268>>>@	
 	   $$)7*:9+SIaSaHb c rr   zRif (_r.isNone(${out_idx})) {
  ${call_dispatch}
} else {
  ${call_dispatch_out}
}
c          
     D   | j                   rt        j                  | j                  j	                         t        | j                  | j                  ||      t        | j                  | j                   ||            S t        | j                  | j                  ||      S )a0  
    Emit dispatch code for a single parsed signature. This corresponds to either
    a single native function, or a pair that differ only in output params. In the
    latter case, a single python signature is used for both and dispatching
    switches on the presence/absence of passed output args.
    r   )out_idxcall_dispatchcall_dispatch_out)outplacePY_VARIABLE_OUTr  r   
output_idxemit_single_dispatchr   )rZ  r  r   s      rp   r  r    s     $))&&113.""HMM3Fv 3""!!#	 * 
 	
 $/B6
 	
rr   c               P    |ryt        |       }t        |      rd| dfS d| dfS )Nru   zstatic PyObject * z#(PyObject* self_, PyObject* args);
z5(PyObject* self_, PyObject* args, PyObject* kwargs);
)rv   r{   )rg   rz   r   ru  s       rp   r   r     sX     $G	) 
 	
) 
 	
rr   c                   t        |       }| j                  rd| d}t        |      r|rdnd}nd| d}d}|dk(  r|dz  }d	|  d
| d| dS )z$
    Generate method def entry.
    zTypeError_to_NotImplemented_<>METH_NOARGSzMETH_VARARGS | METH_KEYWORDSzcastPyCFunctionWithKeywords(r   r   z | METH_STATICra  z", r_  z, NULL},)rv   dunder_methodr{   )rg   r   rz   r   ru  flagss         rp   r   r   8  sx     $G1'!<	!'-K0	;.!!c'"UG955rr   c          
        i }i }| D ]  }|j                   j                  d|      }|j                  j                  j	                         rG||v r=t        d|j                  j                   d||   j                  j                   d      |||<   ||v r=t        d|j                  j                   d||   j                  j                   d      |||<    |j                         D ])  \  }}||vsg }| D ]  }t        |j                  j                  j                  j                        t        |j                  j                  j                  j                        k(  sk|j                  j                  j	                         r|j                   j                  r|j                  |j                   j                  d|              |j                   j                  |      }t        d| d| d	d
j                  d |D              z          |j                         D 	cg c]+  \  }}	t        j                  |	|j                  |            - }
}}	t        |
|      S c c}	}w )NT)skip_outputsr   z(Found duplicated function definition:
- z.
Existing definition:
- .r   z4While identifying overloads, we found an out schema z] without a corresponding non-out variant. We expected the non-out variant to have schema: 
- zy
Please check that you spelled the schema correctly in native_functions.yaml. We discovered the following candidate(s): 
r   c              3  &   K   | ]	  }d |   yw)z- Nru   )r  	candidates     rp   r!  z"group_overloads.<locals>.<genexpr>  s     Ib,Is   )
functionalr   )r   r~  r   rh   	is_out_fnRuntimeErrorr  rk   rg   r  r   r   r   
from_pairsrW  sort_overloads)rz   r   bases	outplacesrZ  sigr   
candidatesout_sigr   r   s              rp   r}  r}  [  s    ;=E>@I  "  ..D.P!!++-i"?@Q@Q@V@V?W X//8~/F/F/K/K.LAO  &IcNe|"?@Q@Q@V@V?W X//4Sz/B/B/G/G.HK  "E#J"" OO% Se$&J% ))..338893<<,,116678$--22<<>$..99%% **88)-f 9  mm111@GFwi PGGJe Lcc ))IjIIJ !8 
 C	 	''c"	
G  '&11s   *0I*c               l   dddfd}t        | fd      } t        t              t        |       D ]J  \  }}t        |       D ]7  \  }} ||j                  |j                        s$|   j                  |       9 L st        |       S t        |       }t        t        fdt        |                  }t        |      D ]R  }	||	   }
t        j                               D ]/  }|   }|j                  |
       |r|= |j                  |       1 T |D cg c]  }| |   	 c}S c c}w )Nc                   t        |       dk(  xr t        |      dk(  xs t        |       dk(  xr t        |      dk(  xs dt        |       v xr dt        |      vxs t        |       dk(  xr t        |      dk(  xs t        |      dk(  xs} t        |       d	k(  xr t        |      j                  d
      dk7  xsN t        |       dk(  xr t        |      dk(  xs. t        |       dk(  xs t        |       dk(  xr t        |      dk(  S )Nr  TensorzScalar?zTensor?Dimnamezint[]intzint?zTensor[]z[]zSymInt[]SymInt)rk   find)t1t2s     rp   is_arg_smallerz&sort_overloads.<locals>.is_arg_smaller  s   Gx $B8#$2w)# %B9$$ CG# )R($ Gw 8RE!6SW%6$ Gz! )BT"b($$ Gz! #B7"'$. W 4CGu$4 $B8#3	
rr   c                    | j                  d      |j                  d      }}t        |      t        |      k7  ryt        d t        ||      D              }t        fdt        ||      D              }|xr | S )z-Returns True if s1 < s2 in the partial order.T)r  Fc              3  T   K   | ]   \  }}|j                   |j                   k(   " y wr}   )r(  )r  arg1arg2s      rp   r!  z5sort_overloads.<locals>.is_smaller.<locals>.<genexpr>  s!     OztTDII*Os   &(c              3     K   | ]Q  \  }}t        |j                        t        |j                        k(  xs  |j                  |j                         S y wr}   )rk   r(  )r  r  r  r  s      rp   r!  z5sort_overloads.<locals>.is_smaller.<locals>.<genexpr>  sI      
d 		Nc$))n,Ttyy$))0TT
s   AA)r$  rx   r,  r-  )s1s2args1args2equalsmaller_or_equalr  s         rp   
is_smallerz"sort_overloads.<locals>.is_smaller  s}    |||6RV8Wuu:U# OS=NOO 
!%/
 
  -I-rr   c                <    | j                   j                        S )Nr   )r   r~  )xr   s    rp   r   z sort_overloads.<locals>.<lambda>  s    )B)B&)B)Q rr   r   c                    | vS r}   ru   )r  larger_thans    rp   r   z sort_overloads.<locals>.<lambda>  s    !;2F rr   )r  r"   r  r"   r   rB  )r  r   r  r   r   rB  )r   r   setr'  r   addr   rx   r   ranger   discardr   )r  r   r  i1	overload1i2	overload2N
sorted_idsidxr/  jlargerr  r  r  s    `            @@rp   r  r    s<   

:.  Q
 (33'7K"#45 (I&'89 	(MB	)--y/B/BCB##B'	((
 %&& 	A (Fa!QRJQx %sO((*+ 	%A ^FNN1N!!!$	%% +55Qa 555s   "D1c               :     t         d fd       } ||      S )z:
    Emit dispatch code for a single native function.
    c                   t        t              rdj                   }nd| j                   }j                  rdnd}t        j                  | j                        }dj                  d t        |       D              }t        |       }t        |       }dj                  t        |             }t        |       }t        |       }	d	j                  |	j                        }
dj                  |	j                        }j                   xr  t#        |        xs j$                  xr d
|v }|rd|d
   j&                   dnd}|dk(  r| j                  j(                  j*                  }t-        | j                  j                        j/                  d      rQ| j                  j1                         t2        j4                  k(  r&|t7        |j8                  j:                        sJ d}nd}| d	|
 d| d| d| d| d| d| d| d| d| d	S j=                  t?        |             }|| dnd}| d	|
 d| d| d| d| d| d| d| d| d| dS )Nz// [deprecated] aten::z	// aten::z[deprecated] r   r_  c              3  R   K   | ]  }|j                    d |j                    ! yw) N)type_strrg   )r  r  s     rp   r!  z3emit_single_dispatch.<locals>.go.<locals>.<genexpr>0  s(      #
)*qzzl!AFF8$#
s   %'r   )python_signaturer   requires_gradz.set_requires_grad(r   void	_foreach_z\PyObject* self_tensorlist = _r.args[0];
Py_INCREF(self_tensorlist);
return self_tensorlist;
rg  z
auto dispatch_z = [](z) -> z, {
  pybind11::gil_scoped_release no_gil;
  (z);
};
dispatch_z;
z3 {
  pybind11::gil_scoped_release no_gil;
  return z);
};
return wrap(	dispatch_z);
) 
isinstancer   r@  rh   r  r   rg   r   r   r   r   r
   r	   r   initsexprsr?  r   r   exprr$  self_argrk   
startswithkindr!   inplacer(   argumentr(  rW  rR  )rm   schema_commentr  rg   lambda_formalslambda_returndispatch_calleedispatch_argsparser_outputslambda_arg_exprsr  lambda_argsneed_set_requires_gradset_requires_gradr  return_stmtr\  structseq_typerefpsr  r   s                     rp   goz emit_single_dispatch.<locals>.go$  s    b345b6J6J5KLN(1N(*_2
 xx #
.B2qQW.X#
 
 315 .a0		"4Q"LM 1QvF0QvF		*001ii 0 6 67 "$!7!7 "
"1%% C		A.@ 	 & "."A"F"F!GqI 	 F" vv''00H AFFKK ++K8FFKKMZ%7%77  +0C%%**1  
 0   fF>*% ?1]O $

qQ01 2 	 	 +../I!/LMH3;3G8*BR   fF>*% ?

	!M? +ya}A>O=P Q rr   rm   r    r   rk   r   )r  rm   r  r   r  s   ` `` rp   r  r    s%     S Sj a5Lrr   )rm   r    r   rB  )rg   r   r   rk   )rz   +Sequence[PythonSignatureNativeFunctionPair]r   rB  )r   rk   r   rk   r   rk   r   rk   r   rk   r   rB  r   None)r   r  r    Callable[[NativeFunction], bool]r   z?dict[BaseOperatorName, list[PythonSignatureNativeFunctionPair]])r   r$   r   r  r   r  r   
str | Noner   rk   r   rB  r   rB  r   r   )
r   r$   r   r  r   r  r   rk   r   r   )r   r$   r   r  r   r  r   r  r   rk   r   rB  r   r  r   rB  r   r   )r   zlist[NativeFunction]r   rk   r   rB  r  rB  r  rB  r   r  )
r   r  r   rk   r   rB  r  rB  r   z'list[PythonSignatureNativeFunctionPair]r  )rz   r  r   z tuple[list[str], dict[str, str]])rz   r  r   ztuple[list[str], list[str]])rz   r  r   z	list[str])rg   r   r   r  rz   r  r   rB  r   rB  r   rk   )
rg   r   r   r  rr  rB  r   rB  r   rk   )rZ  r   r  r   r   rB  r   rk   )rg   r   rz   r  r   rB  r   ztuple[str, ...])
rg   r   r   r  rz   r  r   rB  r   rk   )rz   r  r   rB  r   Sequence[PythonSignatureGroup])r  r  r   rB  r   r  )
r  r   rm   r    r  r   r   rB  r   rk   )]
__future__r   r"  recollectionsr   typingr   r   r   rD  torchgen.apir   torchgen.api.pythonr	   r
   r   r   r   r   r   r   r   r   r   r   r   r   torchgen.code_templater   torchgen.contextr   torchgen.genr   r   r   torchgen.modelr   r   r   r    r!   r"   r#   torchgen.utilsr$   r%   torchgen.yaml_utilsr&   gen_inplace_or_view_typer(   gen_trace_typer)   _SKIP_PYTHON_BINDINGScompileri   rl   rq   rv   r{   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  rR  r]  r   r   r  r  r  r  r   r  r  r  r   r   r}  r  r  )ro   s   0rp   <module>r     s>  D #  	 # / /       0 1 G G   : * 9 (T n 0E$+JBJJ!G9A 	#   *!QDF#$'''($ y3	y3y3 y3 	y3
 y3 y3 
y3x
6

*
 E
* &&6& +& 	&
 & & & 
&R$$6$ +$ 	$
 
$N6 + 	
 
R ++6+ ++ 	+
 + + + + 
+f "<*<< 	<
 < 
< 1<,l6ll 	l
 
l -ll ) ):%>0&:0& 0&f:L * 2    (4( $* )
 * B
BB ;B
 B B 	BJ 
 $. :> HL  H  	
"
'
 	

 	
P


:
 	

 
>6
66 ;6
 6 	6H OS62:62GK62#62N JNN65N6BFN6#N6z aaa (a
 a 	aW#s   H+