U d(o@sUddlZddlmZddlmZddlZddlmZmZmZm Z m Z m Z m Z m Z mZddlmZmZddlZeddGdd d Zed d ZGd d d eZejejejhZejejhZejejejejejejejejej ej!ej"ej#ej$ej%ej&ej'gZ(ee)dddZ*ee)dddZ+ee)dddZ,ee)dddZ-GdddeZ.iZ/ee0e e.fe1d<e.j2e.j3e.j4e.j5e.j6he/d<e.j7e.j8he/d<e.j9e.j:he/d<e/de/dBe/d<e/de/dBe/d<e/de/dBe/d<Gd d!d!eZ;Gd"d#d#eZed(d)Z?eddGd*d+d+Z@eddGd,d-d-ZAeddGd.d/d/ZBeddGd0d1d1ZCeddGd2d3d3ZDeddGd4d5d5ZEeddGd6d7d7ZFed8d9ZGeddGd:d;d;eFZHeddGdd?d?eFZJeddGd@dAdAZKeddGdBdCdCZLeddGdDdEdEZMeddGdFdGdGZNeddGdHdIdIZOdJdKdLdMdNdOdPdQdRdSdTg ZPeddGdUdVdVZQeddGdWdXdXZRe>e@eCe)dYdZd[ZSeddGd\d]d]ZTe>e)d^d_d`ZUe>dXd^dadbZVe0e eLdcfdddedfZWeddGdgdhdhZXddlYmZm[Z[dS)iN) assert_never) dataclass) ListDictOptionalIteratorTupleSetSequenceCallableUnion)EnumautoT)frozenc@s,eZdZUeed<eed<edddZdS)LocationfilelinereturncCsd|j|jS)Nz{}:{})formatrrselfr2/tmp/pip-unpacked-wheel-ua33x9lu/torchgen/model.py__str__)szLocation.__str__N)__name__ __module__ __qualname__str__annotations__intrrrrrr$s rVariant)functionmethodc@seZdZdZeZeZeZeZeZ eZ eZ eZ eZ eZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZ eZ!eZ"e"Z#eZ$eZ%eZ&eZ'eZ(eZ)eZ*eZ+eZ,eZ-eZ.eZ/eZ0eZ1eZ2eZ3eZ4eZ5eZ6eZ7eZ8eZ9eZ:eZ;eZeZ?eZ@eZAeZBeZCeZDeDZEe$ZFe%ZGe?ZHe@ZIeAZJeKdddZLeKdddZMeNeKdddd ZOd S) DispatchKeyrrcCs|jSNnamerrrrrszDispatchKey.__str__cCs t|Sr%)rlowerrrrrr(szDispatchKey.lowervaluercCs6tjD]\}}||kr |Sq td|dS)Nzunknown dispatch key )r$ __members__itemsAssertionErrorr*kvrrrparses zDispatchKey.parseN)Prrr UndefinedZCatchAllrZDenseZFPGAZORTMPSZVulkanZMetalZMKLDNNZOpenGLZOpenCLZIDEEPZ QuantizedZCustomRNGKeyId MkldnnCPUZSparse SparseCsrCPU SparseCsrCUDA ZeroTensorMetaZ BackendSelectZNamedZ AutogradOtherZAutogradFunctionalityZAutogradNestedTensorZTracerZAutocastZBatchedZVmapModeZTESTING_ONLY_GenericWrapperZTESTING_ONLY_GenericModeZEndOfFunctionalityKeysCPUCUDAZHIPZXLAZLazyZIPUZXPUZ NestedTensorZ PrivateUse1Z PrivateUse2Z PrivateUse3 QuantizedCPU QuantizedCUDAZ QuantizedXPU SparseCPU SparseCUDAZ SparseHIPZ SparseXPUNestedTensorCPUNestedTensorCUDAZ AutogradCPU AutogradCUDAZ AutogradXLAZ AutogradLazyZ AutogradIPUZ AutogradMPSZ AutogradXPUZAutogradPrivateUse1ZAutogradPrivateUse2ZAutogradPrivateUse3ZAutogradCompositeImplicitAutogradCompositeExplicitAutogradZEndOfAliasKeysZ CPUTensorId CUDATensorIdZPrivateUse1_PreAutogradZPrivateUse2_PreAutogradZPrivateUse3_PreAutogradrrr( staticmethodr1rrrrr$1sr$)dkrcCs|tjtjhkSr%)r$rCrBrFrrris_generic_dispatch_keysrHcCs$|tjtjtjtjtjtjtjhkSr%)r$r:r<r>r6r@rArDrGrrris_cuda_dispatch_keysrIcCs|tkSr%)STRUCTURED_DISPATCH_KEYSrGrrris_structured_dispatch_keysrKcCs|tkSr%)UFUNC_DISPATCH_KEYSrGrrris_ufunc_dispatch_keysrMc@seZdZeZeZeZeZeZeZ eZ eZ eZ eZ eZeZeZedddZeeeddddZeeddddZeeedd d d Zd S) ScalarTypercCs|jSr%r&rrrrrszScalarType.__str__r)cCs(tjD]\}}||kr |Sq dSr%)rNr+r,r.rrr maybe_parses zScalarType.maybe_parsecCs$t|}|dk s td||S)Nzunknown dtype )rNrOr-)r*Zmb_rrrrr1s zScalarType.parse)valuesrcCsBt}|dD],}|tkr,|t|q|t|q|S)N, )setsplit DTYPE_CLASSESupdateaddrNr1)rPZdtypesr*rrr parse_sets zScalarType.parse_setN)rrrrByteCharShortIntLongZHalfFloatDoubleZ ComplexHalf ComplexFloat ComplexDoubleZBoolZBFloat16rrrErrOr1r rWrrrrrNs(rNrTIntegralZFloatingComplexZAllZ AllAndComplexZFloatingAndComplexc@sXeZdZeZeZeZeZeZeZ eZ e dddZ e e ddddZdS)UfuncKeyrcCs|jSr%r&rrrrrszUfuncKey.__str__r)cCs6tjD]\}}||kr |Sq td|dS)Nzunknown ufunc key )rcr+r,r-r.rrrr1s zUfuncKey.parseN)rrrrZ CUDAFunctorZCUDAFunctorOnOtherZCUDAFunctorOnSelfZ CPUScalarZ CPUVectorZ ScalarOnlyGenericrrrEr1rrrrrc srcc@seZdZdZdZdS)DeviceCheckTyperN)rrrNoCheck ExactSamerrrrre'sreViewSchemaKind)aliasingaliasing_inplace non_aliasingc @seZdZUded<eed<eed<eed<eeed<eeed<ee ed<eed <eed <d ed <e d ed<e e dfed<eed<ed ed<eeed<eded<eeed<eed<eed<eed<eeed<e d-e eefd eeeeeede ee dffdddZdd d!d"Zdd d#d$Zeed d%d&Zeed d'd(Zeed d)d*Zeed d+d,ZdS).NativeFunctionFunctionSchemafunc!use_const_ref_for_mutable_tensors device_guard device_check python_modulecategory_overridevariantsmanual_kernel_registrationmanual_cpp_bindingrloc OperatorNameautogenUfuncInnerLoopufunc_inner_loop structuredstructured_delegatestructured_inherits Precompute precomputedcpp_no_default_args is_abstract&has_composite_implicit_autograd_kernel&has_composite_explicit_autograd_kerneltagsN)ryBackendMetadata)eirx valid_tags ignore_keysrc.sJ|}|d}t|ts*td|t||dg}t|tsNtt|}|dd}t|t spt|dd} t| tstt} | dD]>} | dkr| t j q| d kr| t jqtd | q|d d} t| t std | |d d} t| t s$td | |dd}t|t sJtd ||dd}|dkszt|tsztd||dkrtj}nt|}|dd}t|t std ||dd}|dkst|tstd|d}|dk rt|}|dd}|dks2t|ts2td||dd}|dksbt|tsbtd||dkst j| kstd|dd}|dkst|tstd||dd}|dks|dkst|rt|nd}|dd}t|tstt}t|dkr`t|dks*t| dD]*}||krN| |ntd|q4t|tsptddlm}|dd}|dkst|tst|i}|dk r| rtdd}|D]\} } | d krqt| tst|| d!D]}!t|!}"|r(|"|kr(q|"tksHtd"|"d#| d$t| |oXt|"d%||"<|"tjkr| |krd}qqt|d&kr|rtd'|s |tjhks td(|d)|tjd*n(|s |dkr t|dd%|tj<tj |kr*tj|kr*td+|d,d}#t|#tsFt|#dkrTgnd-d.|# dD}$|d/i}%i}&t|%trt!|%t"j#|&t"j#<nt|%tr|%D]f\}!}'|!d krĐqt|!tstd0|!t|'tstd1| t"|!}(t!|'|(|&|(<qntd2|%|&rv|s:td3t$D]6}"|"|ksZtd4|"tt%&|"dd5||"<q>|rd})n|tjhk})tj|k}*tj |k}+fd6d7|D},|d d|rtd8||dk rt'D] }-|-|kstd9|-d:qt(|| |||||$|&| | |||||||)|*|+|d;|,fS)Ysz,NativeFunction.from_yaml..r|z#ufunc_inner_loop key is not a str: z%ufunc_inner_loop value is not a str: z"ufunc_inner_loop not str or dict: zufunc must be structuredz2ufunc should not have explicit dispatch entry for )kernelr}csi|]\}}|j|iqSrr&)rr/r0rorr sz,NativeFunction.from_yaml..zleftover entries: z+if structured_delegate, then must not have z* in dispatch dictionary (it is delegated!))rorprur}r~rrrzr|rvrwrsrtrqrrrxrrrrr))copypop isinstancerr-rnr1listrRboolrSrVr!r"r#rerhryrlenZ torchgen.apirdictr,r$strip dispatch_keysrrKrBr'keysrCr{rcrdrLufuncZschema_kernel_namerJrm).rrxrrefuncsZcpp_no_default_args_listrrpZ variants_srur0rvrwrqZdevice_check_srrr}Zstructured_delegate_sr~rrsrtZprecomputed_dictrZtags_srtrZ raw_dispatchrZ%redundant_composite_implicit_autogradksr/ dispatch_keyZ autogen_strrzZraw_ufunc_inner_loopr|Zvo ufunc_keyrrrZbackend_metadatakeyrrr from_yamls                                                   zNativeFunction.from_yamlrcCs |jrtd|jstddS)NzMThis function is structured, but there was no valid functional variant of it.zThis function delegates to another structured out function, but no valid function was found (the delegate may not exist, or it has the wrong type))r}r-r~rrrrvalidate_unstructureds z$NativeFunction.validate_unstructuredcCs|jjjr |jtjhks td|jrL|jt jks>td|j sLtd|j rx|jt jksjtd|j sxtd|jr|j rtddd|j D}t |j|}t|dkstd ||jdk r|jstd t|jjd r |jtjks td dS) NzNative functions with out arguments MUST be declared with only function variant; e.g., variants: function; otherwise you will tickle a Python argument binding bug (which usually manifests itself as the result variable being undefined.)zYPut structured field on the out= variant of a function; did you mean structured_delegate?z:device_guard: False is not respected by structured kernelszQstructured_delegate field not allowed on out= functions; did you mean structured?z?Cannot have both structured and structured_delegate on functioncSsh|]}|jdk r|jqSr%)defaultr'rarrr s z/NativeFunction.__post_init__..rzInvalid cpp_no_default_args: z4structured_inherits must also imply structured: TrueZ_foreachzsforeach kernels fall back to slow path when tensor are on different devices, device_check not allowed to be enabled)ro argumentsoutrur!r"r-r}kind SchemaKindrqr~schema_order_argumentsrR differencerrrrr' startswithrrrerg)rZdefaulted_argumentsZ invalid_argsrrr __post_init__sP  zNativeFunction.__post_init__cCs |jp |jSr%)rrrrrrhas_composite_kernelsz#NativeFunction.has_composite_kernelcCsT|jj}t|dko$tdd|D}d|jk}tdd|jD}|pR|pR|S)Nrcss"|]}|jdk o|jj VqdSr% annotationis_writerrrrr sz,NativeFunction.is_view_op.. inplace_viewcss$|]}|jdk o|jjdkVqdS)Nr)ralias_set_after)rinprrrrs)roreturnsranyrr)rZretsZis_non_mutating_viewZis_inplace_viewZis_wildcard_viewrrr is_view_ops zNativeFunction.is_view_opcCs<|jr&|jjjjr&d|jks ttjS|jr2tjStj SdS)Nr) rror'inplacerr-rirkrjrlrrrrview_schema_kinds zNativeFunction.view_schema_kindcCs |jjjjSr%)ror'baserrrr root_nameszNativeFunction.root_name)N)rrrrrrerrr r!rrrcrEobjectr$rrrrpropertyrrrirrrrrrrm<sX              ,  rmr) functionalrrmutablec@seZdZUeed<eeed<eeed<eed<eedddZddd d Z d dd d Z e edddZ ee dddZeeeefeddddZdS)NativeFunctionsGrouprrrrrcCs|jjSr%)rr}rrrrr}%szNativeFunctionsGroup.structuredNcCs|jj}|D],}||jkrtd|d|jq|jjtjksXt|jjrttd|jjd|j jtj kst|j dk r|j jtj kst|j dk r|j jtj kst|j r>|j j rt|jj|j jjkst|jjjd|jjd|j jj|j dk r>|j j|j jjks>tdd|D}d d d |D}|j}d d d |D}t|d krt|d krtd|d|dt|jj||krtd|d|d|ddS)Nz_NativeFunctionsGroup constructed from two NativeFunctions that don't have matching signatures:  != zView operator shouldn't be grouped into NativeFunctionsGroup objects.This is likely because you tried to add an out= variant for 'z', which is an existing view operator.out= variants of view operators are not valid. Please reach out to to the core team if you have questions.z delegates to z but its actual delegate is cSs"g|]}d|jkrt|jjqS) generated)rrror')rfrrrrLs z6NativeFunctionsGroup.__post_init__..rQcss|]}t|VqdSr%rrrrrrOsz5NativeFunctionsGroup.__post_init__..css|]}t|VqdSr%rrrrrrQsrz,The codegen expects to be able to generate 'zv'. In order to generate them however, we expect them to be called out explicitly in the yaml. Please add an 'autogen: z' line to the entry for z*'. To do so, it expects a line: 'autogen: z'. Instead, it found 'autogen: ')rro signature functionsr-rrrr'rrrr}rr~joinrzr RuntimeErrorr)rZtest_sigrZ generated_fnsZgenerated_fns_strZexpected_generated_fnsZexpected_generated_fns_strrrrr*sH      "  z"NativeFunctionsGroup.__post_init__rncCs |jjSr%)rrorrrrrr_szNativeFunctionsGroup.signatureccs8|jV|jV|jdk r"|jV|jdk r4|jVdSr%)rrrrrrrrrbs   zNativeFunctionsGroup.functionscCs|jjSr%)rrrrrrrjszNativeFunctionsGroup.root_name)drcCs|stt|dkrdSt|}|tjd}|tjd}|tjd}|tjd}|r`t|dk slt|dkrxdSt ||||dS)Nrf)rrrr) r-rrrrrrrrr)rrrrrrrr from_dictns$  zNativeFunctionsGroup.from_dict)rrrrmrrrrr}rrrrrrrErrrrrrrrs   5 rc@seZdZUeed<eed<dS)rrr}N)rrrrrrrrrrrs rc@s@eZdZUeed<eeed<eed<eeeddddZ dS)r{r'supported_dtypesr)r*rrcCsj|dd\}}|ddks t|ddks0tt}|dddD]}|t|O}qHt|||dS) N rfr()rQ)r'rr)rSr-rRrNrWr{)r*rr'Zsupported_dtypes_strrr/rrrr1szUfuncInnerLoop.parseN) rrrrrr rNrcrEr1rrrrr{s  r{c@seZdZUeed<eed<eed<eed<edefed<eeeedeffeeedeffddd d Z e e d d d Z e e e fed ddZe e e feed ddZeedddZdS) BackendIndexruse_out_as_primaryrqexternalryindexN) parent_index child_indexrcCsT|D]F\}}|D]4\}}|||ks@td|d|||||<qqdS)Nzduplicate operator z for dispatch key )r,r-)rrr/r0op_namemetadatarrr grow_indexs zBackendIndex.grow_index)grcCs|jr |jS|jSdSr%)rrr)rrrrrprimaryszBackendIndex.primarycCs||}|dk Sr%) get_kernel)rrmrrr has_kernels zBackendIndex.has_kernelcCsNt|tr|}nt|tr&||}nt||jj|jkr@dS|j|jjSr%)rrmrrrror'r)rrrrrrrs   zBackendIndex.get_kernelrcCs|jrt|jdSdSdS)NZNativeFunctions)rrrrrrrnative_function_class_namesz'BackendIndex.native_function_class_name)rrrr$rrrrrErrrmrr rrrrrrrrrrs    rc@seZdZUded<ded<eded<eddd d Zeedd d d Z e dddZ ddddZ e dddZ e dddZedddZeeedddZdddde e e ddddZddd d!Zddd"d#d$Zee dd%d&Zedd'd(ZdS))rnryr' Argumentsr)Return.rArgumentrcCst|jj|jj|jjSr%) itertoolschainrflat_positionalflat_kwarg_onlyrrrrrr1s z%FunctionSchema.schema_order_arguments)rorc Csd|kstd|d}|d|}||tdd}|dd\}}|ddks^td|dd}t|}t|}t|}t|||d} t | |kstt | d || S) N -> z:function schema missing return type (spaces are mandatory)rrfrrzExpecting closing )r'rrr) r-rfindrrSryr1r parse_returnsrnr) ro last_indexZ func_decl return_declopsargsr'rrrrrrr18s      "zFunctionSchema.parsecCstdd|jDS)Ncss$|]}|jdk r|jjr|VqdSr%rrrrrrMs z5FunctionSchema.returns_are_aliased..)rrrrrrreturns_are_aliasedKsz"FunctionSchema.returns_are_aliasedNcs:t|jj|jD]\}|jjkstdq|jjD].tfdd|jDr6tdt|q6t |jjdd|jj D}dd|jD}dd|jD}t |d kst |d kstd t||D]"tfd d|Dstd q|jjrRtd d|jjDr2t |jd ksRtdn t |jjt |jksRtd|j j j r|jj}|r|jjr|jjjst|jjttjkrt |jdkr|jd j|jjkstnt |jd kst|jjdk r |tjks tdt||r6|tjks6tdt|dS)NzsOut arguments must have matching return Tensor; furthermore, the ith-argument needs to correspond to the ith returnc3s|]}j|jkVqdSr%rrrrrr\sz/FunctionSchema.__post_init__..z^If you have a schema with mutable positional args, we expect them to not be returned. schema: cSsg|]}|jdkr|qSrr&rargrrrrcs z0FunctionSchema.__post_init__..cSs"g|]}|jdk r|jjr|qSr%rrretrrrrfs cSs"g|]}|jdks|jjs|qSr%rrrrrrks rzYNativeFunctions must have either only mutable returns, or only immutable returns. Found: csg|]}j|jkqSrrr)rrrryszAll mutable returns must be aliased either to a keyword argument, or to "self". Did you forget to mark an out argument as keyword-only?css|]}|jttjkVqdSr%)typeBaseTypeBaseTyTensorrrrrrsz3out= ops that accept tensor lists as out arguments zMMust return as many arguments as there are out arguments, or no return at allrfzFound an operator that is not functional, but has tensor options arguments.This is not allowed- tensor options arguments are only allowed for factory functions.schema: zFound an operator that is not functional, but its overload contains the string 'functional'.This is a special keyword in the codegen, please use a different overload name.schema: )ziprrrrr-post_self_positional_mutablerrrrrr'rself_argargumentrrrrrtensor_optionsrrris_functional_fn)rrZ out_and_selfZmutable_returnsZimmutable_returnsZself_ar)rrrrSs~                 zFunctionSchema.__post_init__cCs d|jjkS)Nrr' overload_namerrrrr szFunctionSchema.is_functional_fncCs t|jjSr%)rrrrrrr is_out_fnszFunctionSchema.is_out_fncCs`t|jj}|jjj}tdd|jjD}|r8|r8t|rBtjS|rLtjS|rVtj Stj SdS)a  What kind of schema is this? A functional schema is one that returns a newly allocated output; an inplace schema modifies the self argument inplace; an out schema writes the result into an explicitly provided out argument. css |]}|jdk o|jjVqdSr%rrrrrrsz&FunctionSchema.kind..N) rrrr'rrpost_self_positionalr-rrr)rZis_outZ is_inplaceZ is_mutablerrrrs   zFunctionSchema.kindcsg}|jD]|fdd|jjD}t|dkr<|dq t|dkrZ||djq ddd|D}tdjd |d q |S) Ncs&g|]}|jdk r|jjkr|qSr%rrrrrrs z7FunctionSchema.aliased_return_names..rrfrQcss|] }|jVqdSr%r&rrrrrsz6FunctionSchema.aliased_return_names..zFound a return (z)that aliases multiple inputs (r)rrflat_allrappendr'rr-)routsZ aliased_argsZ aliased_namesrrraliased_return_namess     z#FunctionSchema.aliased_return_namesF) strip_defaultstrip_view_copy_namekeep_return_names)rrrrc sttdfdd }jjj}|r8|dr8|dd}tfddtjj dk rbjj j gngjj jj D}tt |j}||}jj|d } tjd krtt| d d } tjd krtt| dd} ttt|djjjddd| |dS)a Certain schemas are 'related', in that they are simply inplace/out/functional versions of the same function. This method factors these schemas into the "core" functional signature which is equal across all versions. Here is what normalization happens to the schema to convert it to a signature: - The overload name is stripped (name is retained, since it expresses semantic content about what the function does) - Inplace is set False - Out arguments are stripped - Mutable post_self_positional args are converted to returns - Mutability annotations are stripped (this is sound because you cannot overload on mutability annotation) - Return names are stripped since they are not overloadable and some variants have return names but some not - TensorOptions are dropped because out= variants of factory functions don't include them (and we want to be able to pair up factory functions with their out variants) Finally, we want to be able to pair up related "view" and their corresponding "view_copy" operators. We do this by optionally stripping the trailing "_copy" from the base name. Example of a mutable op before and after: f.func (Mutable operator): _fused_moving_avg_obs_fq_helper(Tensor self, Tensor observer_on, Tensor fake_quant_on, Tensor(a!) running_min, Tensor(b!) running_max, Tensor(c!) scale, Tensor(d!) zero_point, float averaging_const, int quant_min, int quant_max, int ch_axis, bool per_row_fake_quant=False, bool symmetric_quant=False) -> (Tensor output, Tensor mask) # noqa: B950 f.func (Corresponding functional operator): _fused_moving_avg_obs_fq_helper.functional(Tensor self, Tensor observer_on, Tensor fake_quant_on, Tensor running_min, Tensor running_max, Tensor scale, Tensor zero_point, float averaging_const, int quant_min, int quant_max, int ch_axis, bool per_row_fake_quant=False, bool symmetric_quant=False) -> (Tensor output, Tensor mask, Tensor running_min_out, Tensor running_max_out, Tensor scale_out, Tensor zero_point_out) # noqa: B950 f.func.signature() output: _fused_moving_avg_obs_fq_helper(Tensor self, Tensor observer_on, Tensor fake_quant_on, Tensor running_min, Tensor running_max, Tensor scale, Tensor zero_point, float averaging_const, int quant_min, int quant_max, int ch_axis, bool per_row_fake_quant=False, bool symmetric_quant=False) -> (Tensor, Tensor, Tensor, Tensor, Tensor, Tensor) # noqa: B950 )rrcstr |jnd|jddS)Nr'rr)rr'rr)rrrstrip_ret_annotation.s  z6FunctionSchema.signature..strip_ret_annotation_copyrc3sX|]Pjdk rjjrtfddjDstrBjdndjddVqdS)Nc3s|]}j|jkVqdSr%rrrrrrNsz5FunctionSchema.signature..._outr)rrrrrr'r)rrrrrr:s  z+FunctionSchema.signature..Nrzarange.start_stepz Scalar stepz Scalar step=1z bernoulli.pzfloat pz float p=0.5Frr dunder_methodr r)rr'rendswithreplacetuplerrrrrrrmaprrrrr1rnryBaseOperatorNamer) rrrrr base_nameZreturns_from_mutable_inputsZoriginal_returnsrZargs_sigrrrrsD,    zFunctionSchema.signaturecCs |jddS)NTr)rrrrrview_signaturekszFunctionSchema.view_signature)r'rcCst||j|jdS)Nr)rnrr)rr'rrr with_namens zFunctionSchema.with_namecCs|tjtjtjfkSr%)rrrrrrrrrmodifies_argumentsusz!FunctionSchema.modifies_argumentscCsXt|j}t|jdkr(t|jd}nddtt|jd}|jd|d|S)NrfrrrQrz) -> )rrrrrr"r')rZall_arguments_strrrrrrys  zFunctionSchema.__str__)rrrrrrrrErr1rrrr r rrrrrrr&r'rr(rrrrrrn's4  Z" irnc@sPeZdZUeedfed<eed<eed<eeddddZedd d Z d S) Annotation. alias_setrr)annrcCs|d}|dkr@d}td|d|||tdd}nd}td|}|dk sftd||df}|dd k}t|||d }t||kst|d ||S) Nz -> *r*z^([a-z])(!?)(!?)$rzunrecognized alias annotation rf!)r*rrr)findrematchrr-groupr)r)r+Zbecomes_wildcard_indexZ after_setrr*rrrrrr1s*    zAnnotation.parsercCs>d|j}|jr$|d|j}|jr.dnd}||S)N|rr.r)rr*rr)rr*rrrrrs  zAnnotation.__str__N) rrrrrrrrEr1rrrrrr)s r)c@speZdZeeddddZeeddddZedddZedd d Z edd d Z e d dddZ dS)Type)rrcCs,t|}t||ks(t|d||S)Nr)r4_parserr-)rrrrrr1s z Type.parsecCstd|}|dk r(tt|dStd|}|dk rt|ddk rXt|dnd}tt|d|dSztt |WSt k rt d|YnXdS)Nz^(.+)\?$rfz^(.+)\[([0-9]+)?\]$r-)elemsizezunrecognized type ) r0r1 OptionalTyper4r1r2r ListTyperrKeyErrorr)rrr7rrrr5s   z Type._parsercCstdSr%NotImplementedErrorrrrrrsz Type.__str__cCstdSr%r;rrrris_tensor_likeszType.is_tensor_likecCstdSr%r;rrrr is_nullableszType.is_nullabler9cCstdSr%r;rrrr is_list_likeszType.is_list_likeN) rrrrErr1r5rrr=r>rr?rrrrr4s r4r) GeneratorrNrr ZDimnamefloatrrLayoutDeviceZScalarZ MemoryFormatZQSchemeZStorageZStreamZSymIntZConstQuantizerPtrc@sReZdZUeed<edddZedddZedddZ e d dd d Z d S) rr'rcCs |jjSr%r&rrrrrszBaseType.__str__cCs |jtjkSr%)r'rrrrrrr=szBaseType.is_tensor_likecCsdS)NFrrrrrr>szBaseType.is_nullabler9cCsdSr%rrrrrr?szBaseType.is_list_likeN) rrrrrrrrr=r>rr?rrrrrs rc@sReZdZUeed<edddZedddZedddZ e d dd d Z d S) r8r6rcCs |jdS)N?)r6rrrrrszOptionalType.__str__cCs |jSr%r6r=rrrrr=szOptionalType.is_tensor_likecCsdS)NTrrrrrr>szOptionalType.is_nullabler9cCs |jSr%)r6r?rrrrr?szOptionalType.is_list_likeN) rrrr4rrrrr=r>rr?rrrrr8 s r8c@s^eZdZUeed<eeed<edddZe dddZ e ddd Z eddd d Z d S) r9r6r7rcCs$|jr|jnd}|jd|dS)Nr[])r7r6)rr7rrrr'szListType.__str__cCs |jSr%rErrrrr=+szListType.is_tensor_likecCs |jSr%)r6r>rrrrr>.szListType.is_nullablecCs|Sr%rrrrrr?1szListType.is_list_likeN) rrrr4rrr rrrr=r>r?rrrrr9"s  r9c@sjeZdZUeed<eed<eeed<eeed<eeddddZ e e dd d Z edd d Z d S)rr'rrrrrc Cs|dd\}}d|kr(|d\}}n|}d}td|}|rv|ddksVtdd|d}t|d}n|}d}t|}t ||||d } t | |kstt | d || S) Nrrf=Tensor\((.+)\)(.*)r-rrDz[],unrecognized alias analysis form with Tensorrr'rrrr) rsplitrSr0r1r2r-r)r1r4rr) rtype_and_annotZname_and_defaultr'rr1type_srrrrrrr1Ss.  "zArgument.parsercCs|jdk o|jjSr%rrrrrrvszArgument.is_writecCsl|j}|jr0|dkst|dd|jd}|jdkr>|Sd}|jrTd|j}|d|j|SdS)NrzTensor?zTensor[]rTensor(rrrIr)rrr-r r'r)rrZ mb_defaultrrrrzs   zArgument.__str__N)rrrrrr4rr)rEr1rrrrrrrrr5s   "rc@sbeZdZUeeed<eed<eeed<eeddddZ e e ddd Z edd d Z d S) rr'rrrHcCsd|kr|dd\}}n|}d}td|}|rh|ddksHtdd|d}t|d}n|}d}t|}t|||d}t ||kstt |d ||S) NrrfrJr-rKrLrrr) rNr0r1r2r-r)r1r4rr)rrOr'r1rPrrrrrrr1s*  "z Return.parsercCs|jdk o|jjSr%rrrrrrszReturn.is_writecCsR|j}|jr0|dkst|dd|jd}|jdkr>|S|d|jSdS)NrQrrRrr)rrr-r r')rrrrrrs  zReturn.__str__N)rrrrrrr4r)rEr1rrrrrrrrrs   rc@seZdZUeed<dS) SelfArgumentrN)rrrrrrrrrrSs rSc@s@eZdZUeed<eed<eed<eed<eedddZdS) TensorOptionsArgumentsdtypelayoutdevice pin_memoryrcCs|j|j|j|jgSr%rUrVrWrXrrrrallszTensorOptionsArguments.allN)rrrrrr rZrrrrrTs rTc@seZdZUeedfed<eeed<eedfed<eedfed<eeed<eedfed<eedfed<e e ed d d Z e e ed d d Z e e ed ddZ e e ed ddZe e ed ddZe e eeeefd ddZe e eeefd ddZe e eeefd ddZe e eeeefd ddZeed ddZddedd d!d"Zdd d#d$Zeedd%d&d'Zeeeeeeeeefd(d)d*Zeedd(d+d,Zed d-d.Zd/d d0d1Z d/S)2r.pre_self_positionalrrpre_tensor_options_kwarg_onlyr post_tensor_options_kwarg_onlyrrcCs g}||j||j|Sr%)extendrrrrrrr flat_non_outs  zArguments.flat_non_outcCs8g}||j|jdk r(||jj||j|Sr%)r^r[rrrrr_rrrrs    zArguments.flat_positionalcCsdd|jDS)NcSsg|]}|jr|qSr)rrrrrrsz:Arguments.post_self_positional_mutable..)rrrrrrsz&Arguments.post_self_positional_mutablecCs:g}||j|jdk r*||j||j|Sr%)r^r\r rZr]r_rrrrs    zArguments.flat_kwarg_onlycCs,g}||j||j||j|Sr%)r^rrrr_rrrrs    zArguments.flat_allcCs g}||j||j|Sr%)r^ positional kwarg_onlyr_rrrnon_out s  zArguments.non_outcCs6g}||j|jdk r&||j||j|Sr%)r^r[rrrr_rrrras     zArguments.positionalcCs6g}||j|jdk r&||j||j|Sr%)r^r\r rr]r_rrrrbs     zArguments.kwarg_onlycCs,g}||j||j||j|Sr%)r^rarbrr_rrrrZ(s    z Arguments.allcCsdd|jDS)NcSs$g|]}|jdk r|jjr|jqSr%)rrr'rrrrr1s z/Arguments.mutable_arg_names..)rrrrrmutable_arg_names0szArguments.mutable_arg_namesFr)rrc szttdfdd }ttt||j|jdk r>t||jjndtt||jtt||j tt||j dtddS)N)rrcst|j|js|jndddS)NrM)rr'rrrrrrstrip_arg_annotation:s  z1Arguments.signature..strip_arg_annotationrr[rrr\r r]r) rrr!r"r[rrSrrr\r])rrrerrrr7s(   zArguments.signaturecCs.|jdk sttj|ttj|jjdddS)Nr)r)rr- dataclassesr rSrrrrrremove_self_annotationZsz Arguments.remove_self_annotation)rrcCs$t|jdksttj|t|dS)Nr)r)rrr-rgr r!)rrrrr with_out_argscs zArguments.with_out_args)rrcCsg}g}g}|}|dD]r}|s$q|dkrB||kstt||||d||d||dd} |t |7}| } q| |||d7}qtt||t| t| | t| t|dS)z. Input: 'int x, int y, int z' Nrrf)r'tyrcsfddS)Ncs|jko|jtfkSr%)r'rr8rr'rkrrz/Arguments.parse..pred..rrlrrlrpredszArguments.parse..predrUrNrVrBrWrCrXrrcss|]\}}||VqdSr%r)rprrrrrsz"Arguments.parse..r-rYrf)rrj enumerater'rSrr4r rrr1rrZrr-rTrr!)rrarbrZself_ixirr[rrr\r r]Zkwarg_only_accroZ predicatesrrrr1sd          zArguments.parsecCsZg}|tt|j|js"|jr,|d|tt|j|tt|jd|S)Nr,rQ)r^r"rrrrrr)rZ all_argumentsrrrrs  zArguments.__str__NcCsP|jdkr|jrt|jdkr(|jr(tdd|jD}t|dksLtddS)NcSs"g|]}|jdk r|jjr|qSr%rrrrrrs z+Arguments.__post_init__..rzOmutable pre_self_positional arguments are not currently supported in the schema)rr[r-r r]r)rZmutable_pre_self_positionalsrrrrs     zArguments.__post_init__)!rrrrrrrrSrTrr r`rrrrr rcrarbrZrrrdrrrhrirErjr1rrrrrrrsH   # (#O rrVsubmuldivmodpowlshiftrshiftandxororc@sHeZdZUeed<eed<eed<eeddddZeddd Zd S) r#rrr)oprcs|dks t|drtdtd|}|dk r~d}|dtfddtDrhd}ddqd }d d kstn*d }|d d krd}dd nd }t||d}t||kstt|d||S)Nrrzs_out suffix is reserved and not permitted for operator names; did you mean to specify an out overload name instead?z ^__([^_]+)__$Trfc3s|]}d|kVqdS)rsNr)rnrrrr#sz)BaseOperatorName.parse..Frrsr_rr) r-rr0r1r2rAUGMENTED_ASSIGNMENT_NAMESr#r)r~rrrrrrrr1s,     "zBaseOperatorName.parsercCsF|jr&|jrdnd}d||jdS|jr0dnd}|j|SdS)Nrsr__r)rrr)rrsrrrr9s zBaseOperatorName.__str__N) rrrrrrrEr1rrrrrr#s  r#c@sleZdZUeed<eed<eeddddZedddZedd d Z ddd d Z edd ddZ dS)ryr'r )rrcCsZd|kr|dd\}}n|}d}tt||d}t||ksVtt|d||S)N.rfrr r)rSryr#r1rr-)rr'r rrrrr1Is"zOperatorName.parsercCs$|jr|jd|jS|jSdS)Nrr r'rrrrrTszOperatorName.__str__cCs$|jr|jd|jS|jSdS)Nrrrrrrunambiguous_name_szOperatorName.unambiguous_namecCs tt|jjd|jjd|jdSNFrr )ryr#r'rrr rrrrremove_inplaceeszOperatorName.remove_inplace)overloadrcCstt|jjd|jjd|dSr)ryr#r'rr)rrrrr with_overloadoszOperatorName.with_overloadN) rrrr#rrrEr1rrrrrrrrryDs    ry)rrbrcCs(|jtjk o&|| o&||jSr%)rorrrr)rrrrrr"gets_generated_out_inplace_wrapperzs   rc@szeZdZUeed<eeed<eeed<ddddZdd eeed d d Z e e dd dZ e edddZ dS)NativeFunctionsViewGroupview view_copy view_inplaceNrcCs |jjs t|jdkrFt|jrtt|jjjdt|jdnh|jjjjj ds^t|jj |jjj ddks~td|jj kstt|jjjt|jj fd|j dk r|jj |j j kst|jjr|j dk r|j jstt|jjjdt|j jjd dS) Nz appears to be a new operator that aliases its inputs. The codegen expects you to add a corresponding operator to native_functions.yaml: z3. See Note [view_copy NativeFunctions] for details.rTr%rz appears to be a view_copy operator. The codegen expects view_copy operators to be annotated with the 'view_copy' tag in native_functions.yaml. See Note [view_copy NativeFunction] for details.z and z] must either both have CompositeImplicitAutograd kernels, or both not have composite kernels.)rrr-rgets_generated_view_copyrror'get_view_copy_namerrrrrrrrrrrs&        "z&NativeFunctionsViewGroup.__post_init__T) include_copy)rrccs4|jV|jdk r|jV|jdk r0|r0|jVdSr%)rrr)rrrrrrs  z"NativeFunctionsViewGroup.functionscCs|jjSr%)rrrrrrrsz"NativeFunctionsViewGroup.root_namecCs|jjSr%)rrrrrr compositesz"NativeFunctionsViewGroup.composite)rrrrmrrrrrrrrrrrrrrrs   r)rrcCs&|js dS|jrdSd|jkr"dSdS)NFrT)rrr)rrrrrs rcCs\dg}t|jj|kr"t|s"t|jjjjd}tt|d|jjjjd|jjj d}|S)NZnarrowrFrr ) rror'rr-rryr#rr )rZ-list_of_ops_with_explicit_view_copy_operatorsr$Zview_copy_namerrrrs  r.)rrcCsH|dkr dS|ddkr0|ddkr0|dd}tdd |d DS) z$ Input: '()' Output: [] z()rrrrrrfcss|]}t|VqdSr%)rr1rrrrrsz parse_returns..rQ)r!rS)rrrrrs  rc@sTeZdZUeeeefed<eeed<ee ddddZ eedddZ d S) rr rV)srcrc Cst|tstg}d|dkrF|dd}dd|D}|dd}i}|D]P}t|ts`td|ksptd|d\}}|d}dd|D}|||<qNt||d} | |kstd | S) NrrrcSsg|]}t|qSrrr1rrr'rrrr sz$Precompute.parse..zLprecomputed parameters without replacement are allowed only in the last linecSsg|]}t|qSrrrrrrr" s)r rVzr.to_list() != src)rrr-rSrrto_list) rZadd_argsZadd_listr Zraw_replace_itemrZ with_list_rawZ with_listZwith_list_argsrrrrr1 s&       zPrecompute.parsercCsDg}|jD]0\}}ddd|D}||d|q|S)NrQcss|]}t|VqdSr%r)rparamrrrr, sz%Precompute.to_list..r)r r,rr)rZ replace_listZ kernel_paramZreplacement_params replacementsrrrr) s zPrecompute.to_listN) rrrrrrrrrErr1rrrrrrs  !r)\r0Ztorchgen.utilsrrgrtypingrrrrrr r r r enumr rrrr!r$r3r:r9rJrLr=r5r4r>r6r;r<rBrCr?r@r8r7rrrHrIrKrMrNrTrrrXrYr[r\rZr]r^r_r`rcrerirmrrrr{rrnr)r4rrr8r9rrrSrTrrr#ryrrrrrrZtorchgen.api.ufuncapirrrrrs  , ` * \ jpc-(R4 016 82